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