Allocatable.h

//===-- Allocatable.h -- Allocatable statements lowering ------------------===//
//
// 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_LOWER_ALLOCATABLE_H
#define FORTRAN_LOWER_ALLOCATABLE_H
 
#include "flang/Lower/AbstractConverter.h"
#include "flang/Optimizer/Builder/MutableBox.h"
#include "flang/Runtime/allocator-registry-consts.h"
 
namespace mlir {
class Value;
class ValueRange;
class Location;
} // namespace mlir
 
namespace fir {
class FirOpBuilder;
} // namespace fir
 
namespace Fortran {
namespace parser {
struct AllocateStmt;
struct DeallocateStmt;
} // namespace parser
 
namespace semantics {
class Symbol;
class DerivedTypeSpec;
} // namespace semantics
 
namespace lower {
struct SymbolBox;
 
class StatementContext;
 
bool isArraySectionWithoutVectorSubscript(const SomeExpr &expr);

void genAllocateStmt(AbstractConverter &converter,
                     const parser::AllocateStmt &stmt, mlir::Location loc);

void genDeallocateStmt(AbstractConverter &converter,
                       const parser::DeallocateStmt &stmt, mlir::Location loc);
 
void genDeallocateBox(AbstractConverter &converter,
                      const fir::MutableBoxValue &box, mlir::Location loc,
                      const Fortran::semantics::Symbol *sym = nullptr,
                      mlir::Value declaredTypeDesc = {});

void genDeallocateIfAllocated(AbstractConverter &converter,
                              const fir::MutableBoxValue &box,
                              mlir::Location loc,
                              const Fortran::semantics::Symbol *sym = nullptr);

fir::MutableBoxValue createMutableBox(AbstractConverter &converter,
                                      mlir::Location loc,
                                      const pft::Variable &var,
                                      mlir::Value boxAddr,
                                      mlir::ValueRange nonDeferredParams,
                                      unsigned allocator = kDefaultAllocator);

void associateMutableBox(AbstractConverter &converter, mlir::Location loc,
                         const fir::MutableBoxValue &box,
                         const SomeExpr &source, mlir::ValueRange lbounds,
                         StatementContext &stmtCtx);

bool isWholeAllocatable(const SomeExpr &expr);

bool isWholePointer(const SomeExpr &expr);

mlir::Value getAssumedCharAllocatableOrPointerLen(
    fir::FirOpBuilder &builder, mlir::Location loc,
    const Fortran::semantics::Symbol &sym, mlir::Value box);

mlir::Value
getTypeDescAddr(AbstractConverter &converter, mlir::Location loc,
                const Fortran::semantics::DerivedTypeSpec &typeSpec);
 
} // namespace lower
} // namespace Fortran
 
#endif // FORTRAN_LOWER_ALLOCATABLE_H