avoid passing ReadStableFunctionMapNames around

Author: nocchijiang

llvm/include/llvm/CGData/StableFunctionMapRecord.h

@@ -65,23 +65,20 @@ struct StableFunctionMapRecord {
   /// entry when passed in.
   LLVM_ABI static void deserializeEntry(const unsigned char *Ptr,
                                         stable_hash Hash,
-                                        StableFunctionMap *FunctionMap,
-                                        bool ReadStableFunctionMapNames = true);
+                                        StableFunctionMap *FunctionMap);
 
   /// Serialize the stable function map to a raw_ostream.
   LLVM_ABI void serialize(raw_ostream &OS,
                           std::vector<CGDataPatchItem> &PatchItems) const;
 
   /// Deserialize the stable function map from a raw_ostream.
-  LLVM_ABI void deserialize(const unsigned char *&Ptr,
-                            bool ReadStableFunctionMapNames = true);
+  LLVM_ABI void deserialize(const unsigned char *&Ptr);
 
   /// Lazily deserialize the stable function map from `Buffer` starting at
   /// `Offset`. The individial stable function entry would be read lazily from
   /// `Buffer` when the function map is accessed.
   LLVM_ABI void lazyDeserialize(std::shared_ptr<MemoryBuffer> Buffer,
-                                uint64_t Offset,
-                                bool ReadStableFunctionMapNames = true);
+                                uint64_t Offset);
 
   /// Serialize the stable function map to a YAML stream.
   LLVM_ABI void serializeYAML(yaml::Output &YOS) const;
@@ -106,9 +103,15 @@ struct StableFunctionMapRecord {
     serializeYAML(YOS);
   }
 
+  void setReadStableFunctionMapNames(bool Read) {
+    assert(
+        FunctionMap->empty() &&
+        "Cannot change ReadStableFunctionMapNames after the map is populated");
+    FunctionMap->ReadStableFunctionMapNames = Read;
+  }
+
 private:
-  void deserialize(const unsigned char *&Ptr, bool ReadStableFunctionMapNames,
-                   bool Lazy);
+  void deserialize(const unsigned char *&Ptr, bool Lazy);
 };
 
 } // namespace llvm

llvm/lib/CGData/CodeGenDataReader.cpp

@@ -122,13 +122,13 @@ Error IndexedCodeGenDataReader::read() {
     const unsigned char *Ptr = Start + Header.StableFunctionMapOffset;
     if (Ptr >= End)
       return error(cgdata_error::eof);
+    FunctionMapRecord.setReadStableFunctionMapNames(
+        IndexedCodeGenDataReadFunctionMapNames);
     if (IndexedCodeGenDataLazyLoading)
       FunctionMapRecord.lazyDeserialize(SharedDataBuffer,
-                                        Header.StableFunctionMapOffset,
-                                        IndexedCodeGenDataReadFunctionMapNames);
+                                        Header.StableFunctionMapOffset);
     else
-      FunctionMapRecord.deserialize(Ptr,
-                                    IndexedCodeGenDataReadFunctionMapNames);
+      FunctionMapRecord.deserialize(Ptr);
   }
 
   return success();

llvm/lib/CGData/StableFunctionMap.cpp

@@ -150,8 +150,7 @@ void StableFunctionMap::deserializeLazyLoadingEntry(
   std::call_once(Storage.LazyLoadFlag, [this, HashArg = Hash, &StorageArg = Storage]() {
     for (auto Offset : StorageArg.Offsets)
       StableFunctionMapRecord::deserializeEntry(
-          reinterpret_cast<const unsigned char *>(Offset), HashArg, const_cast<StableFunctionMap *>(this),
-          ReadStableFunctionMapNames);
+          reinterpret_cast<const unsigned char *>(Offset), HashArg, const_cast<StableFunctionMap *>(this));
   });
 }
 

llvm/lib/CGData/StableFunctionMapRecord.cpp

@@ -142,18 +142,17 @@ void StableFunctionMapRecord::serialize(
                           &IndexOperandHashesByteSize, 1);
 }
 
