MCValue: Replace getSymSpecifier with getSpecifier

Commit 52eb11f temporarily introduced
getSymSpecifier to prepare for "MCValue: Replace MCSymbolRefExpr members
with MCSymbol" (d5893fc). The
refactoring is now complete.

Author: MaskRay

llvm/include/llvm/MC/MCValue.h

@@ -55,8 +55,6 @@ class MCValue {
 
   // 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,

llvm/lib/MC/MCAssembler.cpp

@@ -126,7 +126,7 @@ bool MCAssembler::isThumbFunc(const MCSymbol *Symbol) const {
     return false;
 
   auto *Sym = V.getAddSym();
-  if (!Sym || V.getSymSpecifier())
+  if (!Sym || V.getSpecifier())
     return false;
 
   if (!isThumbFunc(Sym))

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

@@ -8224,7 +8224,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/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");

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

@@ -61,8 +61,7 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType(
     FixupKind = FK_PCRel_4;
   }
 
-  auto Modifier =
-      Target.isAbsolute() ? AArch64MCExpr::None : Target.getSymSpecifier();
+  auto Spec = Target.getSpecifier();
   const MCExpr *Expr = Fixup.getValue();
 
   if (const AArch64MCExpr *A64E = dyn_cast<AArch64MCExpr>(Expr)) {
@@ -98,7 +97,7 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType(
     return COFF::IMAGE_REL_ARM64_REL32;
 
   case FK_Data_4:
-    switch (Modifier) {
+    switch (Spec) {
     default:
       return COFF::IMAGE_REL_ARM64_ADDR32;
     case MCSymbolRefExpr::VK_COFF_IMGREL32:

llvm/lib/Target/ARM/MCTargetDesc/ARMWinCOFFObjectWriter.cpp

@@ -44,7 +44,7 @@ unsigned ARMWinCOFFObjectWriter::getRelocType(MCContext &Ctx,
                                               const MCFixup &Fixup,
                                               bool IsCrossSection,
                                               const MCAsmBackend &MAB) const {
-  auto Spec = Target.getAddSym() ? Target.getSymSpecifier() : 0;
+  auto Spec = Target.getSpecifier();
   unsigned FixupKind = Fixup.getKind();
   if (IsCrossSection) {
     if (FixupKind != FK_Data_4) {

llvm/lib/Target/AVR/MCTargetDesc/AVRMCExpr.cpp

@@ -81,7 +81,7 @@ bool AVRMCExpr::evaluateAsRelocatableImpl(MCValue &Result,
       return false;
 
     auto Spec = AVRMCExpr::VK_None;
-    if (Value.getSymSpecifier() != MCSymbolRefExpr::VK_None)
+    if (Value.getSpecifier() != MCSymbolRefExpr::VK_None)
       return false;
     assert(!Value.getSubSym());
     if (specifier == VK_PM)

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp

@@ -40,8 +40,7 @@ llvm::createPPCXCOFFObjectWriter(bool Is64Bit) {
 
 std::pair<uint8_t, uint8_t> PPCXCOFFObjectWriter::getRelocTypeAndSignSize(
     const MCValue &Target, const MCFixup &Fixup, bool IsPCRel) const {
-  const auto Specifier =
-      Target.isAbsolute() ? PPCMCExpr::VK_None : Target.getSymSpecifier();
+  const auto Specifier = Target.getSpecifier();
   // People from AIX OS team says AIX link editor does not care about
   // the sign bit in the relocation entry "most" of the time.
   // The system assembler seems to set the sign bit on relocation entry

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZELFObjectWriter.cpp

@@ -220,7 +220,7 @@ unsigned SystemZELFObjectWriter::getRelocType(MCContext &Ctx,
 bool SystemZELFObjectWriter::needsRelocateWithSymbol(const MCValue &V,
                                                      const MCSymbol &Sym,
                                                      unsigned Type) const {
-  switch (V.getSymSpecifier()) {
+  switch (V.getSpecifier()) {
   case SystemZMCExpr::VK_GOT:
   case SystemZMCExpr::VK_PLT:
     return true;

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

@@ -66,7 +66,7 @@ unsigned WebAssemblyWasmObjectWriter::getRelocType(
     const MCValue &Target, const MCFixup &Fixup,
     const MCSectionWasm &FixupSection, bool IsLocRel) const {
   auto &SymA = cast<MCSymbolWasm>(*Target.getAddSym());
-  auto Spec = Target.getSymSpecifier();
+  auto Spec = Target.getSpecifier();
   switch (Spec) {
   case MCSymbolRefExpr::VK_GOT:
   case MCSymbolRefExpr::VK_WASM_GOT_TLS:

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

@@ -744,7 +744,7 @@ bool X86AsmBackend::fixupNeedsRelaxationAdvanced(const MCAssembler &Asm,
   if (Fixup.getKind() == FK_Data_1) {
     MCValue Target;
     if (Fixup.getValue()->evaluateAsRelocatable(Target, &Asm) &&
-        Target.getAddSym() && Target.getSymSpecifier() == X86MCExpr::VK_ABS8)
+        Target.getAddSym() && Target.getSpecifier() == X86MCExpr::VK_ABS8)
       return false;
   }
   return true;

llvm/lib/Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp

@@ -391,7 +391,7 @@ unsigned X86ELFObjectWriter::getRelocType(MCContext &Ctx, const MCValue &Target,
 bool X86ELFObjectWriter::needsRelocateWithSymbol(const MCValue &V,
                                                  const MCSymbol &Sym,
                                                  unsigned Type) const {
-  switch (V.getSymSpecifier()) {
+  switch (V.getSpecifier()) {
   case X86MCExpr::VK_GOT:
   case X86MCExpr::VK_PLT:
   case X86MCExpr::VK_GOTPCREL:

llvm/lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp

@@ -151,7 +151,7 @@ void X86MachObjectWriter::RecordX86_64Relocation(
     const MCSymbol *B_Base = Writer->getAtom(*B);
 
     // Neither symbol can be modified.
-    if (Target.getSymSpecifier()) {
+    if (Target.getSpecifier()) {
       Asm.getContext().reportError(Fixup.getLoc(),
                                    "unsupported relocation of modified symbol");
       return;
@@ -266,7 +266,7 @@ void X86MachObjectWriter::RecordX86_64Relocation(
       return;
     }
 
-    auto Specifier = Target.getSymSpecifier();
+    auto Specifier = Target.getSpecifier();
     if (IsPCRel) {
       if (IsRIPRel) {
         if (Specifier == X86MCExpr::VK_GOTPCREL) {
@@ -461,7 +461,7 @@ void X86MachObjectWriter::recordTLVPRelocation(MachObjectWriter *Writer,
                                                MCValue Target,
                                                uint64_t &FixedValue) {
   const MCSymbol *SymA = Target.getAddSym();
-  assert(Target.getSymSpecifier() == X86MCExpr::VK_TLVP && !is64Bit() &&
+  assert(Target.getSpecifier() == X86MCExpr::VK_TLVP && !is64Bit() &&
          "Should only be called with a 32-bit TLVP relocation!");
 
   unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind());
@@ -503,7 +503,7 @@ void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer,
   const MCSymbol *A = Target.getAddSym();
 
   // If this is a 32-bit TLVP reloc it's handled a bit differently.
-  if (A && Target.getSymSpecifier() == X86MCExpr::VK_TLVP) {
+  if (A && Target.getSpecifier() == X86MCExpr::VK_TLVP) {
     recordTLVPRelocation(Writer, Asm, Fragment, Fixup, Target, FixedValue);
     return;
   }

llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFObjectWriter.cpp

@@ -59,7 +59,7 @@ unsigned X86WinCOFFObjectWriter::getRelocType(MCContext &Ctx,
     }
   }
 
-  auto Spec = Target.getAddSym() ? Target.getSymSpecifier() : 0;
+  auto Spec = Target.getSpecifier();
   if (Is64Bit) {
     switch (FixupKind) {
     case FK_PCRel_4: