[MC] [AArch64] Support resolving fixups for :abs_g0: etc.

[efriedma]

Summary

This requires a bit more code than other fixups, to distingush between abs_g0/abs_g1/etc. Actually, I think some of the other fixups are missing some checks, but I won't try to address that here.

I haven't seen any real-world code that uses a construct like this, but it clearly should work, and we're considering using it in the implementation of localescape/localrecover on Windows (see https://reviews.llvm.org/D53540). I've verified that binutils produces the same code as llvm-mc for the testcase.

This currently doesn't include support for the *_s variants (that requires a bit more work to set the instruction opcode).

[mgrang]

This doesn't seem to work if the label is defined before the use:

.Lfoo = 0x12345678
movz x0, #:abs_g1:.Lfoo
movk x0, #:abs_g0_nc:.Lfoo

error: immediate must be an integer in range [0, 65535].

In this case it considers the movz/movk operand as an immediate and it cannot apply the relocation specifier to an immediate.
It seems to match these rules in AArch64InstrInfo.td:

def : InstAlias<"movz $dst, $imm", (MOVZXi GPR64:$dst, imm0_65535:$imm, 0)>;
def : InstAlias<"movk $dst, $imm", (MOVKXi GPR64:$dst, imm0_65535:$imm, 0), 0>;

As opposed to these ones:

def : InstAlias<"movz $Rd, $sym", (MOVZXi GPR64:$Rd, movz_symbol_g1:$sym, 16)>;
def : InstAlias<"movk $Rd, $sym", (MOVKXi GPR64:$Rd, movk_symbol_g0:$sym, 0), 0>;

[efriedma]

Yes, AArch64AsmParser::classifySymbolRef currently doesn't treat "#:abs_g0:value" as symbolic if "value" is known. It's straightforward to fix, but it's sort of orthogonal to this patch. I'll post it separately.

[mstorsjo]

LGTM

[peter.smith]

LGTM as well

[mgrang]

LGTM.

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

default:
     llvm_unreachable("Unknown fixup kind!");
 
   case AArch64::fixup_aarch64_tlsdesc_call:
     return 0;
 
   case FK_Data_1:
     return 1;
 
-  case AArch64::fixup_aarch64_movw:
   case FK_Data_2:
   case FK_SecRel_2:
     return 2;
 
+  case AArch64::fixup_aarch64_movw:
   case AArch64::fixup_aarch64_pcrel_branch14:
   case AArch64::fixup_aarch64_add_imm12:
   case AArch64::fixup_aarch64_ldst_imm12_scale1:
   case AArch64::fixup_aarch64_ldst_imm12_scale2:
   case AArch64::fixup_aarch64_ldst_imm12_scale4:
   case AArch64::fixup_aarch64_ldst_imm12_scale8:
   case AArch64::fixup_aarch64_ldst_imm12_scale16:
   case AArch64::fixup_aarch64_ldr_pcrel_imm19:

 }
 
 static unsigned AdrImmBits(unsigned Value) {
   unsigned lo2 = Value & 0x3;
   unsigned hi19 = (Value & 0x1ffffc) >> 2;
   return (hi19 << 5) | (lo2 << 29);
 }
 
