Fix merge conflict issues

Author: rastogishubham

llvm/include/llvm/CASObjectFormats/FlatV1.h

@@ -10,6 +10,7 @@
 #define LLVM_CASOBJECTFORMATS_FLATV1_H
 
 #include "llvm/CAS/CASID.h"
+#include "llvm/CAS/CASReference.h"
 #include "llvm/CASObjectFormats/CASObjectReader.h"
 #include "llvm/CASObjectFormats/Data.h"
 #include "llvm/CASObjectFormats/ObjectFormatSchemaBase.h"
@@ -209,7 +210,7 @@ class BlockRef : public SpecificRef<BlockRef> {
 
   static Expected<BlockRef> create(CompileUnitBuilder &CUB,
                                    const jitlink::Block &Block,
-                                   cas::CASID *AbbrevID = nullptr);
+                                   cas::ObjectRef *AbbrevRef = nullptr);
 
   static Expected<BlockRef> get(Expected<ObjectFormatObjectProxy> Ref);
   static Expected<BlockRef> get(const ObjectFileSchema &Schema,
@@ -314,8 +315,8 @@ class CompileUnitBuilder {
 
   Error createSection(const jitlink::Section &S);
   Error createBlock(const jitlink::Block &B);
-  Expected<cas::CASID> createAbbrevBlock(const jitlink::Block &B);
-  Error createInfoBlock(const jitlink::Block &B, cas::CASID *AbbrevID);
+  Expected<cas::ObjectRef> createAbbrevBlock(const jitlink::Block &B);
+  Error createInfoBlock(const jitlink::Block &B, cas::ObjectRef *AbbrevID);
   Error createSymbol(const jitlink::Symbol &S);
 
   // Lookup functions. The result must exist in the cache already.

llvm/include/llvm/CASObjectFormats/NestedV1.h

@@ -10,6 +10,7 @@
 #define LLVM_CASOBJECTFORMATS_NESTEDV1_H
 
 #include "llvm/CAS/CASID.h"
+#include "llvm/CAS/CASReference.h"
 #include "llvm/CASObjectFormats/Data.h"
 #include "llvm/CASObjectFormats/ObjectFormatSchemaBase.h"
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
@@ -520,7 +521,7 @@ class BlockRef : public SpecificRef<BlockRef> {
   create(const ObjectFileSchema &Schema, const jitlink::Block &Block,
          function_ref<Expected<Optional<TargetRef>>(const jitlink::Symbol &)>
              GetTargetRef,
-         cas::CASID *AbbrevID = nullptr);
+         cas::ObjectRef *AbbrevRef = nullptr);
 
   static Expected<BlockRef> create(const ObjectFileSchema &Schema,
                                    SectionRef Section, BlockDataRef Data) {
@@ -557,11 +558,13 @@ class BlockRef : public SpecificRef<BlockRef> {
 
   explicit BlockRef(SpecificRefT Ref) : SpecificRefT(Ref) {}
 
-  static Expected<BlockRef>
-  createImpl(const ObjectFileSchema &Schema, SectionRef Section,
-             BlockDataRef Data, ArrayRef<TargetInfo> TargetInfo,
-             ArrayRef<TargetRef> Targets, ArrayRef<Fixup> Fixups,
-             cas::CASID *AbbrevID = nullptr, bool IsDebugInfoBlock = false);
+  static Expected<BlockRef> createImpl(const ObjectFileSchema &Schema,
+                                       SectionRef Section, BlockDataRef Data,
+                                       ArrayRef<TargetInfo> TargetInfo,
+                                       ArrayRef<TargetRef> Targets,
+                                       ArrayRef<Fixup> Fixups,
+                                       cas::ObjectRef *AbbrevRef = nullptr,
+                                       bool IsDebugInfoBlock = false);
 };
 
 /// A symbol.

llvm/lib/CASObjectFormats/FlatV1.cpp

@@ -11,6 +11,7 @@
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/CAS/CASDB.h"
+#include "llvm/CAS/CASReference.h"
 #include "llvm/CASObjectFormats/Data.h"
 #include "llvm/CASObjectFormats/Encoding.h"
 #include "llvm/CASObjectFormats/ObjectFormatHelpers.h"
@@ -322,17 +323,17 @@ static Error decodeFixup(const FlatV1ObjectReader &Reader, StringRef &Data,
 
 Expected<BlockRef> BlockRef::create(CompileUnitBuilder &CUB,
                                     const jitlink::Block &Block,
-                                    cas::CASID *AbbrevID) {
+                                    cas::ObjectRef *AbbrevRef) {
   Expected<Builder> B = Builder::startNode(CUB.Schema, KindString);
   if (!B)
     return B.takeError();
 
   // If we are creating a cas block out of a debug_info jitlink::Block, add the
   // debug_abbrev cas block CAS ID as a refrence
   if (Block.getSection().getName() == "__DWARF,__debug_info") {
-    assert(AbbrevID &&
-           "The CAS ID for the abbrev section shouldn't be nullptr");
-    B->IDs.push_back(*AbbrevID);
+    assert(AbbrevRef &&
+           "The CAS Ref for the abbrev section shouldn't be nullptr");
+    B->Refs.push_back(*AbbrevRef);
   }
 
   // Encode Section.
@@ -710,19 +711,19 @@ Error CompileUnitBuilder::createBlock(const jitlink::Block &B) {
   return Error::success();
 }
 
-Expected<cas::CASID>
+Expected<cas::ObjectRef>
 CompileUnitBuilder::createAbbrevBlock(const jitlink::Block &B) {
   // Store the current idx. It is created in order so just add in the end.
   BlockIndexStarts.push_back(Indexes.size());
   auto Block = BlockRef::create(*this, B);
   if (!Block)
     return Block.takeError();
   commitNode(*Block);
-  return Block->getID();
+  return Block->getRef();
 }
 
 Error CompileUnitBuilder::createInfoBlock(const jitlink::Block &B,
-                                          cas::CASID *AbbrevID) {
+                                          cas::ObjectRef *AbbrevID) {
   // Store the current idx. It is created in order so just add in the end.
   BlockIndexStarts.push_back(Indexes.size());
   auto Block = BlockRef::create(*this, B, AbbrevID);
@@ -866,17 +867,17 @@ Expected<CompileUnitRef> CompileUnitRef::create(const ObjectFileSchema &Schema,
   }
 
   // Create BlockRefs for Abbrevs and Compile Units
-  SmallVector<cas::CASID, 16> AbbrevIDs;
+  SmallVector<cas::ObjectRef, 16> AbbrevRefs;
   for (auto *B : AbbrevBlocks) {
-    Expected<cas::CASID> ID = Builder.createAbbrevBlock(*B);
-    if (!ID)
-      return ID.takeError();
-    AbbrevIDs.push_back(*ID);
+    Expected<cas::ObjectRef> Ref = Builder.createAbbrevBlock(*B);
+    if (!Ref)
+      return Ref.takeError();
+    AbbrevRefs.push_back(*Ref);
   }
   unsigned I = 0;
   for (auto *B : InfoBlocks) {
     if (auto E = Builder.createInfoBlock(
-            *B, AbbrevIDs.size() == 1 ? &AbbrevIDs[0] : &AbbrevIDs[I]))
+            *B, AbbrevRefs.size() == 1 ? &AbbrevRefs[0] : &AbbrevRefs[I]))
       return std::move(E);
     I++;
   }

llvm/lib/CASObjectFormats/NestedV1.cpp

@@ -11,6 +11,7 @@
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/CAS/CASReference.h"
 #include "llvm/CASObjectFormats/CASObjectReader.h"
 #include "llvm/CASObjectFormats/Encoding.h"
 #include "llvm/CASObjectFormats/ObjectFormatHelpers.h"
@@ -812,7 +813,7 @@ Expected<BlockRef> BlockRef::create(
     const ObjectFileSchema &Schema, const jitlink::Block &Block,
     function_ref<Expected<Optional<TargetRef>>(const jitlink::Symbol &)>
         GetTargetRef,
-    cas::CASID *AbbrevID) {
+    cas::ObjectRef *AbbrevRef) {
   Expected<SectionRef> Section = SectionRef::create(Schema, Block.getSection());
   if (!Section)
     return Section.takeError();
@@ -832,7 +833,7 @@ Expected<BlockRef> BlockRef::create(
   Expected<BlockDataRef> Data = BlockDataRef::create(Schema, Block, Fixups);
   if (!Data)
     return Data.takeError();
-  return createImpl(Schema, *Section, *Data, TIs, Targets, Fixups, AbbrevID,
+  return createImpl(Schema, *Section, *Data, TIs, Targets, Fixups, AbbrevRef,
                     Block.getSection().getName() == "__DWARF,__debug_info");
 }
 
@@ -845,7 +846,7 @@ Expected<BlockRef>
 BlockRef::createImpl(const ObjectFileSchema &Schema, SectionRef Section,
                      BlockDataRef Data, ArrayRef<TargetInfo> TargetInfo,
                      ArrayRef<TargetRef> Targets, ArrayRef<Fixup> Fixups,
-                     cas::CASID *AbbrevID, bool IsDebugInfoBlock) {
+                     cas::ObjectRef *AbbrevRef, bool IsDebugInfoBlock) {
   Expected<Builder> B = Builder::startNode(Schema, KindString);
   if (!B)
     return B.takeError();
@@ -904,9 +905,9 @@ BlockRef::createImpl(const ObjectFileSchema &Schema, SectionRef Section,
   }
 
   if (IsDebugInfoBlock) {
-    assert(AbbrevID &&
-           "The CAS ID for the abbrev section shouldn't be nullptr");
-    B->IDs.push_back(*AbbrevID);
+    assert(AbbrevRef &&
+           "The CAS Ref for the abbrev section shouldn't be nullptr");
+    B->Refs.push_back(*AbbrevRef);
   }
 
   return get(B->build(), IsDebugInfoBlock);
@@ -1448,7 +1449,7 @@ class CompileUnitBuilder {
 
   /// Create the given symbol and cache it.
   Expected<SymbolRef> createSymbol(const jitlink::Symbol &S,
-                                   cas::CASID *AbbrevID = nullptr);
+                                   cas::ObjectRef *AbbrevRef = nullptr);
 
   /// Cache the symbol. Asserts that the result is not already cached.
   void cacheSymbol(const jitlink::Symbol &S, SymbolRef Ref);
@@ -1467,12 +1468,12 @@ class CompileUnitBuilder {
 
   /// Get or create a block.
   Expected<BlockRef> getOrCreateBlock(const jitlink::Block &B,
-                                      cas::CASID *AbbrevID = nullptr);
+                                      cas::ObjectRef *AbbrevRef = nullptr);
 
   /// Get or create a symbol definition.
   Expected<SymbolDefinitionRef>
   getOrCreateSymbolDefinition(const jitlink::Symbol &S,
-                              cas::CASID *AbbrevID = nullptr);
+                              cas::ObjectRef *AbbrevRef = nullptr);
 
 private:
   /// Guaranteed to be called in post-order. All undefined targets must be
@@ -1564,18 +1565,18 @@ Error CompileUnitBuilder::makeSymbols(const jitlink::LinkGraph &G) {
   llvm::sort(AbbrevSymbols.begin(), AbbrevSymbols.end(),
              compareSymbolBlocksByAddress);
 
-  SmallVector<cas::CASID, 16> AbbrevIDs;
+  SmallVector<cas::ObjectRef, 16> AbbrevRefs;
   for (auto *S : AbbrevSymbols) {
     Expected<SymbolRef> Symbol = createSymbol(*S);
     if (!Symbol)
       return Symbol.takeError();
-    AbbrevIDs.push_back(Symbol->getReferenceID(0));
+    AbbrevRefs.push_back(Symbol->getReference(0));
   }
 
   unsigned I = 0;
   for (auto *S : InfoSymbols) {
-    Expected<SymbolRef> Symbol =
-        createSymbol(*S, AbbrevIDs.size() == 1 ? &AbbrevIDs[0] : &AbbrevIDs[I]);
+    Expected<SymbolRef> Symbol = createSymbol(
+        *S, AbbrevRefs.size() == 1 ? &AbbrevRefs[0] : &AbbrevRefs[I]);
     if (!Symbol)
       return Symbol.takeError();
     I++;
@@ -1593,8 +1594,9 @@ cl::opt<bool> DropLeafSymbolNamesWithDot(
     "drop-leaf-symbol-names-with-dot",
     cl::desc("Drop symbol names with '.' in them from leafs."), cl::init(true));
 
-Expected<SymbolRef> CompileUnitBuilder::createSymbol(const jitlink::Symbol &S,
-                                                     cas::CASID *AbbrevID) {
+Expected<SymbolRef>
+CompileUnitBuilder::createSymbol(const jitlink::Symbol &S,
+                                 cas::ObjectRef *AbbrevRef) {
   assert(!S.isExternal());
   assert(!Symbols.lookup(&S).Symbol);
 
@@ -1605,7 +1607,7 @@ Expected<SymbolRef> CompileUnitBuilder::createSymbol(const jitlink::Symbol &S,
   bool HasIndirectReference = bool(Name);
 
   Expected<SymbolDefinitionRef> Definition =
-      getOrCreateSymbolDefinition(S, AbbrevID);
+      getOrCreateSymbolDefinition(S, AbbrevRef);
   if (!Definition)
     return Definition.takeError();
 
@@ -1685,22 +1687,23 @@ void CompileUnitBuilder::cacheSymbol(const jitlink::Symbol &S, SymbolRef Ref) {
 
 Expected<SymbolDefinitionRef>
 CompileUnitBuilder::getOrCreateSymbolDefinition(const jitlink::Symbol &S,
-                                                cas::CASID *AbbrevID) {
+                                                cas::ObjectRef *AbbrevRef) {
   // If the assertion in S.getBlock() starts failing, probably LinkGraph added
   // support for aliases to external symbols.
-  return SymbolDefinitionRef::get(getOrCreateBlock(S.getBlock(), AbbrevID));
+  return SymbolDefinitionRef::get(getOrCreateBlock(S.getBlock(), AbbrevRef));
 }
 
-Expected<BlockRef> CompileUnitBuilder::getOrCreateBlock(const jitlink::Block &B,
-                                                        cas::CASID *AbbrevID) {
+Expected<BlockRef>
+CompileUnitBuilder::getOrCreateBlock(const jitlink::Block &B,
+                                     cas::ObjectRef *AbbrevRef) {
   auto Cached = Blocks.find(&B);
   if (Cached != Blocks.end())
     return Cached->second;
 
   Expected<BlockRef> ExpectedBlock = BlockRef::create(
       Schema, B,
       [&](const jitlink::Symbol &S) { return getOrCreateTarget(S, B); },
-      AbbrevID);
+      AbbrevRef);
   if (!ExpectedBlock)
     return ExpectedBlock.takeError();
   Cached = Blocks.insert(std::make_pair(&B, *ExpectedBlock)).first;
@@ -2058,7 +2061,7 @@ DefinedSymbolNodeRef::materialize(const NestedV1ObjectReader &Reader) const {
   bool MergeByContent = Flags.Merge & SymbolRef::M_ByContent;
 
   Expected<SectionRef> Section =
-      SectionRef::get(Definition->getSchema(), Definition->getReferenceID(0));
+      SectionRef::get(Definition->getSchema(), Definition->getReference(0));
   if (!Section)
     return Section.takeError();
   Expected<NameRef> SectionName = Section->getName();