[flang] Don't construct TBP bindings for abstract derived types

[klausler]

Summary

The tables constructed by semantics that describe derived types to
the runtime support library must not include "vtable" entries for
the deferred type-bound procedures of abstract derived types;
these can turn out to be unsatisfiable external references to
procedures whose interfaces were used in the definitions of those
bindings.

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

AddValue(dtValues, derivedTypeSchema_, "component"s,
                     dataComponents.size())}));
     AddValue(dtValues, derivedTypeSchema_, "procptr"s,
         SaveDerivedPointerTarget(scope, SaveObjectName(".p."s + distinctName),
             std::move(procPtrComponents),
             evaluate::ConstantSubscripts{
                 static_cast<evaluate::ConstantSubscript>(
                     procPtrComponents.size())}));
     // Compile the "vtable" of type-bound procedure bindings
+    std::uint32_t specialBitSet{0};
+    bool isAbstractType{dtSymbol->attrs().test(Attr::ABSTRACT)};
+    if (!isAbstractType) {
       std::vector<evaluate::StructureConstructor> bindings{
           DescribeBindings(dtScope, scope)};
       AddValue(dtValues, derivedTypeSchema_, "binding"s,
           SaveDerivedPointerTarget(scope, SaveObjectName(".v."s + distinctName),
               std::move(bindings),
               evaluate::ConstantSubscripts{
                   static_cast<evaluate::ConstantSubscript>(bindings.size())}));
       // Describe "special" bindings to defined assignments, FINAL subroutines,
       // and user-defined derived type I/O subroutines.
       const DerivedTypeDetails &dtDetails{dtSymbol->get<DerivedTypeDetails>()};
       for (const auto &pair : dtDetails.finals()) {
-      DescribeSpecialProc(
-          specials, *pair.second, false /*!isAssignment*/, true, std::nullopt);
+        DescribeSpecialProc(specials, *pair.second, false /*!isAssignment*/,
+            true, std::nullopt);
       }
       IncorporateDefinedIoGenericInterfaces(
           specials, GenericKind::DefinedIo::ReadFormatted, &scope);
       IncorporateDefinedIoGenericInterfaces(
           specials, GenericKind::DefinedIo::ReadUnformatted, &scope);
       IncorporateDefinedIoGenericInterfaces(
           specials, GenericKind::DefinedIo::WriteFormatted, &scope);
       IncorporateDefinedIoGenericInterfaces(
           specials, GenericKind::DefinedIo::WriteUnformatted, &scope);
       // Pack the special procedure bindings in ascending order of their "which"
       // code values, and compile a little-endian bit-set of those codes for
       // use in O(1) look-up at run time.
       std::vector<evaluate::StructureConstructor> sortedSpecials;
-    std::uint32_t specialBitSet{0};
       for (auto &pair : specials) {
         auto bit{std::uint32_t{1} << pair.first};
         CHECK(!(specialBitSet & bit));
         specialBitSet |= bit;
         sortedSpecials.emplace_back(std::move(pair.second));
       }
       AddValue(dtValues, derivedTypeSchema_, "special"s,
           SaveDerivedPointerTarget(scope, SaveObjectName(".s."s + distinctName),
               std::move(sortedSpecials),
               evaluate::ConstantSubscripts{
                   static_cast<evaluate::ConstantSubscript>(specials.size())}));
+    }
     AddValue(dtValues, derivedTypeSchema_, "specialbitset"s,
         IntExpr<4>(specialBitSet));
     // Note the presence/absence of a parent component
     AddValue(dtValues, derivedTypeSchema_, "hasparent"s,
         IntExpr<1>(dtScope.GetDerivedTypeParent() != nullptr));
     // To avoid wasting run time attempting to initialize derived type
     // instances without any initialized components, analyze the type
     // and set a flag if there's nothing to do for it at run time.
     AddValue(dtValues, derivedTypeSchema_, "noinitializationneeded"s,
-        IntExpr<1>(
-            derivedTypeSpec && !derivedTypeSpec->HasDefaultInitialization()));
+        IntExpr<1>(isAbstractType ||
+            (derivedTypeSpec && !derivedTypeSpec->HasDefaultInitialization())));
     // Similarly, a flag to short-circuit destruction when not needed.
     AddValue(dtValues, derivedTypeSchema_, "nodestructionneeded"s,
-        IntExpr<1>(derivedTypeSpec && !derivedTypeSpec->HasDestruction()));
+        IntExpr<1>(isAbstractType ||
+            (derivedTypeSpec && !derivedTypeSpec->HasDestruction())));
     // Similarly, a flag to short-circuit finalization when not needed.
     AddValue(dtValues, derivedTypeSchema_, "nofinalizationneeded"s,
-        IntExpr<1>(derivedTypeSpec && !IsFinalizable(*derivedTypeSpec)));
+        IntExpr<1>(isAbstractType ||
+            (derivedTypeSpec && !IsFinalizable(*derivedTypeSpec))));
   }
   dtObject.get<ObjectEntityDetails>().set_init(MaybeExpr{
       StructureExpr(Structure(derivedTypeSchema_, std::move(dtValues)))});
   return &dtObject;
 }
 
 static const Symbol &GetSymbol(const Scope &schemata, SourceName name) {
   auto iter{schemata.find(name)};