[flang] Check & include default component initialization in static initializers

[klausler]

Summary

The combined initializers constructed from DATA statements and explicit
static initialization in declarations needs to include derived type
component default initializations, overriding those default values
without complaint with values from explicit DATA statement or declaration
initializations when they overlap. This also has to work for objects
with storage association due to EQUIVALENCE. When storage association causes
default component initializations to overlap, emit errors if and only
if the values differ (See Fortran 2018 subclause 19.5.3, esp. paragraph
10).

The f18 front-end has a module that analyzes and converts DATA statements
into equivalent static initializers for objects. For storage-associated
objects, compiler-generated objects are created that overlay the entire
association and fill it with a combined initializer. This "data-to-inits"
module already exists, and this patch is essentially extension and
clean-up of its machinery to complete the job.

Also: emit EQUIVALENCE to module files; mark compiler-created symbols
and *don't* emit those to module files; check non-static EQUIVALENCE
sets for conflicting default component initializations, so lowering
doesn't have to check them or emit diagnostics.

flang/include/flang/Evaluate/initial-image.h

public:
   enum Result {
     Ok,
     NotAConstant,
     OutOfRange,
     SizeMismatch,
   };
 
   explicit InitialImage(std::size_t bytes) : data_(bytes) {}
+  InitialImage(InitialImage &&that) = default;
 
   std::size_t size() const { return data_.size(); }
 
   template <typename A>
   Result Add(ConstantSubscript, std::size_t, const A &, FoldingContext &) {
     return NotAConstant;
   }
   template <typename T>
public:
   Result Add(ConstantSubscript offset, std::size_t bytes, const Expr<T> &x,
       FoldingContext &c) {
     return std::visit(
         [&](const auto &y) { return Add(offset, bytes, y, c); }, x.u);
   }
 
   void AddPointer(ConstantSubscript, const Expr<SomeType> &);
 
-  void Incorporate(ConstantSubscript, const InitialImage &);
+  void Incorporate(ConstantSubscript toOffset, const InitialImage &from,
+      ConstantSubscript fromOffset, ConstantSubscript bytes);
 
   // Conversions to constant initializers
   std::optional<Expr<SomeType>> AsConstant(FoldingContext &,
       const DynamicType &, const ConstantSubscripts &,
       ConstantSubscript offset = 0) const;
-  std::optional<Expr<SomeType>> AsConstantDataPointer(
-      const DynamicType &, ConstantSubscript offset = 0) const;
-  const ProcedureDesignator &AsConstantProcPointer(
+  std::optional<Expr<SomeType>> AsConstantPointer(
       ConstantSubscript offset = 0) const;
 
   friend class AsConstantHelper;
-  friend class AsConstantDataPointerHelper;
 
 private:
   std::vector<char> data_;
   std::map<ConstantSubscript, Expr<SomeType>> pointers_;
 };
 
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_INITIAL_IMAGE_H_

