[llvm-mc][macho][RFC] Enable DwarfFDESymbolsUseAbsDiff on aarch64

[int3]

Summary

I am trying to do this to make it easier for LLD to support EH frames
for multiple archs. At present, DwarfFDESymbolsUseAbsDiff (first added
[here][1]) is only enabled for x86 archs. Rather than making LLD support
both abs-diff EH frame relocations as well as regular ones, I'm hoping
we can make MC emit EH frame relocs in the same format across archs.

However, naively toggling the flag gives us an [assertion error][4] when
running MC (and deleting the assertion results in a crash). So I
reverted [the commit that added the assertion][2] and removed some
functionality. This gets me the desired output for aarch64, but causes
[this test][3] to fail instead.

From reading commit #2's message, I suspect reverting it isn't the right
approach. Rafael authored that commit, but he's no longer around;
however the commit does reference r249303 which was also worked on by
@m.ostapenko and a mononymous "andy". I'm not sure who Andy is, so just
adding Maxim for now. Any pointers would be greatly appreciated :)

[1]: https://github.com/llvm/llvm-project/commit/618def651b59bd42c05bbd91d825af2fb2145683
[2]: https://github.com/llvm/llvm-project/commit/06c064824ef29425db785a31fed03821777fbf12
[3]: https://github.com/llvm/llvm-project/blob/main/llvm/test/CodeGen/AArch64/arm64_32.ll
[4]: https://github.com/llvm/llvm-project/blob/2a6669060f3533d144b12d1ec0faafe2de537994/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp#L325

[int3]

@MaskRay, @thakis -- might you guys know of any good reviewers for MC relocation logic? I'm a bit in over my head here...

[MaskRay]

In D123729#3452318, @int3 wrote:

@MaskRay, @thakis -- might you guys know of any good reviewers for MC relocation logic? I'm a bit in over my head here...

Either @lhames is or can point you to the appropriate one:)

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

AArch64MCAsmInfoDarwin::AArch64MCAsmInfoDarwin(bool IsILP32) {
   CommentString = ";";
   CalleeSaveStackSlotSize = 8;
   CodePointerSize = IsILP32 ? 4 : 8;
 
   AlignmentIsInBytes = false;
   UsesELFSectionDirectiveForBSS = true;
   SupportsDebugInformation = true;
   UseDataRegionDirectives = true;
+  DwarfFDESymbolsUseAbsDiff = true;
 
   ExceptionsType = ExceptionHandling::DwarfCFI;
 }
 
 const MCExpr *AArch64MCAsmInfoDarwin::getExprForPersonalitySymbol(
     const MCSymbol *Sym, unsigned Encoding, MCStreamer &Streamer) const {
   // On Darwin, we can reference dwarf symbols with foo@GOT-., which
   // is an indirect pc-relative reference. The default implementation

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

if (Symbol->isTemporary() && (Value || !CanUseLocalRelocation)) {
         return;
       }
       const MCSection &Sec = Symbol->getSection();
       if (!Asm.getContext().getAsmInfo()->isSectionAtomizableBySymbols(Sec))
         Symbol->setUsedInReloc();
     }
 
     const MCSymbol *Base = Asm.getAtom(*Symbol);
-    // If the symbol is a variable it can either be in a section and
-    // we have a base or it is absolute and should have been expanded.
-    assert(!Symbol->isVariable() || Base);
+
+    // If the symbol is a variable and we weren't able to get a Base for it
+    // (i.e., it's not in the symbol table associated with a section) resolve
+    // the relocation based its expansion instead.
+    if (Symbol->isVariable() && !Base) {
+      // If the evaluation is an absolute value, just use that directly
+      // to keep things easy.
+      int64_t Res;
+      if (Symbol->getVariableValue()->evaluateAsAbsolute(
+              Res, Layout, Writer->getSectionAddressMap())) {
+        FixedValue = Res;
+        return;
+      }
+
+      // FIXME: Will the Target we already have ever have any data in it
+      // we need to preserve and merge with the new Target? How about
+      // the FixedValue?
+      if (!Symbol->getVariableValue()->evaluateAsRelocatable(Target, &Layout,
+                                                             &Fixup)) {
+        Asm.getContext().reportError(Fixup.getLoc(),
+                                     "unable to resolve variable '" +
+                                         Symbol->getName() + "'");
+        return;
+      }
+      return recordRelocation(Writer, Asm, Layout, Fragment, Fixup, Target,
+                              FixedValue);
+    }
 
     // Relocations inside debug sections always use local relocations when
     // possible. This seems to be done because the debugger doesn't fully
     // understand relocation entries and expects to find values that
     // have already been fixed up.
     if (Symbol->isInSection()) {
       if (Section.hasAttribute(MachO::S_ATTR_DEBUG))
         Base = nullptr;
if (Base) {
       const MCSection &Sec = Symbol->getSection();
       Index = Sec.getOrdinal() + 1;
       Value += Writer->getSymbolAddress(*Symbol, Layout);
 
       if (IsPCRel)
         Value -= Writer->getFragmentAddress(Fragment, Layout) +
                  Fixup.getOffset() + (1ULL << Log2Size);
     } else {
-      llvm_unreachable(
-          "This constant variable should have been expanded during evaluation");
+      // Resolve constant variables.
+      if (Symbol->isVariable()) {
+        int64_t Res;
+        if (Symbol->getVariableValue()->evaluateAsAbsolute(
+                Res, Layout, Writer->getSectionAddressMap())) {
+          FixedValue = Res;
+          return;
+        }
+      }
+      Asm.getContext().reportError(Fixup.getLoc(),
+                                  "unsupported relocation of variable '" +
+                                      Symbol->getName() + "'");
+      return;
     }
   }
 
   // If the relocation kind is Branch26, Page21, or Pageoff12, any addend
   // is represented via an Addend relocation, not encoded directly into
   // the instruction.
   if ((Type == MachO::ARM64_RELOC_BRANCH26 ||
        Type == MachO::ARM64_RELOC_PAGE21 ||