[flang] Compute sizes and offsets for symbols

[tskeith]

Summary

Add size and offset properties to symbols, representing their byte size
and offset within their enclosing scope.

Add size and align properties to scopes so that they are available for
scopes representing derived types.

Add ComputeOffsets pass over the symbol table to fill in those fields.

Compute descriptor size based on rank and length parameters. Extract
DerivedTypeSpec::NumLengthParameters from DynamicType::RequiresDescriptor
to share the code.

Add Scope::GetSymbols to get symbols in canonical order.
compute-offsets.cpp and mod-file.cpp both need to process symbols in the
order in which they are declared. Move the collecting of those symbols
into Scope so that it can be shared.

Add symbol size and offset to output of -fdebug-dump-symbols and use
that in some tests.

Still to do:

• make size and alignment rules configurable based on target
• use offsets to check EQUIVALENCE statements

[sscalpone]

flang/lib/Semantics/compute-offsets.cpp

77

Please say why the sort must be the same. Is there a way to assert that sizing and alignment match the mod file?

115

SizeInBytes needs to be aware of target size and alignment.

[tskeith]

Add Scope::GetSymbols to get symbols in canonical order

compute-offsets.cpp and mod-file.cpp both need to process symbols in the
order in which they are declared. Move the collecting of those symbols
into Scope so that it can be shared.

[tskeith]

[flang] Compute sizes and offsets for symbols

Add size and offset properties to symbols, representing their byte size
and offset within their enclosing scope.

Add size and align properties to scopes so that they are available for
scopes representing derived types.

Add ComputeOffsets pass over the symbol table to fill in those fields.

Compute descriptor size based on rank and length parameters. Extract
DerivedTypeSpec::NumLengthParameters from DynamicType::RequiresDescriptor
to share the code.

Add symbol size and offset to output of -fdebug-dump-symbols and use
that in some tests.

Still to do:

make size and alignment rules configurable based on target
use offsets to check EQUIVALENCE statements

[tskeith]

Add Scope::GetSymbols to get symbols in canonical order.
compute-offsets.cpp and mod-file.cpp both need to process symbols in the
order in which they are declared. Move the collecting of those symbols
into Scope so that it can be shared.

[tskeith]

flang/lib/Semantics/compute-offsets.cpp

77

I've changed it so that both places get the symbol list the same way, so it's guaranteed to be in the same order.

I suppose that a test we could do is compile the .mod file and verify we get the same sizes and offsets as when compiling the original file.

flang/include/flang/Semantics/scope.h

public:
 
   iterator begin() { return symbols_.begin(); }
   iterator end() { return symbols_.end(); }
   const_iterator begin() const { return symbols_.begin(); }
   const_iterator end() const { return symbols_.end(); }
   const_iterator cbegin() const { return symbols_.cbegin(); }
   const_iterator cend() const { return symbols_.cend(); }
 
+  // Return symbols in declaration order (the iterators above are in name order)
+  SymbolVector GetSymbols() const;
+  std::vector<common::Reference<Symbol>> GetSymbols();
+
   iterator find(const SourceName &name);
   const_iterator find(const SourceName &name) const {
     return symbols_.find(name);
   }
   size_type erase(const SourceName &);
-  size_type size() const { return symbols_.size(); }
   bool empty() const { return symbols_.empty(); }
 
   // Look for symbol by name in this scope and host (depending on imports).
   Symbol *FindSymbol(const SourceName &) const;
 
   // Look for component symbol by name in a derived type's scope and
   // parents'.
   Symbol *FindComponent(SourceName) const;
public:
   DeclTypeSpec &MakeDerivedType(DeclTypeSpec::Category, DerivedTypeSpec &&);
   const DeclTypeSpec &MakeTypeStarType();
   const DeclTypeSpec &MakeClassStarType();
 
   // For modules read from module files, this is the stream of characters
   // that are referenced by SourceName objects.
   void set_chars(parser::CookedSource &);
 