-static uint64_t adjustFixupValue(const MCFixup &Fixup, uint64_t Value,
-                                 MCContext &Ctx, const Triple &TheTriple,
-                                 bool IsResolved) {
+static uint64_t adjustFixupValue(const MCFixup &Fixup, const MCValue &Target,
+                                 uint64_t Value, MCContext &Ctx,
+                                 const Triple &TheTriple, bool IsResolved) {
   unsigned Kind = Fixup.getKind();
   int64_t SignedValue = static_cast<int64_t>(Value);
   switch (Kind) {
   default:
     llvm_unreachable("Unknown fixup kind!");
   case AArch64::fixup_aarch64_pcrel_adr_imm21:
     if (SignedValue > 2097151 || SignedValue < -2097152)
       Ctx.reportError(Fixup.getLoc(), "fixup value out of range");
case AArch64::fixup_aarch64_ldst_imm12_scale16:
     if (TheTriple.isOSBinFormatCOFF() && !IsResolved)
       Value &= 0xfff;
     // Unsigned 12-bit immediate which gets multiplied by 16
     if (Value >= 0x10000)
       Ctx.reportError(Fixup.getLoc(), "fixup value out of range");
     if (Value & 0xf)
       Ctx.reportError(Fixup.getLoc(), "fixup must be 16-byte aligned");
     return Value >> 4;
-  case AArch64::fixup_aarch64_movw:
+  case AArch64::fixup_aarch64_movw: {
+    AArch64MCExpr::VariantKind RefKind =
+        static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
+    if (AArch64MCExpr::getSymbolLoc(RefKind) != AArch64MCExpr::VK_ABS) {
+      if (AArch64MCExpr::getSymbolLoc(RefKind) != AArch64MCExpr::VK_SABS) {
+        // VK_GOTTPREL, VK_TPREL, VK_DTPREL are movw fixups, but they can't
+        // ever be resolved in the assembler.
         Ctx.reportError(Fixup.getLoc(),
-                    "no resolvable MOVZ/MOVK fixups supported yet");
+                        "relocation for a thread-local variable points to an "
+                        "absolute symbol");
+        return Value;
+      }
+      Ctx.reportError(Fixup.getLoc(),
+                      "resolvable R_AARCH64_MOVW_SABS_G* fixups are not "
+                       "yet implemented");
+      return Value;
+    }
+    if (!IsResolved) {
+      // FIXME: Figure out when this can actually happen, and verify our
+      // behavior.
+      Ctx.reportError(Fixup.getLoc(), "unresolved movw fixup not yet "
+                                      "implemented");
       return Value;
+    }
+    switch (AArch64MCExpr::getAddressFrag(RefKind)) {
+    case AArch64MCExpr::VK_G0:
+      break;
+    case AArch64MCExpr::VK_G1:
+      Value = Value >> 16;
+      break;
+    case AArch64MCExpr::VK_G2:
+      Value = Value >> 32;
+      break;
+    case AArch64MCExpr::VK_G3:
+      Value = Value >> 48;
+      break;
+    default:
+      llvm_unreachable("Variant kind doesn't correspond to fixup");
+    }
+    if (RefKind & AArch64MCExpr::VK_NC)
+      Value &= 0xFFFF;
+    else if (Value > 0xFFFF)
+      Ctx.reportError(Fixup.getLoc(), "fixup value out of range");
+    return Value;
+  }
   case AArch64::fixup_aarch64_pcrel_branch14:
     // Signed 16-bit immediate
     if (SignedValue > 32767 || SignedValue < -32768)
       Ctx.reportError(Fixup.getLoc(), "fixup value out of range");
     // Low two bits are not encoded (4-byte alignment assumed).
     if (Value & 0x3)
       Ctx.reportError(Fixup.getLoc(), "fixup not sufficiently aligned");
     return (Value >> 2) & 0x3fff;
void AArch64AsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                                    bool IsResolved,
                                    const MCSubtargetInfo *STI) const {
   unsigned NumBytes = getFixupKindNumBytes(Fixup.getKind());
   if (!Value)
     return; // Doesn't change encoding.
   MCFixupKindInfo Info = getFixupKindInfo(Fixup.getKind());
   MCContext &Ctx = Asm.getContext();
   // Apply any target-specific value adjustments.
-  Value = adjustFixupValue(Fixup, Value, Ctx, TheTriple, IsResolved);
+  Value = adjustFixupValue(Fixup, Target, Value, Ctx, TheTriple, IsResolved);
 
   // Shift the value into position.
   Value <<= Info.TargetOffset;
 
   unsigned Offset = Fixup.getOffset();
   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");
 
   // Used to point to big endian bytes.

llvm/trunk/test/MC/AArch64/fixup-absolute.s

+// RUN: llvm-mc -triple aarch64--none-eabi -filetype obj < %s -o - | llvm-objdump -d - | FileCheck %s
+
+// CHECK: mov     x0, #1311673391471656960
+movz x0, #:abs_g3:fourpart
+// CHECK: mov     x0, #20014547599360
+movz x0, #:abs_g2:threepart
+// CHECK: movk    x0, #22136, lsl #32
+movk x0, #:abs_g2_nc:fourpart
+// CHECK: mov     x0, #305397760
+movz x0, #:abs_g1:twopart
+// CHECK: movk    x0, #37035, lsl #16
+movk x0, #:abs_g1_nc:fourpart
+// CHECK: mov     x0, #4660
+movz x0, #:abs_g0:onepart
+// CHECK: movk    x0, #52719
+movk x0, #:abs_g0_nc:fourpart
+
+onepart = 0x1234
+twopart = 0x12345678
+threepart = 0x1234567890AB
+fourpart = 0x1234567890ABCDEF

llvm/trunk/test/MC/AArch64/fixup-out-of-range.s

// CHECK: :[[@LINE+1]]:{{[0-9]+}}: error: fixup not sufficiently aligned
   tbz x0, #1, unaligned
 
 // CHECK: :[[@LINE+1]]:{{[0-9]+}}: error: fixup value out of range
   b distant
 
 // CHECK: :[[@LINE+1]]:{{[0-9]+}}: error: fixup not sufficiently aligned
   b unaligned
 
+// CHECK: :[[@LINE+1]]:{{[0-9]+}}: error: fixup value out of range
+  movz x0, #:abs_g0:value1
+
+// CHECK: :[[@LINE+1]]:{{[0-9]+}}: error: fixup value out of range
+  movz x0, #:abs_g1:value2
+
+// CHECK: :[[@LINE+1]]:{{[0-9]+}}: error: resolvable R_AARCH64_MOVW_SABS_G* fixups are not yet implemented
+  movz x0, #:abs_g0_s:value1
+
+// CHECK: :[[@LINE+1]]:{{[0-9]+}}: error: relocation for a thread-local variable points to an absolute symbol
+  movz x0, #:tprel_g0:value1
+
+
   .byte 0
 unaligned:
   .byte 0
 
   .space 1<<27
   .balign 8
 distant:
   .word 0
+value1 = 0x12345678
+value2 = 0x123456789