MutableBox.h

//===-- MutableBox.h -- MutableBox utilities  -----------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_OPTIMIZER_BUILDER_MUTABLEBOX_H
#define FORTRAN_OPTIMIZER_BUILDER_MUTABLEBOX_H
 
#include "flang/Optimizer/Builder/BoxValue.h"
#include "flang/Optimizer/Dialect/CUF/Attributes/CUFAttr.h"
#include "flang/Runtime/allocator-registry-consts.h"
#include "llvm/ADT/StringRef.h"
 
namespace mlir {
class Value;
class ValueRange;
class Type;
class Location;
} // namespace mlir
 
namespace fir {
class FirOpBuilder;
class MutableBoxValue;
class ExtendedValue;
} // namespace fir
 
namespace fir::factory {

mlir::Value createUnallocatedBox(fir::FirOpBuilder &builder, mlir::Location loc,
                                 mlir::Type boxType,
                                 mlir::ValueRange nonDeferredParams,
                                 mlir::Value typeSourceBox = {},
                                 unsigned allocator = kDefaultAllocator);

fir::MutableBoxValue createTempMutableBox(fir::FirOpBuilder &builder,
                                          mlir::Location loc, mlir::Type type,
                                          llvm::StringRef name = {},
                                          mlir::Value sourceBox = {},
                                          bool isPolymorphic = false);

void associateMutableBox(fir::FirOpBuilder &builder, mlir::Location loc,
                         const fir::MutableBoxValue &box,
                         const fir::ExtendedValue &source,
                         mlir::ValueRange lbounds);

void associateMutableBoxWithRemap(fir::FirOpBuilder &builder,
                                  mlir::Location loc,
                                  const fir::MutableBoxValue &box,
                                  const fir::ExtendedValue &source,
                                  mlir::ValueRange lbounds,
                                  mlir::ValueRange ubounds);

void disassociateMutableBox(fir::FirOpBuilder &builder, mlir::Location loc,
                            const fir::MutableBoxValue &box,
                            bool polymorphicSetType = true,
                            unsigned allocator = kDefaultAllocator);

struct MutableBoxReallocation {
  fir::ExtendedValue newValue;
  mlir::Value oldAddress;
  mlir::Value wasReallocated;
  mlir::Value oldAddressWasAllocated;
};

using ReallocStorageHandlerFunc = std::function<void(fir::ExtendedValue)>;
 
MutableBoxReallocation
genReallocIfNeeded(fir::FirOpBuilder &builder, mlir::Location loc,
                   const fir::MutableBoxValue &box, mlir::ValueRange shape,
                   mlir::ValueRange lenParams,
                   ReallocStorageHandlerFunc storageHandler = {},
                   cuf::DataAttributeAttr dataAttr = {});
 
void finalizeRealloc(fir::FirOpBuilder &builder, mlir::Location loc,
                     const fir::MutableBoxValue &box, mlir::ValueRange lbounds,
                     bool takeLboundsIfRealloc,
                     const MutableBoxReallocation &realloc,
                     cuf::DataAttributeAttr dataAttr = {});

void genFreememIfAllocated(fir::FirOpBuilder &builder, mlir::Location loc,
                           const fir::MutableBoxValue &box);
 
void genInlinedAllocation(fir::FirOpBuilder &builder, mlir::Location loc,
                          const fir::MutableBoxValue &box,
                          mlir::ValueRange lbounds, mlir::ValueRange extents,
                          mlir::ValueRange lenParams, llvm::StringRef allocName,
                          bool mustBeHeap = false);

mlir::Value genFreemem(fir::FirOpBuilder &builder, mlir::Location loc,
                       const fir::MutableBoxValue &box);

void syncMutableBoxFromIRBox(fir::FirOpBuilder &builder, mlir::Location loc,
                             const fir::MutableBoxValue &box);

fir::ExtendedValue genMutableBoxRead(fir::FirOpBuilder &builder,
                                     mlir::Location loc,
                                     const fir::MutableBoxValue &box,
                                     bool mayBePolymorphic = true,
                                     bool preserveLowerBounds = true);

mlir::Value getMutableIRBox(fir::FirOpBuilder &builder, mlir::Location loc,
                            const fir::MutableBoxValue &box);

mlir::Value genIsAllocatedOrAssociatedTest(fir::FirOpBuilder &builder,
                                           mlir::Location loc,
                                           const fir::MutableBoxValue &box);

mlir::Value genIsNotAllocatedOrAssociatedTest(fir::FirOpBuilder &builder,
                                              mlir::Location loc,
                                              const fir::MutableBoxValue &box);

mlir::Value genNullBoxStorage(fir::FirOpBuilder &builder, mlir::Location loc,
                              mlir::Type boxTy);

mlir::Value getAndEstablishBoxStorage(fir::FirOpBuilder &builder,
                                      mlir::Location loc,
                                      fir::BaseBoxType boxTy, mlir::Value shape,
                                      llvm::ArrayRef<mlir::Value> typeParams,
                                      mlir::Value polymorphicMold);
 
} // namespace fir::factory
 
#endif // FORTRAN_OPTIMIZER_BUILDER_MUTABLEBOX_H