+  std::size_t size() const { return size_; }
+  void set_size(std::size_t size) { size_ = size; }
+  std::size_t align() const { return align_; }
+  void set_align(std::size_t align) { align_ = align; }
+
   ImportKind GetImportKind() const;
   // Names appearing in IMPORT statements in this scope
   std::set<SourceName> importNames() const { return importNames_; }
 
   // Set the kind of imports from host into this scope.
   // Return an error message for incompatible kinds.
   std::optional<parser::MessageFixedText> SetImportKind(ImportKind);
 
return kind_ == Kind::Module && symbol_ &&
         symbol_->test(Symbol::Flag::ModFile);
   }
 
   void InstantiateDerivedTypes(SemanticsContext &);
 
 private:
   Scope &parent_; // this is enclosing scope, not extended derived type base
   const Kind kind_;
+  std::size_t size_{0}; // size in bytes
+  std::size_t align_{0}; // required alignment in bytes
   parser::CharBlock sourceRange_;
   Symbol *const symbol_; // if not null, symbol_->scope() == this
   std::list<Scope> children_;
   mapType symbols_;
   mapType commonBlocks_;
   std::list<EquivalenceSet> equivalenceSets_;
   mapType crayPointers_;
   std::map<SourceName, common::Reference<Scope>> submodules_;

flang/include/flang/Semantics/symbol.h

public:
   Flags &flags() { return flags_; }
   const Flags &flags() const { return flags_; }
   bool test(Flag flag) const { return flags_.test(flag); }
   void set(Flag flag, bool value = true) { flags_.set(flag, value); }
   // The Scope introduced by this symbol, if any.
   Scope *scope() { return scope_; }
   const Scope *scope() const { return scope_; }
   void set_scope(Scope *scope) { scope_ = scope; }
+  std::size_t size() const { return size_; }
+  void set_size(std::size_t size) { size_ = size; }
+  std::size_t offset() const { return offset_; }
+  void set_offset(std::size_t offset) { offset_ = offset; }
   // Give the symbol a name with a different source location but same chars.
   void ReplaceName(const SourceName &);
 
   // Does symbol have this type of details?
   template <typename D> bool has() const {
     return std::holds_alternative<D>(details_);
   }
 
public:
   const DerivedTypeSpec *GetParentTypeSpec(const Scope * = nullptr) const;
 
 private:
   const Scope *owner_;
   SourceName name_;
   Attrs attrs_;
   Flags flags_;
   Scope *scope_{nullptr};
+  std::size_t size_{0}; // size in bytes
+  std::size_t offset_{0}; // byte offset in enclosing scope
   Details details_;
 
   Symbol() {} // only created in class Symbols
   const std::string GetDetailsName() const;
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Symbol &);
   friend llvm::raw_ostream &DumpForUnparse(
       llvm::raw_ostream &, const Symbol &, bool);
 

 inline bool ProcEntityDetails::HasExplicitInterface() const {
   if (auto *symbol{interface_.symbol()}) {
     return symbol->HasExplicitInterface();
   }
   return false;
 }
 
 inline bool operator<(SymbolRef x, SymbolRef y) { return *x < *y; }
+inline bool operator<(
+    common::Reference<Symbol> x, common::Reference<Symbol> y) {
+  return *x < *y;
+}
 using SymbolSet = std::set<SymbolRef>;
 
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_SYMBOL_H_

flang/include/flang/Semantics/type.h

public:
 
   const SourceName &name() const { return name_; }
   const Symbol &typeSymbol() const { return typeSymbol_; }
   const Scope *scope() const { return scope_; }
   void set_scope(const Scope &);
   void ReplaceScope(const Scope &);
   RawParameters &rawParameters() { return rawParameters_; }
   const ParameterMapType &parameters() const { return parameters_; }
+  int NumLengthParameters() const;
 
   bool MightBeParameterized() const;
   bool IsForwardReferenced() const;
   bool HasDefaultInitialization() const;
 
   // The "raw" type parameter list is a simple transcription from the
   // parameter list in the parse tree, built by calling AddRawParamValue().
   // It can be used with forward-referenced derived types.

flang/lib/Evaluate/type.cpp

