This is an archive of the discontinued LLVM Phabricator instance.

../llvm-project/flang/runtime/descriptor.h:52:22: error: array subscript ‘Fortran::runtime::Dimension[1]’ is partly outside array bounds of ‘Fortran::runtime::StaticDescriptor<0, true> [1]’ [-Werror=array-bounds]
   52 |     raw_.lower_bound = lower;
      |     ~~~~~~~~~~~~~~~~~^~~~~~~
../llvm-project/flang/runtime/descriptor-io.cpp:35:31: note: while referencing ‘statDesc’
   35 |     StaticDescriptor<0, true> statDesc;
      |                               ^~~~~~~~

Though it has gone through latest-clang fine: https://lab.llvm.org/buildbot/#/builders/180/builds/440

So could be gcc being pessimistic or clang missing something.

Can you please investigate?

Edit: "latest" gcc is 11

-- The C compiler identification is GNU 11.1.0
-- The CXX compiler identification is GNU 11.1.0

Will do, thanks.

Fix has been pushed, and I'll keep an eye on the buildbots to make sure that they go/stay green. The warning was legitimate and I'm glad it was caught.

Bots are green.

I want to check if clang should have warned here and raise a bug if so, it does support array-bounds. Is it possible to make a small example that represents what was going on?

Revision Contents

Path

Size

flang/

runtime/

1 line

8 lines

17 lines

25 lines

12 lines

3 lines

112 lines

160 lines

test/

Semantics/

offsets01.f90

4 lines

Diff 359800

flang/runtime/CMakeLists.txt

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines	add_flang_library(FortranRuntime
main.cpp		main.cpp
matmul.cpp		matmul.cpp
memory.cpp		memory.cpp
misc-intrinsic.cpp		misc-intrinsic.cpp
namelist.cpp		namelist.cpp
numeric.cpp		numeric.cpp
random.cpp		random.cpp
reduction.cpp		reduction.cpp
		pointer.cpp
product.cpp		product.cpp
stat.cpp		stat.cpp
stop.cpp		stop.cpp
sum.cpp		sum.cpp
terminator.cpp		terminator.cpp
time-intrinsic.cpp		time-intrinsic.cpp
tools.cpp		tools.cpp
transformational.cpp		transformational.cpp
type-code.cpp		type-code.cpp
type-info.cpp		type-info.cpp
unit.cpp		unit.cpp
unit-map.cpp		unit-map.cpp

LINK_LIBS		LINK_LIBS
FortranDecimal		FortranDecimal
)		)