flang/include/flang/Semantics/scope.h

 
 // An equivalence object is represented by a symbol for the variable name,
 // the indices for an array element, and the lower bound for a substring.
 struct EquivalenceObject {
   EquivalenceObject(Symbol &symbol, std::vector<ConstantSubscript> subscripts,
       std::optional<ConstantSubscript> substringStart, parser::CharBlock source)
       : symbol{symbol}, subscripts{subscripts},
         substringStart{substringStart}, source{source} {}
+  explicit EquivalenceObject(Symbol &symbol)
+      : symbol{symbol}, source{symbol.name()} {}
 
   bool operator==(const EquivalenceObject &) const;
   bool operator<(const EquivalenceObject &) const;
   std::string AsFortran() const;
 
   Symbol &symbol;
   std::vector<ConstantSubscript> subscripts; // for array elem
   std::optional<ConstantSubscript> substringStart;

flang/include/flang/Semantics/symbol.h

ENUM_CLASS(Flag,
       ModFile, // symbol came from .mod file
       ParentComp, // symbol is the "parent component" of an extended type
       CrayPointer, CrayPointee,
       LocalityLocal, // named in LOCAL locality-spec
       LocalityLocalInit, // named in LOCAL_INIT locality-spec
       LocalityShared, // named in SHARED locality-spec
       InDataStmt, // initialized in a DATA statement
       InNamelist, // flag is set if the symbol is in Namelist statement
+      CompilerCreated,
       // OpenACC data-sharing attribute
       AccPrivate, AccFirstPrivate, AccShared,
       // OpenACC data-mapping attribute
       AccCopyIn, AccCopyOut, AccCreate, AccDelete, AccPresent,
       // OpenACC miscellaneous flags
       AccCommonBlock, AccThreadPrivate, AccReduction, AccNone, AccPreDetermined,
       // OpenMP data-sharing attribute
       OmpShared, OmpPrivate, OmpLinear, OmpFirstPrivate, OmpLastPrivate,
struct SymbolAddressCompare {
   bool operator()(const SymbolRef &x, const SymbolRef &y) const {
     return &*x < &*y;
   }
   bool operator()(const MutableSymbolRef &x, const MutableSymbolRef &y) const {
     return &*x < &*y;
   }
 };
 
-// Symbol comparison is based on the order of cooked source
+// Symbol comparison is usually based on the order of cooked source
 // stream creation and, when both are from the same cooked source,
 // their positions in that cooked source stream.
 // Don't use this comparator or OrderedSymbolSet to hold
 // Symbols that might be subject to ReplaceName().
 struct SymbolSourcePositionCompare {
   // These functions are implemented in Evaluate/tools.cpp to
   // satisfy complicated shared library interdependency.
   bool operator()(const SymbolRef &, const SymbolRef &) const;
   bool operator()(const MutableSymbolRef &, const MutableSymbolRef &) const;
 };
 
+struct SymbolOffsetCompare {
+  bool operator()(const SymbolRef &, const SymbolRef &) const;
+  bool operator()(const MutableSymbolRef &, const MutableSymbolRef &) const;
+};
+
 using UnorderedSymbolSet = std::set<SymbolRef, SymbolAddressCompare>;
-using OrderedSymbolSet = std::set<SymbolRef, SymbolSourcePositionCompare>;
+using SourceOrderedSymbolSet = std::set<SymbolRef, SymbolSourcePositionCompare>;
 
 template <typename A>
-OrderedSymbolSet OrderBySourcePosition(const A &container) {
-  OrderedSymbolSet result;
+SourceOrderedSymbolSet OrderBySourcePosition(const A &container) {
+  SourceOrderedSymbolSet result;
   for (SymbolRef x : container) {
     result.emplace(x);
   }
   return result;
 }
 
 } // namespace Fortran::semantics
 

flang/include/flang/Semantics/tools.h

 const Symbol *FindFunctionResult(const Symbol &);
 const Symbol *FindOverriddenBinding(const Symbol &);
 
 const DeclTypeSpec *FindParentTypeSpec(const DerivedTypeSpec &);
 const DeclTypeSpec *FindParentTypeSpec(const DeclTypeSpec &);
 const DeclTypeSpec *FindParentTypeSpec(const Scope &);
 const DeclTypeSpec *FindParentTypeSpec(const Symbol &);
 
+const EquivalenceSet *FindEquivalenceSet(const Symbol &);
+
 enum class Tristate { No, Yes, Maybe };
 inline Tristate ToTristate(bool x) { return x ? Tristate::Yes : Tristate::No; }
 
 // Is this a user-defined assignment? If both sides are the same derived type
 // (and the ranks are okay) the answer is Maybe.
 Tristate IsDefinedAssignment(
     const std::optional<evaluate::DynamicType> &lhsType, int lhsRank,
     const std::optional<evaluate::DynamicType> &rhsType, int rhsRank);

 // Is this derived type TEAM_TYPE from module ISO_FORTRAN_ENV
 bool IsTeamType(const DerivedTypeSpec *);
 // Is this derived type either C_PTR or C_FUNPTR from module ISO_C_BINDING
 bool IsIsoCType(const DerivedTypeSpec *);
 bool IsEventTypeOrLockType(const DerivedTypeSpec *);
 bool IsOrContainsEventOrLockComponent(const Symbol &);
 bool CanBeTypeBoundProc(const Symbol *);
 // Does a non-PARAMETER symbol have explicit initialization with =value or
-// =>target in its declaration, or optionally in a DATA statement? (Being
+// =>target in its declaration (but not in a DATA statement)? (Being
 // ALLOCATABLE or having a derived type with default component initialization
 // doesn't count; it must be a variable initialization that implies the SAVE
 // attribute, or a derived type component default value.)
-bool IsStaticallyInitialized(const Symbol &, bool ignoreDATAstatements = false);
+bool HasDeclarationInitializer(const Symbol &);
 // Is the symbol explicitly or implicitly initialized in any way?
-bool IsInitialized(const Symbol &, bool ignoreDATAstatements = false,
-    const Symbol *derivedType = nullptr);
+bool IsInitialized(const Symbol &, bool ignoreDATAstatements = false);
 // Is the symbol a component subject to deallocation or finalization?
 bool IsDestructible(const Symbol &, const Symbol *derivedType = nullptr);
 bool HasIntrinsicTypeName(const Symbol &);
 bool IsSeparateModuleProcedureInterface(const Symbol *);
 bool IsAutomatic(const Symbol &);
 bool HasAlternateReturns(const Symbol &);
 bool InCommonBlock(const Symbol &);
 
enum class ProcedureDefinitionClass {
   Module,
   Dummy,
   Pointer,
   StatementFunction
 };
 
 ProcedureDefinitionClass ClassifyProcedure(const Symbol &);
 
+// Returns a list of storage associations due to EQUIVALENCE in a
+// scope; each storage association is a list of symbol references
+// in ascending order of scope offset.  Note that the scope may have
+// more EquivalenceSets than this function's result has storage
+// associations; these are closures over equivalences.
+std::list<std::list<SymbolRef>> GetStorageAssociations(const Scope &);
+
 // Derived type component iterator that provides a C++ LegacyForwardIterator
 // iterator over the Ordered, Direct, Ultimate or Potential components of a
 // DerivedTypeSpec. These iterators can be used with STL algorithms
 // accepting LegacyForwardIterator.
 // The kind of component is a template argument of the iterator factory
 // ComponentIterator.
 //
 // - Ordered components are the components from the component order defined

flang/lib/Evaluate/initial-image.cpp

auto InitialImage::Add(ConstantSubscript offset, std::size_t bytes,
   }
 }
 
 void InitialImage::AddPointer(
     ConstantSubscript offset, const Expr<SomeType> &pointer) {
   pointers_.emplace(offset, pointer);
 }
 
-void InitialImage::Incorporate(
-    ConstantSubscript offset, const InitialImage &that) {
-  CHECK(that.pointers_.empty()); // pointers are not allowed in EQUIVALENCE
-  CHECK(offset + that.size() <= size());
-  std::memcpy(&data_[offset], &that.data_[0], that.size());
+void InitialImage::Incorporate(ConstantSubscript toOffset,
+    const InitialImage &from, ConstantSubscript fromOffset,
+    ConstantSubscript bytes) {
+  CHECK(from.pointers_.empty()); // pointers are not allowed in EQUIVALENCE
+  CHECK(fromOffset >= 0 && bytes >= 0 &&
+      static_cast<std::size_t>(fromOffset + bytes) <= from.size());
+  CHECK(static_cast<std::size_t>(toOffset + bytes) <= size());
+  std::memcpy(&data_[toOffset], &from.data_[fromOffset], bytes);
 }
 
 // Classes used with common::SearchTypes() to (re)construct Constant<> values
 // of the right type to initialize each symbol from the values that have
 // been placed into its initialization image by DATA statements.
 class AsConstantHelper {
 public:
   using Result = std::optional<Expr<SomeType>>;
auto elemBytes{
         ToInt64(type_.MeasureSizeInBytes(context_, GetRank(extents_) > 0))};
     CHECK(elemBytes && *elemBytes >= 0);
     std::size_t stride{static_cast<std::size_t>(*elemBytes)};
     CHECK(offset_ + elements * stride <= image_.data_.size());
     if constexpr (T::category == TypeCategory::Derived) {
       const semantics::DerivedTypeSpec &derived{type_.GetDerivedTypeSpec()};
       for (auto iter : DEREF(derived.scope())) {
         const Symbol &component{*iter.second};
-        bool isPointer{IsPointer(component)};
-        if (component.has<semantics::ObjectEntityDetails>() ||
-            component.has<semantics::ProcEntityDetails>()) {
-          auto componentType{DynamicType::From(component)};
-          CHECK(componentType);
+        bool isProcPtr{IsProcedurePointer(component)};
+        if (isProcPtr || component.has<semantics::ObjectEntityDetails>()) {
           auto at{offset_ + component.offset()};
-          if (isPointer) {
+          if (isProcPtr) {
+            for (std::size_t j{0}; j < elements; ++j, at += stride) {
+              if (Result value{image_.AsConstantPointer(at)}) {
+                typedValue[j].emplace(component, std::move(*value));
+              }
+            }
+          } else if (IsPointer(component)) {
             for (std::size_t j{0}; j < elements; ++j, at += stride) {
-              Result value{image_.AsConstantDataPointer(*componentType, at)};
-              CHECK(value);
+              if (Result value{image_.AsConstantPointer(at)}) {
                 typedValue[j].emplace(component, std::move(*value));
               }
+            }
           } else {
+            auto componentType{DynamicType::From(component)};
+            CHECK(componentType.has_value());
             auto componentExtents{GetConstantExtents(context_, component)};
-            CHECK(componentExtents);
+            CHECK(componentExtents.has_value());
             for (std::size_t j{0}; j < elements; ++j, at += stride) {
-              Result value{image_.AsConstant(
-                  context_, *componentType, *componentExtents, at)};
-              CHECK(value);
+              if (Result value{image_.AsConstant(
+                      context_, *componentType, *componentExtents, at)}) {
                 typedValue[j].emplace(component, std::move(*value));
               }
             }
           }
         }
+      }
       return AsGenericExpr(
           Const{derived, std::move(typedValue), std::move(extents_)});
     } else if constexpr (T::category == TypeCategory::Character) {
       auto length{static_cast<ConstantSubscript>(stride) / T::kind};
       for (std::size_t j{0}; j < elements; ++j) {
         using Char = typename Scalar::value_type;
         const Char *data{reinterpret_cast<const Char *>(
             &image_.data_[offset_ + j * stride])};

 
 std::optional<Expr<SomeType>> InitialImage::AsConstant(FoldingContext &context,
     const DynamicType &type, const ConstantSubscripts &extents,
     ConstantSubscript offset) const {
   return common::SearchTypes(
       AsConstantHelper{context, type, extents, *this, offset});
 }
 
-class AsConstantDataPointerHelper {
-public:
-  using Result = std::optional<Expr<SomeType>>;
-  using Types = AllTypes;
-  AsConstantDataPointerHelper(const DynamicType &type,
-      const InitialImage &image, ConstantSubscript offset = 0)
-      : type_{type}, image_{image}, offset_{offset} {}
-  template <typename T> Result Test() {
-    if (T::category != type_.category()) {
-      return std::nullopt;
-    }
-    if constexpr (T::category != TypeCategory::Derived) {
-      if (T::kind != type_.kind()) {
-        return std::nullopt;
-      }
-    }
-    auto iter{image_.pointers_.find(offset_)};
-    if (iter == image_.pointers_.end()) {
-      return AsGenericExpr(NullPointer{});
-    }
-    return iter->second;
-  }
-
-private:
-  const DynamicType &type_;
-  const InitialImage &image_;
-  ConstantSubscript offset_;
-};
-
-std::optional<Expr<SomeType>> InitialImage::AsConstantDataPointer(
-    const DynamicType &type, ConstantSubscript offset) const {
-  return common::SearchTypes(AsConstantDataPointerHelper{type, *this, offset});
-}
-
-const ProcedureDesignator &InitialImage::AsConstantProcPointer(
+std::optional<Expr<SomeType>> InitialImage::AsConstantPointer(
     ConstantSubscript offset) const {
-  auto iter{pointers_.find(0)};
-  CHECK(iter != pointers_.end());
-  return DEREF(std::get_if<ProcedureDesignator>(&iter->second.u));
+  auto iter{pointers_.find(offset)};
+  return iter == pointers_.end() ? std::optional<Expr<SomeType>>{}
+                                 : iter->second;
 }
 
 } // namespace Fortran::evaluate

flang/lib/Semantics/check-declarations.cpp

if (InPure() && !IsStmtFunction(DEREF(innermostSymbol_)) &&
       symbol.attrs().test(Attr::INTENT_OUT) ||
       symbol.attrs().test(Attr::INTENT_INOUT)) {
     messages_.Say("INTENT attributes may apply only to a dummy "
                   "argument"_err_en_US); // C843
   } else if (IsOptional(symbol)) {
     messages_.Say("OPTIONAL attribute may apply only to a dummy "
                   "argument"_err_en_US); // C849
   }
-  if (IsStaticallyInitialized(symbol, true /* ignore DATA inits */)) { // C808
+  if (HasDeclarationInitializer(symbol)) { // C808; ignore DATA initialization
     CheckPointerInitialization(symbol);
     if (IsAutomatic(symbol)) {
       messages_.Say(
           "An automatic variable or component must not be initialized"_err_en_US);
     } else if (IsDummy(symbol)) {
       messages_.Say("A dummy argument must not be initialized"_err_en_US);
     } else if (IsFunctionResult(symbol)) {
       messages_.Say("A function result must not be initialized"_err_en_US);

flang/lib/Semantics/compute-offsets.cpp

struct SizeAndAlignment {
     SizeAndAlignment(std::size_t bytes) : size{bytes}, alignment{bytes} {}
     SizeAndAlignment(std::size_t bytes, std::size_t align)
         : size{bytes}, alignment{align} {}
     std::size_t size{0};
     std::size_t alignment{0};
   };
   struct SymbolAndOffset {
     SymbolAndOffset(Symbol &s, std::size_t off, const EquivalenceObject &obj)
-        : symbol{&s}, offset{off}, object{&obj} {}
+        : symbol{s}, offset{off}, object{&obj} {}
     SymbolAndOffset(const SymbolAndOffset &) = default;
-    Symbol *symbol;
+    MutableSymbolRef symbol;
     std::size_t offset;
     const EquivalenceObject *object;
   };
 
   void DoCommonBlock(Symbol &);
   void DoEquivalenceBlockBase(Symbol &, SizeAndAlignment &);
   void DoEquivalenceSet(const EquivalenceSet &);
   SymbolAndOffset Resolve(const SymbolAndOffset &);

flang/lib/Semantics/data-to-inits.h

 }
 namespace Fortran::semantics {
 
 class Symbol;
 
 struct SymbolDataInitialization {
   using Range = common::Interval<common::ConstantSubscript>;
   explicit SymbolDataInitialization(std::size_t bytes) : image{bytes} {}
+  SymbolDataInitialization(SymbolDataInitialization &&) = default;
   evaluate::InitialImage image;
-  std::list<Range> inits;
+  std::list<Range> initializedRanges;
 };
 
 using DataInitializations = std::map<const Symbol *, SymbolDataInitialization>;
 
 // Matches DATA statement variables with their values and checks
 // compatibility.
 void AccumulateDataInitializations(DataInitializations &,
     evaluate::ExpressionAnalyzer &, const parser::DataStmtSet &);
 
 void ConvertToInitializers(
     DataInitializations &, evaluate::ExpressionAnalyzer &);
 
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_DATA_TO_INITS_H_

flang/lib/Semantics/data-to-inits.cpp

 //   DataChecker::ConstructInitializer().
 
 #include "data-to-inits.h"
 #include "pointer-assignment.h"
 #include "flang/Evaluate/fold-designator.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Semantics/tools.h"
 
+// The job of generating explicit static initializers for objects that don't
+// have them in order to implement default component initialization is now being
+// done in lowering, so don't do it here in semantics; but the code remains here
+// in case we change our minds.
+static constexpr bool makeDefaultInitializationExplicit{false};
+
+// Whether to delete the original "init()" initializers from storage-associated
+// objects and pointers.
+static constexpr bool removeOriginalInits{false};
+
 namespace Fortran::semantics {
 
 // Steps through a list of values in a DATA statement set; implements
 // repetition.
 class ValueListIterator {
 public:
   explicit ValueListIterator(const parser::DataStmtSet &set)
       : end_{std::get<std::list<parser::DataStmtValue>>(set.t).end()},
if (auto badDesignator{
       std::string buf;
       llvm::raw_string_ostream ss{buf};
       ss << offsetSymbol.symbol().name() << " offset " << offsetSymbol.offset()
          << " bytes for " << offsetSymbol.size() << " bytes";
       return ss.str();
     }
   }};
   const auto GetImage{[&]() -> evaluate::InitialImage & {
-    auto &symbolInit{inits_.emplace(&symbol, symbol.size()).first->second};
-    symbolInit.inits.emplace_back(offsetSymbol.offset(), offsetSymbol.size());
+    auto iter{inits_.emplace(&symbol, symbol.size())};
+    auto &symbolInit{iter.first->second};
+    symbolInit.initializedRanges.emplace_back(
+        offsetSymbol.offset(), offsetSymbol.size());
     return symbolInit.image;
   }};
   const auto OutOfRangeError{[&]() {
     evaluate::AttachDeclaration(
         exprAnalyzer_.context().Say(
             "DATA statement designator '%s' is out of range for its variable '%s'"_err_en_US,
             DescribeElement(), symbol.name()),
         symbol);
for (const auto &object :
     }
   }
   if (scanner.HasSurplusValues()) {
     exprAnalyzer.context().Say(
         "DATA statement set has more values than objects"_err_en_US);
   }
 }
 
-static bool CombineSomeEquivalencedInits(
-    DataInitializations &inits, evaluate::ExpressionAnalyzer &exprAnalyzer) {
-  auto end{inits.end()};
-  for (auto iter{inits.begin()}; iter != end; ++iter) {
-    const Symbol &symbol{*iter->first};
-    Scope &scope{const_cast<Scope &>(symbol.owner())};
-    if (scope.equivalenceSets().empty()) {
-      continue; // no problem to solve here
-    }
-    const auto *commonBlock{FindCommonBlockContaining(symbol)};
-    // Sweep following DATA initializations in search of overlapping
-    // objects, accumulating into a vector; iterate to a fixed point.
-    std::vector<const Symbol *> conflicts;
-    auto minStart{symbol.offset()};
-    auto maxEnd{symbol.offset() + symbol.size()};
-    std::size_t minElementBytes{1};
-    while (true) {
-      auto prevCount{conflicts.size()};
-      conflicts.clear();
-      for (auto scan{iter}; ++scan != end;) {
-        const Symbol &other{*scan->first};
-        const Scope &otherScope{other.owner()};
-        if (&otherScope == &scope &&
-            FindCommonBlockContaining(other) == commonBlock &&
-            maxEnd > other.offset() &&
-            other.offset() + other.size() > minStart) {
-          // "other" conflicts with "symbol" or another conflict
-          conflicts.push_back(&other);
-          minStart = std::min(minStart, other.offset());
-          maxEnd = std::max(maxEnd, other.offset() + other.size());
+// Looks for default derived type component initialization -- but
+// *not* allocatables.
+static const DerivedTypeSpec *HasDefaultInitialization(const Symbol &symbol) {
+  if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
+    if (object->init().has_value()) {
+      return nullptr; // init is explicit, not default
+    } else if (!object->isDummy() && object->type()) {
+      if (const DerivedTypeSpec * derived{object->type()->AsDerived()}) {
+        DirectComponentIterator directs{*derived};
+        if (std::find_if(
+                directs.begin(), directs.end(), [](const Symbol &component) {
+                  return !IsAllocatable(component) &&
+                      HasDeclarationInitializer(component);
+                })) {
+          return derived;
         }
       }
-      if (conflicts.size() == prevCount) {
-        break;
-      }
-    }
-    if (conflicts.empty()) {
-      continue;
+  return nullptr;
+}
+
+// PopulateWithComponentDefaults() adds initializations to an instance
+// of SymbolDataInitialization containing all of the default component
+// initializers
+
+static void PopulateWithComponentDefaults(SymbolDataInitialization &init,
+    std::size_t offset, const DerivedTypeSpec &derived,
+    evaluate::FoldingContext &foldingContext);
+
+static void PopulateWithComponentDefaults(SymbolDataInitialization &init,
+    std::size_t offset, const DerivedTypeSpec &derived,
+    evaluate::FoldingContext &foldingContext, const Symbol &symbol) {
+  if (auto extents{evaluate::GetConstantExtents(foldingContext, symbol)}) {
+    const Scope &scope{derived.scope() ? *derived.scope()
+                                       : DEREF(derived.typeSymbol().scope())};
+    std::size_t stride{scope.size()};
+    if (std::size_t alignment{scope.alignment().value_or(0)}) {
+      stride = ((stride + alignment - 1) / alignment) * alignment;
+    }
+    for (auto elements{evaluate::GetSize(*extents)}; elements-- > 0;
+         offset += stride) {
+      PopulateWithComponentDefaults(init, offset, derived, foldingContext);
+    }
+  }
+}
+
+// F'2018 19.5.3(10) allows storage-associated default component initialization
+// when the values are identical.
+static void PopulateWithComponentDefaults(SymbolDataInitialization &init,
+    std::size_t offset, const DerivedTypeSpec &derived,
+    evaluate::FoldingContext &foldingContext) {
+  const Scope &scope{
+      derived.scope() ? *derived.scope() : DEREF(derived.typeSymbol().scope())};
+  for (const auto &pair : scope) {
+    const Symbol &component{*pair.second};
+    std::size_t componentOffset{offset + component.offset()};
+    if (const auto *object{component.detailsIf<ObjectEntityDetails>()}) {
+      if (!IsAllocatable(component) && !IsAutomatic(component)) {
+        bool initialized{false};
+        if (object->init()) {
+          initialized = true;
+          if (IsPointer(component)) {
+            if (auto extant{init.image.AsConstantPointer(componentOffset)}) {
+              initialized = !(*extant == *object->init());
+            }
+            if (initialized) {
+              init.image.AddPointer(componentOffset, *object->init());
+            }
+          } else { // data, not pointer
+            if (auto dyType{evaluate::DynamicType::From(component)}) {
+              if (auto extents{evaluate::GetConstantExtents(
+                      foldingContext, component)}) {
+                if (auto extant{init.image.AsConstant(
+                        foldingContext, *dyType, *extents, componentOffset)}) {
+                  initialized = !(*extant == *object->init());
+                }
+              }
+            }
+            if (initialized) {
+              init.image.Add(componentOffset, component.size(), *object->init(),
+                  foldingContext);
+            }
+          }
+        } else if (const DeclTypeSpec * type{component.GetType()}) {
+          if (const DerivedTypeSpec * componentDerived{type->AsDerived()}) {
+            PopulateWithComponentDefaults(init, componentOffset,
+                *componentDerived, foldingContext, component);
+          }
+        }
+        if (initialized) {
+          init.initializedRanges.emplace_back(
+              componentOffset, component.size());
+        }
+      }
+    } else if (const auto *proc{component.detailsIf<ProcEntityDetails>()}) {
+      if (proc->init() && *proc->init()) {
+        SomeExpr procPtrInit{evaluate::ProcedureDesignator{**proc->init()}};
+        auto extant{init.image.AsConstantPointer(componentOffset)};
+        if (!extant || !(*extant == procPtrInit)) {
+          init.initializedRanges.emplace_back(
+              componentOffset, component.size());
+          init.image.AddPointer(componentOffset, std::move(procPtrInit));
+        }
+      }
+    }
+  }
+}
+
+static bool CheckForOverlappingInitialization(
+    const std::list<SymbolRef> &symbols,
+    SymbolDataInitialization &initialization,
+    evaluate::ExpressionAnalyzer &exprAnalyzer, const std::string &what) {
+  bool result{true};
+  auto &context{exprAnalyzer.GetFoldingContext()};
+  initialization.initializedRanges.sort();
+  ConstantSubscript next{0};
+  for (const auto &range : initialization.initializedRanges) {
+    if (range.start() < next) {
+      result = false; // error: overlap
+      bool hit{false};
+      for (const Symbol &symbol : symbols) {
+        auto offset{range.start() -
+            static_cast<ConstantSubscript>(
+                symbol.offset() - symbols.front()->offset())};
+        if (offset >= 0) {
+          if (auto badDesignator{evaluate::OffsetToDesignator(
+                  context, symbol, offset, range.size())}) {
+            hit = true;
+            exprAnalyzer.Say(symbol.name(),
+                "%s affect '%s' more than once"_err_en_US, what,
+                badDesignator->AsFortran());
+          }
+        }
+      }
+      CHECK(hit);
+    }
+    next = range.start() + range.size();
+    CHECK(next <= static_cast<ConstantSubscript>(initialization.image.size()));
+  }
+  return result;
+}
+
+static void IncorporateExplicitInitialization(
+    SymbolDataInitialization &combined, DataInitializations &inits,
+    const Symbol &symbol, ConstantSubscript firstOffset,
+    evaluate::FoldingContext &foldingContext) {
+  auto iter{inits.find(&symbol)};
+  const auto offset{symbol.offset() - firstOffset};
+  if (iter != inits.end()) { // DATA statement initialization
+    for (const auto &range : iter->second.initializedRanges) {
+      auto at{offset + range.start()};
+      combined.initializedRanges.emplace_back(at, range.size());
+      combined.image.Incorporate(
+          at, iter->second.image, range.start(), range.size());
+    }
+    if (removeOriginalInits) {
+      inits.erase(iter);
+    }
+  } else { // Declaration initialization
+    Symbol &mutableSymbol{const_cast<Symbol &>(symbol)};
+    if (IsPointer(mutableSymbol)) {
+      if (auto *object{mutableSymbol.detailsIf<ObjectEntityDetails>()}) {
+        if (object->init()) {
+          combined.initializedRanges.emplace_back(offset, mutableSymbol.size());
+          combined.image.AddPointer(offset, *object->init());
+          if (removeOriginalInits) {
+            object->init().reset();
+          }
+        }
+      } else if (auto *proc{mutableSymbol.detailsIf<ProcEntityDetails>()}) {
+        if (proc->init() && *proc->init()) {
+          combined.initializedRanges.emplace_back(offset, mutableSymbol.size());
+          combined.image.AddPointer(
+              offset, SomeExpr{evaluate::ProcedureDesignator{**proc->init()}});
+          if (removeOriginalInits) {
+            proc->init().reset();
+          }
+        }
+      }
+    } else if (auto *object{mutableSymbol.detailsIf<ObjectEntityDetails>()}) {
+      if (!IsNamedConstant(mutableSymbol) && object->init()) {
+        combined.initializedRanges.emplace_back(offset, mutableSymbol.size());
+        combined.image.Add(
+            offset, mutableSymbol.size(), *object->init(), foldingContext);
+        if (removeOriginalInits) {
+          object->init().reset();
+        }
+      }
+    }
+  }
+}
+
+// Finds the size of the smallest element type in a list of
+// storage-associated objects.
+static std::size_t ComputeMinElementBytes(
+    const std::list<SymbolRef> &associated,
+    evaluate::FoldingContext &foldingContext) {
+  std::size_t minElementBytes{1};
+  const Symbol &first{*associated.front()};
+  for (const Symbol &s : associated) {
+    if (auto dyType{evaluate::DynamicType::From(s)}) {
+      auto size{static_cast<std::size_t>(
+          evaluate::ToInt64(dyType->MeasureSizeInBytes(foldingContext, true))
+              .value_or(1))};
+      if (std::size_t alignment{dyType->GetAlignment(foldingContext)}) {
+        size = ((size + alignment - 1) / alignment) * alignment;
+      }
+      if (&s == &first) {
+        minElementBytes = size;
+      } else {
+        minElementBytes = std::min(minElementBytes, size);
       }
-    // Compute the minimum common granularity
-    if (auto dyType{evaluate::DynamicType::From(symbol)}) {
-      minElementBytes = evaluate::ToInt64(
-          dyType->MeasureSizeInBytes(exprAnalyzer.GetFoldingContext(), true))
-                            .value_or(1);
-    }
-    for (const Symbol *s : conflicts) {
-      if (auto dyType{evaluate::DynamicType::From(*s)}) {
-        minElementBytes = std::min<std::size_t>(minElementBytes,
-            evaluate::ToInt64(dyType->MeasureSizeInBytes(
-                                  exprAnalyzer.GetFoldingContext(), true))
-                .value_or(1));
-      } else {
-        minElementBytes = 1;
-      }
-    }
-    CHECK(minElementBytes > 0);
-    CHECK((minElementBytes & (minElementBytes - 1)) == 0);
-    auto bytes{static_cast<common::ConstantSubscript>(maxEnd - minStart)};
-    CHECK(bytes % minElementBytes == 0);
-    const DeclTypeSpec &typeSpec{scope.MakeNumericType(
-        TypeCategory::Integer, KindExpr{minElementBytes})};
-    // Combine "symbol" and "conflicts[]" into a compiler array temp
-    // that overlaps all of them, and merge their initial values into
-    // the temp's initializer.
+  return minElementBytes;
+}
+
+// Checks for overlapping initialization errors in a list of
+// storage-associated objects.  Default component initializations
+// are allowed to be overridden by explicit initializations.
+// If the objects are static, save the combined initializer as
+// a compiler-created object that covers all of them.
+static bool CombineEquivalencedInitialization(
+    const std::list<SymbolRef> &associated,
+    evaluate::ExpressionAnalyzer &exprAnalyzer, DataInitializations &inits) {
+  // Compute the minimum common granularity and total size
+  const Symbol &first{*associated.front()};
+  std::size_t maxLimit{0};
+  for (const Symbol &s : associated) {
+    CHECK(s.offset() >= first.offset());
+    auto limit{s.offset() + s.size()};
+    if (limit > maxLimit) {
+      maxLimit = limit;
+    }
+  }
+  auto bytes{static_cast<common::ConstantSubscript>(maxLimit - first.offset())};
+  Scope &scope{const_cast<Scope &>(first.owner())};
+  // Combine the initializations of the associated objects.
+  // Apply all default initializations first.
+  SymbolDataInitialization combined{static_cast<std::size_t>(bytes)};
+  auto &foldingContext{exprAnalyzer.GetFoldingContext()};
+  for (const Symbol &s : associated) {
+    if (!IsNamedConstant(s)) {
+      if (const auto *derived{HasDefaultInitialization(s)}) {
+        PopulateWithComponentDefaults(
+            combined, s.offset() - first.offset(), *derived, foldingContext, s);
+      }
+    }
+  }
+  if (!CheckForOverlappingInitialization(associated, combined, exprAnalyzer,
+          "Distinct default component initializations of equivalenced objects"s)) {
+    return false;
+  }
+  // Don't complain about overlap between explicit initializations and
+  // default initializations.
+  combined.initializedRanges.clear();
+  // Now overlay all explicit initializations from DATA statements and
+  // from initializers in declarations.
+  for (const Symbol &symbol : associated) {
+    IncorporateExplicitInitialization(
+        combined, inits, symbol, first.offset(), foldingContext);
+  }
+  if (!CheckForOverlappingInitialization(associated, combined, exprAnalyzer,
+          "Explicit initializations of equivalenced objects"s)) {
+    return false;
+  }
+  // If the items are in static storage, save the final initialization.
+  if (std::find_if(associated.begin(), associated.end(),
+          [](SymbolRef ref) { return IsSaved(*ref); }) != associated.end()) {
+    // Create a compiler array temp that overlaps all the items.
     SourceName name{exprAnalyzer.context().GetTempName(scope)};
     auto emplaced{
         scope.try_emplace(name, Attrs{Attr::SAVE}, ObjectEntityDetails{})};
     CHECK(emplaced.second);
     Symbol &combinedSymbol{*emplaced.first->second};
+    combinedSymbol.set(Symbol::Flag::CompilerCreated);
+    inits.emplace(&combinedSymbol, std::move(combined));
     auto &details{combinedSymbol.get<ObjectEntityDetails>()};
-    combinedSymbol.set_offset(minStart);
+    combinedSymbol.set_offset(first.offset());
     combinedSymbol.set_size(bytes);
+    std::size_t minElementBytes{
+        ComputeMinElementBytes(associated, foldingContext)};
+    if (!evaluate::IsValidKindOfIntrinsicType(
+            TypeCategory::Integer, minElementBytes) ||
+        (bytes % minElementBytes) != 0) {
+      minElementBytes = 1;
+    }
+    const DeclTypeSpec &typeSpec{scope.MakeNumericType(
+        TypeCategory::Integer, KindExpr{minElementBytes})};
     details.set_type(typeSpec);
     ArraySpec arraySpec;
     arraySpec.emplace_back(ShapeSpec::MakeExplicit(Bound{
         bytes / static_cast<common::ConstantSubscript>(minElementBytes)}));
     details.set_shape(arraySpec);
-    if (commonBlock) {
+    if (const auto *commonBlock{FindCommonBlockContaining(first)}) {
       details.set_commonBlock(*commonBlock);
     }
-    // Merge these EQUIVALENCE'd DATA initializations, and remove the
-    // original initializations from the map.
-    auto combinedInit{
-        inits.emplace(&combinedSymbol, static_cast<std::size_t>(bytes))};
-    evaluate::InitialImage &combined{combinedInit.first->second.image};
-    combined.Incorporate(symbol.offset() - minStart, iter->second.image);
-    inits.erase(iter);
-    for (const Symbol *s : conflicts) {
-      auto sIter{inits.find(s)};
-      CHECK(sIter != inits.end());
-      combined.Incorporate(s->offset() - minStart, sIter->second.image);
-      inits.erase(sIter);
+    // Add an EQUIVALENCE set to the scope so that the new object appears in
+    // the results of GetStorageAssociations().
+    auto &newSet{scope.equivalenceSets().emplace_back()};
+    newSet.emplace_back(combinedSymbol);
+    newSet.emplace_back(const_cast<Symbol &>(first));
+  }
+  return true;
+}
+
+// When a statically-allocated derived type variable has no explicit
+// initialization, but its type has at least one nonallocatable ultimate
+// component with default initialization, make its initialization explicit.
+[[maybe_unused]] static void MakeDefaultInitializationExplicit(
+    const Scope &scope, const std::list<std::list<SymbolRef>> &associations,
+    evaluate::FoldingContext &foldingContext, DataInitializations &inits) {
+  UnorderedSymbolSet equivalenced;
+  for (const std::list<SymbolRef> &association : associations) {
+    for (const Symbol &symbol : association) {
+      equivalenced.emplace(symbol);
+    }
+  }
+  for (const auto &pair : scope) {
+    const Symbol &symbol{*pair.second};
+    if (!symbol.test(Symbol::Flag::InDataStmt) &&
+        !HasDeclarationInitializer(symbol) && IsSaved(symbol) &&
+        equivalenced.find(symbol) == equivalenced.end()) {
+      // Static object, no local storage association, no explicit initialization
+      if (const DerivedTypeSpec * derived{HasDefaultInitialization(symbol)}) {
+        auto newInitIter{inits.emplace(&symbol, symbol.size())};
+        CHECK(newInitIter.second);
+        auto &newInit{newInitIter.first->second};
+        PopulateWithComponentDefaults(
+            newInit, 0, *derived, foldingContext, symbol);
+      }
     }
-    return true; // got one
   }
-  return false; // no remaining EQUIVALENCE'd DATA initializations
 }
 
-// Converts the initialization image for all the DATA statement appearances of
-// a single symbol into an init() expression in the symbol table entry.
+// Traverses the Scopes to:
+// 1) combine initialization of equivalenced objects, &
+// 2) optionally make initialization explicit for otherwise uninitialized static
+//    objects of derived types with default component initialization
+// Returns false on error.
+static bool ProcessScopes(const Scope &scope,
+    evaluate::ExpressionAnalyzer &exprAnalyzer, DataInitializations &inits) {
+  bool result{true}; // no error
+  switch (scope.kind()) {
+  case Scope::Kind::Global:
+  case Scope::Kind::Module:
+  case Scope::Kind::MainProgram:
+  case Scope::Kind::Subprogram:
+  case Scope::Kind::BlockData:
+  case Scope::Kind::Block: {
+    std::list<std::list<SymbolRef>> associations{GetStorageAssociations(scope)};
+    for (const std::list<SymbolRef> &associated : associations) {
+      if (std::find_if(associated.begin(), associated.end(), [](SymbolRef ref) {
+            return IsInitialized(*ref);
+          }) != associated.end()) {
+        result &=
+            CombineEquivalencedInitialization(associated, exprAnalyzer, inits);
+      }
+    }
+    if constexpr (makeDefaultInitializationExplicit) {
+      MakeDefaultInitializationExplicit(
+          scope, associations, exprAnalyzer.GetFoldingContext(), inits);
+    }
+    for (const Scope &child : scope.children()) {
+      result &= ProcessScopes(child, exprAnalyzer, inits);
+    }
+  } break;
+  default:;
+  }
+  return result;
+}
+
+// Converts the static initialization image for a single symbol with
+// one or more DATA statement appearances.
 void ConstructInitializer(const Symbol &symbol,
     SymbolDataInitialization &initialization,
     evaluate::ExpressionAnalyzer &exprAnalyzer) {
+  std::list<SymbolRef> symbols{symbol};
+  CheckForOverlappingInitialization(
+      symbols, initialization, exprAnalyzer, "DATA statement initializations"s);
   auto &context{exprAnalyzer.GetFoldingContext()};
-  initialization.inits.sort();
-  ConstantSubscript next{0};
-  for (const auto &init : initialization.inits) {
-    if (init.start() < next) {
-      auto badDesignator{evaluate::OffsetToDesignator(
-          context, symbol, init.start(), init.size())};
-      CHECK(badDesignator);
-      exprAnalyzer.Say(symbol.name(),
-          "DATA statement initializations affect '%s' more than once"_err_en_US,
-          badDesignator->AsFortran());
-    }
-    next = init.start() + init.size();
-    CHECK(next <= static_cast<ConstantSubscript>(initialization.image.size()));
-  }
   if (const auto *proc{symbol.detailsIf<ProcEntityDetails>()}) {
     CHECK(IsProcedurePointer(symbol));
-    const auto &procDesignator{initialization.image.AsConstantProcPointer()};
-    CHECK(!procDesignator.GetComponent());
     auto &mutableProc{const_cast<ProcEntityDetails &>(*proc)};
-    mutableProc.set_init(DEREF(procDesignator.GetSymbol()));
+    if (MaybeExpr expr{initialization.image.AsConstantPointer()}) {
+      if (const auto *procDesignator{
+              std::get_if<evaluate::ProcedureDesignator>(&expr->u)}) {
+        CHECK(!procDesignator->GetComponent());
+        mutableProc.set_init(DEREF(procDesignator->GetSymbol()));
+      } else {
+        CHECK(evaluate::IsNullPointer(*expr));
+        mutableProc.set_init(nullptr);
+      }
+    } else {
+      mutableProc.set_init(nullptr);
+    }
   } else if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
-    if (auto symbolType{evaluate::DynamicType::From(symbol)}) {
-      auto &mutableObject{const_cast<ObjectEntityDetails &>(*object)};
-      if (IsPointer(symbol)) {
-        mutableObject.set_init(
-            initialization.image.AsConstantDataPointer(*symbolType));
+      if (auto ptr{initialization.image.AsConstantPointer()}) {
+        mutableObject.set_init(*ptr);
       } else {
-        if (auto extents{evaluate::GetConstantExtents(context, symbol)}) {
-          mutableObject.set_init(
-              initialization.image.AsConstant(context, *symbolType, *extents));
-        } else {
-          exprAnalyzer.Say(symbol.name(),
-              "internal: unknown shape for '%s' while constructing initializer from DATA"_err_en_US,
-              symbol.name());
-          return;
-        }
-      }
+        mutableObject.set_init(SomeExpr{evaluate::NullPointer{}});
+      }
+    } else if (auto symbolType{evaluate::DynamicType::From(symbol)}) {
     } else {
       exprAnalyzer.Say(symbol.name(),
           "internal: no type for '%s' while constructing initializer from DATA"_err_en_US,
           symbol.name());
       return;
     }
     if (!object->init()) {
       exprAnalyzer.Say(symbol.name(),
           "internal: could not construct an initializer from DATA statements for '%s'"_err_en_US,
           symbol.name());
     }
   } else {
     CHECK(exprAnalyzer.context().AnyFatalError());
   }
 }
 
 void ConvertToInitializers(
     DataInitializations &inits, evaluate::ExpressionAnalyzer &exprAnalyzer) {
-  while (CombineSomeEquivalencedInits(inits, exprAnalyzer)) {
-  }
+  if (ProcessScopes(
+          exprAnalyzer.context().globalScope(), exprAnalyzer, inits)) {
     for (auto &[symbolPtr, initialization] : inits) {
       ConstructInitializer(*symbolPtr, initialization, exprAnalyzer);
     }
   }
+}
 } // namespace Fortran::semantics

flang/lib/Semantics/mod-file.cpp

 // Put out the visible symbols from scope.
 bool ModFileWriter::PutSymbols(const Scope &scope) {
   SymbolVector sorted;
   SymbolVector uses;
   CollectSymbols(scope, sorted, uses);
   std::string buf; // stuff after CONTAINS in derived type
   llvm::raw_string_ostream typeBindings{buf};
   for (const Symbol &symbol : sorted) {
+    if (!symbol.test(Symbol::Flag::CompilerCreated)) {
       PutSymbol(typeBindings, symbol);
     }
+  }
   for (const Symbol &symbol : uses) {
     PutUse(symbol);
   }
+  for (const auto &set : scope.equivalenceSets()) {
+    if (!set.empty() &&
+        !set.front().symbol.test(Symbol::Flag::CompilerCreated)) {
+      char punctuation{'('};
+      decls_ << "equivalence";
+      for (const auto &object : set) {
+        decls_ << punctuation << object.AsFortran();
+        punctuation = ',';
+      }
+      decls_ << ")\n";
+    }
+  }
   if (auto str{typeBindings.str()}; !str.empty()) {
     CHECK(scope.IsDerivedType());
     decls_ << "contains\n" << str;
     return true;
   } else {
     return false;
   }
 }

flang/lib/Semantics/resolve-names.cpp

if (symbol.attrs().test(Attr::EXTERNAL)) {
       ConvertToProcEntity(symbol);
     }
     return symbol;
   }
 }
 
 bool DeclarationVisitor::HasCycle(
     const Symbol &procSymbol, const ProcInterface &interface) {
-  OrderedSymbolSet procsInCycle;
+  SourceOrderedSymbolSet procsInCycle;
   procsInCycle.insert(procSymbol);
   const ProcInterface *thisInterface{&interface};
   bool haveInterface{true};
   while (haveInterface) {
     haveInterface = false;
     if (const Symbol * interfaceSymbol{thisInterface->symbol()}) {
       if (procsInCycle.count(*interfaceSymbol) > 0) {
         for (const auto &procInCycle : procsInCycle) {
bool ConstructVisitor::Pre(const parser::DataImpliedDo &x) {
   Walk(objects);
   if (pushScope) {
     PopScope();
   }
   return false;
 }
 
 // Sets InDataStmt flag on a variable (or misidentified function) in a DATA
-// statement so that the predicate IsStaticallyInitialized() will be true
+// statement so that the predicate IsInitialized() will be true
 // during semantic analysis before the symbol's initializer is constructed.
 bool ConstructVisitor::Pre(const parser::DataIDoObject &x) {
   std::visit(
       common::visitors{
           [&](const parser::Scalar<Indirection<parser::Designator>> &y) {
             Walk(y.thing.value());
             const parser::Name &first{parser::GetFirstName(y.thing.value())};
             if (first.symbol) {

flang/lib/Semantics/runtime-type-info.cpp

if (const auto *spec{scope.FindType(
       object.set_type(scope.MakeNumericType(T::category, KindExpr{T::kind}));
     }
     auto elements{static_cast<evaluate::ConstantSubscript>(x.size())};
     ArraySpec arraySpec;
     arraySpec.push_back(ShapeSpec::MakeExplicit(Bound{0}, Bound{elements - 1}));
     object.set_shape(arraySpec);
     object.set_init(evaluate::AsGenericExpr(evaluate::Constant<T>{
         std::move(x), evaluate::ConstantSubscripts{elements}}));
-    const Symbol &symbol{
-        *scope
-             .try_emplace(
-                 name, Attrs{Attr::TARGET, Attr::SAVE}, std::move(object))
+    Symbol &symbol{*scope
+                        .try_emplace(name, Attrs{Attr::TARGET, Attr::SAVE},
+                            std::move(object))
                         .first->second};
+    symbol.set(Symbol::Flag::CompilerCreated);
     return evaluate::AsGenericExpr(
         evaluate::Expr<T>{evaluate::Designator<T>{symbol}});
   }
 }
 
 // Save an arbitrarily shaped array constant of some derived type
 // as an initialized data object in a scope.
 static SomeExpr SaveDerivedPointerTarget(Scope &scope, SourceName name,
if (!shape.empty()) {
       for (auto n : shape) {
         arraySpec.push_back(ShapeSpec::MakeExplicit(Bound{0}, Bound{n - 1}));
       }
       object.set_shape(arraySpec);
     }
     object.set_init(
         evaluate::AsGenericExpr(evaluate::Constant<evaluate::SomeDerived>{
             derivedType, std::move(x), std::move(shape)}));
-    const Symbol &symbol{
-        *scope
-             .try_emplace(
-                 name, Attrs{Attr::TARGET, Attr::SAVE}, std::move(object))
+    Symbol &symbol{*scope
+                        .try_emplace(name, Attrs{Attr::TARGET, Attr::SAVE},
+                            std::move(object))
                         .first->second};
+    symbol.set(Symbol::Flag::CompilerCreated);
     return evaluate::AsGenericExpr(
         evaluate::Designator<evaluate::SomeDerived>{symbol});
   }
 }
 
 static SomeExpr SaveObjectInit(
     Scope &scope, SourceName name, const ObjectEntityDetails &object) {
-  const Symbol &symbol{*scope
-                            .try_emplace(name, Attrs{Attr::TARGET, Attr::SAVE},
-                                ObjectEntityDetails{object})
-                            .first->second};
+  Symbol &symbol{*scope
   CHECK(symbol.get<ObjectEntityDetails>().init().has_value());
+  symbol.set(Symbol::Flag::CompilerCreated);
   return evaluate::AsGenericExpr(
       evaluate::Designator<evaluate::SomeDerived>{symbol});
 }
 
 template <int KIND> static SomeExpr IntExpr(std::int64_t n) {
   return evaluate::AsGenericExpr(
       evaluate::Constant<evaluate::Type<TypeCategory::Integer, KIND>>{n});
 }

 Symbol &RuntimeTableBuilder::CreateObject(
     const std::string &name, const DeclTypeSpec &type, Scope &scope) {
   ObjectEntityDetails object;
   object.set_type(type);
   auto pair{scope.try_emplace(SaveObjectName(name),
       Attrs{Attr::TARGET, Attr::SAVE}, std::move(object))};
   CHECK(pair.second);
   Symbol &result{*pair.first->second};
+  result.set(Symbol::Flag::CompilerCreated);
   return result;
 }
 
 SourceName RuntimeTableBuilder::SaveObjectName(const std::string &name) {
   return *tables_.names.insert(name).first;
 }
 
 SomeExpr RuntimeTableBuilder::SaveNameAsPointerTarget(
     Scope &scope, const std::string &name) {
   CHECK(!name.empty());
   CHECK(name.front() != '.');
   ObjectEntityDetails object;
   auto len{static_cast<common::ConstantSubscript>(name.size())};
   if (const auto *spec{scope.FindType(DeclTypeSpec{CharacterTypeSpec{
           ParamValue{len, common::TypeParamAttr::Len}, KindExpr{1}}})}) {
     object.set_type(*spec);
   } else {
     object.set_type(scope.MakeCharacterType(
         ParamValue{len, common::TypeParamAttr::Len}, KindExpr{1}));
   }
   using Ascii = evaluate::Type<TypeCategory::Character, 1>;
   using AsciiExpr = evaluate::Expr<Ascii>;
   object.set_init(evaluate::AsGenericExpr(AsciiExpr{name}));
-  const Symbol &symbol{
-      *scope
+  Symbol &symbol{*scope
                       .try_emplace(SaveObjectName(".n."s + name),
                           Attrs{Attr::TARGET, Attr::SAVE}, std::move(object))
                       .first->second};
+  symbol.set(Symbol::Flag::CompilerCreated);
   return evaluate::AsGenericExpr(
       AsciiExpr{evaluate::Designator<Ascii>{symbol}});
 }
 
 evaluate::StructureConstructor RuntimeTableBuilder::DescribeComponent(
     const Symbol &symbol, const ObjectEntityDetails &object, Scope &scope,
     Scope &dtScope, const std::string &distinctName,
     const SymbolVector *parameters) {
bool RuntimeTableBuilder::InitializeDataPointer(
     evaluate::StructureConstructorValues &values, const Symbol &symbol,
     const ObjectEntityDetails &object, Scope &scope, Scope &dtScope,
     const std::string &distinctName) {
   if (object.init().has_value()) {
     SourceName ptrDtName{SaveObjectName(
         ".dp."s + distinctName + "."s + symbol.name().ToString())};
     Symbol &ptrDtSym{
         *scope.try_emplace(ptrDtName, Attrs{}, UnknownDetails{}).first->second};
+    ptrDtSym.set(Symbol::Flag::CompilerCreated);
     Scope &ptrDtScope{scope.MakeScope(Scope::Kind::DerivedType, &ptrDtSym)};
     ignoreScopes_.insert(&ptrDtScope);
     ObjectEntityDetails ptrDtObj;
     ptrDtObj.set_type(DEREF(object.type()));
     ptrDtObj.set_shape(object.shape());
     Symbol &ptrDtComp{*ptrDtScope
                            .try_emplace(symbol.name(), Attrs{Attr::POINTER},
                                std::move(ptrDtObj))

flang/lib/Semantics/symbol.cpp

#endif
       u);
 }
 
 bool GenericKind::Is(GenericKind::OtherKind x) const {
   const OtherKind *y{std::get_if<OtherKind>(&u)};
   return y && *y == x;
 }
 
+bool SymbolOffsetCompare::operator()(
+    const SymbolRef &x, const SymbolRef &y) const {
+  const Symbol *xCommon{FindCommonBlockContaining(*x)};
+  const Symbol *yCommon{FindCommonBlockContaining(*y)};
+  if (xCommon) {
+    if (yCommon) {
+      const SymbolSourcePositionCompare sourceCmp;
+      if (sourceCmp(*xCommon, *yCommon)) {
+        return true;
+      } else if (sourceCmp(*yCommon, *xCommon)) {
+        return false;
+      } else if (x->offset() == y->offset()) {
+        return x->size() > y->size();
+      } else {
+        return x->offset() < y->offset();
+      }
+    } else {
+      return false;
+    }
+  } else if (yCommon) {
+    return true;
+  } else if (x->offset() == y->offset()) {
+    return x->size() > y->size();
+  } else {
+    return x->offset() < y->offset();
+  }
+  return x->GetSemanticsContext().allCookedSources().Precedes(
+      x->name(), y->name());
+}
+bool SymbolOffsetCompare::operator()(
+    const MutableSymbolRef &x, const MutableSymbolRef &y) const {
+  return (*this)(SymbolRef{*x}, SymbolRef{*y});
+}
+
 } // namespace Fortran::semantics

flang/lib/Semantics/tools.cpp

if (const auto *details{symbol.detailsIf<DerivedTypeDetails>()}) {
       if (const Symbol * parent{details->GetParentComponent(*scope)}) {
         return parent->GetType();
       }
     }
   }
   return nullptr;
 }
 
+const EquivalenceSet *FindEquivalenceSet(const Symbol &symbol) {
+  const Symbol &ultimate{symbol.GetUltimate()};
+  for (const EquivalenceSet &set : ultimate.owner().equivalenceSets()) {
+    for (const EquivalenceObject &object : set) {
+      if (object.symbol == ultimate) {
+        return &set;
+      }
+    }
+  }
+  return nullptr;
+}
+
 bool IsExtensibleType(const DerivedTypeSpec *derived) {
   return derived && !IsIsoCType(derived) &&
       !derived->typeSymbol().attrs().test(Attr::BIND_C) &&
       !derived->typeSymbol().get<DerivedTypeDetails>().sequence();
 }
 
 bool IsBuiltinDerivedType(const DerivedTypeSpec *derived, const char *name) {
   if (!derived) {
bool CanBeTypeBoundProc(const Symbol *symbol) {
   } else if (const auto *proc{symbol->detailsIf<ProcEntityDetails>()}) {
     return !symbol->attrs().test(Attr::INTRINSIC) &&
         proc->HasExplicitInterface();
   } else {
     return false;
   }
 }
 
-bool IsStaticallyInitialized(const Symbol &symbol, bool ignoreDATAstatements) {
-  if (!ignoreDATAstatements && symbol.test(Symbol::Flag::InDataStmt)) {
-    return true;
-  } else if (IsNamedConstant(symbol)) {
+bool HasDeclarationInitializer(const Symbol &symbol) {
+  if (IsNamedConstant(symbol)) {
     return false;
   } else if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
     return object->init().has_value();
   } else if (const auto *proc{symbol.detailsIf<ProcEntityDetails>()}) {
     return proc->init().has_value();
-  }
+  } else {
     return false;
   }
+}
 
-bool IsInitialized(const Symbol &symbol, bool ignoreDATAstatements,
-    const Symbol *derivedTypeSymbol) {
-  if (IsStaticallyInitialized(symbol, ignoreDATAstatements) ||
-      IsAllocatable(symbol)) {
+bool IsInitialized(const Symbol &symbol, bool ignoreDataStatements) {
+  if (IsAllocatable(symbol) ||
+      (!ignoreDataStatements && symbol.test(Symbol::Flag::InDataStmt)) ||
+      HasDeclarationInitializer(symbol)) {
     return true;
   } else if (IsNamedConstant(symbol) || IsFunctionResult(symbol) ||
       IsPointer(symbol)) {
     return false;
   } else if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
     if (!object->isDummy() && object->type()) {
-      const auto *derived{object->type()->AsDerived()};
-      // error recovery: avoid infinite recursion on invalid
-      // recursive usage of a derived type
-      return derived && &derived->typeSymbol() != derivedTypeSymbol &&
-          derived->HasDefaultInitialization();
+      if (const auto *derived{object->type()->AsDerived()}) {
+        DirectComponentIterator directs{*derived};
+        return bool{std::find_if(
+            directs.begin(), directs.end(), [](const Symbol &component) {
+              return IsAllocatable(component) ||
+                  HasDeclarationInitializer(component);
+            })};
+      }
     }
   }
   return false;
 }
 
 bool IsDestructible(const Symbol &symbol, const Symbol *derivedTypeSymbol) {
   if (IsAllocatable(symbol) || IsAutomatic(symbol)) {
     return true;

 }
 
 // C722 and C723:  For a function to be assumed length, it must be external and
 // of CHARACTER type
 bool IsExternal(const Symbol &symbol) {
   return ClassifyProcedure(symbol) == ProcedureDefinitionClass::External;
 }
 
+// Most scopes have no EQUIVALENCE, and this function is a fast no-op for them.
+std::list<std::list<SymbolRef>> GetStorageAssociations(const Scope &scope) {
+  UnorderedSymbolSet distinct;
+  for (const EquivalenceSet &set : scope.equivalenceSets()) {
+    for (const EquivalenceObject &object : set) {
+      distinct.emplace(object.symbol);
+    }
+  }
+  // This set is ordered by ascending offsets, with ties broken by greatest
+  // size.  A multiset is used here because multiple symbols may have the
+  // same offset and size; the symbols in the set, however, are distinct.
+  std::multiset<SymbolRef, SymbolOffsetCompare> associated;
+  for (SymbolRef ref : distinct) {
+    associated.emplace(*ref);
+  }
+  std::list<std::list<SymbolRef>> result;
+  std::size_t limit{0};
+  const Symbol *currentCommon{nullptr};
+  for (const Symbol &symbol : associated) {
+    const Symbol *thisCommon{FindCommonBlockContaining(symbol)};
+    if (result.empty() || symbol.offset() >= limit ||
+        thisCommon != currentCommon) {
+      // Start a new group
+      result.emplace_back(std::list<SymbolRef>{});
+      limit = 0;
+      currentCommon = thisCommon;
+    }
+    result.back().emplace_back(symbol);
+    limit = std::max(limit, symbol.offset() + symbol.size());
+  }
+  return result;
+}
+
 bool IsModuleProcedure(const Symbol &symbol) {
   return ClassifyProcedure(symbol) == ProcedureDefinitionClass::Module;
 }
 const Symbol *IsExternalInPureContext(
     const Symbol &symbol, const Scope &scope) {
   if (const auto *pureProc{FindPureProcedureContaining(scope)}) {
     return FindExternallyVisibleObject(symbol.GetUltimate(), *pureProc);
   }

flang/lib/Semantics/type.cpp

 }
 
 bool DerivedTypeSpec::IsForwardReferenced() const {
   return typeSymbol_.get<DerivedTypeDetails>().isForwardReferenced();
 }
 
 bool DerivedTypeSpec::HasDefaultInitialization() const {
   DirectComponentIterator components{*this};
-  return bool{std::find_if(
-      components.begin(), components.end(), [&](const Symbol &component) {
-        return IsInitialized(component, false, &typeSymbol());
-      })};
+  return bool{std::find_if(components.begin(), components.end(),
+      [&](const Symbol &component) { return IsInitialized(component); })};
 }
 
 bool DerivedTypeSpec::HasDestruction() const {
   if (!typeSymbol().get<DerivedTypeDetails>().finals().empty()) {
     return true;
   }
   DirectComponentIterator components{*this};
   return bool{std::find_if(

flang/test/Semantics/data12.f90

+! RUN: %S/test_errors.sh %s %t %flang_fc1
+! REQUIRES: shell
+type :: t1
+  sequence
+  integer :: m = 123
+  integer :: pad
+end type
+type :: t2
+  sequence
+  integer :: n = 123
+  integer :: pad
+end type
+type :: t3
+  sequence
+  integer :: k = 234
+  integer :: pad
+end type
+!ERROR: Distinct default component initializations of equivalenced objects affect 'x1a%m' more than once
+type(t1) :: x1a
+!ERROR: Distinct default component initializations of equivalenced objects affect 'x2a%n' more than once
+type(t2) :: x2a
+!ERROR: Distinct default component initializations of equivalenced objects affect 'x3%k' more than once
+type(t3), save :: x3
+!ERROR: Explicit initializations of equivalenced objects affect 'ja(2_8)' more than once
+!ERROR: Explicit initializations of equivalenced objects affect 'ka(1_8)' more than once
+integer :: ja(2), ka(2)
+data ja/345, 456/
+data ka/456, 567/
+equivalence(x1a, x2a, x3)
+! Same value: no error
+type(t1) :: x1b
+type(t2) :: x2b
+equivalence(x1b, x2b)
+equivalence(ja(2),ka(1))
+end

flang/test/Semantics/data13.f90

+! RUN: %flang_fc1 -fsyntax-only -fdebug-dump-symbols %s 2>&1 | FileCheck %s
+! Verify that the closure of EQUIVALENCE'd symbols with any DATA
+! initialization produces a combined initializer, with explicit
+! initialization overriding any default component initialization.
+! CHECK: .F18.0, SAVE (CompilerCreated) size=8 offset=0: ObjectEntity type: INTEGER(4) shape: 1_8:2_8 init:[INTEGER(4)::456_4,234_4]
+! CHECK: ja (InDataStmt) size=8 offset=0: ObjectEntity type: INTEGER(4) shape: 1_8:2_8
+! CHECK-NOT: x0, SAVE size=8 offset=8: ObjectEntity type: TYPE(t1) init:t1(m=123_4,n=234_4)
+! CHECK: x1 size=8 offset=16: ObjectEntity type: TYPE(t1) init:t1(m=345_4,n=234_4)
+! CHECK: x2 size=8 offset=0: ObjectEntity type: TYPE(t1)
+! CHECK-NOT: x3a, SAVE size=8 offset=24: ObjectEntity type: TYPE(t3) init:t3(t2=t2(k=567_4),j=0_4)
+! CHECK: x3b size=8 offset=32: ObjectEntity type: TYPE(t3) init:t3(k=567_4,j=678_4)
+! CHECK: Equivalence Sets: (x2,ja(1)) (.F18.0,x2)
+type :: t1
+  sequence
+  integer :: m = 123
+  integer :: n = 234
+end type
+type :: t2
+  integer :: k = 567
+end type
+type, extends(t2) :: t3
+  integer :: j ! uninitialized
+end type
+type(t1), save :: x0 ! not enabled
+type(t1) :: x1 = t1(m=345)
+type(t1) :: x2
+type(t3), save :: x3a ! not enabled
+type(t3) :: x3b = t3(j=678)
+integer :: ja(2)
+equivalence(x2, ja)
+data ja(1)/456/
+end

flang/test/Semantics/typeinfo01.f90

 !RUN: %flang_fc1 -fdebug-dump-symbols %s | FileCheck %s
 ! Tests for derived type runtime descriptions
 
 module m01
   type :: t1
     integer :: n
   end type
 !CHECK: Module scope: m01
-!CHECK: .c.t1, SAVE, TARGET: ObjectEntity type: TYPE(component) shape: 0_8:0_8 init:[component::component(name=.n.n,genre=1_1,category=0_1,kind=4_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
-!CHECK: .dt.t1, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t1,sizeinbytes=4_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=.c.t1,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .n.n, SAVE, TARGET: ObjectEntity type: CHARACTER(1_8,1) init:"n"
-!CHECK: .n.t1, SAVE, TARGET: ObjectEntity type: CHARACTER(2_8,1) init:"t1"
+!CHECK: .c.t1, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(component) shape: 0_8:0_8 init:[component::component(name=.n.n,genre=1_1,category=0_1,kind=4_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
+!CHECK: .dt.t1, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t1,sizeinbytes=4_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=.c.t1,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .n.n, SAVE, TARGET (CompilerCreated): ObjectEntity type: CHARACTER(1_8,1) init:"n"
+!CHECK: .n.t1, SAVE, TARGET (CompilerCreated): ObjectEntity type: CHARACTER(2_8,1) init:"t1"
 !CHECK: DerivedType scope: t1
 end module
 
 module m02
   type :: parent
     integer :: pn
   end type
   type, extends(parent) :: child
     integer :: cn
   end type
-!CHECK: .c.child, SAVE, TARGET: ObjectEntity type: TYPE(component) shape: 0_8:1_8 init:[component::component(name=.n.parent,genre=1_1,category=5_1,kind=0_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=.dt.parent,lenvalue=NULL(),bounds=NULL(),initialization=NULL()),component(name=.n.cn,genre=1_1,category=0_1,kind=4_1,rank=0_1,offset=4_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
-!CHECK: .c.parent, SAVE, TARGET: ObjectEntity type: TYPE(component) shape: 0_8:0_8 init:[component::component(name=.n.pn,genre=1_1,category=0_1,kind=4_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
-!CHECK: .dt.child, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.child,sizeinbytes=8_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=.c.child,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=1_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .dt.parent, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.parent,sizeinbytes=4_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=.c.parent,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .c.child, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(component) shape: 0_8:1_8 init:[component::component(name=.n.parent,genre=1_1,category=5_1,kind=0_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=.dt.parent,lenvalue=NULL(),bounds=NULL(),initialization=NULL()),component(name=.n.cn,genre=1_1,category=0_1,kind=4_1,rank=0_1,offset=4_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
+!CHECK: .c.parent, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(component) shape: 0_8:0_8 init:[component::component(name=.n.pn,genre=1_1,category=0_1,kind=4_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
+!CHECK: .dt.child, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.child,sizeinbytes=8_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=.c.child,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=1_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .dt.parent, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.parent,sizeinbytes=4_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=.c.parent,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
 end module
 
 module m03
   type :: kpdt(k)
     integer(kind=1), kind :: k = 1
     real(kind=k) :: a
   end type
   type(kpdt(4)) :: x
-!CHECK: .c.kpdt.0, SAVE, TARGET: ObjectEntity type: TYPE(component) shape: 0_8:0_8 init:[component::component(name=.n.a,genre=1_1,category=1_1,kind=4_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
-!CHECK: .dt.kpdt, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(name=.n.kpdt,uninstantiated=NULL(),kindparameter=.kp.kpdt,lenparameterkind=NULL())
-!CHECK: .dt.kpdt.0, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.kpdt,sizeinbytes=4_8,uninstantiated=.dt.kpdt,kindparameter=.kp.kpdt.0,lenparameterkind=NULL(),component=.c.kpdt.0,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .kp.kpdt, SAVE, TARGET: ObjectEntity type: INTEGER(8) shape: 0_8:0_8 init:[INTEGER(8)::1_8]
-!CHECK: .kp.kpdt.0, SAVE, TARGET: ObjectEntity type: INTEGER(8) shape: 0_8:0_8 init:[INTEGER(8)::4_8]
+!CHECK: .c.kpdt.0, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(component) shape: 0_8:0_8 init:[component::component(name=.n.a,genre=1_1,category=1_1,kind=4_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
+!CHECK: .dt.kpdt, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(name=.n.kpdt,uninstantiated=NULL(),kindparameter=.kp.kpdt,lenparameterkind=NULL())
+!CHECK: .dt.kpdt.0, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.kpdt,sizeinbytes=4_8,uninstantiated=.dt.kpdt,kindparameter=.kp.kpdt.0,lenparameterkind=NULL(),component=.c.kpdt.0,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .kp.kpdt, SAVE, TARGET (CompilerCreated): ObjectEntity type: INTEGER(8) shape: 0_8:0_8 init:[INTEGER(8)::1_8]
+!CHECK: .kp.kpdt.0, SAVE, TARGET (CompilerCreated): ObjectEntity type: INTEGER(8) shape: 0_8:0_8 init:[INTEGER(8)::4_8]
 end module
 
 module m04
   type :: tbps
    contains
     procedure :: b2 => s1
     procedure :: b1 => s1
   end type
  contains
   subroutine s1(x)
     class(tbps), intent(in) :: x
   end subroutine
-!CHECK: .dt.tbps, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.tbps,name=.n.tbps,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .v.tbps, SAVE, TARGET: ObjectEntity type: TYPE(binding) shape: 0_8:1_8 init:[binding::binding(proc=s1,name=.n.b1),binding(proc=s1,name=.n.b2)]
+!CHECK: .dt.tbps, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.tbps,name=.n.tbps,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .v.tbps, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(binding) shape: 0_8:1_8 init:[binding::binding(proc=s1,name=.n.b1),binding(proc=s1,name=.n.b2)]
 end module
 
 module m05
   type :: t
     procedure(s1), pointer :: p1 => s1
   end type
  contains
   subroutine s1(x)
     class(t), intent(in) :: x
   end subroutine
-!CHECK: .dt.t, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t,sizeinbytes=24_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=.p.t,special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=0_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .p.t, SAVE, TARGET: ObjectEntity type: TYPE(procptrcomponent) shape: 0_8:0_8 init:[procptrcomponent::procptrcomponent(name=.n.p1,offset=0_8,initialization=s1)]
+!CHECK: .dt.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t,sizeinbytes=24_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=.p.t,special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=0_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .p.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(procptrcomponent) shape: 0_8:0_8 init:[procptrcomponent::procptrcomponent(name=.n.p1,offset=0_8,initialization=s1)]
 end module
 
 module m06
   type :: t
    contains
     procedure :: s1
     generic :: assignment(=) => s1
   end type
   type, extends(t) :: t2
    contains
     procedure :: s1 => s2 ! override
   end type
  contains
   subroutine s1(x, y)
     class(t), intent(out) :: x
     class(t), intent(in) :: y
   end subroutine
   subroutine s2(x, y)
     class(t2), intent(out) :: x
     class(t), intent(in) :: y
   end subroutine
-!CHECK: .c.t2, SAVE, TARGET: ObjectEntity type: TYPE(component) shape: 0_8:0_8 init:[component::component(name=.n.t,genre=1_1,category=5_1,kind=0_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=.dt.t,lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
-!CHECK: .dt.t, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.t,name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=2_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .dt.t2, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.t2,name=.n.t2,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=.c.t2,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=1_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .s.t, SAVE, TARGET: ObjectEntity type: TYPE(specialbinding) shape: 0_8:0_8 init:[specialbinding::specialbinding(which=1_1,isargdescriptorset=3_1,proc=s1)]
-!CHECK: .v.t, SAVE, TARGET: ObjectEntity type: TYPE(binding) shape: 0_8:0_8 init:[binding::binding(proc=s1,name=.n.s1)]
-!CHECK: .v.t2, SAVE, TARGET: ObjectEntity type: TYPE(binding) shape: 0_8:0_8 init:[binding::binding(proc=s2,name=.n.s1)]
+!CHECK: .c.t2, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(component) shape: 0_8:0_8 init:[component::component(name=.n.t,genre=1_1,category=5_1,kind=0_1,rank=0_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=.dt.t,lenvalue=NULL(),bounds=NULL(),initialization=NULL())]
+!CHECK: .dt.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.t,name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=2_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .dt.t2, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.t2,name=.n.t2,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=.c.t2,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=1_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .s.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(specialbinding) shape: 0_8:0_8 init:[specialbinding::specialbinding(which=1_1,isargdescriptorset=3_1,proc=s1)]
+!CHECK: .v.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(binding) shape: 0_8:0_8 init:[binding::binding(proc=s1,name=.n.s1)]
+!CHECK: .v.t2, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(binding) shape: 0_8:0_8 init:[binding::binding(proc=s2,name=.n.s1)]
 end module
 
 module m07
   type :: t
    contains
     procedure :: s1
     generic :: assignment(=) => s1
   end type
  contains
   impure elemental subroutine s1(x, y)
     class(t), intent(out) :: x
     class(t), intent(in) :: y
   end subroutine
-!CHECK: .dt.t, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.t,name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=4_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .s.t, SAVE, TARGET: ObjectEntity type: TYPE(specialbinding) shape: 0_8:0_8 init:[specialbinding::specialbinding(which=2_1,isargdescriptorset=3_1,proc=s1)]
-!CHECK: .v.t, SAVE, TARGET: ObjectEntity type: TYPE(binding) shape: 0_8:0_8 init:[binding::binding(proc=s1,name=.n.s1)]
+!CHECK: .dt.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.t,name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=4_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .s.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(specialbinding) shape: 0_8:0_8 init:[specialbinding::specialbinding(which=2_1,isargdescriptorset=3_1,proc=s1)]
+!CHECK: .v.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(binding) shape: 0_8:0_8 init:[binding::binding(proc=s1,name=.n.s1)]
 end module
 
 module m08
   type :: t
    contains
     final :: s1, s2, s3
   end type
  contains
   subroutine s1(x)
     type(t) :: x(:)
   end subroutine
   subroutine s2(x)
     type(t) :: x(3,3)
   end subroutine
   impure elemental subroutine s3(x)
     type(t) :: x
   end subroutine
-!CHECK: .dt.t, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=3200_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=0_1,nofinalizationneeded=0_1)
-!CHECK: .s.t, SAVE, TARGET: ObjectEntity type: TYPE(specialbinding) shape: 0_8:2_8 init:[specialbinding::specialbinding(which=7_1,isargdescriptorset=0_1,proc=s3),specialbinding(which=10_1,isargdescriptorset=1_1,proc=s1),specialbinding(which=11_1,isargdescriptorset=0_1,proc=s2)]
+!CHECK: .dt.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=3200_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=0_1,nofinalizationneeded=0_1)
+!CHECK: .s.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(specialbinding) shape: 0_8:2_8 init:[specialbinding::specialbinding(which=7_1,isargdescriptorset=0_1,proc=s3),specialbinding(which=10_1,isargdescriptorset=1_1,proc=s1),specialbinding(which=11_1,isargdescriptorset=0_1,proc=s2)]
 end module
 
 module m09
   type :: t
    contains
     procedure :: rf, ru, wf, wu
     generic :: read(formatted) => rf
     generic :: read(unformatted) => ru
subroutine wf(x,u,iot,v,iostat,iomsg)
     character(len=*), intent(inout) :: iomsg
   end subroutine
   subroutine wu(x,u,iostat,iomsg)
     class(t), intent(in) :: x
     integer, intent(in) :: u
     integer, intent(out) :: iostat
     character(len=*), intent(inout) :: iomsg
   end subroutine
-!CHECK: .dt.t, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.t,name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=120_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .s.t, SAVE, TARGET: ObjectEntity type: TYPE(specialbinding) shape: 0_8:3_8 init:[specialbinding::specialbinding(which=3_1,isargdescriptorset=1_1,proc=rf),specialbinding(which=4_1,isargdescriptorset=1_1,proc=ru),specialbinding(which=5_1,isargdescriptorset=1_1,proc=wf),specialbinding(which=6_1,isargdescriptorset=1_1,proc=wu)]
-!CHECK: .v.t, SAVE, TARGET: ObjectEntity type: TYPE(binding) shape: 0_8:3_8 init:[binding::binding(proc=rf,name=.n.rf),binding(proc=ru,name=.n.ru),binding(proc=wf,name=.n.wf),binding(proc=wu,name=.n.wu)]
+!CHECK: .dt.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=.v.t,name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=120_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .s.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(specialbinding) shape: 0_8:3_8 init:[specialbinding::specialbinding(which=3_1,isargdescriptorset=1_1,proc=rf),specialbinding(which=4_1,isargdescriptorset=1_1,proc=ru),specialbinding(which=5_1,isargdescriptorset=1_1,proc=wf),specialbinding(which=6_1,isargdescriptorset=1_1,proc=wu)]
+!CHECK: .v.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(binding) shape: 0_8:3_8 init:[binding::binding(proc=rf,name=.n.rf),binding(proc=ru,name=.n.ru),binding(proc=wf,name=.n.wf),binding(proc=wu,name=.n.wu)]
 end module
 
 module m10
   type, bind(c) :: t ! non-extensible
   end type
   interface read(formatted)
     procedure :: rf
   end interface
subroutine wf(x,u,iot,v,iostat,iomsg)
     character(len=*), intent(inout) :: iomsg
   end subroutine
   subroutine wu(x,u,iostat,iomsg)
     type(t), intent(in) :: x
     integer, intent(in) :: u
     integer, intent(out) :: iostat
     character(len=*), intent(inout) :: iomsg
   end subroutine
-!CHECK: .dt.t, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=120_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
-!CHECK: .s.t, SAVE, TARGET: ObjectEntity type: TYPE(specialbinding) shape: 0_8:3_8 init:[specialbinding::specialbinding(which=3_1,isargdescriptorset=0_1,proc=rf),specialbinding(which=4_1,isargdescriptorset=0_1,proc=ru),specialbinding(which=5_1,isargdescriptorset=0_1,proc=wf),specialbinding(which=6_1,isargdescriptorset=0_1,proc=wu)]
+!CHECK: .dt.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t,sizeinbytes=0_8,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=NULL(),component=NULL(),procptr=NULL(),special=.s.t,specialbitset=120_4,hasparent=0_1,noinitializationneeded=1_1,nodestructionneeded=1_1,nofinalizationneeded=1_1)
+!CHECK: .s.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(specialbinding) shape: 0_8:3_8 init:[specialbinding::specialbinding(which=3_1,isargdescriptorset=0_1,proc=rf),specialbinding(which=4_1,isargdescriptorset=0_1,proc=ru),specialbinding(which=5_1,isargdescriptorset=0_1,proc=wf),specialbinding(which=6_1,isargdescriptorset=0_1,proc=wu)]
 end module
 
 module m11
   real, target :: target
   type :: t(len)
     integer(kind=8), len :: len
     real, allocatable :: allocatable(:)
     real, pointer :: pointer => target
     character(len=len) :: chauto
     real :: automatic(len)
   end type
-!CHECK: .dt.t, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(name=.n.t,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=.lpk.t)
-!CHECK: .lpk.t, SAVE, TARGET: ObjectEntity type: INTEGER(1) shape: 0_8:0_8 init:[INTEGER(1)::8_1]
+!CHECK: .dt.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(name=.n.t,uninstantiated=NULL(),kindparameter=NULL(),lenparameterkind=.lpk.t)
+!CHECK: .lpk.t, SAVE, TARGET (CompilerCreated): ObjectEntity type: INTEGER(1) shape: 0_8:0_8 init:[INTEGER(1)::8_1]
  contains
   subroutine s1(x)
-!CHECK: .b.t.1.automatic, SAVE, TARGET: ObjectEntity type: TYPE(value) shape: 0_8:1_8,0_8:0_8 init:reshape([value::value(genre=2_1,value=1_8),value(genre=3_1,value=0_8)],shape=[2,1])
-!CHECK: .c.t.1, SAVE, TARGET: ObjectEntity type: TYPE(component) shape: 0_8:3_8 init:[component::component(name=.n.allocatable,genre=3_1,category=1_1,kind=4_1,rank=1_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL()),component(name=.n.pointer,genre=2_1,category=1_1,kind=4_1,rank=0_1,offset=48_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=.di.t.1.pointer),component(name=.n.chauto,genre=4_1,category=3_1,kind=1_1,rank=0_1,offset=72_8,characterlen=value(genre=3_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL()),component(name=.n.automatic,genre=4_1,category=1_1,kind=4_1,rank=1_1,offset=96_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=.b.t.1.automatic,initialization=NULL())]
-!CHECK: .di.t.1.pointer, SAVE, TARGET: ObjectEntity type: TYPE(.dp.t.1.pointer) init:.dp.t.1.pointer(pointer=target)
-!CHECK: .dp.t.1.pointer: DerivedType components: pointer
-!CHECK: .dt.t.1, SAVE, TARGET: ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t,sizeinbytes=144_8,uninstantiated=.dt.t,kindparameter=NULL(),lenparameterkind=.lpk.t.1,component=.c.t.1,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=0_1,nodestructionneeded=0_1,nofinalizationneeded=1_1)
-!CHECK: .lpk.t.1, SAVE, TARGET: ObjectEntity type: INTEGER(1) shape: 0_8:0_8 init:[INTEGER(1)::8_1]
+!CHECK: .b.t.1.automatic, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(value) shape: 0_8:1_8,0_8:0_8 init:reshape([value::value(genre=2_1,value=1_8),value(genre=3_1,value=0_8)],shape=[2,1])
+!CHECK: .c.t.1, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(component) shape: 0_8:3_8 init:[component::component(name=.n.allocatable,genre=3_1,category=1_1,kind=4_1,rank=1_1,offset=0_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL()),component(name=.n.pointer,genre=2_1,category=1_1,kind=4_1,rank=0_1,offset=48_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=.di.t.1.pointer),component(name=.n.chauto,genre=4_1,category=3_1,kind=1_1,rank=0_1,offset=72_8,characterlen=value(genre=3_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=NULL(),initialization=NULL()),component(name=.n.automatic,genre=4_1,category=1_1,kind=4_1,rank=1_1,offset=96_8,characterlen=value(genre=1_1,value=0_8),derived=NULL(),lenvalue=NULL(),bounds=.b.t.1.automatic,initialization=NULL())]
+!CHECK: .di.t.1.pointer, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(.dp.t.1.pointer) init:.dp.t.1.pointer(pointer=target)
+!CHECK: .dp.t.1.pointer (CompilerCreated): DerivedType components: pointer
+!CHECK: .dt.t.1, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(derivedtype) init:derivedtype(binding=NULL(),name=.n.t,sizeinbytes=144_8,uninstantiated=.dt.t,kindparameter=NULL(),lenparameterkind=.lpk.t.1,component=.c.t.1,procptr=NULL(),special=NULL(),specialbitset=0_4,hasparent=0_1,noinitializationneeded=0_1,nodestructionneeded=0_1,nofinalizationneeded=1_1)
+!CHECK: .lpk.t.1, SAVE, TARGET (CompilerCreated): ObjectEntity type: INTEGER(1) shape: 0_8:0_8 init:[INTEGER(1)::8_1]
 !CHECK: DerivedType scope: .dp.t.1.pointer size=24 alignment=8 instantiation of .dp.t.1.pointer
 !CHECK: pointer, POINTER size=24 offset=0: ObjectEntity type: REAL(4)
     type(t(*)), intent(in) :: x
   end subroutine
 end module
 
 module m12
   type :: t1
     integer :: n
     integer :: n2
     integer :: n_3
-    ! CHECK: .n.n, SAVE, TARGET: ObjectEntity type: CHARACTER(1_8,1) init:"n"
-    ! CHECK: .n.n2, SAVE, TARGET: ObjectEntity type: CHARACTER(2_8,1) init:"n2"
-    ! CHECK: .n.n_3, SAVE, TARGET: ObjectEntity type: CHARACTER(3_8,1) init:"n_3"
+    ! CHECK: .n.n, SAVE, TARGET (CompilerCreated): ObjectEntity type: CHARACTER(1_8,1) init:"n"
+    ! CHECK: .n.n2, SAVE, TARGET (CompilerCreated): ObjectEntity type: CHARACTER(2_8,1) init:"n2"
+    ! CHECK: .n.n_3, SAVE, TARGET (CompilerCreated): ObjectEntity type: CHARACTER(3_8,1) init:"n_3"
   end type
 end module
 
 module m13
   type :: t1
     integer :: n
    contains
     procedure :: assign1, assign2
     generic :: assignment(=) => assign1, assign2
-    ! CHECK: .s.t1, SAVE, TARGET: ObjectEntity type: TYPE(specialbinding) shape: 0_8:0_8 init:[specialbinding::specialbinding(which=2_1,isargdescriptorset=3_1,proc=assign1)]
+    ! CHECK: .s.t1, SAVE, TARGET (CompilerCreated): ObjectEntity type: TYPE(specialbinding) shape: 0_8:0_8 init:[specialbinding::specialbinding(which=2_1,isargdescriptorset=3_1,proc=assign1)]
   end type
  contains
   impure elemental subroutine assign1(to, from)
     class(t1), intent(out) :: to
     class(t1), intent(in) :: from
   end subroutine
   impure elemental subroutine assign2(to, from)
     class(t1), intent(out) :: to
     integer, intent(in) :: from
   end subroutine
 end module