From 2bd473de8207dcd5fc870a1c7b8f3e42bf1f4636 Mon Sep 17 00:00:00 2001 From: peter klausler Date: Thu, 12 Mar 2020 17:07:16 -0700 Subject: [PATCH] [flang] more edits Remove AllocateDefaultCharacter Refinements in code review Original-commit: flang-compiler/f18@688512ddc671fa1ed54224b7cfef49a1c2284c99 Reviewed-on: https://github.com/flang-compiler/f18/pull/1070 --- flang/runtime/allocatable.h | 115 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 115 insertions(+) create mode 100644 flang/runtime/allocatable.h diff --git a/flang/runtime/allocatable.h b/flang/runtime/allocatable.h new file mode 100644 index 0000000..bcb7035 --- /dev/null +++ b/flang/runtime/allocatable.h @@ -0,0 +1,115 @@ +//===-- runtime/allocatable.h -----------------------------------*- C++ -*-===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +// Defines APIs for Fortran runtime library support of code generated +// to manipulate and query allocatable variables, dummy arguments, & components. +#ifndef FORTRAN_RUNTIME_ALLOCATABLE_H_ +#define FORTRAN_RUNTIME_ALLOCATABLE_H_ +#include "descriptor.h" +#include "entry-names.h" + +namespace Fortran::runtime { +extern "C" { + +// Initializes the descriptor for an allocatable of intrinsic or derived type. +// The incoming descriptor is treated as (and can be) uninitialized garbage. +// Must be called for each allocatable variable as its scope comes into being. +// The storage for the allocatable's descriptor must have already been +// allocated to a size sufficient for the rank, corank, and type. +// A descriptor must be initialized before being used for any purpose, +// but needs reinitialization in a deallocated state only when there is +// a change of type, rank, or corank. +void RTNAME(AllocatableInitIntrinsic)( + Descriptor &, TypeCategory, int kind, int rank = 0, int corank = 0); +void RTNAME(AllocatableInitCharacter)(Descriptor &, SubscriptValue length, + int kind = 1, int rank = 0, int corank = 0); +void RTNAME(AllocatableInitDerived)( + Descriptor &, const DerivedType &, int rank = 0, int corank = 0); + +// Checks that an allocatable is not already allocated in statements +// with STAT=. Use this on a value descriptor before setting bounds or +// type parameters. Not necessary on a freshly initialized descriptor. +// (If there's no STAT=, the error will be caught later anyway, but +// this API allows the error to be caught before descriptor is modified.) +// Return 0 on success (deallocated state), else the STAT= value. +int RTNAME(AllocatableCheckAllocated)(Descriptor &, + Descriptor *errMsg = nullptr, const char *sourceFile = nullptr, + int sourceLine = 0); + +// For MOLD= allocation; sets bounds, cobounds, and length type +// parameters from another descriptor. The destination descriptor must +// be initialized and deallocated. +void RTNAME(AllocatableApplyMold)(Descriptor &, const Descriptor &mold); + +// Explicitly sets the bounds and length type parameters of an initialized +// deallocated allocatable. +void RTNAME(AllocatableSetBounds)( + Descriptor &, int zeroBasedDim, SubscriptValue lower, SubscriptValue upper); + +// The upper bound is ignored for the last codimension. +void RTNAME(AllocatableSetCoBounds)(Descriptor &, int zeroBasedCoDim, + SubscriptValue lower, SubscriptValue upper = 0); + +// Length type parameters are indexed in declaration order; i.e., 0 is the +// first length type parameter in the deepest base type. (Not for use +// with CHARACTER; see above.) +void RTNAME(AllocatableSetDerivedLength)( + Descriptor &, int which, SubscriptValue); + +// When an explicit type-spec appears in an ALLOCATE statement for an +// allocatable with an explicit (non-deferred) length type paramater for +// a derived type or CHARACTER value, the explicit value has to match +// the length type parameter's value. This API checks that requirement. +// Returns 0 for success, or the STAT= value on failure with hasStat==true. +int RTNAME(AllocatableCheckLengthParameter)(Descriptor &, + int which /* 0 for CHARACTER length */, SubscriptValue other, + bool hasStat = false, Descriptor *errMsg = nullptr, + const char *sourceFile = nullptr, int sourceLine = 0); + +// Allocates an allocatable. The allocatable descriptor must have been +// initialized and its bounds and length type parameters set and must be +// in a deallocated state. +// On failure, if hasStat is true, returns a nonzero error code for +// STAT= and (if present) fills in errMsg; if hasStat is false, the +// image is terminated. On success, leaves errMsg alone and returns zero. +// Successfully allocated memory is initialized if the allocatable has a +// derived type, and is always initialized by AllocatableAllocateSource(). +// Performs all necessary coarray synchronization and validation actions. +int RTNAME(AllocatableAllocate)(Descriptor &, bool hasStat = false, + Descriptor *errMsg = nullptr, const char *sourceFile = nullptr, + int sourceLine = 0); +int RTNAME(AllocatableAllocateSource)(Descriptor &, const Descriptor &source, + bool hasStat = false, Descriptor *errMsg = nullptr, + const char *sourceFile = nullptr, int sourceLine = 0); + +// Assigns to a whole allocatable, with automatic (re)allocation when the +// destination is unallocated or nonconforming (Fortran 2003 semantics). +// The descriptor must be initialized. +// Recursively assigns components with (re)allocation as necessary. +// TODO: Consider renaming to a more general name that will work for +// assignments to pointers, dummy arguments, and anything else with a +// descriptor. +void RTNAME(AllocatableAssignment)(Descriptor &to, const Descriptor &from); + +// Implements the intrinsic subroutine MOVE_ALLOC (16.9.137 in F'2018, +// but note the order of first two arguments is reversed for consistency +// with the other APIs for allocatables.) The destination descriptor +// must be initialized. +int RTNAME(MoveAlloc)(Descriptor &to, const Descriptor &from, + bool hasStat = false, Descriptor *errMsg = nullptr, + const char *sourceFile = nullptr, int sourceLine = 0); + +// Deallocates an allocatable. Finalizes elements &/or components as needed. +// The allocatable is left in an initialized state suitable for reallocation +// with the same bounds, cobounds, and length type parameters. +int RTNAME(AllocatableDeallocate)(Descriptor &, bool hasStat = false, + Descriptor *errMsg = nullptr, const char *sourceFile = nullptr, + int sourceLine = 0); +} +} +#endif // FORTRAN_RUNTIME_ALLOCATABLE_H_ -- 2.7.4