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 static 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   default:
 168   //case RT64_64:
 169     llvm_unreachable("Unimplemented");
 170   case RT64_32:
 171   case RT64_32S:
 172     return RT32_32;
 173   case RT64_16:
 174     return RT32_16;
 175   case RT64_8:
 176     return RT32_8;
 177   }
 178 }
 179
 180 static unsigned getRelocType32(MCSymbolRefExpr::VariantKind Modifier,
 181                                X86_32RelType Type, bool IsPCRel) {
 182   switch (Modifier) {
 183   default:
 184     llvm_unreachable("Unimplemented");
 185   case MCSymbolRefExpr::VK_None:
 186     switch (Type) {
 187     case RT32_32:
 188       return IsPCRel ? ELF::R_386_PC32 : ELF::R_386_32;
 189     case RT32_16:
 190       return IsPCRel ? ELF::R_386_PC16 : ELF::R_386_16;
 191     case RT32_8:
 192       return IsPCRel ? ELF::R_386_PC8 : ELF::R_386_8;
 193     }
 194   case MCSymbolRefExpr::VK_GOT:
 195     assert(Type == RT32_32);
 196     return IsPCRel ? ELF::R_386_GOTPC : ELF::R_386_GOT32;
 197   case MCSymbolRefExpr::VK_GOTOFF:
 198     assert(Type == RT32_32);
 199     assert(!IsPCRel);
 200     return ELF::R_386_GOTOFF;
 201   case MCSymbolRefExpr::VK_TPOFF:
 202     assert(Type == RT32_32);
 203     assert(!IsPCRel);
 204     return ELF::R_386_TLS_LE_32;
 205   case MCSymbolRefExpr::VK_DTPOFF:
 206     assert(Type == RT32_32);
 207     assert(!IsPCRel);
 208     return ELF::R_386_TLS_LDO_32;
 209   case MCSymbolRefExpr::VK_TLSGD:
 210     assert(Type == RT32_32);
 211     assert(!IsPCRel);
 212     return ELF::R_386_TLS_GD;
 213   case MCSymbolRefExpr::VK_GOTTPOFF:
 214     assert(Type == RT32_32);
 215     assert(!IsPCRel);
 216     return ELF::R_386_TLS_IE_32;
 217   case MCSymbolRefExpr::VK_PLT:
 218     assert(Type == RT32_32);
 219     return ELF::R_386_PLT32;
 220   case MCSymbolRefExpr::VK_INDNTPOFF:
 221     assert(Type == RT32_32);
 222     assert(!IsPCRel);
 223     return ELF::R_386_TLS_IE;
 224   case MCSymbolRefExpr::VK_NTPOFF:
 225     assert(Type == RT32_32);
 226     assert(!IsPCRel);
 227     return ELF::R_386_TLS_LE;
 228   case MCSymbolRefExpr::VK_GOTNTPOFF:
 229     assert(Type == RT32_32);
 230     assert(!IsPCRel);
 231     return ELF::R_386_TLS_GOTIE;
 232   case MCSymbolRefExpr::VK_TLSLDM:
 233     assert(Type == RT32_32);
 234     assert(!IsPCRel);
 235     return ELF::R_386_TLS_LDM;
 236   }
 237 }
 238
 239 unsigned X86ELFObjectWriter::GetRelocType(const MCValue &Target,
 240                                           const MCFixup &Fixup,
 241                                           bool IsPCRel) const {
 242   MCSymbolRefExpr::VariantKind Modifier = Target.getAccessVariant();
 243   X86_64RelType Type = getType64(Fixup.getKind(), Modifier, IsPCRel);
 244   if (getEMachine() == ELF::EM_X86_64)
 245     return getRelocType64(Modifier, Type, IsPCRel);
 246
 247   assert(getEMachine() == ELF::EM_386 && "Unsupported ELF machine type.");
 248   return getRelocType32(Modifier, getType32(Type), IsPCRel);
 249 }
 250
 251 MCObjectWriter *llvm::createX86ELFObjectWriter(raw_ostream &OS,
 252                                                bool IsELF64,
 253                                                uint8_t OSABI,
 254                                                uint16_t EMachine) {
 255   MCELFObjectTargetWriter *MOTW =
 256     new X86ELFObjectWriter(IsELF64, OSABI, EMachine);
 257   return createELFObjectWriter(MOTW, OS,  /*IsLittleEndian=*/true);
 258 }