MCValue: Simplify code with getSubSym

MCValue::SymB is a MCSymbolRefExpr *, which might become MCSymbol * in
the future. Simplify some code that uses MCValue::SymB.

Author: MaskRay

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

@@ -1564,7 +1564,7 @@ const MCExpr *TargetLoweringObjectFileMachO::getIndirectSymViaGOTPCRel(
   // The offset must consider the original displacement from the base symbol
   // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
   Offset = -MV.getConstant();
-  const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
+  const MCSymbol *BaseSym = MV.getSubSym();
 
   // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
   // non_lazy_ptr stubs.

llvm/lib/MC/ELFObjectWriter.cpp

@@ -1376,8 +1376,8 @@ void ELFObjectWriter::recordRelocation(MCAssembler &Asm,
   MCContext &Ctx = Asm.getContext();
   const MCTargetOptions *TO = Ctx.getTargetOptions();
 
-  if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
-    const auto &SymB = cast<MCSymbolELF>(RefB->getSymbol());
+  if (auto *RefB = Target.getSubSym()) {
+    const auto &SymB = cast<MCSymbolELF>(*RefB);
     if (SymB.isUndefined()) {
       Ctx.reportError(Fixup.getLoc(),
                       Twine("symbol '") + SymB.getName() +

llvm/lib/MC/MCAssembler.cpp

@@ -122,7 +122,7 @@ bool MCAssembler::isThumbFunc(const MCSymbol *Symbol) const {
   if (!Expr->evaluateAsRelocatable(V, nullptr))
     return false;
 
-  if (V.getSymB() || V.getRefKind() != MCSymbolRefExpr::VK_None)
+  if (V.getSubSym() || V.getRefKind() != MCSymbolRefExpr::VK_None)
     return false;
 
   const MCSymbolRefExpr *Ref = V.getSymA();
@@ -236,7 +236,7 @@ bool MCAssembler::evaluateFixup(const MCFixup &Fixup, const MCFragment *DF,
 
   // A linker relaxation target may emit ADD/SUB relocations for A-B+C. Let
   // recordRelocation handle non-VK_None cases like A@plt-B+C.
-  if (!IsResolved && Target.getSymA() && Target.getSymB() &&
+  if (!IsResolved && Target.getSymA() && Target.getSubSym() &&
       Target.getSymA()->getKind() == MCSymbolRefExpr::VK_None &&
       getBackend().handleAddSubRelocations(*this, *DF, Fixup, Target, Value))
     return true;

llvm/lib/MC/MCExpr.cpp

@@ -547,7 +547,7 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
           // which evaluate exactly to a single unadorned symbol. Attach the
           // original VariantKind to SymA of the result.
           if (Res.getRefKind() != MCSymbolRefExpr::VK_None || !Res.getSymA() ||
-              Res.getSymB() || Res.getConstant())
+              Res.getSubSym() || Res.getConstant())
             return false;
           Res =
               MCValue::get(MCSymbolRefExpr::create(&Res.getSymA()->getSymbol(),
@@ -558,7 +558,7 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
           return true;
 
         const MCSymbolRefExpr *A = Res.getSymA();
-        const MCSymbolRefExpr *B = Res.getSymB();
+        auto *B = Res.getSubSym();
         // FIXME: This is small hack. Given
         // a = b + 4
         // .long a
@@ -592,7 +592,7 @@ bool MCExpr::evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
       break;
     case MCUnaryExpr::Minus:
       /// -(a - b + const) ==> (b - a - const)
-      if (Value.getSymA() && !Value.getSymB())
+      if (Value.getSymA() && !Value.getSubSym())
         return false;
 
       // The cast avoids undefined behavior if the constant is INT64_MIN.

llvm/lib/MC/MCMachOStreamer.cpp

@@ -184,7 +184,8 @@ void MCMachOStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
   if (Value->evaluateAsRelocatable(Res, nullptr)) {
     if (const MCSymbolRefExpr *SymAExpr = Res.getSymA()) {
       const MCSymbol &SymA = SymAExpr->getSymbol();
-      if (!Res.getSymB() && (SymA.getName() == "" || Res.getConstant() != 0))
+      if (!Res.getSubSym() &&
+          (SymA.getName().empty() || Res.getConstant() != 0))
         cast<MCSymbolMachO>(Symbol)->setAltEntry();
     }
   }

llvm/lib/MC/MCObjectStreamer.cpp

@@ -605,7 +605,7 @@ getOffsetAndDataFragment(const MCSymbol &Symbol, uint32_t &RelocOffset,
       return std::nullopt;
     }
 
-    if (OffsetVal.getSymB())
+    if (OffsetVal.getSubSym())
       return std::make_pair(false,
                             std::string(".reloc symbol offset is not "
                                         "representable"));
@@ -672,7 +672,7 @@ MCObjectStreamer::emitRelocDirective(const MCExpr &Offset, StringRef Name,
         MCFixup::create(OffsetVal.getConstant(), Expr, Kind, Loc));
     return std::nullopt;
   }
-  if (OffsetVal.getSymB())
+  if (OffsetVal.getSubSym())
     return std::make_pair(false,
                           std::string(".reloc offset is not representable"));
 

llvm/lib/MC/MachObjectWriter.cpp

@@ -112,15 +112,15 @@ uint64_t MachObjectWriter::getSymbolAddress(const MCSymbol &S,
     if (Target.getSymA() && Target.getSymA()->getSymbol().isUndefined())
       report_fatal_error("unable to evaluate offset to undefined symbol '" +
                          Target.getSymA()->getSymbol().getName() + "'");
-    if (Target.getSymB() && Target.getSymB()->getSymbol().isUndefined())
+    if (Target.getSubSym() && Target.getSubSym()->isUndefined())
       report_fatal_error("unable to evaluate offset to undefined symbol '" +
-                         Target.getSymB()->getSymbol().getName() + "'");
+                         Target.getSubSym()->getName() + "'");
 
     uint64_t Address = Target.getConstant();
     if (Target.getSymA())
       Address += getSymbolAddress(Target.getSymA()->getSymbol(), Asm);
-    if (Target.getSymB())
-      Address += getSymbolAddress(Target.getSymB()->getSymbol(), Asm);
+    if (Target.getSubSym())
+      Address += getSymbolAddress(*Target.getSubSym(), Asm);
     return Address;
   }
 
@@ -507,7 +507,7 @@ void MachObjectWriter::writeLinkerOptionsLoadCommand(
 static bool isFixupTargetValid(const MCValue &Target) {
   // Target is (LHS - RHS + cst).
   // We don't support the form where LHS is null: -RHS + cst
-  if (!Target.getSymA() && Target.getSymB())
+  if (!Target.getSymA() && Target.getSubSym())
     return false;
   return true;
 }

llvm/lib/MC/WasmObjectWriter.cpp

@@ -490,9 +490,8 @@ void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
   MCContext &Ctx = Asm.getContext();
   bool IsLocRel = false;
 
-  if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
-
-    const auto &SymB = cast<MCSymbolWasm>(RefB->getSymbol());
+  if (const auto *RefB = Target.getSubSym()) {
+    const auto &SymB = cast<MCSymbolWasm>(*RefB);
 
     if (FixupSection.isText()) {
       Ctx.reportError(Fixup.getLoc(),

llvm/lib/MC/WinCOFFObjectWriter.cpp

@@ -860,10 +860,7 @@ void WinCOFFWriter::recordRelocation(MCAssembler &Asm,
          "Section must already have been defined in executePostLayoutBinding!");
 
   COFFSection *Sec = SectionMap[MCSec];
-  const MCSymbolRefExpr *SymB = Target.getSymB();
-
-  if (SymB) {
-    const MCSymbol *B = &SymB->getSymbol();
+  if (const MCSymbol *B = Target.getSubSym()) {
     if (!B->getFragment()) {
       Asm.getContext().reportError(
           Fixup.getLoc(),
@@ -923,7 +920,7 @@ void WinCOFFWriter::recordRelocation(MCAssembler &Asm,
 
   Reloc.Data.VirtualAddress += Fixup.getOffset();
   Reloc.Data.Type = OWriter.TargetObjectWriter->getRelocType(
-      Asm.getContext(), Target, Fixup, SymB, Asm.getBackend());
+      Asm.getContext(), Target, Fixup, Target.getSubSym(), Asm.getBackend());
 
   // The *_REL32 relocations are relative to the end of the relocation,
   // not to the start.

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

@@ -213,7 +213,7 @@ void AArch64MachObjectWriter::recordRelocation(
       // FIXME: x86_64 sets the type to a branch reloc here. Should we do
       // something similar?
     }
-  } else if (Target.getSymB()) { // A - B + constant
+  } else if (Target.getSubSym()) { // A - B + constant
     const MCSymbol *A = &Target.getSymA()->getSymbol();
     const MCSymbol *A_Base = Writer->getAtom(*A);
 

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

@@ -378,7 +378,7 @@ void ARMMachObjectWriter::recordRelocation(MachObjectWriter *Writer,
   // If this is a difference or a defined symbol plus an offset, then we need a
   // scattered relocation entry.  Differences always require scattered
   // relocations.
-  if (Target.getSymB()) {
+  if (Target.getSubSym()) {
     if (RelocType == MachO::ARM_RELOC_HALF)
       return recordARMScatteredHalfRelocation(Writer, Asm, Fragment, Fixup,
                                               Target, FixedValue);

llvm/lib/Target/RISCV/MCTargetDesc/RISCVAsmBackend.cpp

@@ -551,7 +551,7 @@ bool RISCVAsmBackend::evaluateTargetFixup(const MCAssembler &Asm,
   }
   }
 
-  if (!AUIPCTarget.getSymA() || AUIPCTarget.getSymB())
+  if (!AUIPCTarget.getSymA() || AUIPCTarget.getSubSym())
     return false;
 
   const MCSymbolRefExpr *A = AUIPCTarget.getSymA();

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

@@ -139,13 +139,13 @@ void X86MachObjectWriter::RecordX86_64Relocation(
       IsExtern = 1;
       Type = MachO::X86_64_RELOC_BRANCH;
     }
-  } else if (Target.getSymB()) { // A - B + constant
+  } else if (Target.getSubSym()) { // A - B + constant
     const MCSymbol *A = &Target.getSymA()->getSymbol();
     if (A->isTemporary())
       A = &Writer->findAliasedSymbol(*A);
     const MCSymbol *A_Base = Writer->getAtom(*A);
 
-    const MCSymbol *B = &Target.getSymB()->getSymbol();
+    const MCSymbol *B = Target.getSubSym();
     if (B->isTemporary())
       B = &Writer->findAliasedSymbol(*B);
     const MCSymbol *B_Base = Writer->getAtom(*B);
@@ -385,9 +385,7 @@ bool X86MachObjectWriter::recordScatteredRelocation(MachObjectWriter *Writer,
   FixedValue += SecAddr;
   uint32_t Value2 = 0;
 
-  if (const MCSymbolRefExpr *B = Target.getSymB()) {
-    const MCSymbol *SB = &B->getSymbol();
-
+  if (const MCSymbol *SB = Target.getSubSym()) {
     if (!SB->getFragment()) {
       Asm.getContext().reportError(
           Fixup.getLoc(),
@@ -474,13 +472,12 @@ void X86MachObjectWriter::recordTLVPRelocation(MachObjectWriter *Writer,
   // subtraction from the picbase. For 32-bit pic the addend is the difference
   // between the picbase and the next address.  For 32-bit static the addend is
   // zero.
-  if (auto *SymB = Target.getSymB()) {
+  if (auto *SymB = Target.getSubSym()) {
     // If this is a subtraction then we're pcrel.
     uint32_t FixupAddress =
         Writer->getFragmentAddress(Asm, Fragment) + Fixup.getOffset();
     IsPCRel = 1;
-    FixedValue = FixupAddress -
-                 Writer->getSymbolAddress(SymB->getSymbol(), Asm) +
+    FixedValue = FixupAddress - Writer->getSymbolAddress(*SymB, Asm) +
                  Target.getConstant();
     FixedValue += 1ULL << Log2Size;
   } else {
@@ -514,7 +511,7 @@ void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer,
   // If this is a difference or a defined symbol plus an offset, then we need a
   // scattered relocation entry. Differences always require scattered
   // relocations.
-  if (Target.getSymB()) {
+  if (Target.getSubSym()) {
     recordScatteredRelocation(Writer, Asm, Fragment, Fixup, Target, Log2Size,
                               FixedValue);
     return;