[PowerPC] Add support for high and high-adjusted symbol modifiers.

[sfertile]

Summary

Adds support for the @high and @higha symbol modifiers which are used as part of the sequence for building a 64-bit offset.

[syzaara]

LGTM

llvm/trunk/include/llvm/BinaryFormat/ELFRelocs/PowerPC64.def

 #undef R_PPC64_DTPREL16_DS
 #undef R_PPC64_DTPREL16_LO_DS
 #undef R_PPC64_DTPREL16_HIGHER
 #undef R_PPC64_DTPREL16_HIGHERA
 #undef R_PPC64_DTPREL16_HIGHEST
 #undef R_PPC64_DTPREL16_HIGHESTA
 #undef R_PPC64_TLSGD
 #undef R_PPC64_TLSLD
+#undef R_PPC64_ADDR16_HIGH
+#undef R_PPC64_ADDR16_HIGHA
 #undef R_PPC64_IRELATIVE
 #undef R_PPC64_REL16
 #undef R_PPC64_REL16_LO
 #undef R_PPC64_REL16_HI
 #undef R_PPC64_REL16_HA
 
 ELF_RELOC(R_PPC64_NONE,                 0)
 ELF_RELOC(R_PPC64_ADDR32,               1)

 ELF_RELOC(R_PPC64_DTPREL16_DS,          101)
 ELF_RELOC(R_PPC64_DTPREL16_LO_DS,       102)
 ELF_RELOC(R_PPC64_DTPREL16_HIGHER,      103)
 ELF_RELOC(R_PPC64_DTPREL16_HIGHERA,     104)
 ELF_RELOC(R_PPC64_DTPREL16_HIGHEST,     105)
 ELF_RELOC(R_PPC64_DTPREL16_HIGHESTA,    106)
 ELF_RELOC(R_PPC64_TLSGD,                107)
 ELF_RELOC(R_PPC64_TLSLD,                108)
+ELF_RELOC(R_PPC64_ADDR16_HIGH,          110)
+ELF_RELOC(R_PPC64_ADDR16_HIGHA,         111)
 ELF_RELOC(R_PPC64_IRELATIVE,            248)
 ELF_RELOC(R_PPC64_REL16,                249)
 ELF_RELOC(R_PPC64_REL16_LO,             250)
 ELF_RELOC(R_PPC64_REL16_HI,             251)
 ELF_RELOC(R_PPC64_REL16_HA,             252)

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

enum VariantKind : uint16_t {
     VK_AVR_HLO8,
     VK_AVR_DIFF8,
     VK_AVR_DIFF16,
     VK_AVR_DIFF32,
 
     VK_PPC_LO,             // symbol@l
     VK_PPC_HI,             // symbol@h
     VK_PPC_HA,             // symbol@ha
+    VK_PPC_HIGH,           // symbol@high
+    VK_PPC_HIGHA,          // symbol@higha
     VK_PPC_HIGHER,         // symbol@higher
     VK_PPC_HIGHERA,        // symbol@highera
     VK_PPC_HIGHEST,        // symbol@highest
     VK_PPC_HIGHESTA,       // symbol@highesta
     VK_PPC_GOT_LO,         // symbol@got@l
     VK_PPC_GOT_HI,         // symbol@got@h
     VK_PPC_GOT_HA,         // symbol@got@ha
     VK_PPC_TOCBASE,        // symbol@tocbase

llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

case ELF::R_PPC64_ADDR16_DS:
     break;
   case ELF::R_PPC64_ADDR16_LO:
     writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
     break;
   case ELF::R_PPC64_ADDR16_LO_DS:
     writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3);
     break;
   case ELF::R_PPC64_ADDR16_HI:
+  case ELF::R_PPC64_ADDR16_HIGH:
     writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
     break;
   case ELF::R_PPC64_ADDR16_HA:
+  case ELF::R_PPC64_ADDR16_HIGHA:
     writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
     break;
   case ELF::R_PPC64_ADDR16_HIGHER:
     writeInt16BE(LocalAddress, applyPPChigher(Value + Addend));
     break;
   case ELF::R_PPC64_ADDR16_HIGHERA:
     writeInt16BE(LocalAddress, applyPPChighera(Value + Addend));
     break;

