lib/Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp

   1 //===-- X86ELFObjectWriter.cpp - X86 ELF Writer ---------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "MCTargetDesc/X86FixupKinds.h"
  11 #include "MCTargetDesc/X86MCTargetDesc.h"
  12 #include "llvm/MC/MCELFObjectWriter.h"
  13 #include "llvm/MC/MCExpr.h"
  14 #include "llvm/MC/MCValue.h"
  15 #include "llvm/Support/ELF.h"
  16 #include "llvm/Support/ErrorHandling.h"
  17
  18 using namespace llvm;
  19
  20 namespace {
  21   class X86ELFObjectWriter : public MCELFObjectTargetWriter {
  22   public:
  23     X86ELFObjectWriter(bool IsELF64, uint8_t OSABI, uint16_t EMachine);
  24
  25     virtual ~X86ELFObjectWriter();
  26   protected:
  27     unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
  28                           bool IsPCRel) const override;
  29   };
  30 }
  31
  32 X86ELFObjectWriter::X86ELFObjectWriter(bool IsELF64, uint8_t OSABI,
  33                                        uint16_t EMachine)
  34   : MCELFObjectTargetWriter(IsELF64, OSABI, EMachine,
  35                             // Only i386 uses Rel instead of RelA.
  36                             /*HasRelocationAddend*/ EMachine != ELF::EM_386) {}
  37
  38 X86ELFObjectWriter::~X86ELFObjectWriter()
  39 {}
  40
  41 enum X86_64RelType { RT64_64, RT64_32, RT64_32S, RT64_16, RT64_8 };
  42
  43 static X86_64RelType getType64(unsigned Kind,
  44                                MCSymbolRefExpr::VariantKind &Modifier,
  45                                bool &IsPCRel) {
  46   switch (Kind) {
  47   default:
  48     llvm_unreachable("Unimplemented");
  49   case X86::reloc_global_offset_table8:
  50     Modifier = MCSymbolRefExpr::VK_GOT;
  51     IsPCRel = true;
  52     return RT64_64;
  53   case FK_Data_8:
  54     return RT64_64;
  55   case X86::reloc_signed_4byte:
  56     if (Modifier == MCSymbolRefExpr::VK_None && !IsPCRel)
  57       return RT64_32S;
  58     return RT64_32;
  59   case X86::reloc_global_offset_table:
  60     Modifier = MCSymbolRefExpr::VK_GOT;
  61     IsPCRel = true;
  62     return RT64_32;
  63   case FK_Data_4:
  64   case FK_PCRel_4:
  65   case X86::reloc_riprel_4byte:
  66   case X86::reloc_riprel_4byte_movq_load:
  67     return RT64_32;
  68   case FK_Data_2:
  69     return RT64_16;
  70   case FK_PCRel_1:
  71   case FK_Data_1:
  72     return RT64_8;
  73   }
  74 }
  75
  76 unsigned getRelocType64(MCSymbolRefExpr::VariantKind Modifier,
  77                         X86_64RelType Type, bool IsPCRel) {
  78   switch (Modifier) {
  79   default:
  80     llvm_unreachable("Unimplemented");
  81   case MCSymbolRefExpr::VK_None:
  82     switch (Type) {
  83     case RT64_64:
  84       return IsPCRel ? ELF::R_X86_64_PC64 : ELF::R_X86_64_64;
  85     case RT64_32:
  86       return IsPCRel ? ELF::R_X86_64_PC32 : ELF::R_X86_64_32;
  87     case RT64_32S:
  88       return ELF::R_X86_64_32S;
  89     case RT64_16:
  90       return IsPCRel ? ELF::R_X86_64_PC16 : ELF::R_X86_64_16;
  91     case RT64_8:
  92       return IsPCRel ? ELF::R_X86_64_PC8 : ELF::R_X86_64_8;
  93     }
  94   case MCSymbolRefExpr::VK_GOT:
  95     switch (Type) {
  96     case RT64_64:
  97       return IsPCRel ? ELF::R_X86_64_GOTPC64 : ELF::R_X86_64_GOT64;
  98     case RT64_32:
  99       return IsPCRel ? ELF::R_X86_64_GOTPC32 : ELF::R_X86_64_GOT32;
 100     case RT64_32S:
 101     case RT64_16:
 102     case RT64_8:
 103       llvm_unreachable("Unimplemented");
 104     }
 105   case MCSymbolRefExpr::VK_GOTOFF:
 106     assert(Type == RT64_64);
 107     assert(!IsPCRel);
 108     return ELF::R_X86_64_GOTOFF64;
 109   case MCSymbolRefExpr::VK_TPOFF:
 110     assert(!IsPCRel);
 111     switch (Type) {
 112     case RT64_64:
 113       return ELF::R_X86_64_TPOFF64;
 114     case RT64_32:
 115       return ELF::R_X86_64_TPOFF32;
 116     case RT64_32S:
 117     case RT64_16:
 118     case RT64_8:
 119       llvm_unreachable("Unimplemented");
 120     }
 121   case MCSymbolRefExpr::VK_DTPOFF:
 122     assert(!IsPCRel);
 123     switch (Type) {
 124     case RT64_64:
 125       return ELF::R_X86_64_DTPOFF64;
 126     case RT64_32:
 127       return ELF::R_X86_64_DTPOFF32;
 128     case RT64_32S:
 129     case RT64_16:
 130     case RT64_8:
 131       llvm_unreachable("Unimplemented");
 132     }
 133   case MCSymbolRefExpr::VK_SIZE:
 134     assert(!IsPCRel);
 135     switch (Type) {
 136     case RT64_64:
 137       return ELF::R_X86_64_SIZE64;
 138     case RT64_32:
 139       return ELF::R_X86_64_SIZE32;
 140     case RT64_32S:
 141     case RT64_16:
 142     case RT64_8:
 143       llvm_unreachable("Unimplemented");
 144     }
 145   case MCSymbolRefExpr::VK_TLSGD:
 146     assert(Type == RT64_32);
 147     return ELF::R_X86_64_TLSGD;
 148   case MCSymbolRefExpr::VK_GOTTPOFF:
 149     assert(Type == RT64_32);
 150     return ELF::R_X86_64_GOTTPOFF;
 151   case MCSymbolRefExpr::VK_TLSLD:
 152     assert(Type == RT64_32);
 153     return ELF::R_X86_64_TLSLD;
 154   case MCSymbolRefExpr::VK_PLT:
 155     assert(Type == RT64_32);
 156     return ELF::R_X86_64_PLT32;
 157   case MCSymbolRefExpr::VK_GOTPCREL:
 158     assert(Type == RT64_32);
 159     return ELF::R_X86_64_GOTPCREL;
 160   }
 161 }
 162
 163 enum X86_32RelType { RT32_32, RT32_16, RT32_8 };
 164
 165 static X86_32RelType getType32(X86_64RelType T) {
 166   switch (T) {
 167   case RT64_64:
 168     llvm_unreachable("Unimplemented");
 169   case RT64_32:
 170   case RT64_32S:
 171     return RT32_32;
 172   case RT64_16:
 173     return RT32_16;
 174   case RT64_8:
 175     return RT32_8;
 176   }
 177 }
 178
 179 unsigned getRelocType32(MCSymbolRefExpr::VariantKind Modifier,
 180                         X86_32RelType Type, bool IsPCRel) {
 181   switch (Modifier) {
 182   default:
 183     llvm_unreachable("Unimplemented");
 184   case MCSymbolRefExpr::VK_None:
 185     switch (Type) {
 186     case RT32_32:
 187       return IsPCRel ? ELF::R_386_PC32 : ELF::R_386_32;
 188     case RT32_16:
 189       return IsPCRel ? ELF::R_386_PC16 : ELF::R_386_16;
 190     case RT32_8:
 191       return IsPCRel ? ELF::R_386_PC8 : ELF::R_386_8;
 192     }
 193   case MCSymbolRefExpr::VK_GOT:
 194     assert(Type == RT32_32);
 195     return IsPCRel ? ELF::R_386_GOTPC : ELF::R_386_GOT32;
 196   case MCSymbolRefExpr::VK_GOTOFF:
 197     assert(Type == RT32_32);
 198     assert(!IsPCRel);
 199     return ELF::R_386_GOTOFF;
 200   case MCSymbolRefExpr::VK_TPOFF:
 201     assert(Type == RT32_32);
 202     assert(!IsPCRel);
 203     return ELF::R_386_TLS_LE_32;
 204   case MCSymbolRefExpr::VK_DTPOFF:
 205     assert(Type == RT32_32);
 206     assert(!IsPCRel);
 207     return ELF::R_386_TLS_LDO_32;
 208   case MCSymbolRefExpr::VK_TLSGD:
 209     assert(Type == RT32_32);
 210     assert(!IsPCRel);
 211     return ELF::R_386_TLS_GD;
 212   case MCSymbolRefExpr::VK_GOTTPOFF:
 213     assert(Type == RT32_32);
 214     assert(!IsPCRel);
 215     return ELF::R_386_TLS_IE_32;
 216   case MCSymbolRefExpr::VK_PLT:
 217     assert(Type == RT32_32);
 218     return ELF::R_386_PLT32;
 219   case MCSymbolRefExpr::VK_INDNTPOFF:
 220     assert(Type == RT32_32);
 221     assert(!IsPCRel);
 222     return ELF::R_386_TLS_IE;
 223   case MCSymbolRefExpr::VK_NTPOFF:
 224     assert(Type == RT32_32);
 225     assert(!IsPCRel);
 226     return ELF::R_386_TLS_LE;
 227   case MCSymbolRefExpr::VK_GOTNTPOFF:
 228     assert(Type == RT32_32);
 229     assert(!IsPCRel);
 230     return ELF::R_386_TLS_GOTIE;
 231   case MCSymbolRefExpr::VK_TLSLDM:
 232     assert(Type == RT32_32);
 233     assert(!IsPCRel);
 234     return ELF::R_386_TLS_LDM;
 235   }
 236 }
 237
 238 unsigned X86ELFObjectWriter::GetRelocType(const MCValue &Target,
 239                                           const MCFixup &Fixup,
 240                                           bool IsPCRel) const {
 241   MCSymbolRefExpr::VariantKind Modifier = Target.getAccessVariant();
 242   X86_64RelType Type = getType64(Fixup.getKind(), Modifier, IsPCRel);
 243   if (getEMachine() == ELF::EM_X86_64)
 244     return getRelocType64(Modifier, Type, IsPCRel);
 245
 246   assert(getEMachine() == ELF::EM_386 && "Unsupported ELF machine type.");
 247   return getRelocType32(Modifier, getType32(Type), IsPCRel);
 248 }
 249
 250 MCObjectWriter *llvm::createX86ELFObjectWriter(raw_ostream &OS,
 251                                                bool IsELF64,
 252                                                uint8_t OSABI,
 253                                                uint16_t EMachine) {
 254   MCELFObjectTargetWriter *MOTW =
 255     new X86ELFObjectWriter(IsELF64, OSABI, EMachine);
 256   return createELFObjectWriter(MOTW, OS,  /*IsLittleEndian=*/true);
 257 }