Remove IsMetadataMaterialized from BitcodeReader (NFC)

[mehdi_amini]

Summary

It does not seem useful.

[tejohnson]

Not sure I understand the flow requiring this either. LGTM

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

3962 ↗

(On Diff #81043)

The existing IsMetadataMaterialized flag would only ever make a difference here if we already materialized some functions (which materializes any already deferred metadata and sets IsMetadataMaterialized=true). It isn't clear to me when we would encounter a module-level metadata block after materializing a function. Even if we did, removing this flag just means deferring these newly encountered blocks, then we would materialize the newly deferred metadata block once we materialize the next GV anyway.

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
   /// types. Once the old style function blocks have been phased out, we would
   /// not need this flag.
   bool UseRelativeIDs = false;
 
   /// True if all functions will be materialized, negating the need to process
   /// (e.g.) blockaddress forward references.
   bool WillMaterializeAllForwardRefs = false;
 
-  /// True if any Metadata block has been materialized.
-  bool IsMetadataMaterialized = false;
-
   bool StripDebugInfo = false;
 
   /// Functions that need to be matched with subprograms when upgrading old
   /// metadata.
   SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs;
 
   std::vector<std::string> BundleTags;
 

 }
 
 /// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
 /// module level metadata.
 Error BitcodeReader::parseMetadata(bool ModuleLevel) {
   assert((ModuleLevel || DeferredMetadataInfo.empty()) &&
          "Must read all module-level metadata before function-level");
 
-  IsMetadataMaterialized = true;
   unsigned NextMetadataNo = MetadataList.size();
 
   if (!ModuleLevel && MetadataList.hasFwdRefs())
     return error("Invalid metadata: fwd refs into function blocks");
 
   if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
     return error("Invalid record");
 
case BitstreamEntry::SubBlock:
         break;
       case bitc::CONSTANTS_BLOCK_ID:
         if (Error Err = parseConstants())
           return Err;
         if (Error Err = resolveGlobalAndIndirectSymbolInits())
           return Err;
         break;
       case bitc::METADATA_BLOCK_ID:
-        if (ShouldLazyLoadMetadata && !IsMetadataMaterialized) {
+        if (ShouldLazyLoadMetadata) {
           if (Error Err = rememberAndSkipMetadata())
             return Err;
           break;
         }
         assert(DeferredMetadataInfo.empty() && "Unexpected deferred metadata");
         if (Error Err = parseMetadata(true))
           return Err;
         break;