flang/runtime/allocatable.h

	//===-- runtime/allocatable.h ------------------------------------ C++ --===//			//===-- runtime/allocatable.h ------------------------------------ C++ --===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	// Defines APIs for Fortran runtime library support of code generated			// Defines APIs for Fortran runtime library support of code generated
	// to manipulate and query allocatable variables, dummy arguments, & components.			// to manipulate and query allocatable variables, dummy arguments, & components.
	#ifndef FORTRAN_RUNTIME_ALLOCATABLE_H_			#ifndef FORTRAN_RUNTIME_ALLOCATABLE_H_
	#define FORTRAN_RUNTIME_ALLOCATABLE_H_			#define FORTRAN_RUNTIME_ALLOCATABLE_H_

	#include "descriptor.h"			#include "descriptor.h"
	#include "entry-names.h"			#include "entry-names.h"

	namespace Fortran::runtime::typeInfo {
	class DerivedType;
	}

	namespace Fortran::runtime {			namespace Fortran::runtime {

	extern "C" {			extern "C" {

	// Initializes the descriptor for an allocatable of intrinsic or derived type.			// Initializes the descriptor for an allocatable of intrinsic or derived type.
	// The incoming descriptor is treated as (and can be) uninitialized garbage.			// The incoming descriptor is treated as (and can be) uninitialized garbage.
	// Must be called for each allocatable variable as its scope comes into being.			// Must be called for each allocatable variable as its scope comes into being.
	// The storage for the allocatable's descriptor must have already been			// The storage for the allocatable's descriptor must have already been
	// allocated to a size sufficient for the rank, corank, and type.			// allocated to a size sufficient for the rank, corank, and type.
	// A descriptor must be initialized before being used for any purpose,			// A descriptor must be initialized before being used for any purpose,
	Show All 21 Lines
	// be initialized and deallocated.			// be initialized and deallocated.
	void RTNAME(AllocatableApplyMold)(Descriptor &, const Descriptor &mold);			void RTNAME(AllocatableApplyMold)(Descriptor &, const Descriptor &mold);

	// Explicitly sets the bounds and length type parameters of an initialized			// Explicitly sets the bounds and length type parameters of an initialized
	// deallocated allocatable.			// deallocated allocatable.
	void RTNAME(AllocatableSetBounds)(			void RTNAME(AllocatableSetBounds)(
	Descriptor &, int zeroBasedDim, SubscriptValue lower, SubscriptValue upper);			Descriptor &, int zeroBasedDim, SubscriptValue lower, SubscriptValue upper);

	// The upper bound is ignored for the last codimension.			// The upper cobound is ignored for the last codimension.
	void RTNAME(AllocatableSetCoBounds)(Descriptor &, int zeroBasedCoDim,			void RTNAME(AllocatableSetCoBounds)(Descriptor &, int zeroBasedCoDim,
	SubscriptValue lower, SubscriptValue upper = 0);			SubscriptValue lower, SubscriptValue upper = 0);

	// Length type parameters are indexed in declaration order; i.e., 0 is the			// 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			// first length type parameter in the deepest base type. (Not for use
	// with CHARACTER; see above.)			// with CHARACTER; see above.)
	void RTNAME(AllocatableSetDerivedLength)(			void RTNAME(AllocatableSetDerivedLength)(
	Descriptor &, int which, SubscriptValue);			Descriptor &, int which, SubscriptValue);
	▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

flang/runtime/allocatable.cpp

	Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines

	void RTNAME(AllocatableSetBounds)(Descriptor &descriptor, int zeroBasedDim,			void RTNAME(AllocatableSetBounds)(Descriptor &descriptor, int zeroBasedDim,
	SubscriptValue lower, SubscriptValue upper) {			SubscriptValue lower, SubscriptValue upper) {
	INTERNAL_CHECK(zeroBasedDim >= 0 && zeroBasedDim < descriptor.rank());			INTERNAL_CHECK(zeroBasedDim >= 0 && zeroBasedDim < descriptor.rank());
	descriptor.GetDimension(zeroBasedDim).SetBounds(lower, upper);			descriptor.GetDimension(zeroBasedDim).SetBounds(lower, upper);
	// The byte strides are computed when the object is allocated.			// The byte strides are computed when the object is allocated.
	}			}

				void RTNAME(AllocatableSetDerivedLength)(
				Descriptor &descriptor, int which, SubscriptValue x) {
				DescriptorAddendum *addendum{descriptor.Addendum()};
				INTERNAL_CHECK(addendum != nullptr);
				addendum->SetLenParameterValue(which, x);
				}

				void RTNAME(AllocatableApplyMold)(
				Descriptor &descriptor, const Descriptor &mold) {
				descriptor = mold;
				descriptor.set_base_addr(nullptr);
				descriptor.raw().attribute = CFI_attribute_allocatable;
				}

	int RTNAME(AllocatableAllocate)(Descriptor &descriptor, bool hasStat,			int RTNAME(AllocatableAllocate)(Descriptor &descriptor, bool hasStat,
	const Descriptor errMsg, const char sourceFile, int sourceLine) {			const Descriptor errMsg, const char sourceFile, int sourceLine) {
	Terminator terminator{sourceFile, sourceLine};			Terminator terminator{sourceFile, sourceLine};
	if (!descriptor.IsAllocatable()) {			if (!descriptor.IsAllocatable()) {
	return ReturnError(terminator, StatInvalidDescriptor, errMsg, hasStat);			return ReturnError(terminator, StatInvalidDescriptor, errMsg, hasStat);
	}			}
	if (descriptor.IsAllocated()) {			if (descriptor.IsAllocated()) {
	return ReturnError(terminator, StatBaseNotNull, errMsg, hasStat);			return ReturnError(terminator, StatBaseNotNull, errMsg, hasStat);
	}			}
	return ReturnError(terminator, descriptor.Allocate(), errMsg, hasStat);			return ReturnError(terminator, descriptor.Allocate(), errMsg, hasStat);
				// TODO: default component initialization
	}			}

	int RTNAME(AllocatableDeallocate)(Descriptor &descriptor, bool hasStat,			int RTNAME(AllocatableDeallocate)(Descriptor &descriptor, bool hasStat,
	const Descriptor errMsg, const char sourceFile, int sourceLine) {			const Descriptor errMsg, const char sourceFile, int sourceLine) {
	Terminator terminator{sourceFile, sourceLine};			Terminator terminator{sourceFile, sourceLine};
	if (!descriptor.IsAllocatable()) {			if (!descriptor.IsAllocatable()) {
	return ReturnError(terminator, StatInvalidDescriptor, errMsg, hasStat);			return ReturnError(terminator, StatInvalidDescriptor, errMsg, hasStat);
	}			}
	if (!descriptor.IsAllocated()) {			if (!descriptor.IsAllocated()) {
	return ReturnError(terminator, StatBaseNull, errMsg, hasStat);			return ReturnError(terminator, StatBaseNull, errMsg, hasStat);
	}			}
	return ReturnError(terminator, descriptor.Deallocate(), errMsg, hasStat);			return ReturnError(terminator, descriptor.Deallocate(), errMsg, hasStat);
	}			}

				// TODO: AllocatableCheckLengthParameter, AllocatableAllocateSource
	}			}
	} // namespace Fortran::runtime			} // namespace Fortran::runtime

flang/runtime/descriptor.h

	Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
	// The storage for this object follows the last used dim[] entry in a			// The storage for this object follows the last used dim[] entry in a
	// Descriptor (CFI_cdesc_t) generic descriptor. Space matters here, since			// Descriptor (CFI_cdesc_t) generic descriptor. Space matters here, since
	// descriptors serve as POINTER and ALLOCATABLE components of derived type			// descriptors serve as POINTER and ALLOCATABLE components of derived type
	// instances. The presence of this structure is implied by the flag			// instances. The presence of this structure is implied by the flag
	// CFI_cdesc_t.f18Addendum, and the number of elements in the len_[]			// CFI_cdesc_t.f18Addendum, and the number of elements in the len_[]
	// array is determined by derivedType_->LenParameters().			// array is determined by derivedType_->LenParameters().
	class DescriptorAddendum {			class DescriptorAddendum {
	public:			public:
	enum Flags {			explicit DescriptorAddendum(const typeInfo::DerivedType *dt = nullptr)
	StaticDescriptor = 0x001,			: derivedType_{dt} {}
	ImplicitAllocatable = 0x002, // compiler-created allocatable
	DoNotFinalize = 0x004, // compiler temporary
	Target = 0x008, // TARGET attribute
	};

	explicit DescriptorAddendum(
	const typeInfo::DerivedType *dt = nullptr, std::uint64_t flags = 0)
	: derivedType_{dt}, flags_{flags} {}
	DescriptorAddendum &operator=(const DescriptorAddendum &);			DescriptorAddendum &operator=(const DescriptorAddendum &);

	const typeInfo::DerivedType *derivedType() const { return derivedType_; }			const typeInfo::DerivedType *derivedType() const { return derivedType_; }
	DescriptorAddendum &set_derivedType(const typeInfo::DerivedType *dt) {			DescriptorAddendum &set_derivedType(const typeInfo::DerivedType *dt) {
	derivedType_ = dt;			derivedType_ = dt;
	return *this;			return *this;
	}			}
	std::uint64_t &flags() { return flags_; }
	const std::uint64_t &flags() const { return flags_; }

	std::size_t LenParameters() const;			std::size_t LenParameters() const;

	typeInfo::TypeParameterValue LenParameterValue(int which) const {			typeInfo::TypeParameterValue LenParameterValue(int which) const {
	return len_[which];			return len_[which];
	}			}
	static constexpr std::size_t SizeInBytes(int lenParameters) {			static constexpr std::size_t SizeInBytes(int lenParameters) {
	// TODO: Don't waste that last word if lenParameters == 0			// TODO: Don't waste that last word if lenParameters == 0
	return sizeof(DescriptorAddendum) +			return sizeof(DescriptorAddendum) +
	std::max(lenParameters - 1, 0) * sizeof(typeInfo::TypeParameterValue);			std::max(lenParameters - 1, 0) * sizeof(typeInfo::TypeParameterValue);
	}			}
	std::size_t SizeInBytes() const;			std::size_t SizeInBytes() const;

	void SetLenParameterValue(int which, typeInfo::TypeParameterValue x) {			void SetLenParameterValue(int which, typeInfo::TypeParameterValue x) {
	len_[which] = x;			len_[which] = x;
	}			}

	void Dump(FILE * = stdout) const;			void Dump(FILE * = stdout) const;

	private:			private:
	const typeInfo::DerivedType *derivedType_;			const typeInfo::DerivedType *derivedType_;
	std::uint64_t flags_{0};
	typeInfo::TypeParameterValue len_[1]; // must be the last component			typeInfo::TypeParameterValue len_[1]; // must be the last component
	// The LEN type parameter values can also include captured values of			// The LEN type parameter values can also include captured values of
	// specification expressions that were used for bounds and for LEN type			// specification expressions that were used for bounds and for LEN type
	// parameters of components. The values have been truncated to the LEN			// parameters of components. The values have been truncated to the LEN
	// type parameter's type, if shorter than 64 bits, then sign-extended.			// type parameter's type, if shorter than 64 bits, then sign-extended.
	};			};

	// A C++ view of a standard descriptor object.			// A C++ view of a standard descriptor object.
	class Descriptor {			class Descriptor {
	public:			public:
	// Be advised: this class type is not suitable for use when allocating			// Be advised: this class type is not suitable for use when allocating
	// a descriptor -- it is a dynamic view of the common descriptor format.			// a descriptor -- it is a dynamic view of the common descriptor format.
	// If used in a simple declaration of a local variable or dynamic allocation,			// If used in a simple declaration of a local variable or dynamic allocation,
	// the size is going to be correct only by accident, since the true size of			// the size is going to be correct only by accident, since the true size of
	// a descriptor depends on the number of its dimensions and the presence and			// a descriptor depends on the number of its dimensions and the presence and
	// size of an addendum, which depends on the type of the data.			// size of an addendum, which depends on the type of the data.
	// Use the class template StaticDescriptor (below) to declare a descriptor			// Use the class template StaticDescriptor (below) to declare a descriptor
	// whose type and rank are fixed and known at compilation time. Use the			// whose type and rank are fixed and known at compilation time. Use the
	// Create() static member functions otherwise to dynamically allocate a			// Create() static member functions otherwise to dynamically allocate a
	// descriptor.			// descriptor.

	Descriptor() {
	// Minimal initialization to prevent the destructor from running amuck
	// later if the descriptor is never established.
	raw_.base_addr = nullptr;
	raw_.f18Addendum = false;
	}
	Descriptor(const Descriptor &);			Descriptor(const Descriptor &);
	~Descriptor();			~Descriptor();
	Descriptor &operator=(const Descriptor &);			Descriptor &operator=(const Descriptor &);

	static constexpr std::size_t BytesFor(TypeCategory category, int kind) {			static constexpr std::size_t BytesFor(TypeCategory category, int kind) {
	return category == TypeCategory::Complex ? kind * 2 : kind;			return category == TypeCategory::Complex ? kind * 2 : kind;
	}			}

	▲ Show 20 Lines • Show All 192 Lines • ▼ Show 20 Lines
	class alignas(Descriptor) StaticDescriptor {			class alignas(Descriptor) StaticDescriptor {
	public:			public:
	static constexpr int maxRank{MAX_RANK};			static constexpr int maxRank{MAX_RANK};
	static constexpr int maxLengthTypeParameters{MAX_LEN_PARMS};			static constexpr int maxLengthTypeParameters{MAX_LEN_PARMS};
	static constexpr bool hasAddendum{ADDENDUM \|\| MAX_LEN_PARMS > 0};			static constexpr bool hasAddendum{ADDENDUM \|\| MAX_LEN_PARMS > 0};
	static constexpr std::size_t byteSize{			static constexpr std::size_t byteSize{
	Descriptor::SizeInBytes(maxRank, hasAddendum, maxLengthTypeParameters)};			Descriptor::SizeInBytes(maxRank, hasAddendum, maxLengthTypeParameters)};

	StaticDescriptor() { new (storage_) Descriptor{}; }

	~StaticDescriptor() { descriptor().~Descriptor(); }			~StaticDescriptor() { descriptor().~Descriptor(); }

	Descriptor &descriptor() { return reinterpret_cast<Descriptor >(storage_); }			Descriptor &descriptor() { return reinterpret_cast<Descriptor >(storage_); }
	const Descriptor &descriptor() const {			const Descriptor &descriptor() const {
	return reinterpret_cast<const Descriptor >(storage_);			return reinterpret_cast<const Descriptor >(storage_);
	}			}

	void Check() {			void Check() {
	assert(descriptor().rank() <= maxRank);			assert(descriptor().rank() <= maxRank);
	assert(descriptor().SizeInBytes() <= byteSize);			assert(descriptor().SizeInBytes() <= byteSize);
	if (DescriptorAddendum * addendum{descriptor().Addendum()}) {			if (DescriptorAddendum * addendum{descriptor().Addendum()}) {
	assert(hasAddendum);			assert(hasAddendum);
	assert(addendum->LenParameters() <= maxLengthTypeParameters);			assert(addendum->LenParameters() <= maxLengthTypeParameters);
	} else {			} else {
	assert(!hasAddendum);			assert(!hasAddendum);
	assert(maxLengthTypeParameters == 0);			assert(maxLengthTypeParameters == 0);
	}			}
	descriptor().Check();			descriptor().Check();
	}			}

	private:			private:
	char storage_[byteSize];			char storage_[byteSize]{};
	};			};
	} // namespace Fortran::runtime			} // namespace Fortran::runtime
	#endif // FORTRAN_RUNTIME_DESCRIPTOR_H_			#endif // FORTRAN_RUNTIME_DESCRIPTOR_H_

flang/runtime/descriptor.cpp

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Lines
int Descriptor::Deallocate(bool finalize) {		int Descriptor::Deallocate(bool finalize) {
Destroy(finalize);		Destroy(finalize);
return ISO::CFI_deallocate(&raw_);		return ISO::CFI_deallocate(&raw_);
}		}

void Descriptor::Destroy(bool finalize) const {		void Descriptor::Destroy(bool finalize) const {
if (const DescriptorAddendum * addendum{Addendum()}) {		if (const DescriptorAddendum * addendum{Addendum()}) {
if (const typeInfo::DerivedType * dt{addendum->derivedType()}) {		if (const typeInfo::DerivedType * dt{addendum->derivedType()}) {
if (addendum->flags() & DescriptorAddendum::DoNotFinalize) {
finalize = false;
}
runtime::Destroy(this, finalize, dt);		runtime::Destroy(this, finalize, dt);
}		}
}		}
}		}

bool Descriptor::IncrementSubscripts(		bool Descriptor::IncrementSubscripts(
SubscriptValue subscript, const int permutation) const {		SubscriptValue subscript, const int permutation) const {
for (int j{0}; j < raw_.rank; ++j) {		for (int j{0}; j < raw_.rank; ++j) {
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines	void Descriptor::Dump(FILE *f) const {
if (const DescriptorAddendum * addendum{Addendum()}) {		if (const DescriptorAddendum * addendum{Addendum()}) {
addendum->Dump(f);		addendum->Dump(f);
}		}
}		}

DescriptorAddendum &DescriptorAddendum::operator=(		DescriptorAddendum &DescriptorAddendum::operator=(
const DescriptorAddendum &that) {		const DescriptorAddendum &that) {
derivedType_ = that.derivedType_;		derivedType_ = that.derivedType_;
flags_ = that.flags_;
auto lenParms{that.LenParameters()};		auto lenParms{that.LenParameters()};
for (std::size_t j{0}; j < lenParms; ++j) {		for (std::size_t j{0}; j < lenParms; ++j) {
len_[j] = that.len_[j];		len_[j] = that.len_[j];
}		}
return *this;		return *this;
}		}

std::size_t DescriptorAddendum::SizeInBytes() const {		std::size_t DescriptorAddendum::SizeInBytes() const {
return SizeInBytes(LenParameters());		return SizeInBytes(LenParameters());
}		}

std::size_t DescriptorAddendum::LenParameters() const {		std::size_t DescriptorAddendum::LenParameters() const {
const auto *type{derivedType()};		const auto *type{derivedType()};
return type ? type->LenParameters() : 0;		return type ? type->LenParameters() : 0;
}		}

void DescriptorAddendum::Dump(FILE *f) const {		void DescriptorAddendum::Dump(FILE *f) const {
std::fprintf(		std::fprintf(
f, " derivedType @ %p\n", reinterpret_cast<const void *>(derivedType_));		f, " derivedType @ %p\n", reinterpret_cast<const void *>(derivedType()));
std::fprintf(f, " flags 0x%jx\n", static_cast<std::intmax_t>(flags_));		std::size_t lenParms{LenParameters()};
// TODO: LEN parameter values		for (std::size_t j{0}; j < lenParms; ++j) {
		std::fprintf(f, " len[%zd] %jd\n", j, static_cast<std::intmax_t>(len_[j]));
		}
}		}
} // namespace Fortran::runtime		} // namespace Fortran::runtime

flang/runtime/misc-intrinsic.cpp

Show All 35 Lines	void RTNAME(TransferSize)(Descriptor &result, const Descriptor &source,
std::size_t elementBytes{mold.ElementBytes()};		std::size_t elementBytes{mold.ElementBytes()};
result.Establish(mold.type(), elementBytes, nullptr, rank, nullptr,		result.Establish(mold.type(), elementBytes, nullptr, rank, nullptr,
CFI_attribute_allocatable, mold.Addendum() != nullptr);		CFI_attribute_allocatable, mold.Addendum() != nullptr);
if (rank > 0) {		if (rank > 0) {
result.GetDimension(0).SetBounds(1, size);		result.GetDimension(0).SetBounds(1, size);
}		}
if (const DescriptorAddendum * addendum{mold.Addendum()}) {		if (const DescriptorAddendum * addendum{mold.Addendum()}) {
result.Addendum() = addendum;		result.Addendum() = addendum;
auto &flags{result.Addendum()->flags()};
flags &= ~DescriptorAddendum::StaticDescriptor;
flags \|= DescriptorAddendum::DoNotFinalize;
}		}
if (int stat{result.Allocate()}) {		if (int stat{result.Allocate()}) {
Terminator{sourceFile, line}.Crash(		Terminator{sourceFile, line}.Crash(
"TRANSFER: could not allocate memory for result; STAT=%d", stat);		"TRANSFER: could not allocate memory for result; STAT=%d", stat);
}		}
char *to{result.OffsetElement<char>()};		char *to{result.OffsetElement<char>()};
std::size_t resultBytes{size * elementBytes};		std::size_t resultBytes{size * elementBytes};
const std::size_t sourceElementBytes{source.ElementBytes()};		const std::size_t sourceElementBytes{source.ElementBytes()};
Show All 18 Lines

flang/runtime/pointer.h

This file was added.

				//===-- runtime/pointer.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 data pointers.

				#ifndef FORTRAN_RUNTIME_POINTER_H_
				#define FORTRAN_RUNTIME_POINTER_H_

				#include "descriptor.h"
				#include "entry-names.h"

				namespace Fortran::runtime {
				extern "C" {

				// Data pointer initialization for NULLIFY(), "p=>NULL()`, & for ALLOCATE().

				// Initializes a pointer to a disassociated state for NULLIFY() or "p=>NULL()".
				void RTNAME(PointerNullifyIntrinsic)(
				Descriptor &, TypeCategory, int kind, int rank = 0, int corank = 0);
				void RTNAME(PointerNullifyCharacter)(Descriptor &, SubscriptValue length = 0,
				int kind = 1, int rank = 0, int corank = 0);
				void RTNAME(PointerNullifyDerived)(
				Descriptor &, const typeInfo::DerivedType &, int rank = 0, int corank = 0);

				// Explicitly sets the bounds of an initialized disassociated pointer.
				// The upper cobound is ignored for the last codimension.
				void RTNAME(PointerSetBounds)(
				Descriptor &, int zeroBasedDim, SubscriptValue lower, SubscriptValue upper);
				void RTNAME(PointerSetCoBounds)(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(PointerSetDerivedLength)(Descriptor &, int which, SubscriptValue);

				// For MOLD= allocation: acquires information from another descriptor
				// to initialize a null data pointer.
				void RTNAME(PointerApplyMold)(Descriptor &, const Descriptor &mold);

				// Data pointer association for "p=>TARGET"

				// Associates a scalar pointer with a simple scalar target.
				void RTNAME(PointerAssociateScalar)(Descriptor &, void *);

				// Associates a pointer with a target of the same rank, possibly with new lower
				// bounds, which are passed in a vector whose length must equal the rank.
				void RTNAME(PointerAssociate)(Descriptor &, const Descriptor &target);
				void RTNAME(PointerAssociateLowerBounds)(
				Descriptor &, const Descriptor &target, const Descriptor &lowerBounds);

				// Associates a pointer with a target with bounds remapping. The target must be
				// simply contiguous &/or of rank 1. The bounds constitute a [2,newRank]
				// integer array whose columns are [lower bound, upper bound] on each dimension.
				void RTNAME(PointerAssociateRemapping)(Descriptor &, const Descriptor &target,
				const Descriptor &bounds, const char *sourceFile = nullptr,
				int sourceLine = 0);

				// Data pointer allocation and deallocation

				// When an explicit type-spec appears in an ALLOCATE statement for an
				// pointer 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(PointerCheckLengthParameter)(Descriptor &,
				int which /* 0 for CHARACTER length */, SubscriptValue other,
				bool hasStat = false, const Descriptor *errMsg = nullptr,
				const char *sourceFile = nullptr, int sourceLine = 0);

				// Allocates a data pointer. Its descriptor must have been initialized
				// and its bounds and length type parameters set. It need not be disassociated.
				// 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 pointer has a
				// derived type, and is always initialized by PointerAllocateSource().
				// Performs all necessary coarray synchronization and validation actions.
				int RTNAME(PointerAllocate)(Descriptor &, bool hasStat = false,
				const Descriptor errMsg = nullptr, const char sourceFile = nullptr,
				int sourceLine = 0);
				int RTNAME(PointerAllocateSource)(Descriptor &, const Descriptor &source,
				bool hasStat = false, const Descriptor *errMsg = nullptr,
				const char *sourceFile = nullptr, int sourceLine = 0);

				// Deallocates a data pointer, which must have been allocated by
				// PointerAllocate(), possibly copied with PointerAssociate().
				// Finalizes elements &/or components as needed. The pointer is left
				// in an initialized disassociated state suitable for reallocation
				// with the same bounds, cobounds, and length type parameters.
				int RTNAME(PointerDeallocate)(Descriptor &, bool hasStat = false,
				const Descriptor errMsg = nullptr, const char sourceFile = nullptr,
				int sourceLine = 0);

				// Association inquiries for ASSOCIATED()

				// True when the pointer is not disassociated.
				bool RTNAME(PointerIsAssociated)(const Descriptor &);

				// True when the pointer is associated with a specific target.
				bool RTNAME(PointerIsAssociatedWith)(
				const Descriptor &, const Descriptor &target);

				} // extern "C"
				} // namespace Fortran::runtime
				#endif // FORTRAN_RUNTIME_POINTER_H_

flang/runtime/pointer.cpp

This file was added.

				//===-- runtime/pointer.cpp -----------------------------------------------===//
				//
				// 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
				//
				//===----------------------------------------------------------------------===//

				#include "pointer.h"
				#include "stat.h"
				#include "terminator.h"
				#include "tools.h"

				namespace Fortran::runtime {
				extern "C" {

				void RTNAME(PointerNullifyIntrinsic)(Descriptor &pointer, TypeCategory category,
				int kind, int rank, int corank) {
				INTERNAL_CHECK(corank == 0);
				pointer.Establish(TypeCode{category, kind},
				Descriptor::BytesFor(category, kind), nullptr, rank, nullptr,
				CFI_attribute_pointer);
				}

				void RTNAME(PointerNullifyCharacter)(Descriptor &pointer, SubscriptValue length,
				int kind, int rank, int corank) {
				INTERNAL_CHECK(corank == 0);
				pointer.Establish(
				kind, length, nullptr, rank, nullptr, CFI_attribute_pointer);
				}

				void RTNAME(PointerNullifyDerived)(Descriptor &pointer,
				const typeInfo::DerivedType &derivedType, int rank, int corank) {
				INTERNAL_CHECK(corank == 0);
				pointer.Establish(derivedType, nullptr, rank, nullptr, CFI_attribute_pointer);
				}

				void RTNAME(PointerSetBounds)(Descriptor &pointer, int zeroBasedDim,
				SubscriptValue lower, SubscriptValue upper) {
				INTERNAL_CHECK(zeroBasedDim >= 0 && zeroBasedDim < pointer.rank());
				pointer.GetDimension(zeroBasedDim).SetBounds(lower, upper);
				// The byte strides are computed when the pointer is allocated.
				}

				// TODO: PointerSetCoBounds

				void RTNAME(PointerSetDerivedLength)(
				Descriptor &pointer, int which, SubscriptValue x) {
				DescriptorAddendum *addendum{pointer.Addendum()};
				INTERNAL_CHECK(addendum != nullptr);
				addendum->SetLenParameterValue(which, x);
				}

				void RTNAME(PointerApplyMold)(Descriptor &pointer, const Descriptor &mold) {
				pointer = mold;
				pointer.set_base_addr(nullptr);
				pointer.raw().attribute = CFI_attribute_pointer;
				}

				void RTNAME(PointerAssociateScalar)(Descriptor &pointer, void *target) {
				pointer.set_base_addr(target);
				}

				void RTNAME(PointerAssociate)(Descriptor &pointer, const Descriptor &target) {
				pointer = target;
				pointer.raw().attribute = CFI_attribute_pointer;
				}

				void RTNAME(PointerAssociateLowerBounds)(Descriptor &pointer,
				const Descriptor &target, const Descriptor &lowerBounds) {
				pointer = target;
				pointer.raw().attribute = CFI_attribute_pointer;
				int rank{pointer.rank()};
				Terminator terminator{__FILE__, __LINE__};
				std::size_t boundElementBytes{lowerBounds.ElementBytes()};
				for (int j{0}; j < rank; ++j) {
				pointer.GetDimension(j).SetLowerBound(
				GetInt64(lowerBounds.ZeroBasedIndexedElement<const char>(j),
				boundElementBytes, terminator));
				}
				}

				void RTNAME(PointerAssociateRemapping)(Descriptor &pointer,
				const Descriptor &target, const Descriptor &bounds, const char *sourceFile,
				int sourceLine) {
				pointer = target;
				pointer.raw().attribute = CFI_attribute_pointer;
				int rank{pointer.rank()};
				Terminator terminator{sourceFile, sourceLine};
				SubscriptValue byteStride{/captured from first dimension/};
				std::size_t boundElementBytes{bounds.ElementBytes()};
				for (int j{0}; j < rank; ++j) {
				auto &dim{pointer.GetDimension(j)};
				dim.SetBounds(GetInt64(bounds.ZeroBasedIndexedElement<const char>(2 * j),
				boundElementBytes, terminator),
				GetInt64(bounds.ZeroBasedIndexedElement<const char>(2 * j + 1),
				boundElementBytes, terminator));
				if (j == 0) {
				byteStride = dim.ByteStride();
				} else {
				dim.SetByteStride(byteStride);
				byteStride *= dim.Extent();
				}
				}
				if (pointer.Elements() > target.Elements()) {
				terminator.Crash("PointerAssociateRemapping: too many elements in remapped "
				"pointer (%zd > %zd)",
				pointer.Elements(), target.Elements());
				}
				}

				int RTNAME(PointerAllocate)(Descriptor &pointer, bool hasStat,
				const Descriptor errMsg, const char sourceFile, int sourceLine) {
				Terminator terminator{sourceFile, sourceLine};
				if (!pointer.IsPointer()) {
				return ReturnError(terminator, StatInvalidDescriptor, errMsg, hasStat);
				}
				return ReturnError(terminator, pointer.Allocate(), errMsg, hasStat);
				// TODO: default component initialization
				}

				int RTNAME(PointerDeallocate)(Descriptor &pointer, bool hasStat,
				const Descriptor errMsg, const char sourceFile, int sourceLine) {
				Terminator terminator{sourceFile, sourceLine};
				if (!pointer.IsPointer()) {
				return ReturnError(terminator, StatInvalidDescriptor, errMsg, hasStat);
				}
				if (!pointer.IsAllocated()) {
				return ReturnError(terminator, StatBaseNull, errMsg, hasStat);
				}
				return ReturnError(terminator, pointer.Deallocate(), errMsg, hasStat);
				}

				bool RTNAME(PointerIsAssociated)(const Descriptor &pointer) {
				return pointer.raw().base_addr != nullptr;
				}

				bool RTNAME(PointerIsAssociatedWith)(
				const Descriptor &pointer, const Descriptor &target) {
				int rank{pointer.rank()};
				if (pointer.raw().base_addr != target.raw().base_addr \|\|
				pointer.ElementBytes() != target.ElementBytes() \|\|
				rank != target.rank()) {
				return false;
				}
				for (int j{0}; j < rank; ++j) {
				const Dimension &pDim{pointer.GetDimension(j)};
				const Dimension &tDim{target.GetDimension(j)};
				if (pDim.Extent() != tDim.Extent() \|\|
				pDim.ByteStride() != tDim.ByteStride()) {
				return false;
				}
				}
				return true;
				}

				// TODO: PointerCheckLengthParameter, PointerAllocateSource

				} // extern "C"
				} // namespace Fortran::runtime

flang/test/Semantics/offsets01.f90

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	type :: t1(l)
integer, len :: l		integer, len :: l
real :: a(l)		real :: a(l)
end type		end type
type :: t2(l1, l2)		type :: t2(l1, l2)
integer, len :: l1		integer, len :: l1
integer, len :: l2		integer, len :: l2
real :: b(l1, l2)		real :: b(l1, l2)
end type		end type
type(t1(n)) :: x1 !CHECK: x1 size=48 offset=		type(t1(n)) :: x1 !CHECK: x1 size=40 offset=
type(t2(n,n)) :: x2 !CHECK: x2 size=56 offset=		type(t2(n,n)) :: x2 !CHECK: x2 size=48 offset=
!CHECK: a size=48 offset=0:		!CHECK: a size=48 offset=0:
!CHECK: b size=72 offset=0:		!CHECK: b size=72 offset=0:
end		end