llvm/trunk/lib/MC/MCExpr.cpp

StringRef MCSymbolRefExpr::getVariantKindName(VariantKind Kind) {
   case VK_AVR_HI8: return "hi8";
   case VK_AVR_HLO8: return "hlo8";
   case VK_AVR_DIFF8: return "diff8";
   case VK_AVR_DIFF16: return "diff16";
   case VK_AVR_DIFF32: return "diff32";
   case VK_PPC_LO: return "l";
   case VK_PPC_HI: return "h";
   case VK_PPC_HA: return "ha";
+  case VK_PPC_HIGH: return "high";
+  case VK_PPC_HIGHA: return "higha";
   case VK_PPC_HIGHER: return "higher";
   case VK_PPC_HIGHERA: return "highera";
   case VK_PPC_HIGHEST: return "highest";
   case VK_PPC_HIGHESTA: return "highesta";
   case VK_PPC_GOT_LO: return "got@l";
   case VK_PPC_GOT_HI: return "got@h";
   case VK_PPC_GOT_HA: return "got@ha";
   case VK_PPC_TOCBASE: return "tocbase";
return StringSwitch<VariantKind>(Name.lower())
     .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("high", VK_PPC_HIGH)
+    .Case("higha", VK_PPC_HIGHA)
     .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)
     .Case("got@h", VK_PPC_GOT_HI)
     .Case("got@ha", VK_PPC_GOT_HA)
     .Case("local", VK_PPC_LOCAL)

llvm/trunk/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp

case MCSymbolRefExpr::VK_PPC_LO:
       Variant = PPCMCExpr::VK_PPC_LO;
       break;
     case MCSymbolRefExpr::VK_PPC_HI:
       Variant = PPCMCExpr::VK_PPC_HI;
       break;
     case MCSymbolRefExpr::VK_PPC_HA:
       Variant = PPCMCExpr::VK_PPC_HA;
       break;
+    case MCSymbolRefExpr::VK_PPC_HIGH:
+      Variant = PPCMCExpr::VK_PPC_HIGH;
+      break;
+    case MCSymbolRefExpr::VK_PPC_HIGHA:
+      Variant = PPCMCExpr::VK_PPC_HIGHA;
+      break;
     case MCSymbolRefExpr::VK_PPC_HIGHER:
       Variant = PPCMCExpr::VK_PPC_HIGHER;
       break;
     case MCSymbolRefExpr::VK_PPC_HIGHERA:
       Variant = PPCMCExpr::VK_PPC_HIGHERA;
       break;
     case MCSymbolRefExpr::VK_PPC_HIGHEST:
       Variant = PPCMCExpr::VK_PPC_HIGHEST;
PPCAsmParser::applyModifierToExpr(const MCExpr *E,
                                   MCContext &Ctx) {
   switch (Variant) {
   case MCSymbolRefExpr::VK_PPC_LO:
     return PPCMCExpr::create(PPCMCExpr::VK_PPC_LO, E, false, Ctx);
   case MCSymbolRefExpr::VK_PPC_HI:
     return PPCMCExpr::create(PPCMCExpr::VK_PPC_HI, E, false, Ctx);
   case MCSymbolRefExpr::VK_PPC_HA:
     return PPCMCExpr::create(PPCMCExpr::VK_PPC_HA, E, false, Ctx);
+  case MCSymbolRefExpr::VK_PPC_HIGH:
+    return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGH, E, false, Ctx);
+  case MCSymbolRefExpr::VK_PPC_HIGHA:
+    return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHA, E, false, Ctx);
   case MCSymbolRefExpr::VK_PPC_HIGHER:
     return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHER, E, false, Ctx);
   case MCSymbolRefExpr::VK_PPC_HIGHERA:
     return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHERA, E, false, Ctx);
   case MCSymbolRefExpr::VK_PPC_HIGHEST:
     return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHEST, E, false, Ctx);
   case MCSymbolRefExpr::VK_PPC_HIGHESTA:
     return PPCMCExpr::create(PPCMCExpr::VK_PPC_HIGHESTA, E, false, Ctx);
   default:
     return nullptr;
   }
 }

llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCELFObjectWriter.cpp