case TypeCategory::Logical:
     break;
   default:
     CRASH_NO_CASE;
   }
   return *this;
 }
 
 bool DynamicType::RequiresDescriptor() const {
-  if (IsPolymorphic() || IsUnknownLengthCharacter()) {
-    return true;
-  }
-  if (derived_) {
-    // Any length type parameter?
-    if (const auto *scope{derived_->scope()}) {
-      if (const auto *symbol{scope->symbol()}) {
-        if (const auto *details{
-                symbol->detailsIf<semantics::DerivedTypeDetails>()}) {
-          for (const Symbol &param : details->paramDecls()) {
-            if (const auto *details{
-                    param.detailsIf<semantics::TypeParamDetails>()}) {
-              if (details->attr() == common::TypeParamAttr::Len) {
-                return true;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  return false;
+  return IsPolymorphic() || IsUnknownLengthCharacter() ||
+      (derived_ && derived_->NumLengthParameters() > 0);
 }
 
 bool DynamicType::HasDeferredTypeParameter() const {
   if (derived_) {
     for (const auto &pair : derived_->parameters()) {
       if (pair.second.isDeferred()) {
         return true;
       }

flang/lib/Semantics/CMakeLists.txt

add_flang_library(FortranSemantics
   check-if-stmt.cpp
   check-io.cpp
   check-namelist.cpp
   check-nullify.cpp
   check-omp-structure.cpp
   check-purity.cpp
   check-return.cpp
   check-stop.cpp
+  compute-offsets.cpp
   expression.cpp
   mod-file.cpp
   pointer-assignment.cpp
   program-tree.cpp
   resolve-labels.cpp
   resolve-names.cpp
   resolve-names-utils.cpp
   rewrite-parse-tree.cpp

flang/lib/Semantics/compute-offsets.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_SEMANTICS_COMPUTE_OFFSETS_H_
+#define FORTRAN_SEMANTICS_COMPUTE_OFFSETS_H_
+namespace Fortran::semantics {
+
+class SemanticsContext;
+void ComputeOffsets(SemanticsContext &);
+
+} // namespace Fortran::semantics
+#endif

flang/lib/Semantics/compute-offsets.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 "compute-offsets.h"
+#include "../../runtime/descriptor.h"
+#include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/shape.h"
+#include "flang/Evaluate/type.h"
+#include "flang/Semantics/scope.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/symbol.h"
+#include "flang/Semantics/tools.h"
+#include "flang/Semantics/type.h"
+#include <algorithm>
+#include <vector>
+
+namespace Fortran::semantics {
+
+class ComputeOffsetsHelper {
+public:
+  // TODO: configure based on target
+  static constexpr int descriptorSize{3 * 8};
+  static constexpr int maxAlignment{8};
+
+  ComputeOffsetsHelper(SemanticsContext &context) : context_{context} {}
+  void Compute() { Compute(context_.globalScope()); }
+
+private:
+  struct SizeAndAlign {
+    SizeAndAlign() {}
+    SizeAndAlign(std::size_t size) : size{size}, align{size} {}
+    SizeAndAlign(std::size_t size, std::size_t align)
+        : size{size}, align{align} {}
+    std::size_t size{0};
+    std::size_t align{0};
+  };
+
+  void Compute(Scope &);
+  void DoScope(Scope &);
+  void DoSymbol(Symbol &);
+  SizeAndAlign GetSizeAndAlign(const Symbol &);
+  std::size_t CountElements(const Symbol &);
+  static std::size_t Align(std::size_t, std::size_t);
+  static SizeAndAlign GetIntrinsicSizeAndAlign(TypeCategory, int);
+
+  SemanticsContext &context_;
+  evaluate::FoldingContext &foldingContext_{context_.foldingContext()};
+  std::size_t offset_{0};
+  std::size_t align_{0};
+};
+
+void ComputeOffsetsHelper::Compute(Scope &scope) {
+  for (Scope &child : scope.children()) {
+    Compute(child);
+  }
+  DoScope(scope);
+}
+
+void ComputeOffsetsHelper::DoScope(Scope &scope) {
+  if (scope.symbol() && scope.IsParameterizedDerivedType()) {
+    return; // only process instantiations of parameterized derived types
+  }
+  offset_ = 0;
+  align_ = 0;
+  for (auto symbol : scope.GetSymbols()) {
+    if (!symbol->has<TypeParamDetails>() && !symbol->has<SubprogramDetails>()) {
+      DoSymbol(*symbol);
+    }
+  }
+  scope.set_size(offset_);
+  scope.set_align(align_);
+}
+
+void ComputeOffsetsHelper::DoSymbol(Symbol &symbol) {
+  SizeAndAlign s{GetSizeAndAlign(symbol)};
+  if (s.size == 0) {
+    return;
+  }
+  offset_ = Align(offset_, s.align);
+  symbol.set_size(s.size);
+  symbol.set_offset(offset_);
+  offset_ += s.size;
+  if (s.align > align_) {
+    align_ = s.align;
+  }
+}
+
+auto ComputeOffsetsHelper::GetSizeAndAlign(const Symbol &symbol)
+    -> SizeAndAlign {
+  const DeclTypeSpec *type{symbol.GetType()};
+  if (!type) {
+    return {};
+  }
+  if (IsDescriptor(symbol) || IsProcedure(symbol)) {
+    int lenParams{0};
+    if (const DerivedTypeSpec * derived{type->AsDerived()}) {
+      lenParams = derived->NumLengthParameters();
+    }
+    std::size_t size{
+        runtime::Descriptor::SizeInBytes(symbol.Rank(), false, lenParams)};
+    return {size, maxAlignment};
+  }
+  SizeAndAlign result;
+  if (const IntrinsicTypeSpec * intrinsic{type->AsIntrinsic()}) {
+    if (auto kind{ToInt64(intrinsic->kind())}) {
+      result = GetIntrinsicSizeAndAlign(intrinsic->category(), *kind);
+    }
+    if (type->category() == DeclTypeSpec::Character) {
+      ParamValue length{type->characterTypeSpec().length()};
+      CHECK(length.isExplicit()); // else should be descriptor
+      if (MaybeIntExpr lengthExpr{length.GetExplicit()}) {
+        if (auto lengthInt{ToInt64(*lengthExpr)}) {
+          result.size *= *lengthInt;
+        }
+      }
+    }
+  } else if (const DerivedTypeSpec * derived{type->AsDerived()}) {
+    if (derived->scope()) {
+      result.size = derived->scope()->size();
+      result.align = derived->scope()->align();
+    }
+  } else {
+    DIE("not intrinsic or derived");
+  }
+  std::size_t elements{CountElements(symbol)};
+  if (elements > 1) {
+    result.size = Align(result.size, result.align);
+  }
+  result.size *= elements;
+  return result;
+}
+
+std::size_t ComputeOffsetsHelper::CountElements(const Symbol &symbol) {
+  if (auto shape{GetShape(foldingContext_, symbol)}) {
+    if (auto sizeExpr{evaluate::GetSize(std::move(*shape))}) {
+      if (auto size{ToInt64(Fold(foldingContext_, std::move(*sizeExpr)))}) {
+        return *size;
+      }
+    }
+  }
+  return 1;
+}
+
+// Align a size to its natural alignment, up to maxAlignment.
+std::size_t ComputeOffsetsHelper::Align(std::size_t x, std::size_t alignment) {
+  if (alignment > maxAlignment) {
+    alignment = maxAlignment;
+  }
+  return (x + alignment - 1) & -alignment;
+}
+
+auto ComputeOffsetsHelper::GetIntrinsicSizeAndAlign(
+    TypeCategory category, int kind) -> SizeAndAlign {
+  // TODO: does kind==10 need special handling?
+  std::size_t size{kind == 3 ? 2 : static_cast<std::size_t>(kind)};
+  if (category == TypeCategory::Complex) {
+    return {2 * size, size};
+  } else {
+    return {size};
+  }
+}
+
+void ComputeOffsets(SemanticsContext &context) {
+  ComputeOffsetsHelper{context}.Compute();
+}
+
+} // namespace Fortran::semantics

flang/lib/Semantics/mod-file.cpp

if (local.attrs().test(attr) && !use.attrs().test(attr)) {
     PutAttr(useExtraAttrs_, attr) << "::";
     useExtraAttrs_ << local.name() << '\n';
   }
 }
 
 // Collect the symbols of this scope sorted by their original order, not name.
 // Namelists are an exception: they are sorted after other symbols.
 SymbolVector CollectSymbols(const Scope &scope) {
-  SymbolSet symbols; // to prevent duplicates
   SymbolVector sorted;
   SymbolVector namelist;
-  SymbolVector common;
-  sorted.reserve(scope.size() + scope.commonBlocks().size());
-  for (const auto &pair : scope) {
-    const Symbol &symbol{*pair.second};
-    if (!symbol.test(Symbol::Flag::ParentComp)) {
-      if (symbols.insert(symbol).second) {
-        if (symbol.has<NamelistDetails>()) {
-          namelist.push_back(symbol);
-        } else {
-          sorted.push_back(symbol);
-        }
-      }
-    }
-  }
+  std::size_t commonSize{scope.commonBlocks().size()};
+  auto symbols{scope.GetSymbols()};
+  sorted.reserve(symbols.size() + commonSize);
+  for (SymbolRef symbol : symbols) {
+    if (!symbol->test(Symbol::Flag::ParentComp)) {
+      if (symbol->has<NamelistDetails>()) {
+  sorted.insert(sorted.end(), namelist.begin(), namelist.end());
   for (const auto &pair : scope.commonBlocks()) {
-    const Symbol &symbol{*pair.second};
-    if (symbols.insert(symbol).second) {
-      common.push_back(symbol);
-    }
+    sorted.push_back(*pair.second);
   }
-  // sort normal symbols, then namelists, then common blocks:
-  auto cursor{sorted.begin()};
-  std::sort(cursor, sorted.end());
-  cursor = sorted.insert(sorted.end(), namelist.begin(), namelist.end());
-  std::sort(cursor, sorted.end());
-  cursor = sorted.insert(sorted.end(), common.begin(), common.end());
-  std::sort(cursor, sorted.end());
+  std::sort(sorted.end() - commonSize, sorted.end());
   return sorted;
 }
 
 void PutEntity(llvm::raw_ostream &os, const Symbol &symbol) {
   std::visit(
       common::visitors{
           [&](const ObjectEntityDetails &) { PutObjectEntity(os, symbol); },
           [&](const ProcEntityDetails &) { PutProcEntity(os, symbol); },

flang/lib/Semantics/scope.cpp

 bool Scope::IsSubmodule() const {
   return kind_ == Kind::Module && symbol_->get<ModuleDetails>().isSubmodule();
 }
 
 Scope &Scope::MakeScope(Kind kind, Symbol *symbol) {
   return children_.emplace_back(*this, kind, symbol);
 }
 
+template <typename T>
+static std::vector<common::Reference<T>> GetSortedSymbols(
+    std::map<SourceName, common::Reference<Symbol>> symbols) {
+  std::vector<common::Reference<T>> result;
+  result.reserve(symbols.size());
+  for (auto &pair : symbols) {
+    result.push_back(*pair.second);
+  }
+  std::sort(result.begin(), result.end());
+  return result;
+}
+
+std::vector<common::Reference<Symbol>> Scope::GetSymbols() {
+  return GetSortedSymbols<Symbol>(symbols_);
+}
+SymbolVector Scope::GetSymbols() const {
+  return GetSortedSymbols<const Symbol>(symbols_);
+}
+
 Scope::iterator Scope::find(const SourceName &name) {
   return symbols_.find(name);
 }
 Scope::size_type Scope::erase(const SourceName &name) {
   auto it{symbols_.find(name)};
   if (it != end()) {
     symbols_.erase(it);
     return 1;
void Scope::AddSourceRange(const parser::CharBlock &source) {
   }
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Scope &scope) {
   os << Scope::EnumToString(scope.kind()) << " scope: ";
   if (auto *symbol{scope.symbol()}) {
     os << *symbol << ' ';
   }
+  if (scope.derivedTypeSpec_) {
+    os << "instantiation of " << *scope.derivedTypeSpec_ << ' ';
+  }
   os << scope.children_.size() << " children\n";
   for (const auto &pair : scope.symbols_) {
     const Symbol &symbol{*pair.second};
     os << "  " << symbol << '\n';
   }
   if (!scope.equivalenceSets_.empty()) {
     os << "  Equivalence Sets:\n";
     for (const auto &set : scope.equivalenceSets_) {

flang/lib/Semantics/semantics.cpp

 #include "check-if-stmt.h"
 #include "check-io.h"
 #include "check-namelist.h"
 #include "check-nullify.h"
 #include "check-omp-structure.h"
 #include "check-purity.h"
 #include "check-return.h"
 #include "check-stop.h"
+#include "compute-offsets.h"
 #include "mod-file.h"
 #include "resolve-labels.h"
 #include "resolve-names.h"
 #include "rewrite-parse-tree.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/tools.h"
 #include "flang/Semantics/expression.h"
using StatementSemanticsPass2 = SemanticsVisitor<AllocateChecker,
     DataChecker, DeallocateChecker, DoForallChecker, IfStmtChecker, IoChecker,
     MiscChecker, NamelistChecker, NullifyChecker, OmpStructureChecker,
     PurityChecker, ReturnStmtChecker, StopChecker>;
 
 static bool PerformStatementSemantics(
     SemanticsContext &context, parser::Program &program) {
   ResolveNames(context, program);
   RewriteParseTree(context, program);
+  ComputeOffsets(context);
   CheckDeclarations(context);
   StatementSemanticsPass1{context}.Walk(program);
   StatementSemanticsPass2{context}.Walk(program);
   return !context.AnyFatalError();
 }
 
 SemanticsContext::SemanticsContext(
     const common::IntrinsicTypeDefaultKinds &defaultKinds,

 }
 
 void DoDumpSymbols(llvm::raw_ostream &os, const Scope &scope, int indent) {
   PutIndent(os, indent);
   os << Scope::EnumToString(scope.kind()) << " scope:";
   if (const auto *symbol{scope.symbol()}) {
     os << ' ' << symbol->name();
   }
+  if (scope.size()) {
+    os << " size=" << scope.size() << " align=" << scope.align();
+  }
+  if (scope.derivedTypeSpec()) {
+    os << " instantiation of " << *scope.derivedTypeSpec();
+  }
   os << '\n';
   ++indent;
   for (const auto &pair : scope) {
     const auto &symbol{*pair.second};
     PutIndent(os, indent);
     os << symbol << '\n';
     if (const auto *details{symbol.detailsIf<GenericDetails>()}) {
       if (const auto &type{details->derivedType()}) {

flang/lib/Semantics/symbol.cpp

 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Symbol &symbol) {
   os << symbol.name();
   if (!symbol.attrs().empty()) {
     os << ", " << symbol.attrs();
   }
   if (!symbol.flags().empty()) {
     os << " (" << symbol.flags() << ')';
   }
+  if (symbol.size_) {
+    os << " size=" << symbol.size_ << " offset=" << symbol.offset_;
+  }
   os << ": " << symbol.details_;
   return os;
 }
 
 // Output a unique name for a scope by qualifying it with the names of
 // parent scopes. For scopes without corresponding symbols, use the kind
 // with an index (e.g. Block1, Block2, etc.).
 static void DumpUniqueName(llvm::raw_ostream &os, const Scope &scope) {

flang/lib/Semantics/type.cpp

 }
 
 void DerivedTypeSpec::AddParamValue(SourceName name, ParamValue &&value) {
   CHECK(cooked_);
   auto pair{parameters_.insert(std::make_pair(name, std::move(value)))};
   CHECK(pair.second); // name was not already present
 }
 
+int DerivedTypeSpec::NumLengthParameters() const {
+  int result{0};
+  for (const auto &pair : parameters_) {
+    if (pair.second.isLen()) {
+      ++result;
+    }
+  }
+  return result;
+}
+
 bool DerivedTypeSpec::MightBeParameterized() const {
   return !cooked_ || !parameters_.empty();
 }
 
 bool DerivedTypeSpec::IsForwardReferenced() const {
   return typeSymbol_.get<DerivedTypeDetails>().isForwardReferenced();
 }
 

flang/test/Semantics/offsets01.f90

+!RUN: %f18 -fdebug-dump-symbols -fparse-only %s | FileCheck %s
+
+! Size and alignment of intrinsic types
+subroutine s1
+  integer(1) :: a_i1  !CHECK: a_i1 size=1 offset=0:
+  integer(8) :: b_i8  !CHECK: b_i8 size=8 offset=8:
+  real(2)    :: c_r2  !CHECK: c_r2 size=2 offset=16:
+  real(2)    :: d_r2  !CHECK: d_r2 size=2 offset=18:
+  real(8)    :: e_r8  !CHECK: e_r8 size=8 offset=24:
+  real(4)    :: f_r4  !CHECK: f_r4 size=4 offset=32:
+  complex(8) :: g_c8  !CHECK: g_c8 size=16 offset=40:
+  complex(4) :: h_c4  !CHECK: h_c4 size=8 offset=56:
+  logical    :: i_l4  !CHECK: i_l4 size=4 offset=64:
+end
+
+! Character
+subroutine s2
+  character(10)        :: c1 !CHECK: c1 size=10 offset=0:
+  character(1)         :: c2 !CHECK: c2 size=1 offset=10:
+  character(10,kind=2) :: c3 !CHECK: c3 size=20 offset=12:
+end
+
+! Descriptors
+subroutine s3(n)
+  integer :: n
+  real, pointer :: x !CHECK: x, POINTER size=24 offset=8:
+  character(n)  :: y !CHECK: y size=24 offset=32:
+end
+
+! Descriptors for arrays
+subroutine s4
+  integer, allocatable :: z0        !CHECK: z0, ALLOCATABLE size=24 offset=
+  integer, allocatable :: z1(:)     !CHECK: z1, ALLOCATABLE size=48 offset=
+  integer, allocatable :: z2(:,:)   !CHECK: z2, ALLOCATABLE size=72 offset=
+  integer, allocatable :: z3(:,:,:) !CHECK: z3, ALLOCATABLE size=96 offset=
+end
+
+! Descriptors with length parameters
+subroutine s5(n)
+  integer :: n
+  type :: t1(l)
+    integer, len :: l
+    real :: a(l)
+  end type
+  type :: t2(l1, l2)
+    integer, len :: l1
+    integer, len :: l2
+    real :: b(l1, l2)
+  end type
+  type(t1(n))   :: x1 !CHECK: x1 size=48 offset=
+  type(t2(n,n)) :: x2 !CHECK: x2 size=56 offset=
+end

flang/test/Semantics/offsets02.f90

+!RUN: %f18 -fdebug-dump-symbols -fparse-only %s | FileCheck %s
+
+! Size and alignment of derived types
+
+! Array of derived type with 64-bit alignment
+subroutine s1
+  type t1
+    real(8) :: a
+    real(4) :: b
+  end type
+  !CHECK: x1 size=12 offset=0:
+  !CHECK: y1 size=12 offset=16:
+  type(t1) :: x1, y1
+  !CHECK: z1 size=160 offset=32:
+  type(t1) :: z1(10)
+end
+
+! Like t1 but t2 does not need to be aligned on 64-bit boundary
+subroutine s2
+  type t2
+    real(4) :: a
+    real(4) :: b
+    real(4) :: c
+  end type
+  !CHECK: x2 size=12 offset=0:
+  !CHECK: y2 size=12 offset=12:
+  type(t2) :: x2, y2
+  !CHECK: z2 size=120 offset=24:
+  type(t2) :: z2(10)
+end
+
+! Parameterized derived types
+subroutine s3
+  type :: t(k, l)
+    integer, kind :: k
+    integer, len :: l
+    real(k) :: a3
+    integer(kind=k) :: b3
+    character(kind=k, len=8) :: c3
+    character(kind=k, len=l) :: d3
+  end type
+  !CHECK: DerivedType scope: size=48 align=8 instantiation of t(k=2_4,l=10_4)
+  !CHECK: a3 size=2 offset=0:
+  !CHECK: b3 size=2 offset=2:
+  !CHECK: c3 size=16 offset=4:
+  !CHECK: d3 size=24 offset=24:
+  type(t(2, 10)) :: x3
+  !CHECK: DerivedType scope: size=64 align=8 instantiation of t(k=4_4,l=20_4)
+  !CHECK: a3 size=4 offset=0:
+  !CHECK: b3 size=4 offset=4:
+  !CHECK: c3 size=32 offset=8:
+  !CHECK: d3 size=24 offset=40:
+  type(t(4, 20)) :: x4
+end