MC: Introduce the ABS8 symbol modifier.

[pcc]

Summary

@ABS8 can be applied to symbols which appear as immediate operands to
instructions that have a 8-bit immediate form for that operand. It causes
the assembler to use the 8-bit form and an 8-bit relocation (e.g. R_386_8
or R_X86_64_8) for the symbol.

[RKSimon]

llvm/include/llvm/MC/MCExpr.h

193 ↗

(On Diff #84346)

Should this be VK_X86_ABS8 or do we expect other targets to use this?

[pcc]

• Address review comments

[pcc]

llvm/include/llvm/MC/MCExpr.h

193 ↗

(On Diff #84346)

Browsing the lists of relocations in include/llvm/Support/ELFRelocs I can see that ARM and a few other targets have 8-bit relocations, but then of course ARM represents immediate operands in a completely different way (haven't thought about other targets). Renamed to be X86-specific and we can think about a more generic name if a need arises.

llvm/trunk/docs/Extensions.rst

 
 
 The unique number is not present in the resulting object at all. It is just used
 in the assembler to differentiate the sections.
 
 Target Specific Behaviour
 =========================
 
+X86
+---
+
+Relocations
+^^^^^^^^^^^
+
+``@ABS8`` can be applied to symbols which appear as immediate operands to
+instructions that have an 8-bit immediate form for that operand. It causes
+the assembler to use the 8-bit form and an 8-bit relocation (e.g. ``R_386_8``
+or ``R_X86_64_8``) for the symbol.
+
+For example:
+
+.. code-block:: gas
+
+  cmpq $foo@ABS8, %rdi
+
+This causes the assembler to select the form of the 64-bit ``cmpq`` instruction
+that takes an 8-bit immediate operand that is sign extended to 64 bits, as
+opposed to ``cmpq $foo, %rdi`` which takes a 32-bit immediate operand. This
+is also not the same as ``cmpb $foo, %dil``, which is an 8-bit comparison.
+
 Windows on ARM
 --------------
 
 Stack Probe Emission
 ^^^^^^^^^^^^^^^^^^^^
 
 The reference implementation (Microsoft Visual Studio 2012) emits stack probes
 in the following fashion:

llvm/trunk/include/llvm/MC/MCExpr.h

enum VariantKind : uint16_t {
     VK_PAGE,
     VK_PAGEOFF,
     VK_GOTPAGE,
     VK_GOTPAGEOFF,
     VK_SECREL,
     VK_SIZE,      // symbol@SIZE
     VK_WEAKREF,   // The link between the symbols in .weakref foo, bar
 
+    VK_X86_ABS8,
+
     VK_ARM_NONE,
     VK_ARM_GOT_PREL,
     VK_ARM_TARGET1,
     VK_ARM_TARGET2,
     VK_ARM_PREL31,
     VK_ARM_SBREL,          // symbol(sbrel)
     VK_ARM_TLSLDO,         // symbol(tlsldo)
     VK_ARM_TLSDESCSEQ,

llvm/trunk/lib/MC/MCAssembler.cpp

 }
 
 bool MCAssembler::fixupNeedsRelaxation(const MCFixup &Fixup,
                                        const MCRelaxableFragment *DF,
                                        const MCAsmLayout &Layout) const {
   MCValue Target;
   uint64_t Value;
   bool Resolved = evaluateFixup(Layout, Fixup, DF, Target, Value);
+  if (Target.getSymA() &&
+      Target.getSymA()->getKind() == MCSymbolRefExpr::VK_X86_ABS8 &&
+      Fixup.getKind() == FK_Data_1)
+    return false;
   return getBackend().fixupNeedsRelaxationAdvanced(Fixup, Resolved, Value, DF,
                                                    Layout);
 }
 
 bool MCAssembler::fragmentNeedsRelaxation(const MCRelaxableFragment *F,
                                           const MCAsmLayout &Layout) const {
   // If this inst doesn't ever need relaxation, ignore it. This occurs when we
   // are intentionally pushing out inst fragments, or because we relaxed a

llvm/trunk/lib/MC/MCExpr.cpp

StringRef MCSymbolRefExpr::getVariantKindName(VariantKind Kind) {
   case VK_TLVPPAGEOFF: return "TLVPPAGEOFF";
   case VK_PAGE: return "PAGE";
   case VK_PAGEOFF: return "PAGEOFF";
   case VK_GOTPAGE: return "GOTPAGE";
   case VK_GOTPAGEOFF: return "GOTPAGEOFF";
   case VK_SECREL: return "SECREL32";
   case VK_SIZE: return "SIZE";
   case VK_WEAKREF: return "WEAKREF";
+  case VK_X86_ABS8: return "ABS8";
   case VK_ARM_NONE: return "none";
   case VK_ARM_GOT_PREL: return "GOT_PREL";
   case VK_ARM_TARGET1: return "target1";
   case VK_ARM_TARGET2: return "target2";
   case VK_ARM_PREL31: return "prel31";
   case VK_ARM_SBREL: return "sbrel";
   case VK_ARM_TLSLDO: return "tlsldo";
   case VK_ARM_TLSDESCSEQ: return "tlsdescseq";
return StringSwitch<VariantKind>(Name.lower())
     .Case("tlvppageoff", VK_TLVPPAGEOFF)
     .Case("page", VK_PAGE)
     .Case("pageoff", VK_PAGEOFF)
     .Case("gotpage", VK_GOTPAGE)
     .Case("gotpageoff", VK_GOTPAGEOFF)
     .Case("imgrel", VK_COFF_IMGREL32)
     .Case("secrel32", VK_SECREL)
     .Case("size", VK_SIZE)
+    .Case("abs8", VK_X86_ABS8)
     .Case("l", VK_PPC_LO)
     .Case("h", VK_PPC_HI)
     .Case("ha", VK_PPC_HA)
     .Case("higher", VK_PPC_HIGHER)
     .Case("highera", VK_PPC_HIGHERA)
     .Case("highest", VK_PPC_HIGHEST)
     .Case("highesta", VK_PPC_HIGHESTA)
     .Case("got@l", VK_PPC_GOT_LO)

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

 static unsigned getRelocType64(MCContext &Ctx, SMLoc Loc,
                                MCSymbolRefExpr::VariantKind Modifier,
                                X86_64RelType Type, bool IsPCRel,
                                unsigned Kind) {
   switch (Modifier) {
   default:
     llvm_unreachable("Unimplemented");
   case MCSymbolRefExpr::VK_None:
+  case MCSymbolRefExpr::VK_X86_ABS8:
     switch (Type) {
     case RT64_64:
       return IsPCRel ? ELF::R_X86_64_PC64 : ELF::R_X86_64_64;
     case RT64_32:
       return IsPCRel ? ELF::R_X86_64_PC32 : ELF::R_X86_64_32;
     case RT64_32S:
       return ELF::R_X86_64_32S;
     case RT64_16:

 static unsigned getRelocType32(MCContext &Ctx,
                                MCSymbolRefExpr::VariantKind Modifier,
                                X86_32RelType Type, bool IsPCRel,
                                unsigned Kind) {
   switch (Modifier) {
   default:
     llvm_unreachable("Unimplemented");
   case MCSymbolRefExpr::VK_None:
+  case MCSymbolRefExpr::VK_X86_ABS8:
     switch (Type) {
     case RT32_32:
       return IsPCRel ? ELF::R_386_PC32 : ELF::R_386_32;
     case RT32_16:
       return IsPCRel ? ELF::R_386_PC16 : ELF::R_386_16;
     case RT32_8:
       return IsPCRel ? ELF::R_386_PC8 : ELF::R_386_8;
     }

llvm/trunk/test/MC/X86/abs8.s

+// RUN: llvm-mc -filetype=obj %s -o - -triple i686-pc-linux | llvm-objdump -d -r - | FileCheck --check-prefix=32 %s
+// RUN: llvm-mc -filetype=obj %s -o - -triple x86_64-pc-linux | llvm-objdump -d -r - | FileCheck --check-prefix=64 %s
+
+// 32: 0: 83 ff 00  cmpl $0, %edi
+// 32:   00000002:  R_386_8 foo
+// 64: 0: 83 ff 00  cmpl $0, %edi
+// 64:  0000000000000002:  R_X86_64_8 foo+0
+cmp $foo@ABS8, %edi