1 //===-- X86TargetObjectFile.cpp - X86 Object Info -------------------------===//
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 "X86TargetObjectFile.h"
11 #include "llvm/ADT/StringExtras.h"
12 #include "llvm/IR/Mangler.h"
13 #include "llvm/IR/Operator.h"
14 #include "llvm/MC/MCContext.h"
15 #include "llvm/MC/MCExpr.h"
16 #include "llvm/MC/MCSectionCOFF.h"
17 #include "llvm/MC/MCSectionELF.h"
18 #include "llvm/Support/Dwarf.h"
19 #include "llvm/Target/TargetLowering.h"
20 
21 using namespace llvm;
22 using namespace dwarf;
23 
24 X86_64MachoTargetObjectFile::X86_64MachoTargetObjectFile()
25   : TargetLoweringObjectFileMachO() {
26   SupportIndirectSymViaGOTPCRel = true;
27 }
28 
29 const MCExpr *X86_64MachoTargetObjectFile::getTTypeGlobalReference(
30     const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
31     const TargetMachine &TM, MachineModuleInfo *MMI,
32     MCStreamer &Streamer) const {
33 
34   // On Darwin/X86-64, we can reference dwarf symbols with foo@GOTPCREL+4, which
35   // is an indirect pc-relative reference.
36   if ((Encoding & DW_EH_PE_indirect) && (Encoding & DW_EH_PE_pcrel)) {
37     const MCSymbol *Sym = TM.getSymbol(GV, Mang);
38     const MCExpr *Res =
39       MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_GOTPCREL, getContext());
40     const MCExpr *Four = MCConstantExpr::Create(4, getContext());
41     return MCBinaryExpr::CreateAdd(Res, Four, getContext());
42   }
43 
44   return TargetLoweringObjectFileMachO::getTTypeGlobalReference(
45       GV, Encoding, Mang, TM, MMI, Streamer);
46 }
47 
48 MCSymbol *X86_64MachoTargetObjectFile::getCFIPersonalitySymbol(
49     const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
50     MachineModuleInfo *MMI) const {
51   return TM.getSymbol(GV, Mang);
52 }
53 
54 const MCExpr *X86_64MachoTargetObjectFile::getIndirectSymViaGOTPCRel(
55     const MCSymbol *Sym, int64_t Offset) const {
56   // On Darwin/X86-64, we need to use foo@GOTPCREL+4 to access the got entry
57   // from a data section. In case there's an additional offset, then use
58   // foo@GOTPCREL+4+<offset>.
59   const MCExpr *Res =
60     MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_GOTPCREL, getContext());
61   const MCExpr *Off = MCConstantExpr::Create(Offset+4, getContext());
62   return MCBinaryExpr::CreateAdd(Res, Off, getContext());
63 }
64 
65 void
66 X86LinuxTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM) {
67   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
68   InitializeELF(TM.Options.UseInitArray);
69 }
70 
71 const MCExpr *
72 X86LinuxTargetObjectFile::getDebugThreadLocalSymbol(
73     const MCSymbol *Sym) const {
74   return MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_DTPOFF, getContext());
75 }
76 
77 const MCExpr *X86WindowsTargetObjectFile::getExecutableRelativeSymbol(
78     const ConstantExpr *CE, Mangler &Mang, const TargetMachine &TM) const {
79   // We are looking for the difference of two symbols, need a subtraction
80   // operation.
81   const SubOperator *Sub = dyn_cast<SubOperator>(CE);
82   if (!Sub)
83     return nullptr;
84 
85   // Symbols must first be numbers before we can subtract them, we need to see a
86   // ptrtoint on both subtraction operands.
87   const PtrToIntOperator *SubLHS =
88       dyn_cast<PtrToIntOperator>(Sub->getOperand(0));
89   const PtrToIntOperator *SubRHS =
90       dyn_cast<PtrToIntOperator>(Sub->getOperand(1));
91   if (!SubLHS || !SubRHS)
92     return nullptr;
93 
94   // Our symbols should exist in address space zero, cowardly no-op if
95   // otherwise.
96   if (SubLHS->getPointerAddressSpace() != 0 ||
97       SubRHS->getPointerAddressSpace() != 0)
98     return nullptr;
99 
100   // Both ptrtoint instructions must wrap global variables:
101   // - Only global variables are eligible for image relative relocations.
102   // - The subtrahend refers to the special symbol __ImageBase, a global.
103   const GlobalVariable *GVLHS =
104       dyn_cast<GlobalVariable>(SubLHS->getPointerOperand());
105   const GlobalVariable *GVRHS =
106       dyn_cast<GlobalVariable>(SubRHS->getPointerOperand());
107   if (!GVLHS || !GVRHS)
108     return nullptr;
109 
110   // We expect __ImageBase to be a global variable without a section, externally
111   // defined.
112   //
113   // It should look something like this: @__ImageBase = external constant i8
114   if (GVRHS->isThreadLocal() || GVRHS->getName() != "__ImageBase" ||
115       !GVRHS->hasExternalLinkage() || GVRHS->hasInitializer() ||
116       GVRHS->hasSection())
117     return nullptr;
118 
119   // An image-relative, thread-local, symbol makes no sense.
120   if (GVLHS->isThreadLocal())
121     return nullptr;
122 
123   return MCSymbolRefExpr::Create(TM.getSymbol(GVLHS, Mang),
124                                  MCSymbolRefExpr::VK_COFF_IMGREL32,
125                                  getContext());
126 }
127 
128 static std::string APIntToHexString(const APInt &AI) {
129   unsigned Width = (AI.getBitWidth() / 8) * 2;
130   std::string HexString = utohexstr(AI.getLimitedValue(), /*LowerCase=*/true);
131   unsigned Size = HexString.size();
132   assert(Width >= Size && "hex string is too large!");
133   HexString.insert(HexString.begin(), Width - Size, '0');
134 
135   return HexString;
136 }
137 
138 
139 static std::string scalarConstantToHexString(const Constant *C) {
140   Type *Ty = C->getType();
141   APInt AI;
142   if (isa<UndefValue>(C)) {
143     AI = APInt(Ty->getPrimitiveSizeInBits(), /*val=*/0);
144   } else if (Ty->isFloatTy() || Ty->isDoubleTy()) {
145     const auto *CFP = cast<ConstantFP>(C);
146     AI = CFP->getValueAPF().bitcastToAPInt();
147   } else if (Ty->isIntegerTy()) {
148     const auto *CI = cast<ConstantInt>(C);
149     AI = CI->getValue();
150   } else {
151     llvm_unreachable("unexpected constant pool element type!");
152   }
153   return APIntToHexString(AI);
154 }
155 
156 const MCSection *
157 X86WindowsTargetObjectFile::getSectionForConstant(SectionKind Kind,
158                                                   const Constant *C) const {
159   if (Kind.isReadOnly()) {
160     if (C) {
161       Type *Ty = C->getType();
162       SmallString<32> COMDATSymName;
163       if (Ty->isFloatTy() || Ty->isDoubleTy()) {
164         COMDATSymName = "__real@";
165         COMDATSymName += scalarConstantToHexString(C);
166       } else if (const auto *VTy = dyn_cast<VectorType>(Ty)) {
167         uint64_t NumBits = VTy->getBitWidth();
168         if (NumBits == 128 || NumBits == 256) {
169           COMDATSymName = NumBits == 128 ? "__xmm@" : "__ymm@";
170           for (int I = VTy->getNumElements() - 1, E = -1; I != E; --I)
171             COMDATSymName +=
172                 scalarConstantToHexString(C->getAggregateElement(I));
173         }
174       }
175       if (!COMDATSymName.empty()) {
176         unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
177                                    COFF::IMAGE_SCN_MEM_READ |
178                                    COFF::IMAGE_SCN_LNK_COMDAT;
179         return getContext().getCOFFSection(".rdata", Characteristics, Kind,
180                                            COMDATSymName,
181                                            COFF::IMAGE_COMDAT_SELECT_ANY);
182       }
183     }
184   }
185 
186   return TargetLoweringObjectFile::getSectionForConstant(Kind, C);
187 }
188