[MC] Move isMemtag test to AArch64

And introduce MCValue::getAddSym & MCValue::getSubSym to simplify code.

We do not utilize the MCSymbol argument of needsRelocateWithSymbol
as it will go away in the future.

Author: MaskRay

llvm/include/llvm/MC/MCValue.h

@@ -45,6 +45,13 @@ class MCValue {
   const MCSymbolRefExpr *getSymB() const { return SymB; }
   uint32_t getRefKind() const { return RefKind; }
 
+  const MCSymbol *getAddSym() const {
+    return SymA ? &SymA->getSymbol() : nullptr;
+  }
+  const MCSymbol *getSubSym() const {
+    return SymB ? &SymB->getSymbol() : nullptr;
+  }
+
   /// Is this an absolute (as opposed to relocatable) value.
   bool isAbsolute() const { return !SymA && !SymB; }
 

llvm/lib/MC/ELFObjectWriter.cpp

@@ -1271,15 +1271,6 @@ bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
              TargetObjectWriter->getEMachine() == ELF::EM_PPC64);
   }
 
-  // For memory-tagged symbols, ensure that the relocation uses the symbol. For
-  // tagged symbols, we emit an empty relocation (R_AARCH64_NONE) in a special
-  // section (SHT_AARCH64_MEMTAG_GLOBALS_STATIC) to indicate to the linker that
-  // this global needs to be tagged. In addition, the linker needs to know
-  // whether to emit a special addend when relocating `end` symbols, and this
-  // can only be determined by the attributes of the symbol itself.
-  if (Sym->isMemtag())
-    return true;
-
   unsigned Binding = Sym->getBinding();
   switch(Binding) {
   default:

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

@@ -19,6 +19,7 @@
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
@@ -543,6 +544,15 @@ unsigned AArch64ELFObjectWriter::getRelocType(MCContext &Ctx,
 bool AArch64ELFObjectWriter::needsRelocateWithSymbol(const MCValue &Val,
                                                      const MCSymbol &,
                                                      unsigned) const {
+  // For memory-tagged symbols, ensure that the relocation uses the symbol. For
+  // tagged symbols, we emit an empty relocation (R_AARCH64_NONE) in a special
+  // section (SHT_AARCH64_MEMTAG_GLOBALS_STATIC) to indicate to the linker that
+  // this global needs to be tagged. In addition, the linker needs to know
+  // whether to emit a special addend when relocating `end` symbols, and this
+  // can only be determined by the attributes of the symbol itself.
+  if (Val.getAddSym() && cast<MCSymbolELF>(Val.getAddSym())->isMemtag())
+    return true;
+
   if ((Val.getRefKind() & AArch64MCExpr::VK_GOT) == AArch64MCExpr::VK_GOT)
     return true;
   return is_contained({MCSymbolRefExpr::VK_GOTPCREL, MCSymbolRefExpr::VK_PLT},