From f62176f04759d1841e97064297337645cf536423 Mon Sep 17 00:00:00 2001 From: David Majnemer Date: Wed, 15 Jan 2014 09:16:42 +0000 Subject: [PATCH] WinCOFF: Transform IR expressions featuring __ImageBase into image relative relocations MSVC on x64 requires that we create image relative symbol references to refer to RTTI data. Seeing as how there is no way to explicitly make reference to a given relocation type in LLVM IR, pattern match expressions of the form &foo - &__ImageBase. Differential Revision: http://llvm-reviews.chandlerc.com/D2523 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199312 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/Operator.h | 30 +++++++++++ .../llvm/Target/TargetLoweringObjectFile.h | 6 +++ lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 4 ++ lib/Target/X86/X86ISelLowering.cpp | 2 + lib/Target/X86/X86TargetObjectFile.cpp | 52 +++++++++++++++++++ lib/Target/X86/X86TargetObjectFile.h | 6 +++ test/MC/COFF/ir-to-imgrel.ll | 6 +++ 7 files changed, 106 insertions(+) create mode 100644 test/MC/COFF/ir-to-imgrel.ll diff --git a/include/llvm/IR/Operator.h b/include/llvm/IR/Operator.h index 5b9bee7fc60..119156a50e0 100644 --- a/include/llvm/IR/Operator.h +++ b/include/llvm/IR/Operator.h @@ -473,6 +473,36 @@ public: }; +class PtrToIntOperator + : public ConcreteOperator { + friend class PtrToInt; + friend class ConstantExpr; + +public: + Value *getPointerOperand() { + return getOperand(0); + } + const Value *getPointerOperand() const { + return getOperand(0); + } + static unsigned getPointerOperandIndex() { + return 0U; // get index for modifying correct operand + } + + /// getPointerOperandType - Method to return the pointer operand as a + /// PointerType. + Type *getPointerOperandType() const { + return getPointerOperand()->getType(); + } + + /// getPointerAddressSpace - Method to return the address space of the + /// pointer operand. + unsigned getPointerAddressSpace() const { + return cast(getPointerOperandType())->getAddressSpace(); + } +}; + + } // End llvm namespace #endif diff --git a/include/llvm/Target/TargetLoweringObjectFile.h b/include/llvm/Target/TargetLoweringObjectFile.h index f389e1966c0..4aedd3aa31d 100644 --- a/include/llvm/Target/TargetLoweringObjectFile.h +++ b/include/llvm/Target/TargetLoweringObjectFile.h @@ -29,6 +29,7 @@ namespace llvm { class MCSymbol; class MCSymbolRefExpr; class MCStreamer; + class ConstantExpr; class GlobalValue; class TargetMachine; @@ -152,6 +153,11 @@ public: /// emitting the address in debug info. virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const; + virtual const MCExpr * + getExecutableRelativeSymbol(const ConstantExpr *CE, Mangler *Mang) const { + return 0; + } + protected: virtual const MCSection * SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, diff --git a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index cf950f8cc75..365a73d9753 100644 --- a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -1512,6 +1512,10 @@ static const MCExpr *lowerConstant(const Constant *CV, AsmPrinter &AP) { llvm_unreachable("Unknown constant value to lower!"); } + if (const MCExpr *RelocExpr = + AP.getObjFileLowering().getExecutableRelativeSymbol(CE, AP.Mang)) + return RelocExpr; + switch (CE->getOpcode()) { default: // If the code isn't optimized, there may be outstanding folding diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp index 85999a21818..431101b6eb7 100644 --- a/lib/Target/X86/X86ISelLowering.cpp +++ b/lib/Target/X86/X86ISelLowering.cpp @@ -189,6 +189,8 @@ static TargetLoweringObjectFile *createTLOF(X86TargetMachine &TM) { return new X86LinuxTargetObjectFile(); if (Subtarget->isTargetELF()) return new TargetLoweringObjectFileELF(); + if (Subtarget->isTargetWindows()) + return new X86WindowsTargetObjectFile(); if (Subtarget->isTargetCOFF()) return new TargetLoweringObjectFileCOFF(); llvm_unreachable("unknown subtarget type"); diff --git a/lib/Target/X86/X86TargetObjectFile.cpp b/lib/Target/X86/X86TargetObjectFile.cpp index 709fc972560..bc1064e17f4 100644 --- a/lib/Target/X86/X86TargetObjectFile.cpp +++ b/lib/Target/X86/X86TargetObjectFile.cpp @@ -9,6 +9,7 @@ #include "X86TargetObjectFile.h" #include "llvm/IR/Mangler.h" +#include "llvm/IR/Operator.h" #include "llvm/MC/MCContext.h" #include "llvm/MC/MCExpr.h" #include "llvm/MC/MCSectionELF.h" @@ -53,3 +54,54 @@ X86LinuxTargetObjectFile::getDebugThreadLocalSymbol( const MCSymbol *Sym) const { return MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_DTPOFF, getContext()); } + +const MCExpr * +X86WindowsTargetObjectFile::getExecutableRelativeSymbol(const ConstantExpr *CE, + Mangler *Mang) const { + // We are looking for the difference of two symbols, need a subtraction + // operation. + const SubOperator *Sub = dyn_cast(CE); + if (!Sub) + return 0; + + // Symbols must first be numbers before we can subtract them, we need to see a + // ptrtoint on both subtraction operands. + const PtrToIntOperator *SubLHS = + dyn_cast(Sub->getOperand(0)); + const PtrToIntOperator *SubRHS = + dyn_cast(Sub->getOperand(1)); + if (!SubLHS || !SubRHS) + return 0; + + // Our symbols should exist in address space zero, cowardly no-op if + // otherwise. + if (SubLHS->getPointerAddressSpace() != 0 || + SubRHS->getPointerAddressSpace() != 0) + return 0; + + // Both ptrtoint instructions must wrap global variables: + // - Only global variables are eligible for image relative relocations. + // - The subtrahend refers to the special symbol __ImageBase, a global. + const GlobalVariable *GVLHS = + dyn_cast(SubLHS->getPointerOperand()); + const GlobalVariable *GVRHS = + dyn_cast(SubRHS->getPointerOperand()); + if (!GVLHS || !GVRHS) + return 0; + + // We expect __ImageBase to be a global variable without a section, externally + // defined. + // + // It should look something like this: @__ImageBase = external constant i8 + if (GVRHS->isThreadLocal() || GVRHS->getName() != "__ImageBase" || + !GVRHS->hasExternalLinkage() || GVRHS->hasInitializer() || + GVRHS->hasSection()) + return 0; + + // An image-relative, thread-local, symbol makes no sense. + if (GVLHS->isThreadLocal()) + return 0; + + return MCSymbolRefExpr::Create( + getSymbol(*Mang, GVLHS), MCSymbolRefExpr::VK_COFF_IMGREL32, getContext()); +} diff --git a/lib/Target/X86/X86TargetObjectFile.h b/lib/Target/X86/X86TargetObjectFile.h index 79c861d2e12..5fcd0dfba67 100644 --- a/lib/Target/X86/X86TargetObjectFile.h +++ b/lib/Target/X86/X86TargetObjectFile.h @@ -41,6 +41,12 @@ namespace llvm { virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const; }; + /// \brief This implementation is used for Windows targets on x86 and x86-64. + class X86WindowsTargetObjectFile : public TargetLoweringObjectFileCOFF { + virtual const MCExpr *getExecutableRelativeSymbol(const ConstantExpr *CE, + Mangler *Mang) const; + }; + } // end namespace llvm #endif diff --git a/test/MC/COFF/ir-to-imgrel.ll b/test/MC/COFF/ir-to-imgrel.ll new file mode 100644 index 00000000000..39884d2a15e --- /dev/null +++ b/test/MC/COFF/ir-to-imgrel.ll @@ -0,0 +1,6 @@ +; RUN: llc -mtriple=x86_64-pc-win32 %s -o - | FileCheck %s --check-prefix=X64 + +@__ImageBase = external global i8 + +; X64: .quad "?x@@3HA"@IMGREL32 +@"\01?x@@3HA" = global i64 sub nsw (i64 ptrtoint (i64* @"\01?x@@3HA" to i64), i64 ptrtoint (i8* @__ImageBase to i64)), align 8 -- 2.34.1