[flang] Make subscript list argument a nullable pointer

[klausler]

Summary

Component::CreatePointerDescriptor unconditionally expects a
vector of subscripts to be passed as an argument, but is called
from NAMELIST input with a null pointer. Make that argument
a nullable pointer, move it to the end of the argument list,
and give it a default value of nullptr.

[rovka]

LGTM, but I think it would look even better if the terminator were the first parameter (instead of breaking up the flow of the other parameters).

flang/runtime/type-info.cpp

174

Why are you removing all the 0x? Seems off-topic.

[klausler]

flang/runtime/type-info.cpp

174

Because I noticed that the dump output had "0x0x" in it as I was debugging the problem, so I cleaned that up.

flang/runtime/assign.cpp

for (std::size_t k{0}; k < numComponents; ++k) {
       switch (comp.genre()) {
       case typeInfo::Component::Genre::Data:
         if (comp.category() == TypeCategory::Derived) {
           StaticDescriptor<maxRank, true, 10 /*?*/> statDesc[2];
           Descriptor &toCompDesc{statDesc[0].descriptor()};
           Descriptor &fromCompDesc{statDesc[1].descriptor()};
           for (std::size_t j{0}; j < toElements; ++j,
                to.IncrementSubscripts(toAt), from.IncrementSubscripts(fromAt)) {
-            comp.CreatePointerDescriptor(toCompDesc, to, toAt, terminator);
+            comp.CreatePointerDescriptor(toCompDesc, to, terminator, toAt);
             comp.CreatePointerDescriptor(
-                fromCompDesc, from, fromAt, terminator);
+                fromCompDesc, from, terminator, fromAt);
             Assign(toCompDesc, fromCompDesc, terminator);
           }
         } else { // Component has intrinsic type; simply copy raw bytes
           std::size_t componentByteSize{comp.SizeInBytes(to)};
           for (std::size_t j{0}; j < toElements; ++j,
                to.IncrementSubscripts(toAt), from.IncrementSubscripts(fromAt)) {
             std::memmove(to.Element<char>(toAt) + comp.offset(),
                 from.Element<const char>(fromAt) + comp.offset(),

flang/runtime/descriptor-io.h

 static bool DefaultFormattedComponentIO(IoStatementState &io,
     const typeInfo::Component &component, const Descriptor &origDescriptor,
     const SubscriptValue origSubscripts[], Terminator &terminator) {
   if (component.genre() == typeInfo::Component::Genre::Data) {
     // Create a descriptor for the component
     StaticDescriptor<maxRank, true, 16 /*?*/> statDesc;
     Descriptor &desc{statDesc.descriptor()};
     component.CreatePointerDescriptor(
-        desc, origDescriptor, origSubscripts, terminator);
+        desc, origDescriptor, terminator, origSubscripts);
     return DescriptorIO<DIR>(io, desc);
   } else {
     // Component is itself a descriptor
     char *pointer{
         origDescriptor.Element<char>(origSubscripts) + component.offset()};
     RUNTIME_CHECK(
         terminator, component.genre() == typeInfo::Component::Genre::Automatic);
     const Descriptor &compDesc{*reinterpret_cast<const Descriptor *>(pointer)};

flang/runtime/namelist.cpp

static bool HandleComponent(IoStatementState &io, Descriptor &desc,
   io.HandleRelativePosition(1); // skip '%'
   char compName[nameBufferSize];
   if (GetLowerCaseName(io, compName, sizeof compName)) {
     const DescriptorAddendum *addendum{source.Addendum()};
     if (const typeInfo::DerivedType *
         type{addendum ? addendum->derivedType() : nullptr}) {
       if (const typeInfo::Component *
           comp{type->FindDataComponent(compName, std::strlen(compName))}) {
-        comp->CreatePointerDescriptor(desc, source, nullptr, handler);
+        comp->CreatePointerDescriptor(desc, source, handler);
         return true;
       } else {
         handler.SignalError(
             "NAMELIST component reference '%%%s' of input group item %s is not "
             "a component of its derived type",
             compName, name);
       }
+    } else if (source.type().IsDerived()) {
+      handler.Crash("Derived type object '%s' in NAMELIST is missing its "
+                    "derived type information!",
+          name);
     } else {
       handler.SignalError("NAMELIST component reference '%%%s' of input group "
                           "item %s for non-derived type",
           compName, name);
     }
   } else {
     handler.SignalError("NAMELIST component reference of input group item %s "
                         "has no name after '%'",
while (true) {
     StaticDescriptor<maxRank, true, 16> staticDesc[2];
     int whichStaticDesc{0};
     next = io.GetCurrentChar();
     if (next && (*next == '(' || *next == '%')) {
       do {
         Descriptor &mutableDescriptor{staticDesc[whichStaticDesc].descriptor()};
         whichStaticDesc ^= 1;
         if (*next == '(') {
-          HandleSubscripts(io, mutableDescriptor, *useDescriptor, name);
+          if (!(HandleSubscripts(
+                  io, mutableDescriptor, *useDescriptor, name))) {
+            return false;
+          }
         } else {
-          HandleComponent(io, mutableDescriptor, *useDescriptor, name);
+          if (!HandleComponent(io, mutableDescriptor, *useDescriptor, name)) {
+            return false;
+          }
         }
         useDescriptor = &mutableDescriptor;
         next = io.GetCurrentChar();
       } while (next && (*next == '(' || *next == '%'));
     }
     // Skip the '='
     next = io.GetNextNonBlank();
     if (!next || *next != '=') {

flang/runtime/type-info.h

public:
   // For ocmponents that are descriptors, returns size of descriptor;
   // for Genre::Data, returns elemental byte size times element count.
   std::size_t SizeInBytes(const Descriptor &) const;
 
   // Establishes a descriptor from this component description.
   void EstablishDescriptor(
       Descriptor &, const Descriptor &container, Terminator &) const;
 
-  // Creates a pointer descriptor from this component description.
+  // Creates a pointer descriptor from this component description, possibly
+  // with subscripts
   void CreatePointerDescriptor(Descriptor &, const Descriptor &container,
-      const SubscriptValue[], Terminator &) const;
+      Terminator &, const SubscriptValue * = nullptr) const;
 
   FILE *Dump(FILE * = stdout) const;
 
 private:
   StaticDescriptor<0> name_; // CHARACTER(:), POINTER
   Genre genre_{Genre::Data};
   std::uint8_t category_; // common::TypeCategory
   std::uint8_t kind_{0};

flang/runtime/type-info.cpp

for (int j{0}; j < rank_; ++j) {
       dim.SetBounds(*lb, *ub);
       dim.SetByteStride(byteStride);
       byteStride *= dim.Extent();
     }
   }
 }
 
 void Component::CreatePointerDescriptor(Descriptor &descriptor,
-    const Descriptor &container, const SubscriptValue subscripts[],
-    Terminator &terminator) const {
+    const Descriptor &container, Terminator &terminator,
+    const SubscriptValue *subscripts) const {
   RUNTIME_CHECK(terminator, genre_ == Genre::Data);
   EstablishDescriptor(descriptor, container, terminator);
+  if (subscripts) {
     descriptor.set_base_addr(container.Element<char>(subscripts) + offset_);
+  } else {
+    descriptor.set_base_addr(container.OffsetElement<char>() + offset_);
+  }
   descriptor.raw().attribute = CFI_attribute_pointer;
 }
 
 const DerivedType *DerivedType::GetParentType() const {
   if (hasParent_) {
     const Descriptor &compDesc{component()};
     const Component &component{*compDesc.OffsetElement<const Component>()};
     return component.derivedType();
if (desc.raw().version == CFI_VERSION &&
     std::fwrite(desc.OffsetElement(), desc.ElementBytes(), 1, f);
   } else {
     std::fprintf(f, "bad %s descriptor: ", what);
     desc.Dump(f);
   }
 }
 
 FILE *DerivedType::Dump(FILE *f) const {
-  std::fprintf(
-      f, "DerivedType @ 0x%p:\n", reinterpret_cast<const void *>(this));
+  std::fprintf(f, "DerivedType @ %p:\n", reinterpret_cast<const void *>(this));
   const std::uint64_t *uints{reinterpret_cast<const std::uint64_t *>(this)};
   for (int j{0}; j < 64; ++j) {
     int offset{j * static_cast<int>(sizeof *uints)};
-    std::fprintf(f, "    [+%3d](0x%p) 0x%016jx", offset,
+    std::fprintf(f, "    [+%3d](%p) 0x%016jx", offset,
         reinterpret_cast<const void *>(&uints[j]),
         static_cast<std::uintmax_t>(uints[j]));
     if (offset == offsetof(DerivedType, binding_)) {
       std::fputs(" <-- binding_\n", f);
     } else if (offset == offsetof(DerivedType, name_)) {
       std::fputs(" <-- name_\n", f);
     } else if (offset == offsetof(DerivedType, sizeInBytes_)) {
       std::fputs(" <-- sizeInBytes_\n", f);
FILE *DerivedType::Dump(FILE *f) const {
   for (std::size_t j{0}; j < specials; ++j) {
     std::fprintf(f, "  [%3zd] ", j);
     specialDesc.ZeroBasedIndexedElement<SpecialBinding>(j)->Dump(f);
   }
   return f;
 }
 
 FILE *Component::Dump(FILE *f) const {
-  std::fprintf(f, "Component @ 0x%p:\n", reinterpret_cast<const void *>(this));
+  std::fprintf(f, "Component @ %p:\n", reinterpret_cast<const void *>(this));
   std::fputs("    name: ", f);
   DumpScalarCharacter(f, name(), "Component::name");
   if (genre_ == Genre::Data) {
     std::fputs("    Data       ", f);
   } else if (genre_ == Genre::Pointer) {
     std::fputs("    Pointer    ", f);
   } else if (genre_ == Genre::Allocatable) {
     std::fputs("    Allocatable", f);
   } else if (genre_ == Genre::Automatic) {
     std::fputs("    Automatic  ", f);
   } else {
     std::fprintf(f, "    (bad genre 0x%x)", static_cast<int>(genre_));
   }
   std::fprintf(f, " category %d  kind %d  rank %d  offset 0x%zx\n", category_,
       kind_, rank_, static_cast<std::size_t>(offset_));
   if (initialization_) {
-    std::fprintf(f, " initialization @ 0x%p:\n",
+    std::fprintf(f, " initialization @ %p:\n",
         reinterpret_cast<const void *>(initialization_));
     for (int j{0}; j < 128; j += sizeof(std::uint64_t)) {
       std::fprintf(f, " [%3d] 0x%016jx\n", j,
           static_cast<std::uintmax_t>(
               *reinterpret_cast<const std::uint64_t *>(initialization_ + j)));
     }
   }
   return f;
 }
 
 FILE *SpecialBinding::Dump(FILE *f) const {
   std::fprintf(
-      f, "SpecialBinding @ 0x%p:\n", reinterpret_cast<const void *>(this));
+      f, "SpecialBinding @ %p:\n", reinterpret_cast<const void *>(this));
   switch (which_) {
   case Which::ScalarAssignment:
     std::fputs("    ScalarAssignment", f);
     break;
   case Which::ElementalAssignment:
     std::fputs("    ElementalAssignment", f);
     break;
   case Which::ReadFormatted:
case Which::AssumedRankFinal:
     std::fputs("    AssumedRankFinal", f);
     break;
   default:
     std::fprintf(f, "    rank-%d final:",
         static_cast<int>(which_) - static_cast<int>(Which::ScalarFinal));
     break;
   }
   std::fprintf(f, "    isArgDescriptorSet: 0x%x\n", isArgDescriptorSet_);
-  std::fprintf(f, "    proc: 0x%p\n", reinterpret_cast<void *>(proc_));
+  std::fprintf(f, "    proc: %p\n", reinterpret_cast<void *>(proc_));
   return f;
 }
 
 } // namespace Fortran::runtime::typeInfo