static MCSymbolRefExpr::VariantKind getAccessVariant(const MCValue &Target,
   case PPCMCExpr::VK_PPC_None:
     return MCSymbolRefExpr::VK_None;
   case PPCMCExpr::VK_PPC_LO:
     return MCSymbolRefExpr::VK_PPC_LO;
   case PPCMCExpr::VK_PPC_HI:
     return MCSymbolRefExpr::VK_PPC_HI;
   case PPCMCExpr::VK_PPC_HA:
     return MCSymbolRefExpr::VK_PPC_HA;
+  case PPCMCExpr::VK_PPC_HIGH:
+    return MCSymbolRefExpr::VK_PPC_HIGH;
+  case PPCMCExpr::VK_PPC_HIGHA:
+    return MCSymbolRefExpr::VK_PPC_HIGHA;
   case PPCMCExpr::VK_PPC_HIGHERA:
     return MCSymbolRefExpr::VK_PPC_HIGHERA;
   case PPCMCExpr::VK_PPC_HIGHER:
     return MCSymbolRefExpr::VK_PPC_HIGHER;
   case PPCMCExpr::VK_PPC_HIGHEST:
     return MCSymbolRefExpr::VK_PPC_HIGHEST;
   case PPCMCExpr::VK_PPC_HIGHESTA:
     return MCSymbolRefExpr::VK_PPC_HIGHESTA;
case PPC::fixup_ppc_half16:
         Type = ELF::R_PPC_ADDR16_LO;
         break;
       case MCSymbolRefExpr::VK_PPC_HI:
         Type = ELF::R_PPC_ADDR16_HI;
         break;
       case MCSymbolRefExpr::VK_PPC_HA:
         Type = ELF::R_PPC_ADDR16_HA;
         break;
+      case MCSymbolRefExpr::VK_PPC_HIGH:
+        Type = ELF::R_PPC64_ADDR16_HIGH;
+        break;
+      case MCSymbolRefExpr::VK_PPC_HIGHA:
+        Type = ELF::R_PPC64_ADDR16_HIGHA;
+        break;
       case MCSymbolRefExpr::VK_PPC_HIGHER:
         Type = ELF::R_PPC64_ADDR16_HIGHER;
         break;
       case MCSymbolRefExpr::VK_PPC_HIGHERA:
         Type = ELF::R_PPC64_ADDR16_HIGHERA;
         break;
       case MCSymbolRefExpr::VK_PPC_HIGHEST:
         Type = ELF::R_PPC64_ADDR16_HIGHEST;

llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMCExpr.h

 
 class PPCMCExpr : public MCTargetExpr {
 public:
   enum VariantKind {
     VK_PPC_None,
     VK_PPC_LO,
     VK_PPC_HI,
     VK_PPC_HA,
+    VK_PPC_HIGH,
+    VK_PPC_HIGHA,
     VK_PPC_HIGHER,
     VK_PPC_HIGHERA,
     VK_PPC_HIGHEST,
     VK_PPC_HIGHESTA
   };
 
 private:
   const VariantKind Kind;

llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMCExpr.cpp

void PPCMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
   } else {
     getSubExpr()->print(OS, MAI);
 
     switch (Kind) {
     default: llvm_unreachable("Invalid kind!");
     case VK_PPC_LO: OS << "@l"; break;
     case VK_PPC_HI: OS << "@h"; break;
     case VK_PPC_HA: OS << "@ha"; break;
+    case VK_PPC_HIGH: OS << "@high"; break;
+    case VK_PPC_HIGHA: OS << "@higha"; break;
     case VK_PPC_HIGHER: OS << "@higher"; break;
     case VK_PPC_HIGHERA: OS << "@highera"; break;
     case VK_PPC_HIGHEST: OS << "@highest"; break;
     case VK_PPC_HIGHESTA: OS << "@highesta"; break;
     }
   }
 }
 

 PPCMCExpr::evaluateAsInt64(int64_t Value) const {
   switch (Kind) {
     case VK_PPC_LO:
       return Value & 0xffff;
     case VK_PPC_HI:
       return (Value >> 16) & 0xffff;
     case VK_PPC_HA:
       return ((Value + 0x8000) >> 16) & 0xffff;
+    case VK_PPC_HIGH:
+      return (Value >> 16) & 0xffff;
+    case VK_PPC_HIGHA:
+      return ((Value + 0x8000) >> 16) & 0xffff;
     case VK_PPC_HIGHER:
       return (Value >> 32) & 0xffff;
     case VK_PPC_HIGHERA:
       return ((Value + 0x8000) >> 32) & 0xffff;
     case VK_PPC_HIGHEST:
       return (Value >> 48) & 0xffff;
     case VK_PPC_HIGHESTA:
       return ((Value + 0x8000) >> 48) & 0xffff;
switch (Kind) {
         Modifier = MCSymbolRefExpr::VK_PPC_LO;
         break;
       case VK_PPC_HI:
         Modifier = MCSymbolRefExpr::VK_PPC_HI;
         break;
       case VK_PPC_HA:
         Modifier = MCSymbolRefExpr::VK_PPC_HA;
         break;
+      case VK_PPC_HIGH:
+        Modifier = MCSymbolRefExpr::VK_PPC_HIGH;
+        break;
+      case VK_PPC_HIGHA:
+        Modifier = MCSymbolRefExpr::VK_PPC_HIGHA;
+        break;
       case VK_PPC_HIGHERA:
         Modifier = MCSymbolRefExpr::VK_PPC_HIGHERA;
         break;
       case VK_PPC_HIGHER:
         Modifier = MCSymbolRefExpr::VK_PPC_HIGHER;
         break;
       case VK_PPC_HIGHEST:
         Modifier = MCSymbolRefExpr::VK_PPC_HIGHEST;

llvm/trunk/test/MC/PowerPC/ppc64-fixup-apply.s

 1:
 addi 1, 1, 2f-1b@l
 addis 1, 1, 1b-2f@ha
 2:
 
 addi 1, 1, target6@h
 addis 1, 1, target6@h
 
+addi  1, 1, target6@high
+addis 1, 1, target6@higha
+
 .set target6, 0x4321fedc
 
 addi 1, 1, target7@higher
 addis 1, 1, target7@highest
 addi 1, 1, target7@highera
 addis 1, 1, target7@highesta
 
 .set target7, 0x1234ffffffff8000

 # CHECK:         Name: .text
 # CHECK-NEXT:    Type: SHT_PROGBITS
 # CHECK-NEXT:    Flags [
 # CHECK-NEXT:      SHF_ALLOC
 # CHECK-NEXT:      SHF_EXECINSTR
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Address: 0x0
 # CHECK-NEXT:    Offset:
-# CHECK-NEXT:    Size: 72
+# CHECK-NEXT:    Size: 80
 # CHECK-NEXT:    Link: 0
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 4
 # CHECK-NEXT:    EntrySize: 0
 # CHECK-NEXT:    SectionData (
 # CHECK-BE-NEXT:   0000: 38211234 3C211234 38215678 3C211234
 # CHECK-LE-NEXT:   0000: 34122138 3412213C 78562138 3412213C
 # CHECK-BE-NEXT:   0010: 38214444 3C211111 38218001 3C211001
 # CHECK-LE-NEXT:   0010: 44442138 1111213C 01802138 0110213C
 # CHECK-BE-NEXT:   0020: 60218001 64211001 38210008 3C210000
 # CHECK-LE-NEXT:   0020: 01802160 01102164 08002138 0000213C
-# CHECK-BE-NEXT:   0030: 38214321 3C214321 3821FFFF 3C211234
-# CHECK-LE-NEXT:   0030: 21432138 2143213C FFFF2138 3412213C
-# CHECK-BE-NEXT:   0040: 38210000 3C211235
-# CHECK-LE-NEXT:   0040: 00002138 3512213C
+# CHECK-BE-NEXT:   0030: 38214321 3C214321 38214321 3C214322
+# CHECK-LE-NEXT:   0030: 21432138 2143213C 21432138 2243213C
+# CHECK-BE-NEXT:   0040: 3821FFFF 3C211234 38210000 3C211235
+# CHECK-LE-NEXT:   0040: FFFF2138 3412213C 00002138 3512213C
 # CHECK-NEXT:    )
 # CHECK-NEXT:  }
 
 # CHECK:        Section {
 # CHECK:          Name: .data
 # CHECK-NEXT:     Type: SHT_PROGBITS
 # CHECK-NEXT:     Flags [
 # CHECK-NEXT:       SHF_ALLOC

llvm/trunk/test/MC/PowerPC/ppc64-fixups.s

 # CHECK-BE: addis 3, 3, target@ha           # encoding: [0x3c,0x63,A,A]
 # CHECK-LE: addis 3, 3, target@ha           # encoding: [A,A,0x63,0x3c]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 2, value: target@ha, kind: fixup_ppc_half16
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target@ha, kind: fixup_ppc_half16
 # CHECK-BE-REL:                             0x{{[0-9A-F]*[26AE]}} R_PPC64_ADDR16_HA target 0x0
 # CHECK-LE-REL:                             0x{{[0-9A-F]*[048C]}} R_PPC64_ADDR16_HA target 0x0
             addis 3, 3, target@ha
 
+# CHECK-BE: addis 3, 3, target@higha        # encoding: [0x3c,0x63,A,A]
+# CHECK-LE: addis 3, 3, target@higha        # encoding: [A,A,0x63,0x3c]
+# CHECK-BE-NEXT:                            #   fixup A - offset: 2, value: target@higha, kind: fixup_ppc_half16
+# CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target@higha, kind: fixup_ppc_half16
+# CHECK-BE-REL:                             0x{{[0-9A-F]*[26AE]}} R_PPC64_ADDR16_HIGHA target 0x0
+# CHECK-LE-REL:                             0x{{[0-9A-F]*[048C]}} R_PPC64_ADDR16_HIGHA target 0x0
+
+            addis 3, 3, target@higha
+
 # CHECK-BE: lis 3, target@ha                # encoding: [0x3c,0x60,A,A]
 # CHECK-LE: lis 3, target@ha                # encoding: [A,A,0x60,0x3c]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 2, value: target@ha, kind: fixup_ppc_half16
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target@ha, kind: fixup_ppc_half16
 # CHECK-BE-REL:                             0x{{[0-9A-F]*[26AE]}} R_PPC64_ADDR16_HA target 0x0
 # CHECK-LE-REL:                             0x{{[0-9A-F]*[048C]}} R_PPC64_ADDR16_HA target 0x0
             lis 3, target@ha
 

 # CHECK-BE: oris 3, 3, target@h             # encoding: [0x64,0x63,A,A]
 # CHECK-LE: oris 3, 3, target@h             # encoding: [A,A,0x63,0x64]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 2, value: target@h, kind: fixup_ppc_half16
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target@h, kind: fixup_ppc_half16
 # CHECK-BE-REL:                             0x{{[0-9A-F]*[26AE]}} R_PPC64_ADDR16_HI target 0x0
 # CHECK-LE-REL:                             0x{{[0-9A-F]*[048C]}} R_PPC64_ADDR16_HI target 0x0
             oris 3, 3, target@h
 
+# CHECK-BE:  oris 3, 3, target@high         # encoding: [0x64,0x63,A,A]
+# CHECK-LE:  oris 3, 3, target@high         # encoding: [A,A,0x63,0x64]
+# CHECK-BE-NEXT:                            #   fixup A - offset: 2, value: target@high, kind: fixup_ppc_half16
+# CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target@high, kind: fixup_ppc_half16
+# CHECK-BE-REL:                             0x{{[0-9A-F]*[26AE]}} R_PPC64_ADDR16_HIGH target 0x0
+# CHECK-LE-REL:                             0x{{[0-9A-F]*[048C]}} R_PPC64_ADDR16_HIGH target 0x0
+            oris 3, 3, target@high
+
 # CHECK-BE: ld 1, target@toc(2)             # encoding: [0xe8,0x22,A,0bAAAAAA00]
 # CHECK-LE: ld 1, target@toc(2)             # encoding: [0bAAAAAA00,A,0x22,0xe8]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 2, value: target@toc, kind: fixup_ppc_half16ds
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target@toc, kind: fixup_ppc_half16ds
 # CHECK-BE-REL:                             0x{{[0-9A-F]*[26AE]}} R_PPC64_TOC16_DS target 0x0
 # CHECK-LE-REL:                             0x{{[0-9A-F]*[048C]}} R_PPC64_TOC16_DS target 0x0
             ld 1, target@toc(2)