-void StableFunctionMapRecord::deserializeEntry(
-    const unsigned char *Ptr, stable_hash Hash, StableFunctionMap *FunctionMap,
-    bool ReadStableFunctionMapNames) {
-  assert(FunctionMap->ReadStableFunctionMapNames == ReadStableFunctionMapNames);
+void StableFunctionMapRecord::deserializeEntry(const unsigned char *Ptr,
+                                               stable_hash Hash,
+                                               StableFunctionMap *FunctionMap) {
   auto FunctionNameId =
       endian::readNext<uint32_t, endianness::little, unaligned>(Ptr);
-  if (ReadStableFunctionMapNames)
+  if (FunctionMap->ReadStableFunctionMapNames)
     assert(FunctionMap->getNameForId(FunctionNameId) &&
            "FunctionNameId out of range");
   auto ModuleNameId =
       endian::readNext<uint32_t, endianness::little, unaligned>(Ptr);
-  if (ReadStableFunctionMapNames)
+  if (FunctionMap->ReadStableFunctionMapNames)
     assert(FunctionMap->getNameForId(ModuleNameId) &&
            "ModuleNameId out of range");
   auto InstCount =
@@ -191,7 +190,6 @@ void StableFunctionMapRecord::deserializeEntry(
 }
 
 void StableFunctionMapRecord::deserialize(const unsigned char *&Ptr,
-                                          bool ReadStableFunctionMapNames,
                                           bool Lazy) {
   // Assert that Ptr is 4-byte aligned
   assert(((uintptr_t)Ptr % 4) == 0);
@@ -204,8 +202,7 @@ void StableFunctionMapRecord::deserialize(const unsigned char *&Ptr,
   const auto NamesByteSize =
       endian::readNext<uint64_t, endianness::little, unaligned>(Ptr);
   const auto NamesOffset = reinterpret_cast<uintptr_t>(Ptr);
-  FunctionMap->ReadStableFunctionMapNames = ReadStableFunctionMapNames;
-  if (ReadStableFunctionMapNames) {
+  if (FunctionMap->ReadStableFunctionMapNames) {
     for (unsigned I = 0; I < NumNames; ++I) {
       StringRef Name(reinterpret_cast<const char *>(Ptr));
       Ptr += Name.size() + 1;
@@ -243,7 +240,7 @@ void StableFunctionMapRecord::deserialize(const unsigned char *&Ptr,
     else
       deserializeEntry(
           reinterpret_cast<const unsigned char *>(FixedSizeFieldsOffset), Hash,
-          FunctionMap.get(), ReadStableFunctionMapNames);
+          FunctionMap.get());
     FixedSizeFieldsOffset += FixedSizeFieldsSizePerEntry;
   }
 
@@ -256,17 +253,15 @@ void StableFunctionMapRecord::deserialize(const unsigned char *&Ptr,
       reinterpret_cast<uintptr_t>(Ptr) + IndexOperandHashesByteSize);
 }
 
-void StableFunctionMapRecord::deserialize(const unsigned char *&Ptr,
-                                          bool ReadStableFunctionMapNames) {
-  deserialize(Ptr, ReadStableFunctionMapNames, /*Lazy=*/false);
+void StableFunctionMapRecord::deserialize(const unsigned char *&Ptr) {
+  deserialize(Ptr, /*Lazy=*/false);
 }
 
 void StableFunctionMapRecord::lazyDeserialize(
-    std::shared_ptr<MemoryBuffer> Buffer, uint64_t Offset,
-    bool ReadStableFunctionMapNames) {
+    std::shared_ptr<MemoryBuffer> Buffer, uint64_t Offset) {
   const auto *Ptr = reinterpret_cast<const unsigned char *>(
       reinterpret_cast<uintptr_t>(Buffer->getBufferStart()) + Offset);
-  deserialize(Ptr, ReadStableFunctionMapNames, /*Lazy=*/true);
+  deserialize(Ptr, /*Lazy=*/true);
   FunctionMap->Buffer = std::move(Buffer);
 }