lib/Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp

   1 //===-- X86ELFObjectWriter.cpp - X86 ELF Writer ---------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "MCTargetDesc/X86FixupKinds.h"
  10 #include "MCTargetDesc/X86MCTargetDesc.h"
  11 #include "llvm/BinaryFormat/ELF.h"
  12 #include "llvm/MC/MCAsmInfo.h"
  13 #include "llvm/MC/MCContext.h"
  14 #include "llvm/MC/MCELFObjectWriter.h"
  15 #include "llvm/MC/MCExpr.h"
  16 #include "llvm/MC/MCFixup.h"
  17 #include "llvm/MC/MCObjectWriter.h"
  18 #include "llvm/MC/MCValue.h"
  19 #include "llvm/Support/ErrorHandling.h"
  20 #include <cassert>
  21 #include <cstdint>
  22
  23 using namespace llvm;
  24
  25 namespace {
  26
  27 class X86ELFObjectWriter : public MCELFObjectTargetWriter {
  28 public:
  29   X86ELFObjectWriter(bool IsELF64, uint8_t OSABI, uint16_t EMachine);
  30   ~X86ELFObjectWriter() override = default;
  31
  32 protected:
  33   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
  34                         const MCFixup &Fixup, bool IsPCRel) const override;
  35 };
  36
  37 } // end anonymous namespace
  38
  39 X86ELFObjectWriter::X86ELFObjectWriter(bool IsELF64, uint8_t OSABI,
  40                                        uint16_t EMachine)
  41     : MCELFObjectTargetWriter(IsELF64, OSABI, EMachine,
  42                               // Only i386 and IAMCU use Rel instead of RelA.
  43                               /*HasRelocationAddend*/
  44                               (EMachine != ELF::EM_386) &&
  45                                   (EMachine != ELF::EM_IAMCU)) {}
  46
  47 enum X86_64RelType { RT64_NONE, RT64_64, RT64_32, RT64_32S, RT64_16, RT64_8 };
  48
  49 static X86_64RelType getType64(MCFixupKind Kind,
  50                                MCSymbolRefExpr::VariantKind &Modifier,
  51                                bool &IsPCRel) {
  52   switch (unsigned(Kind)) {
  53   default:
  54     llvm_unreachable("Unimplemented");
  55   case FK_NONE:
  56     return RT64_NONE;
  57   case X86::reloc_global_offset_table8:
  58     Modifier = MCSymbolRefExpr::VK_GOT;
  59     IsPCRel = true;
  60     return RT64_64;
  61   case FK_Data_8:
  62     return RT64_64;
  63   case X86::reloc_signed_4byte:
  64   case X86::reloc_signed_4byte_relax:
  65     if (Modifier == MCSymbolRefExpr::VK_None && !IsPCRel)
  66       return RT64_32S;
  67     return RT64_32;
  68   case X86::reloc_global_offset_table:
  69     Modifier = MCSymbolRefExpr::VK_GOT;
  70     IsPCRel = true;
  71     return RT64_32;
  72   case FK_Data_4:
  73   case FK_PCRel_4:
  74   case X86::reloc_riprel_4byte:
  75   case X86::reloc_riprel_4byte_relax:
  76   case X86::reloc_riprel_4byte_relax_rex:
  77   case X86::reloc_riprel_4byte_movq_load:
  78     return RT64_32;
  79   case X86::reloc_branch_4byte_pcrel:
  80     Modifier = MCSymbolRefExpr::VK_PLT;
  81     return RT64_32;
  82   case FK_PCRel_2:
  83   case FK_Data_2:
  84     return RT64_16;
  85   case FK_PCRel_1:
  86   case FK_Data_1:
  87     return RT64_8;
  88   }
  89 }
  90
  91 static void checkIs32(MCContext &Ctx, SMLoc Loc, X86_64RelType Type) {
  92   if (Type != RT64_32)
  93     Ctx.reportError(Loc,
  94                     "32 bit reloc applied to a field with a different size");
  95 }
  96
  97 static unsigned getRelocType64(MCContext &Ctx, SMLoc Loc,
  98                                MCSymbolRefExpr::VariantKind Modifier,
  99                                X86_64RelType Type, bool IsPCRel,
 100                                MCFixupKind Kind) {
 101   switch (Modifier) {
 102   default:
 103     llvm_unreachable("Unimplemented");
 104   case MCSymbolRefExpr::VK_None:
 105   case MCSymbolRefExpr::VK_X86_ABS8:
 106     switch (Type) {
 107     case RT64_NONE:
 108       if (Modifier == MCSymbolRefExpr::VK_None)
 109         return ELF::R_X86_64_NONE;
 110       llvm_unreachable("Unimplemented");
 111     case RT64_64:
 112       return IsPCRel ? ELF::R_X86_64_PC64 : ELF::R_X86_64_64;
 113     case RT64_32:
 114       return IsPCRel ? ELF::R_X86_64_PC32 : ELF::R_X86_64_32;
 115     case RT64_32S:
 116       return ELF::R_X86_64_32S;
 117     case RT64_16:
 118       return IsPCRel ? ELF::R_X86_64_PC16 : ELF::R_X86_64_16;
 119     case RT64_8:
 120       return IsPCRel ? ELF::R_X86_64_PC8 : ELF::R_X86_64_8;
 121     }
 122     llvm_unreachable("unexpected relocation type!");
 123   case MCSymbolRefExpr::VK_GOT:
 124     switch (Type) {
 125     case RT64_64:
 126       return IsPCRel ? ELF::R_X86_64_GOTPC64 : ELF::R_X86_64_GOT64;
 127     case RT64_32:
 128       return IsPCRel ? ELF::R_X86_64_GOTPC32 : ELF::R_X86_64_GOT32;
 129     case RT64_32S:
 130     case RT64_16:
 131     case RT64_8:
 132     case RT64_NONE:
 133       llvm_unreachable("Unimplemented");
 134     }
 135     llvm_unreachable("unexpected relocation type!");
 136   case MCSymbolRefExpr::VK_GOTOFF:
 137     assert(Type == RT64_64);
 138     assert(!IsPCRel);
 139     return ELF::R_X86_64_GOTOFF64;
 140   case MCSymbolRefExpr::VK_TPOFF:
 141     assert(!IsPCRel);
 142     switch (Type) {
 143     case RT64_64:
 144       return ELF::R_X86_64_TPOFF64;
 145     case RT64_32:
 146       return ELF::R_X86_64_TPOFF32;
 147     case RT64_32S:
 148     case RT64_16:
 149     case RT64_8:
 150     case RT64_NONE:
 151       llvm_unreachable("Unimplemented");
 152     }
 153     llvm_unreachable("unexpected relocation type!");
 154   case MCSymbolRefExpr::VK_DTPOFF:
 155     assert(!IsPCRel);
 156     switch (Type) {
 157     case RT64_64:
 158       return ELF::R_X86_64_DTPOFF64;
 159     case RT64_32:
 160       return ELF::R_X86_64_DTPOFF32;
 161     case RT64_32S:
 162     case RT64_16:
 163     case RT64_8:
 164     case RT64_NONE:
 165       llvm_unreachable("Unimplemented");
 166     }
 167     llvm_unreachable("unexpected relocation type!");
 168   case MCSymbolRefExpr::VK_SIZE:
 169     assert(!IsPCRel);
 170     switch (Type) {
 171     case RT64_64:
 172       return ELF::R_X86_64_SIZE64;
 173     case RT64_32:
 174       return ELF::R_X86_64_SIZE32;
 175     case RT64_32S:
 176     case RT64_16:
 177     case RT64_8:
 178     case RT64_NONE:
 179       llvm_unreachable("Unimplemented");
 180     }
 181     llvm_unreachable("unexpected relocation type!");
 182   case MCSymbolRefExpr::VK_TLSCALL:
 183     return ELF::R_X86_64_TLSDESC_CALL;
 184   case MCSymbolRefExpr::VK_TLSDESC:
 185     return ELF::R_X86_64_GOTPC32_TLSDESC;
 186   case MCSymbolRefExpr::VK_TLSGD:
 187     checkIs32(Ctx, Loc, Type);
 188     return ELF::R_X86_64_TLSGD;
 189   case MCSymbolRefExpr::VK_GOTTPOFF:
 190     checkIs32(Ctx, Loc, Type);
 191     return ELF::R_X86_64_GOTTPOFF;
 192   case MCSymbolRefExpr::VK_TLSLD:
 193     checkIs32(Ctx, Loc, Type);
 194     return ELF::R_X86_64_TLSLD;
 195   case MCSymbolRefExpr::VK_PLT:
 196     checkIs32(Ctx, Loc, Type);
 197     return ELF::R_X86_64_PLT32;
 198   case MCSymbolRefExpr::VK_GOTPCREL:
 199     checkIs32(Ctx, Loc, Type);
 200     // Older versions of ld.bfd/ld.gold/lld
 201     // do not support GOTPCRELX/REX_GOTPCRELX,
 202     // and we want to keep back-compatibility.
 203     if (!Ctx.getAsmInfo()->canRelaxRelocations())
 204       return ELF::R_X86_64_GOTPCREL;
 205     switch (unsigned(Kind)) {
 206     default:
 207       return ELF::R_X86_64_GOTPCREL;
 208     case X86::reloc_riprel_4byte_relax:
 209       return ELF::R_X86_64_GOTPCRELX;
 210     case X86::reloc_riprel_4byte_relax_rex:
 211     case X86::reloc_riprel_4byte_movq_load:
 212       return ELF::R_X86_64_REX_GOTPCRELX;
 213     }
 214     llvm_unreachable("unexpected relocation type!");
 215   }
 216 }
 217
 218 enum X86_32RelType { RT32_NONE, RT32_32, RT32_16, RT32_8 };
 219
 220 static X86_32RelType getType32(X86_64RelType T) {
 221   switch (T) {
 222   case RT64_NONE:
 223     return RT32_NONE;
 224   case RT64_64:
 225     llvm_unreachable("Unimplemented");
 226   case RT64_32:
 227   case RT64_32S:
 228     return RT32_32;
 229   case RT64_16:
 230     return RT32_16;
 231   case RT64_8:
 232     return RT32_8;
 233   }
 234   llvm_unreachable("unexpected relocation type!");
 235 }
 236
 237 static unsigned getRelocType32(MCContext &Ctx,
 238                                MCSymbolRefExpr::VariantKind Modifier,
 239                                X86_32RelType Type, bool IsPCRel,
 240                                MCFixupKind Kind) {
 241   switch (Modifier) {
 242   default:
 243     llvm_unreachable("Unimplemented");
 244   case MCSymbolRefExpr::VK_None:
 245   case MCSymbolRefExpr::VK_X86_ABS8:
 246     switch (Type) {
 247     case RT32_NONE:
 248       if (Modifier == MCSymbolRefExpr::VK_None)
 249         return ELF::R_386_NONE;
 250       llvm_unreachable("Unimplemented");
 251     case RT32_32:
 252       return IsPCRel ? ELF::R_386_PC32 : ELF::R_386_32;
 253     case RT32_16:
 254       return IsPCRel ? ELF::R_386_PC16 : ELF::R_386_16;
 255     case RT32_8:
 256       return IsPCRel ? ELF::R_386_PC8 : ELF::R_386_8;
 257     }
 258     llvm_unreachable("unexpected relocation type!");
 259   case MCSymbolRefExpr::VK_GOT:
 260     assert(Type == RT32_32);
 261     if (IsPCRel)
 262       return ELF::R_386_GOTPC;
 263     // Older versions of ld.bfd/ld.gold/lld do not support R_386_GOT32X and we
 264     // want to maintain compatibility.
 265     if (!Ctx.getAsmInfo()->canRelaxRelocations())
 266       return ELF::R_386_GOT32;
 267
 268     return Kind == MCFixupKind(X86::reloc_signed_4byte_relax)
 269                ? ELF::R_386_GOT32X
 270                : ELF::R_386_GOT32;
 271   case MCSymbolRefExpr::VK_GOTOFF:
 272     assert(Type == RT32_32);
 273     assert(!IsPCRel);
 274     return ELF::R_386_GOTOFF;
 275   case MCSymbolRefExpr::VK_TLSCALL:
 276     return ELF::R_386_TLS_DESC_CALL;
 277   case MCSymbolRefExpr::VK_TLSDESC:
 278     return ELF::R_386_TLS_GOTDESC;
 279   case MCSymbolRefExpr::VK_TPOFF:
 280     assert(Type == RT32_32);
 281     assert(!IsPCRel);
 282     return ELF::R_386_TLS_LE_32;
 283   case MCSymbolRefExpr::VK_DTPOFF:
 284     assert(Type == RT32_32);
 285     assert(!IsPCRel);
 286     return ELF::R_386_TLS_LDO_32;
 287   case MCSymbolRefExpr::VK_TLSGD:
 288     assert(Type == RT32_32);
 289     assert(!IsPCRel);
 290     return ELF::R_386_TLS_GD;
 291   case MCSymbolRefExpr::VK_GOTTPOFF:
 292     assert(Type == RT32_32);
 293     assert(!IsPCRel);
 294     return ELF::R_386_TLS_IE_32;
 295   case MCSymbolRefExpr::VK_PLT:
 296     assert(Type == RT32_32);
 297     return ELF::R_386_PLT32;
 298   case MCSymbolRefExpr::VK_INDNTPOFF:
 299     assert(Type == RT32_32);
 300     assert(!IsPCRel);
 301     return ELF::R_386_TLS_IE;
 302   case MCSymbolRefExpr::VK_NTPOFF:
 303     assert(Type == RT32_32);
 304     assert(!IsPCRel);
 305     return ELF::R_386_TLS_LE;
 306   case MCSymbolRefExpr::VK_GOTNTPOFF:
 307     assert(Type == RT32_32);
 308     assert(!IsPCRel);
 309     return ELF::R_386_TLS_GOTIE;
 310   case MCSymbolRefExpr::VK_TLSLDM:
 311     assert(Type == RT32_32);
 312     assert(!IsPCRel);
 313     return ELF::R_386_TLS_LDM;
 314   }
 315 }
 316
 317 unsigned X86ELFObjectWriter::getRelocType(MCContext &Ctx, const MCValue &Target,
 318                                           const MCFixup &Fixup,
 319                                           bool IsPCRel) const {
 320   MCSymbolRefExpr::VariantKind Modifier = Target.getAccessVariant();
 321   MCFixupKind Kind = Fixup.getKind();
 322   X86_64RelType Type = getType64(Kind, Modifier, IsPCRel);
 323   if (getEMachine() == ELF::EM_X86_64)
 324     return getRelocType64(Ctx, Fixup.getLoc(), Modifier, Type, IsPCRel, Kind);
 325
 326   assert((getEMachine() == ELF::EM_386 || getEMachine() == ELF::EM_IAMCU) &&
 327          "Unsupported ELF machine type.");
 328   return getRelocType32(Ctx, Modifier, getType32(Type), IsPCRel, Kind);
 329 }
 330
 331 std::unique_ptr<MCObjectTargetWriter>
 332 llvm::createX86ELFObjectWriter(bool IsELF64, uint8_t OSABI, uint16_t EMachine) {
 333   return std::make_unique<X86ELFObjectWriter>(IsELF64, OSABI, EMachine);
 334 }