Revert "WIP fix MCCAS, builds but round trip verification error due to FragType not staying the same after materialization, does it not get saved?"

rastogishubham · rastogishubham · commit d21a96fb6453 · 2025-08-04T17:55:48.000-07:00
This reverts commit 36becd8.
diff --git a/llvm/include/llvm/MCCAS/MCCASObjectV1.def b/llvm/include/llvm/MCCAS/MCCASObjectV1.def
@@ -85,4 +85,3 @@ MCFRAGMENT_NODE_REF(MCCVDefRangeFragment, FT_CVDefRange, mc:cv_def_range)
 
 #undef MCFRAGMENT_NODE_REF
 #endif /* MCFRAGMENT_NODE_REF */
-
diff --git a/llvm/include/llvm/MCCAS/MCCASObjectV1.h b/llvm/include/llvm/MCCAS/MCCASObjectV1.h
@@ -418,63 +418,6 @@ class SpecificRef : public MCObjectProxy {
   };
 #include "llvm/MCCAS/MCCASObjectV1.def"
 
-class MCGenericFragmentRef : public SpecificRef<MCGenericFragmentRef> {
-  using SpecificRefT = SpecificRef<MCGenericFragmentRef>;
-  friend class SpecificRef<MCGenericFragmentRef>;
-
-public:
-  MCGenericFragmentRef(SpecificRefT ST, MCFragment::FragmentType FragType)
-      : SpecificRef<MCGenericFragmentRef>(ST), FragType(FragType) {}
-  MCFragment::FragmentType FragType;
-  static constexpr StringLiteral KindString = "mc:generic_fragment";
-  static Expected<MCGenericFragmentRef> create(MCCASBuilder &MB,
-                                               const MCFragment &Fragment,
-                                               unsigned FragmentSize,
-                                               ArrayRef<char> FragmentContents);
-  static Expected<MCGenericFragmentRef> get(Expected<MCObjectProxy> Ref,
-                                            MCFragment::FragmentType FragType) {
-    auto Specific = SpecificRefT::getSpecific(std::move(Ref));
-    if (!Specific)
-      return Specific.takeError();
-    return MCGenericFragmentRef(*Specific, FragType);
-  }
-  static Expected<MCGenericFragmentRef> get(const MCSchema &Schema,
-                                            cas::ObjectRef ID,
-                                            MCFragment::FragmentType FragType) {
-    return get(Schema.get(ID), FragType);
-  }
-  static std::optional<MCGenericFragmentRef> Cast(MCObjectProxy Ref) {
-    auto Specific = SpecificRefT::Cast(Ref);
-    if (!Specific)
-      return std::nullopt;
-    return MCGenericFragmentRef(*Specific);
-  }
-  Expected<uint64_t> materialize(const MCFragment::FragmentType FragType,
-                                 MCCASReader &Reader,
-                                 raw_ostream *Stream) const;
-
-  static Expected<MCGenericFragmentRef>
-  createGenericAlignFragmentRef(MCCASBuilder &MB, const MCFragment &F,
-                                unsigned FragmentSize,
-                                ArrayRef<char> FragmentContents);
-
-  static Expected<MCGenericFragmentRef>
-  createGenericLEBFragmentRef(MCCASBuilder &MB, const MCFragment &F,
-                              unsigned FragmentSize,
-                              ArrayRef<char> FragmentContents);
-
-  Expected<uint64_t>
-  materializeGenericAlignFragmentRef(MCCASReader &Reader,
-                                     raw_ostream *Stream) const;
-
-  Expected<uint64_t>
-  materializeGenericLEBFragmentRef(MCCASReader &Reader,
-                                   raw_ostream *Stream) const;
-
-private:
-  explicit MCGenericFragmentRef(SpecificRefT Ref) : SpecificRefT(Ref) {}
-};
-
 class PaddingRef : public SpecificRef<PaddingRef> {
   using SpecificRefT = SpecificRef<PaddingRef>;
   friend class SpecificRef<PaddingRef>;
diff --git a/llvm/lib/MCCAS/MCCASObjectV1.cpp b/llvm/lib/MCCAS/MCCASObjectV1.cpp
@@ -48,7 +48,6 @@ constexpr StringLiteral PaddingRef::KindString;
 #define MCFRAGMENT_NODE_REF(MCFragmentName, MCEnumName, MCEnumIdentifier)      \
   constexpr StringLiteral MCFragmentName##Ref::KindString;
 #include "llvm/MCCAS/MCCASObjectV1.def"
-constexpr StringLiteral MCGenericFragmentRef::KindString;
 constexpr StringLiteral DebugInfoSectionRef::KindString;
 
 void MCSchema::anchor() {}
@@ -173,7 +172,6 @@ Error MCSchema::fillCache() {
       PaddingRef::KindString,
       MCAssemblerRef::KindString,
       DebugInfoSectionRef::KindString,
-      MCGenericFragmentRef::KindString,
 #define CASV1_SIMPLE_DATA_REF(RefName, IdentifierName) RefName::KindString,
 #define CASV1_SIMPLE_GROUP_REF(RefName, IdentifierName) RefName::KindString,
 #define MCFRAGMENT_NODE_REF(MCFragmentName, MCEnumName, MCEnumIdentifier)      \
@@ -1533,33 +1531,34 @@ Expected<uint64_t> AtomRef::materialize(MCCASReader &Reader,
   return Size;
 }
 
-Expected<MCGenericFragmentRef>
-MCGenericFragmentRef::createGenericAlignFragmentRef(
-    MCCASBuilder &MB, const MCFragment &F, unsigned FragmentSize,
-    ArrayRef<char> FragmentContents) {
+Expected<MCAlignFragmentRef>
+MCAlignFragmentRef::create(MCCASBuilder &MB, const MCAlignFragment &F,
+                           unsigned FragmentSize,
+                           ArrayRef<char> FragmentContents) {
   Expected<Builder> B = Builder::startNode(MB.Schema, KindString);
   if (!B)
     return B.takeError();
 
-  uint64_t Count = FragmentSize / F.getAlignFillLen();
-  if (F.hasAlignEmitNops()) {
+  uint64_t Count = FragmentSize / F.getFillLen();
+  if (F.hasEmitNops()) {
     // Write 0 as size and use backend to emit nop.
     writeVBR8(0, B->Data);
     if (!MB.Asm.getBackend().writeNopData(MB.FragmentOS, Count,
                                           F.getSubtargetInfo()))
       report_fatal_error("unable to write nop sequence of " + Twine(Count) +
                          " bytes");
     B->Data.append(MB.FragmentData);
-    return get(B->build(), MCFragment::FT_Align);
+    return get(B->build());
   }
   writeVBR8(Count, B->Data);
-  writeVBR8(F.getAlignFill(), B->Data);
-  writeVBR8(F.getAlignFillLen(), B->Data);
-  return get(B->build(), MCFragment::FT_Align);
+  writeVBR8(F.getFill(), B->Data);
+  writeVBR8(F.getFillLen(), B->Data);
+  return get(B->build());
 }
 
-Expected<uint64_t> MCGenericFragmentRef::materializeGenericAlignFragmentRef(
-    MCCASReader &Reader, raw_ostream *Stream) const {
+Expected<uint64_t> MCAlignFragmentRef::materialize(MCCASReader &Reader,
+                                                   raw_ostream *Stream) const
+                                                   {
   uint64_t Count;
   auto Remaining = getData();
   auto Endian = Reader.getEndian();
@@ -1687,76 +1686,23 @@ Expected<uint64_t> MCFillFragmentRef::materialize(MCCASReader &Reader,
   return Size;
 }
 
-Expected<MCGenericFragmentRef>
-MCGenericFragmentRef::createGenericLEBFragmentRef(
-    MCCASBuilder &MB, const MCFragment &F, unsigned FragmentSize,
-    ArrayRef<char> FragmentContents) {
+Expected<MCLEBFragmentRef>
+MCLEBFragmentRef::create(MCCASBuilder &MB, const MCLEBFragment &F,
+                         unsigned FragmentSize,
+                         ArrayRef<char> FragmentContents) {
   Expected<Builder> B = Builder::startNode(MB.Schema, KindString);
   if (!B)
     return B.takeError();
   llvm::append_range(B->Data, F.getContents());
-  return get(B->build(), MCFragment::FT_LEB);
+  return get(B->build());
 }
 
-Expected<uint64_t> MCGenericFragmentRef::materializeGenericLEBFragmentRef(
-    MCCASReader &Reader, raw_ostream *Stream) const {
+Expected<uint64_t> MCLEBFragmentRef::materialize(MCCASReader &Reader,
+                                                 raw_ostream *Stream) const {
   *Stream << getData();
   return getData().size();
 }
 
-Expected<MCGenericFragmentRef>
-MCGenericFragmentRef::create(MCCASBuilder &MB, const MCFragment &Fragment,
-                             unsigned int FragmentSize,
-                             ArrayRef<char> FragmentContents) {
-  auto FragType = Fragment.getKind();
-  switch (FragType) {
-  case MCFragment::FT_Align:
-    return createGenericAlignFragmentRef(MB, Fragment, FragmentSize,
-                                         FragmentContents);
-  case MCFragment::FT_LEB:
-    return createGenericLEBFragmentRef(MB, Fragment, FragmentSize,
-                                       FragmentContents);
-  case MCFragment::FT_Relaxable:
-  case MCFragment::FT_Data:
-  case MCFragment::FT_Dwarf:
-  case MCFragment::FT_DwarfFrame: {
-    Expected<Builder> B = Builder::startNode(MB.Schema, KindString);
-    if (!B)
-      return B.takeError();
-    B->Data.append(MB.FragmentData);
-    B->Data.append(FragmentContents.begin(), FragmentContents.end());
-    assert(((MB.FragmentData.empty() && Fragment.getContents().empty()) ||
-            (MB.FragmentData.size() + Fragment.getContents().size() ==
-             FragmentSize)) &&
-           "Size should match");
-    return get(B->build(), FragType);
-  }
-  default:
-    llvm_unreachable("Other Fragment Kinds should be handled elsewhere!");
-  }
-}
-
-Expected<uint64_t>
-MCGenericFragmentRef::materialize(const MCFragment::FragmentType FragType,
-                                  MCCASReader &Reader,
-                                  raw_ostream *Stream) const {
-  switch (FragType) {
-  case MCFragment::FT_Align:
-    return materializeGenericAlignFragmentRef(Reader, Stream);
-  case MCFragment::FT_LEB:
-    return materializeGenericLEBFragmentRef(Reader, Stream);
-  case MCFragment::FT_Relaxable:
-  case MCFragment::FT_Data:
-  case MCFragment::FT_Dwarf:
-  case MCFragment::FT_DwarfFrame: {
-    *Stream << getData();
-    return getData().size();
-  }
-  default:
-    llvm_unreachable("Other Fragment Kinds should be handled elsewhere!");
-  }
-}
-
 Expected<MCNopsFragmentRef>
 MCNopsFragmentRef::create(MCCASBuilder &MB, const MCNopsFragment &F,
                           unsigned FragmentSize,
@@ -1912,18 +1858,6 @@ Error MCCASBuilder::buildFragment(const MCFragment &F, unsigned Size,
     return Error::success();                                                   \
   }
 #include "llvm/MCCAS/MCCASObjectV1.def"
-  case MCFragment::FT_Relaxable:
-  case MCFragment::FT_Data:
-  case MCFragment::FT_Align:
-  case MCFragment::FT_Dwarf:
-  case MCFragment::FT_DwarfFrame:
-  case MCFragment::FT_LEB: {
-    auto GF = MCGenericFragmentRef::create(*this, F, Size, FragmentContents);
-    if (!GF)
-      return GF.takeError();
-    addNode(*GF);
-    return Error::success();
-  }
   }
   llvm_unreachable("unknown fragment");
 }
@@ -2050,14 +1984,6 @@ Error MCDataFragmentMerger::emitMergedFragments() {
         return E;
       break;
     }
-    case MCFragment::FT_Relaxable:
-    case MCFragment::FT_Data:
-    case MCFragment::FT_Dwarf:
-    case MCFragment::FT_DwarfFrame:
-    case MCFragment::FT_LEB: {
-      FragmentData.append(CandidateContents);
-      break;
-    }
     default:
       llvm_unreachable("other framgents should not be added");
     }
@@ -2935,11 +2861,6 @@ static ArrayRef<char> getFragmentContents(const MCFragment &Fragment) {
         cast<MCCVInlineLineTableFragment>(Fragment);
     return SF.getContents();
   }
-  case MCFragment::FT_Relaxable:
-  case MCFragment::FT_Data:
-  case MCFragment::FT_Align:
-  case MCFragment::FT_Dwarf:
-  case MCFragment::FT_DwarfFrame:
   case MCFragment::FT_LEB: {
     return Fragment.getContents();
   }
@@ -3681,9 +3602,6 @@ Expected<uint64_t> MCCASReader::materializeAtom(cas::ObjectRef ID,
     return F->materialize(*Stream);
   if (auto F = MergedFragmentRef::Cast(*Node))
     return F->materialize(*Stream);
-  if (auto F = MCGenericFragmentRef::Cast(*Node)) {
-    return F->materialize(F->FragType, *this, Stream);
-  }
 
   return createStringError(inconvertibleErrorCode(),
                            "unsupported CAS node for fragment");

Original file line number	Diff line number	Diff line change
`@@ -85,4 +85,3 @@ MCFRAGMENT_NODE_REF(MCCVDefRangeFragment, FT_CVDefRange, mc:cv_def_range)`
`85`	`85`
`86`	`86`	`#undef MCFRAGMENT_NODE_REF`
`87`	`87`	`#endif /* MCFRAGMENT_NODE_REF */`
`88`		`-`