From cebae36f57456fe6b0e13726acd1e0250654f02d Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Wed, 10 Mar 2010 22:34:10 +0000 Subject: [PATCH] Add a bit along with the MCSymbols stored in the MachineModuleInfo maps that indicates that an MCSymbol is external or not. (It's true if it's external.) This will be used to specify the correct information to add to non-lazy pointers. That will be explained further when this bit is used. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98199 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/MachineModuleInfo.h | 30 +++++----- include/llvm/CodeGen/MachineModuleInfoImpls.h | 22 ++++---- lib/CodeGen/MachineModuleInfoImpls.cpp | 9 ++- lib/CodeGen/TargetLoweringObjectFileImpl.cpp | 26 ++++++--- lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp | 16 +++--- .../PowerPC/AsmPrinter/PPCAsmPrinter.cpp | 55 +++++++++++-------- lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp | 46 +++++++++------- lib/Target/X86/AsmPrinter/X86MCInstLower.cpp | 34 ++++++++---- 8 files changed, 140 insertions(+), 98 deletions(-) diff --git a/include/llvm/CodeGen/MachineModuleInfo.h b/include/llvm/CodeGen/MachineModuleInfo.h index fff8e83354c..1453c1e2315 100644 --- a/include/llvm/CodeGen/MachineModuleInfo.h +++ b/include/llvm/CodeGen/MachineModuleInfo.h @@ -31,48 +31,46 @@ #ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H #define LLVM_CODEGEN_MACHINEMODULEINFO_H -#include "llvm/Support/Dwarf.h" -#include "llvm/System/DataTypes.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/DenseMap.h" -#include "llvm/ADT/UniqueVector.h" -#include "llvm/ADT/SmallPtrSet.h" -#include "llvm/ADT/SmallSet.h" -#include "llvm/ADT/StringMap.h" -#include "llvm/CodeGen/MachineLocation.h" #include "llvm/GlobalValue.h" #include "llvm/Pass.h" #include "llvm/Metadata.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/PointerIntPair.h" +#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/ADT/SmallSet.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/ADT/UniqueVector.h" +#include "llvm/CodeGen/MachineLocation.h" +#include "llvm/Support/Dwarf.h" #include "llvm/Support/ValueHandle.h" +#include "llvm/System/DataTypes.h" namespace llvm { //===----------------------------------------------------------------------===// // Forward declarations. class Constant; +class GlobalVariable; class MCSymbol; class MDNode; -class GlobalVariable; class MachineBasicBlock; class MachineFunction; class Module; class PointerType; class StructType; - /// MachineModuleInfoImpl - This class can be derived from and used by targets /// to hold private target-specific information for each Module. Objects of /// type are accessed/created with MMI::getInfo and destroyed when the /// MachineModuleInfo is destroyed. class MachineModuleInfoImpl { public: + typedef PointerIntPair StubValueTy; virtual ~MachineModuleInfoImpl(); - - typedef std::vector > - SymbolListTy; + typedef std::vector > SymbolListTy; protected: - static SymbolListTy - GetSortedStubs(const DenseMap &Map); + static SymbolListTy GetSortedStubs(const DenseMap&); }; diff --git a/include/llvm/CodeGen/MachineModuleInfoImpls.h b/include/llvm/CodeGen/MachineModuleInfoImpls.h index 89b820740a8..9401ffd199d 100644 --- a/include/llvm/CodeGen/MachineModuleInfoImpls.h +++ b/include/llvm/CodeGen/MachineModuleInfoImpls.h @@ -25,32 +25,34 @@ namespace llvm { class MachineModuleInfoMachO : public MachineModuleInfoImpl { /// FnStubs - Darwin '$stub' stubs. The key is something like "Lfoo$stub", /// the value is something like "_foo". - DenseMap FnStubs; + DenseMap FnStubs; /// GVStubs - Darwin '$non_lazy_ptr' stubs. The key is something like - /// "Lfoo$non_lazy_ptr", the value is something like "_foo". - DenseMap GVStubs; + /// "Lfoo$non_lazy_ptr", the value is something like "_foo". The extra bit + /// is true if this GV is external. + DenseMap GVStubs; /// HiddenGVStubs - Darwin '$non_lazy_ptr' stubs. The key is something like /// "Lfoo$non_lazy_ptr", the value is something like "_foo". Unlike GVStubs - /// these are for things with hidden visibility. - DenseMap HiddenGVStubs; + /// these are for things with hidden visibility. The extra bit is true if + /// this GV is external. + DenseMap HiddenGVStubs; virtual void Anchor(); // Out of line virtual method. public: MachineModuleInfoMachO(const MachineModuleInfo &) {} - MCSymbol *&getFnStubEntry(MCSymbol *Sym) { + StubValueTy &getFnStubEntry(MCSymbol *Sym) { assert(Sym && "Key cannot be null"); return FnStubs[Sym]; } - MCSymbol *&getGVStubEntry(MCSymbol *Sym) { + StubValueTy &getGVStubEntry(MCSymbol *Sym) { assert(Sym && "Key cannot be null"); return GVStubs[Sym]; } - MCSymbol *&getHiddenGVStubEntry(MCSymbol *Sym) { + StubValueTy &getHiddenGVStubEntry(MCSymbol *Sym) { assert(Sym && "Key cannot be null"); return HiddenGVStubs[Sym]; } @@ -72,13 +74,13 @@ namespace llvm { class MachineModuleInfoELF : public MachineModuleInfoImpl { /// GVStubs - These stubs are used to materialize global addresses in PIC /// mode. - DenseMap GVStubs; + DenseMap GVStubs; virtual void Anchor(); // Out of line virtual method. public: MachineModuleInfoELF(const MachineModuleInfo &) {} - MCSymbol *&getGVStubEntry(MCSymbol *Sym) { + StubValueTy &getGVStubEntry(MCSymbol *Sym) { assert(Sym && "Key cannot be null"); return GVStubs[Sym]; } diff --git a/lib/CodeGen/MachineModuleInfoImpls.cpp b/lib/CodeGen/MachineModuleInfoImpls.cpp index 39d2c7504f0..5ab56c09f5f 100644 --- a/lib/CodeGen/MachineModuleInfoImpls.cpp +++ b/lib/CodeGen/MachineModuleInfoImpls.cpp @@ -25,10 +25,9 @@ void MachineModuleInfoMachO::Anchor() {} void MachineModuleInfoELF::Anchor() {} static int SortSymbolPair(const void *LHS, const void *RHS) { - const MCSymbol *LHSS = - ((const std::pair*)LHS)->first; - const MCSymbol *RHSS = - ((const std::pair*)RHS)->first; + typedef std::pair PairTy; + const MCSymbol *LHSS = ((const PairTy *)LHS)->first; + const MCSymbol *RHSS = ((const PairTy *)RHS)->first; return LHSS->getName().compare(RHSS->getName()); } @@ -36,7 +35,7 @@ static int SortSymbolPair(const void *LHS, const void *RHS) { /// sorted orer. MachineModuleInfoImpl::SymbolListTy MachineModuleInfoImpl::GetSortedStubs(const DenseMap &Map) { + MachineModuleInfoImpl::StubValueTy>&Map) { MachineModuleInfoImpl::SymbolListTy List(Map.begin(), Map.end()); if (!List.empty()) diff --git a/lib/CodeGen/TargetLoweringObjectFileImpl.cpp b/lib/CodeGen/TargetLoweringObjectFileImpl.cpp index 2014b429bd9..169e2cae1f8 100644 --- a/lib/CodeGen/TargetLoweringObjectFileImpl.cpp +++ b/lib/CodeGen/TargetLoweringObjectFileImpl.cpp @@ -404,14 +404,19 @@ getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang, // Add information about the stub reference to ELFMMI so that the stub // gets emitted by the asmprinter. MCSymbol *Sym = getContext().GetOrCreateTemporarySymbol(Name.str()); - MCSymbol *&StubSym = ELFMMI.getGVStubEntry(Sym); - if (StubSym == 0) { + MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(Sym); + if (StubSym.getPointer() == 0) { Name.clear(); Mang->getNameWithPrefix(Name, GV, false); + if (GV->hasPrivateLinkage()) - StubSym = getContext().GetOrCreateTemporarySymbol(Name.str()); + StubSym = MachineModuleInfoImpl:: + StubValueTy(getContext().GetOrCreateTemporarySymbol(Name.str()), + false); else - StubSym = getContext().GetOrCreateSymbol(Name.str()); + StubSym = MachineModuleInfoImpl:: + StubValueTy(getContext().GetOrCreateSymbol(Name.str()), + !GV->hasInternalLinkage()); } return TargetLoweringObjectFile:: @@ -761,14 +766,19 @@ getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang, // Add information about the stub reference to MachOMMI so that the stub // gets emitted by the asmprinter. MCSymbol *Sym = getContext().GetOrCreateTemporarySymbol(Name.str()); - MCSymbol *&StubSym = MachOMMI.getGVStubEntry(Sym); - if (StubSym == 0) { + MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Sym); + if (StubSym.getPointer() == 0) { Name.clear(); Mang->getNameWithPrefix(Name, GV, false); + if (GV->hasPrivateLinkage()) - StubSym = getContext().GetOrCreateTemporarySymbol(Name.str()); + StubSym = MachineModuleInfoImpl:: + StubValueTy(getContext().GetOrCreateTemporarySymbol(Name.str()), + false); else - StubSym = getContext().GetOrCreateSymbol(Name.str()); + StubSym = MachineModuleInfoImpl:: + StubValueTy(getContext().GetOrCreateSymbol(Name.str()), + !GV->hasInternalLinkage()); } return TargetLoweringObjectFile:: diff --git a/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp b/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp index 716f4fb0e30..c1490cbff1c 100644 --- a/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp +++ b/lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp @@ -205,11 +205,12 @@ namespace { MachineModuleInfoMachO &MMIMachO = MMI->getObjFileInfo(); - MCSymbol *&StubSym = + MachineModuleInfoImpl::StubValueTy &StubSym = GV->hasHiddenVisibility() ? MMIMachO.getHiddenGVStubEntry(Sym) : MMIMachO.getGVStubEntry(Sym); - if (StubSym == 0) - StubSym = GetGlobalValueSymbol(GV); + if (StubSym.getPointer() == 0) + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetGlobalValueSymbol(GV), !GV->hasInternalLinkage()); } } else { assert(ACPV->isExtSymbol() && "unrecognized constant pool value"); @@ -1126,7 +1127,7 @@ void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) { // Output non-lazy-pointers for external and common global variables. MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetGVStubList(); - + if (!Stubs.empty()) { // Switch with ".non_lazy_symbol_pointer" directive. OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection()); @@ -1135,7 +1136,7 @@ void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) { // L_foo$stub: OutStreamer.EmitLabel(Stubs[i].first); // .indirect_symbol _foo - MCSymbol *MCSym = Stubs[i].second; + MCSymbol *MCSym = Stubs[i].second.getPointer(); OutStreamer.EmitSymbolAttribute(MCSym, MCSA_IndirectSymbol); if (MCSym->isUndefined()) @@ -1159,8 +1160,9 @@ void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) { // L_foo$stub: OutStreamer.EmitLabel(Stubs[i].first); // .long _foo - OutStreamer.EmitValue(MCSymbolRefExpr::Create(Stubs[i].second, - OutContext), + OutStreamer.EmitValue(MCSymbolRefExpr:: + Create(Stubs[i].second.getPointer(), + OutContext), 4/*size*/, 0/*addrspace*/); } diff --git a/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp b/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp index 3c7dfaf0f6e..7dd5ae26dac 100644 --- a/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp +++ b/lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp @@ -198,10 +198,11 @@ namespace { if (GV->isDeclaration() || GV->isWeakForLinker()) { // Dynamically-resolved functions need a stub for the function. MCSymbol *Sym = GetSymbolWithGlobalValueBase(GV, "$stub"); - MCSymbol *&StubSym = + MachineModuleInfoImpl::StubValueTy &StubSym = MMI->getObjFileInfo().getFnStubEntry(Sym); - if (StubSym == 0) - StubSym = GetGlobalValueSymbol(GV); + if (StubSym.getPointer() == 0) + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetGlobalValueSymbol(GV),!GV->hasInternalLinkage()); O << *Sym; return; } @@ -212,10 +213,11 @@ namespace { TempNameStr += StringRef("$stub"); MCSymbol *Sym = GetExternalSymbolSymbol(TempNameStr.str()); - MCSymbol *&StubSym = + MachineModuleInfoImpl::StubValueTy &StubSym = MMI->getObjFileInfo().getFnStubEntry(Sym); - if (StubSym == 0) - StubSym = GetExternalSymbolSymbol(MO.getSymbolName()); + if (StubSym.getPointer() == 0) + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetExternalSymbolSymbol(MO.getSymbolName()), true); O << *Sym; return; } @@ -404,10 +406,11 @@ void PPCAsmPrinter::printOp(const MachineOperand &MO) { MCSymbol *NLPSym = OutContext.GetOrCreateSymbol(StringRef(MAI->getGlobalPrefix())+ MO.getSymbolName()+"$non_lazy_ptr"); - MCSymbol *&StubSym = + MachineModuleInfoImpl::StubValueTy &StubSym = MMI->getObjFileInfo().getGVStubEntry(NLPSym); - if (StubSym == 0) - StubSym = GetExternalSymbolSymbol(MO.getSymbolName()); + if (StubSym.getPointer() == 0) + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetExternalSymbolSymbol(MO.getSymbolName()), true); O << *NLPSym; return; @@ -422,19 +425,23 @@ void PPCAsmPrinter::printOp(const MachineOperand &MO) { (GV->isDeclaration() || GV->isWeakForLinker())) { if (!GV->hasHiddenVisibility()) { SymToPrint = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); - MCSymbol *&StubSym = - MMI->getObjFileInfo().getGVStubEntry(SymToPrint); - if (StubSym == 0) - StubSym = GetGlobalValueSymbol(GV); + MachineModuleInfoImpl::StubValueTy &StubSym = + MMI->getObjFileInfo() + .getGVStubEntry(SymToPrint); + if (StubSym.getPointer() == 0) + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetGlobalValueSymbol(GV), !GV->hasInternalLinkage()); } else if (GV->isDeclaration() || GV->hasCommonLinkage() || GV->hasAvailableExternallyLinkage()) { SymToPrint = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); - MCSymbol *&StubSym = + MachineModuleInfoImpl::StubValueTy &StubSym = MMI->getObjFileInfo(). getHiddenGVStubEntry(SymToPrint); - if (StubSym == 0) - StubSym = GetGlobalValueSymbol(GV); + if (StubSym.getPointer() == 0) + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetGlobalValueSymbol(GV), + !GV->hasInternalLinkage()); } else { SymToPrint = GetGlobalValueSymbol(GV); } @@ -704,7 +711,7 @@ EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) { EmitAlignment(4); const MCSymbol *Stub = Stubs[i].first; - const MCSymbol *RawSym = Stubs[i].second; + const MCSymbol *RawSym = Stubs[i].second.getPointer(); const MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext); const MCSymbol *AnonSymbol = GetAnonSym(Stub, OutContext); @@ -738,7 +745,7 @@ EmitFunctionStubs(const MachineModuleInfoMachO::SymbolListTy &Stubs) { 16, SectionKind::getText()); for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { const MCSymbol *Stub = Stubs[i].first; - const MCSymbol *RawSym = Stubs[i].second; + const MCSymbol *RawSym = Stubs[i].second.getPointer(); const MCSymbol *LazyPtr = GetLazyPtr(Stub, OutContext); OutStreamer.SwitchSection(StubSection); @@ -781,8 +788,10 @@ bool PPCDarwinAsmPrinter::doFinalization(Module &M) { E = Personalities.end(); I != E; ++I) { if (*I) { MCSymbol *NLPSym = GetSymbolWithGlobalValueBase(*I, "$non_lazy_ptr"); - MCSymbol *&StubSym = MMIMacho.getGVStubEntry(NLPSym); - StubSym = GetGlobalValueSymbol(*I); + MachineModuleInfoImpl::StubValueTy &StubSym = + MMIMacho.getGVStubEntry(NLPSym); + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetGlobalValueSymbol(*I), true); } } } @@ -798,7 +807,8 @@ bool PPCDarwinAsmPrinter::doFinalization(Module &M) { for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { O << *Stubs[i].first << ":\n"; - O << "\t.indirect_symbol " << *Stubs[i].second << '\n'; + O << "\t.indirect_symbol " << *Stubs[i].second.getPointer() << '\n'; + // FIXME: This should use the "GV is external" bit. O << (isPPC64 ? "\t.quad\t0\n" : "\t.long\t0\n"); } } @@ -810,7 +820,8 @@ bool PPCDarwinAsmPrinter::doFinalization(Module &M) { for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { O << *Stubs[i].first << ":\n"; - O << (isPPC64 ? "\t.quad\t" : "\t.long\t") << *Stubs[i].second << '\n'; + O << (isPPC64 ? "\t.quad\t" : "\t.long\t") + << *Stubs[i].second.getPointer() << '\n'; } } diff --git a/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp b/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp index caf84b67f94..4911683d4dd 100644 --- a/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp +++ b/lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp @@ -133,24 +133,25 @@ void X86AsmPrinter::printSymbolOperand(const MachineOperand &MO) { if (MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY || MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY_PIC_BASE) { MCSymbol *Sym = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); - - MCSymbol *&StubSym = + MachineModuleInfoImpl::StubValueTy &StubSym = MMI->getObjFileInfo().getGVStubEntry(Sym); - if (StubSym == 0) - StubSym = GetGlobalValueSymbol(GV); - + if (StubSym.getPointer() == 0) + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetGlobalValueSymbol(GV), !GV->hasInternalLinkage()); } else if (MO.getTargetFlags() == X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE){ MCSymbol *Sym = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); - MCSymbol *&StubSym = + MachineModuleInfoImpl::StubValueTy &StubSym = MMI->getObjFileInfo().getHiddenGVStubEntry(Sym); - if (StubSym == 0) - StubSym = GetGlobalValueSymbol(GV); + if (StubSym.getPointer() == 0) + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetGlobalValueSymbol(GV), !GV->hasInternalLinkage()); } else if (MO.getTargetFlags() == X86II::MO_DARWIN_STUB) { MCSymbol *Sym = GetSymbolWithGlobalValueBase(GV, "$stub"); - MCSymbol *&StubSym = + MachineModuleInfoImpl::StubValueTy &StubSym = MMI->getObjFileInfo().getFnStubEntry(Sym); - if (StubSym == 0) - StubSym = GetGlobalValueSymbol(GV); + if (StubSym.getPointer() == 0) + StubSym = MachineModuleInfoImpl:: + StubValueTy(GetGlobalValueSymbol(GV), !GV->hasInternalLinkage()); } // If the name begins with a dollar-sign, enclose it in parens. We do this @@ -170,13 +171,15 @@ void X86AsmPrinter::printSymbolOperand(const MachineOperand &MO) { TempNameStr += StringRef("$stub"); MCSymbol *Sym = GetExternalSymbolSymbol(TempNameStr.str()); - MCSymbol *&StubSym = + MachineModuleInfoImpl::StubValueTy &StubSym = MMI->getObjFileInfo().getFnStubEntry(Sym); - if (StubSym == 0) { + if (StubSym.getPointer() == 0) { TempNameStr.erase(TempNameStr.end()-5, TempNameStr.end()); - StubSym = OutContext.GetOrCreateSymbol(TempNameStr.str()); + StubSym = MachineModuleInfoImpl:: + StubValueTy(OutContext.GetOrCreateSymbol(TempNameStr.str()), + true); } - SymToPrint = StubSym; + SymToPrint = StubSym.getPointer(); } else { SymToPrint = GetExternalSymbolSymbol(MO.getSymbolName()); } @@ -507,7 +510,8 @@ void X86AsmPrinter::EmitEndOfAsmFile(Module &M) { // L_foo$stub: OutStreamer.EmitLabel(Stubs[i].first); // .indirect_symbol _foo - OutStreamer.EmitSymbolAttribute(Stubs[i].second, MCSA_IndirectSymbol); + OutStreamer.EmitSymbolAttribute(Stubs[i].second.getPointer(), + MCSA_IndirectSymbol); // hlt; hlt; hlt; hlt; hlt hlt = 0xf4 = -12. const char HltInsts[] = { -12, -12, -12, -12, -12 }; OutStreamer.EmitBytes(StringRef(HltInsts, 5), 0/*addrspace*/); @@ -530,7 +534,8 @@ void X86AsmPrinter::EmitEndOfAsmFile(Module &M) { // L_foo$non_lazy_ptr: OutStreamer.EmitLabel(Stubs[i].first); // .indirect_symbol _foo - OutStreamer.EmitSymbolAttribute(Stubs[i].second, MCSA_IndirectSymbol); + OutStreamer.EmitSymbolAttribute(Stubs[i].second.getPointer(), + MCSA_IndirectSymbol); // .long 0 OutStreamer.EmitIntValue(0, 4/*size*/, 0/*addrspace*/); } @@ -547,8 +552,9 @@ void X86AsmPrinter::EmitEndOfAsmFile(Module &M) { // L_foo$non_lazy_ptr: OutStreamer.EmitLabel(Stubs[i].first); // .long _foo - OutStreamer.EmitValue(MCSymbolRefExpr::Create(Stubs[i].second, - OutContext), + OutStreamer.EmitValue(MCSymbolRefExpr:: + Create(Stubs[i].second.getPointer(), + OutContext), 4/*size*/, 0/*addrspace*/); } Stubs.clear(); @@ -624,7 +630,7 @@ void X86AsmPrinter::EmitEndOfAsmFile(Module &M) { O << *Stubs[i].first << ":\n" << (TD->getPointerSize() == 8 ? MAI->getData64bitsDirective() : MAI->getData32bitsDirective()) - << *Stubs[i].second << '\n'; + << *Stubs[i].second.getPointer() << '\n'; Stubs.clear(); } diff --git a/lib/Target/X86/AsmPrinter/X86MCInstLower.cpp b/lib/Target/X86/AsmPrinter/X86MCInstLower.cpp index b8a6eeb518a..bde7bfd63a8 100644 --- a/lib/Target/X86/AsmPrinter/X86MCInstLower.cpp +++ b/lib/Target/X86/AsmPrinter/X86MCInstLower.cpp @@ -91,35 +91,49 @@ GetSymbolFromOperand(const MachineOperand &MO) const { Name += "$non_lazy_ptr"; MCSymbol *Sym = Ctx.GetOrCreateTemporarySymbol(Name.str()); - MCSymbol *&StubSym = getMachOMMI().getGVStubEntry(Sym); - if (StubSym == 0) { + MachineModuleInfoImpl::StubValueTy &StubSym = + getMachOMMI().getGVStubEntry(Sym); + if (StubSym.getPointer() == 0) { assert(MO.isGlobal() && "Extern symbol not handled yet"); - StubSym = AsmPrinter.GetGlobalValueSymbol(MO.getGlobal()); + StubSym = + MachineModuleInfoImpl:: + StubValueTy(AsmPrinter.GetGlobalValueSymbol(MO.getGlobal()), + !MO.getGlobal()->hasInternalLinkage()); } return Sym; } case X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE: { Name += "$non_lazy_ptr"; MCSymbol *Sym = Ctx.GetOrCreateTemporarySymbol(Name.str()); - MCSymbol *&StubSym = getMachOMMI().getHiddenGVStubEntry(Sym); - if (StubSym == 0) { + MachineModuleInfoImpl::StubValueTy &StubSym = + getMachOMMI().getHiddenGVStubEntry(Sym); + if (StubSym.getPointer() == 0) { assert(MO.isGlobal() && "Extern symbol not handled yet"); - StubSym = AsmPrinter.GetGlobalValueSymbol(MO.getGlobal()); + StubSym = + MachineModuleInfoImpl:: + StubValueTy(AsmPrinter.GetGlobalValueSymbol(MO.getGlobal()), + !MO.getGlobal()->hasInternalLinkage()); } return Sym; } case X86II::MO_DARWIN_STUB: { Name += "$stub"; MCSymbol *Sym = Ctx.GetOrCreateTemporarySymbol(Name.str()); - MCSymbol *&StubSym = getMachOMMI().getFnStubEntry(Sym); - if (StubSym) + MachineModuleInfoImpl::StubValueTy &StubSym = + getMachOMMI().getFnStubEntry(Sym); + if (StubSym.getPointer()) return Sym; if (MO.isGlobal()) { - StubSym = AsmPrinter.GetGlobalValueSymbol(MO.getGlobal()); + StubSym = + MachineModuleInfoImpl:: + StubValueTy(AsmPrinter.GetGlobalValueSymbol(MO.getGlobal()), + !MO.getGlobal()->hasInternalLinkage()); } else { Name.erase(Name.end()-5, Name.end()); - StubSym = Ctx.GetOrCreateTemporarySymbol(Name.str()); + StubSym = + MachineModuleInfoImpl:: + StubValueTy(Ctx.GetOrCreateTemporarySymbol(Name.str()), false); } return Sym; }