rebase

Created using spr 1.3.5-bogner

Author: MaskRay

llvm/include/llvm/MC/MCExpr.h

@@ -262,8 +262,8 @@ class MCSymbolRefExpr : public MCExpr {
   const MCSymbol &getSymbol() const { return *Symbol; }
 
   // Some targets encode the relocation specifier within SymA using
-  // MCSymbolRefExpr::SubclassData and access it via getAccessVariant(), though
-  // this method is now deprecated.
+  // MCSymbolRefExpr::SubclassData, which is copied to MCValue::Specifier,
+  // though this method is now deprecated.
   VariantKind getKind() const {
     return (VariantKind)(getSubclassData() & VariantKindMask);
   }

llvm/include/llvm/MC/MCValue.h

@@ -32,12 +32,16 @@ class MCValue {
   int64_t Cst = 0;
   uint32_t Specifier = 0;
 
+  void print(raw_ostream &OS) const;
+
+  /// Print the value to stderr.
+  void dump() const;
+
 public:
   friend class MCAssembler;
   friend class MCExpr;
   MCValue() = default;
   int64_t getConstant() const { return Cst; }
-  uint32_t getRefKind() const { return Specifier; }
   uint32_t getSpecifier() const { return Specifier; }
   void setSpecifier(uint32_t S) { Specifier = S; }
 
@@ -47,18 +51,6 @@ class MCValue {
   /// Is this an absolute (as opposed to relocatable) value.
   bool isAbsolute() const { return !SymA && !SymB; }
 
-  /// Print the value to the stream \p OS.
-  void print(raw_ostream &OS) const;
-
-  /// Print the value to stderr.
-  void dump() const;
-
-  // Get the relocation specifier from SymA. This is a workaround for targets
-  // that do not use MCValue::Specifier.
-  uint16_t getSymSpecifier() const { return Specifier; }
-  // Get the relocation specifier from SymA, or 0 when SymA is null.
-  uint16_t getAccessVariant() const { return Specifier; }
-
   static MCValue get(const MCSymbol *SymA, const MCSymbol *SymB = nullptr,
                      int64_t Val = 0, uint32_t Specifier = 0) {
     MCValue R;

llvm/lib/MC/MCAssembler.cpp

@@ -122,11 +122,11 @@ bool MCAssembler::isThumbFunc(const MCSymbol *Symbol) const {
   if (!Expr->evaluateAsRelocatable(V, nullptr))
     return false;
 
-  if (V.getSubSym() || V.getRefKind() != MCSymbolRefExpr::VK_None)
+  if (V.getSubSym() || V.getSpecifier() != MCSymbolRefExpr::VK_None)
     return false;
 
   auto *Sym = V.getAddSym();
-  if (!Sym || V.getSymSpecifier())
+  if (!Sym || V.getSpecifier())
     return false;
 
   if (!isThumbFunc(Sym))

llvm/lib/MC/MCExpr.cpp

@@ -291,7 +291,7 @@ bool MCExpr::evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
   // Value with RefKind (e.g. %hi(0xdeadbeef) in MIPS) is not considered
   // absolute (the value is unknown at parse time), even if it might be resolved
   // by evaluateFixup.
-  return IsRelocatable && Value.isAbsolute() && Value.getRefKind() == 0;
+  return IsRelocatable && Value.isAbsolute() && Value.getSpecifier() == 0;
 }
 
 /// Helper method for \see EvaluateSymbolAdd().
@@ -533,7 +533,7 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
           // If the reference has a variant kind, we can only handle expressions
           // which evaluate exactly to a single unadorned symbol. Attach the
           // original VariantKind to SymA of the result.
-          if (Res.getRefKind() != MCSymbolRefExpr::VK_None ||
+          if (Res.getSpecifier() != MCSymbolRefExpr::VK_None ||
               !Res.getAddSym() || Res.getSubSym() || Res.getConstant())
             return false;
           Res.Specifier = Kind;

llvm/lib/MC/MCValue.cpp

@@ -24,8 +24,8 @@ void MCValue::print(raw_ostream &OS) const {
 
   // FIXME: prints as a number, which isn't ideal. But the meaning will be
   // target-specific anyway.
-  if (getRefKind())
-    OS << ':' << getRefKind() <<  ':';
+  if (getSpecifier())
+    OS << ':' << getSpecifier() << ':';
 
   SymA->print(OS, nullptr);
 

llvm/lib/MC/WasmObjectWriter.cpp

@@ -606,7 +606,7 @@ void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
     SymA->setUsedInReloc();
   }
 
-  switch (Target.getSymSpecifier()) {
+  switch (Target.getSpecifier()) {
   case MCSymbolRefExpr::VK_GOT:
   case MCSymbolRefExpr::VK_WASM_GOT_TLS:
     SymA->setUsedInGOT();

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

@@ -8243,7 +8243,7 @@ bool AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
     return false;
 
   if (Res.getAddSym())
-    DarwinSpec = AArch64MCExpr::Specifier(Res.getSymSpecifier());
+    DarwinSpec = AArch64MCExpr::Specifier(Res.getSpecifier());
   Addend = Res.getConstant();
 
   // It's some symbol reference + a constant addend, but really

llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp

@@ -222,7 +222,7 @@ static uint64_t adjustFixupValue(const MCFixup &Fixup, const MCValue &Target,
     return Value >> 4;
   case AArch64::fixup_aarch64_movw: {
     AArch64MCExpr::Specifier RefKind =
-        static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
+        static_cast<AArch64MCExpr::Specifier>(Target.getSpecifier());
     if (AArch64MCExpr::getSymbolLoc(RefKind) != AArch64MCExpr::VK_ABS &&
         AArch64MCExpr::getSymbolLoc(RefKind) != AArch64MCExpr::VK_SABS) {
       if (!RefKind) {
@@ -422,7 +422,7 @@ void AArch64AsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                                    bool IsResolved,
                                    const MCSubtargetInfo *STI) const {
   if (Fixup.getTargetKind() == FK_Data_8 && TheTriple.isOSBinFormatELF()) {
-    auto RefKind = static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
+    auto RefKind = static_cast<AArch64MCExpr::Specifier>(Target.getSpecifier());
     AArch64MCExpr::Specifier SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
     if (SymLoc == AArch64AuthMCExpr::VK_AUTH ||
         SymLoc == AArch64AuthMCExpr::VK_AUTHADDR) {
@@ -480,7 +480,7 @@ void AArch64AsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
   // FIXME: getFixupKindInfo() and getFixupKindNumBytes() could be fixed to
   // handle this more cleanly. This may affect the output of -show-mc-encoding.
   AArch64MCExpr::Specifier RefKind =
-      static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
+      static_cast<AArch64MCExpr::Specifier>(Target.getSpecifier());
   if (AArch64MCExpr::getSymbolLoc(RefKind) == AArch64MCExpr::VK_SABS ||
       (!RefKind && Fixup.getTargetKind() == AArch64::fixup_aarch64_movw)) {
     // If the immediate is negative, generate MOVN else MOVZ.

llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp

@@ -112,7 +112,7 @@ unsigned AArch64ELFObjectWriter::getRelocType(MCContext &Ctx,
   if (Kind >= FirstLiteralRelocationKind)
     return Kind - FirstLiteralRelocationKind;
   AArch64MCExpr::Specifier RefKind =
-      static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
+      static_cast<AArch64MCExpr::Specifier>(Target.getSpecifier());
   AArch64MCExpr::Specifier SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
   bool IsNC = AArch64MCExpr::isNotChecked(RefKind);
 
@@ -137,7 +137,7 @@ unsigned AArch64ELFObjectWriter::getRelocType(MCContext &Ctx,
     case FK_Data_2:
       return R_CLS(PREL16);
     case FK_Data_4: {
-      return AArch64MCExpr::Specifier(Target.getAccessVariant()) ==
+      return AArch64MCExpr::Specifier(Target.getSpecifier()) ==
                      AArch64MCExpr::VK_PLT
                  ? R_CLS(PLT32)
                  : R_CLS(PREL32);
@@ -249,7 +249,7 @@ unsigned AArch64ELFObjectWriter::getRelocType(MCContext &Ctx,
     case FK_Data_2:
       return R_CLS(ABS16);
     case FK_Data_4:
-      return (!IsILP32 && AArch64MCExpr::Specifier(Target.getAccessVariant()) ==
+      return (!IsILP32 && AArch64MCExpr::Specifier(Target.getSpecifier()) ==
                               AArch64MCExpr::VK_GOTPCREL)
                  ? ELF::R_AARCH64_GOTPCREL32
                  : R_CLS(ABS32);
@@ -543,10 +543,10 @@ bool AArch64ELFObjectWriter::needsRelocateWithSymbol(const MCValue &Val,
   if (Val.getAddSym() && cast<MCSymbolELF>(Val.getAddSym())->isMemtag())
     return true;
 
-  if ((Val.getRefKind() & AArch64MCExpr::VK_GOT) == AArch64MCExpr::VK_GOT)
+  if ((Val.getSpecifier() & AArch64MCExpr::VK_GOT) == AArch64MCExpr::VK_GOT)
     return true;
   return is_contained({AArch64MCExpr::VK_GOTPCREL, AArch64MCExpr::VK_PLT},
-                      AArch64MCExpr::Specifier(Val.getAccessVariant()));
+                      AArch64MCExpr::Specifier(Val.getSpecifier()));
 }
 
 std::unique_ptr<MCObjectTargetWriter>

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp

@@ -192,7 +192,7 @@ void AArch64MachObjectWriter::recordRelocation(
   }
 
   if (!getAArch64FixupKindMachOInfo(
-          Fixup, Type, AArch64MCExpr::Specifier(Target.getSymSpecifier()),
+          Fixup, Type, AArch64MCExpr::Specifier(Target.getSpecifier()),
           Log2Size, Asm)) {
     Asm.getContext().reportError(Fixup.getLoc(), "unknown AArch64 fixup kind!");
     return;
@@ -221,7 +221,7 @@ void AArch64MachObjectWriter::recordRelocation(
     // Check for "_foo@got - .", which comes through here as:
     // Ltmp0:
     //    ... _foo@got - Ltmp0
-    if (Target.getSymSpecifier() == AArch64MCExpr::M_GOT &&
+    if (Target.getSpecifier() == AArch64MCExpr::M_GOT &&
         Asm.getSymbolOffset(*B) ==
             Asm.getFragmentOffset(*Fragment) + Fixup.getOffset()) {
       // SymB is the PC, so use a PC-rel pointer-to-GOT relocation.
@@ -232,7 +232,7 @@ void AArch64MachObjectWriter::recordRelocation(
       MRE.r_word1 = (IsPCRel << 24) | (Log2Size << 25) | (Type << 28);
       Writer->addRelocation(A_Base, Fragment->getParent(), MRE);
       return;
-    } else if (Target.getSymSpecifier() != AArch64MCExpr::None) {
+    } else if (Target.getSpecifier() != AArch64MCExpr::None) {
       // Otherwise, neither symbol can be modified.
       Asm.getContext().reportError(Fixup.getLoc(),
                                    "unsupported relocation of modified symbol");
@@ -391,8 +391,8 @@ void AArch64MachObjectWriter::recordRelocation(
     Value = 0;
   }
 
-  if (Target.getRefKind() == AArch64MCExpr::VK_AUTH ||
-      Target.getRefKind() == AArch64MCExpr::VK_AUTHADDR) {
+  if (Target.getSpecifier() == AArch64MCExpr::VK_AUTH ||
+      Target.getSpecifier() == AArch64MCExpr::VK_AUTHADDR) {
     auto *Expr = cast<AArch64AuthMCExpr>(Fixup.getValue());
 
     assert(Type == MachO::ARM64_RELOC_UNSIGNED);