diff --git a/include/llvm/CodeGen/ScheduleDAG.h b/include/llvm/CodeGen/ScheduleDAG.h index 67f3dbb69fb..bca57127379 100644 --- a/include/llvm/CodeGen/ScheduleDAG.h +++ b/include/llvm/CodeGen/ScheduleDAG.h @@ -278,7 +278,7 @@ namespace llvm { if (isa(Node)) return true; if (isa(Node)) return true; if (isa(Node)) return true; - if (isa(Node)) return true; + if (isa(Node)) return true; if (isa(Node)) return true; if (Node->getOpcode() == ISD::EntryToken) return true; return false; diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h index 15d0edc3d8a..b2611dfa796 100644 --- a/include/llvm/CodeGen/SelectionDAG.h +++ b/include/llvm/CodeGen/SelectionDAG.h @@ -282,8 +282,11 @@ public: return getConstantPool(C, VT, Align, Offset, true); } SDValue getBasicBlock(MachineBasicBlock *MBB); - SDValue getExternalSymbol(const char *Sym, MVT VT); - SDValue getTargetExternalSymbol(const char *Sym, MVT VT); + SDValue getSymbol(const char *Sym, MVT VT, + GlobalValue::LinkageTypes LT = GlobalValue::ExternalLinkage); + SDValue getTargetSymbol(const char *Sym, MVT VT, + GlobalValue::LinkageTypes LT = + GlobalValue::ExternalLinkage); SDValue getArgFlags(ISD::ArgFlagsTy Flags); SDValue getValueType(MVT); SDValue getRegister(unsigned Reg, MVT VT); @@ -758,8 +761,8 @@ private: std::vector ValueTypeNodes; std::map ExtendedValueTypeNodes; - StringMap ExternalSymbols; - StringMap TargetExternalSymbols; + StringMap Symbols; + StringMap TargetSymbols; }; template <> struct GraphTraits : public GraphTraits { diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h index 7cd9eef2abc..4ba5603fab8 100644 --- a/include/llvm/CodeGen/SelectionDAGNodes.h +++ b/include/llvm/CodeGen/SelectionDAGNodes.h @@ -21,6 +21,7 @@ #include "llvm/Value.h" #include "llvm/Constants.h" +#include "llvm/GlobalValue.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/GraphTraits.h" #include "llvm/ADT/iterator.h" @@ -89,7 +90,7 @@ namespace ISD { BasicBlock, VALUETYPE, ARG_FLAGS, CONDCODE, Register, Constant, ConstantFP, GlobalAddress, GlobalTLSAddress, FrameIndex, - JumpTable, ConstantPool, ExternalSymbol, + JumpTable, ConstantPool, Symbol, // The address of the GOT GLOBAL_OFFSET_TABLE, @@ -133,7 +134,7 @@ namespace ISD { TargetFrameIndex, TargetJumpTable, TargetConstantPool, - TargetExternalSymbol, + TargetSymbol, /// RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...) /// This node represents a target intrinsic function with no side effects. @@ -487,7 +488,7 @@ namespace ISD { // INLINEASM - Represents an inline asm block. This node always has two // return values: a chain and a flag result. The inputs are as follows: // Operand #0 : Input chain. - // Operand #1 : a ExternalSymbolSDNode with a pointer to the asm string. + // Operand #1 : A SymbolSDNode with a pointer to the asm string. // Operand #2n+2: A RegisterNode. // Operand #2n+3: A TargetConstant, indicating if the reg is a use/def // Operand #last: Optional, an incoming flag. @@ -2045,23 +2046,24 @@ public: } }; -class ExternalSymbolSDNode : public SDNode { +class SymbolSDNode : public SDNode { const char *Symbol; + GlobalValue::LinkageTypes Linkage; virtual void ANCHOR(); // Out-of-line virtual method to give class a home. protected: friend class SelectionDAG; - ExternalSymbolSDNode(bool isTarget, const char *Sym, MVT VT) - : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol, - getSDVTList(VT)), Symbol(Sym) { - } + SymbolSDNode(bool isTarget, const char *Sym, MVT VT, + GlobalValue::LinkageTypes L) + : SDNode(isTarget ? ISD::TargetSymbol : ISD::Symbol, + getSDVTList(VT)), Symbol(Sym), Linkage(L) {} public: - const char *getSymbol() const { return Symbol; } + GlobalValue::LinkageTypes getLinkage() const { return Linkage; } - static bool classof(const ExternalSymbolSDNode *) { return true; } + static bool classof(const SymbolSDNode *) { return true; } static bool classof(const SDNode *N) { - return N->getOpcode() == ISD::ExternalSymbol || - N->getOpcode() == ISD::TargetExternalSymbol; + return N->getOpcode() == ISD::Symbol || + N->getOpcode() == ISD::TargetSymbol; } }; diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp index ba78b8166a6..741e3f78c6c 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp @@ -799,7 +799,7 @@ SDValue SelectionDAGLegalize::LegalizeOp(SDValue Op) { case ISD::TargetConstantPool: case ISD::TargetGlobalAddress: case ISD::TargetGlobalTLSAddress: - case ISD::TargetExternalSymbol: + case ISD::TargetSymbol: case ISD::VALUETYPE: case ISD::SRCVALUE: case ISD::MEMOPERAND: @@ -832,7 +832,7 @@ SDValue SelectionDAGLegalize::LegalizeOp(SDValue Op) { case ISD::GLOBAL_OFFSET_TABLE: case ISD::GlobalAddress: case ISD::GlobalTLSAddress: - case ISD::ExternalSymbol: + case ISD::Symbol: case ISD::ConstantPool: case ISD::JumpTable: // Nothing to do. switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { @@ -3979,7 +3979,7 @@ SDValue SelectionDAGLegalize::LegalizeOp(SDValue Op) { std::pair CallResult = TLI.LowerCallTo(Tmp1, Type::VoidTy, false, false, false, CallingConv::C, false, - DAG.getExternalSymbol("abort", TLI.getPointerTy()), + DAG.getSymbol("abort", TLI.getPointerTy()), Args, DAG); Result = CallResult.second; break; @@ -5293,8 +5293,9 @@ SDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, Entry.isZExt = !isSigned; Args.push_back(Entry); } - SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), - TLI.getPointerTy()); + + SDValue Callee = DAG.getSymbol(TLI.getLibcallName(LC), + TLI.getPointerTy()); // Splice the libcall in wherever FindInputOutputChains tells us to. const Type *RetTy = Node->getValueType(0).getTypeForMVT(); diff --git a/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp b/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp index 640392f26cf..9a055012342 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp @@ -623,8 +623,8 @@ SDValue DAGTypeLegalizer::MakeLibCall(RTLIB::Libcall LC, MVT RetVT, Entry.isZExt = !isSigned; Args.push_back(Entry); } - SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), - TLI.getPointerTy()); + + SDValue Callee = DAG.getSymbol(TLI.getLibcallName(LC), TLI.getPointerTy()); const Type *RetTy = RetVT.getTypeForMVT(); std::pair CallInfo = diff --git a/lib/CodeGen/SelectionDAG/ScheduleDAGEmit.cpp b/lib/CodeGen/SelectionDAG/ScheduleDAGEmit.cpp index 156905a708a..52428cb4256 100644 --- a/lib/CodeGen/SelectionDAG/ScheduleDAGEmit.cpp +++ b/lib/CodeGen/SelectionDAG/ScheduleDAGEmit.cpp @@ -288,7 +288,7 @@ void ScheduleDAG::AddOperand(MachineInstr *MI, SDValue Op, else Idx = ConstPool->getConstantPoolIndex(CP->getConstVal(), Align); MI->addOperand(MachineOperand::CreateCPI(Idx, Offset)); - } else if (ExternalSymbolSDNode *ES = dyn_cast(Op)) { + } else if (SymbolSDNode *ES = dyn_cast(Op)) { MI->addOperand(MachineOperand::CreateES(ES->getSymbol())); } else { assert(Op.getValueType() != MVT::Other && @@ -571,8 +571,7 @@ void ScheduleDAG::EmitNode(SDNode *Node, bool IsClone, MachineInstr *MI = BuildMI(*MF, TII->get(TargetInstrInfo::INLINEASM)); // Add the asm string as an external symbol operand. - const char *AsmStr = - cast(Node->getOperand(1))->getSymbol(); + const char *AsmStr = cast(Node->getOperand(1))->getSymbol(); MI->addOperand(MachineOperand::CreateES(AsmStr)); // Add all of the operand registers to the instruction. diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index 793f5c99972..9e42307fbec 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -614,12 +614,11 @@ bool SelectionDAG::RemoveNodeFromCSEMaps(SDNode *N) { Erased = CondCodeNodes[cast(N)->get()] != 0; CondCodeNodes[cast(N)->get()] = 0; break; - case ISD::ExternalSymbol: - Erased = ExternalSymbols.erase(cast(N)->getSymbol()); + case ISD::Symbol: + Erased = Symbols.erase(cast(N)->getSymbol()); break; - case ISD::TargetExternalSymbol: - Erased = - TargetExternalSymbols.erase(cast(N)->getSymbol()); + case ISD::TargetSymbol: + Erased = TargetSymbols.erase(cast(N)->getSymbol()); break; case ISD::VALUETYPE: { MVT VT = cast(N)->getVT(); @@ -842,8 +841,8 @@ void SelectionDAG::clear() { CSEMap.clear(); ExtendedValueTypeNodes.clear(); - ExternalSymbols.clear(); - TargetExternalSymbols.clear(); + Symbols.clear(); + TargetSymbols.clear(); std::fill(CondCodeNodes.begin(), CondCodeNodes.end(), static_cast(0)); std::fill(ValueTypeNodes.begin(), ValueTypeNodes.end(), @@ -1098,20 +1097,22 @@ SDValue SelectionDAG::getValueType(MVT VT) { return SDValue(N, 0); } -SDValue SelectionDAG::getExternalSymbol(const char *Sym, MVT VT) { - SDNode *&N = ExternalSymbols[Sym]; +SDValue SelectionDAG::getSymbol(const char *Sym, MVT VT, + GlobalValue::LinkageTypes LT) { + SDNode *&N = Symbols[Sym]; if (N) return SDValue(N, 0); - N = NodeAllocator.Allocate(); - new (N) ExternalSymbolSDNode(false, Sym, VT); + N = NodeAllocator.Allocate(); + new (N) SymbolSDNode(false, Sym, VT, LT); AllNodes.push_back(N); return SDValue(N, 0); } -SDValue SelectionDAG::getTargetExternalSymbol(const char *Sym, MVT VT) { - SDNode *&N = TargetExternalSymbols[Sym]; +SDValue SelectionDAG::getTargetSymbol(const char *Sym, MVT VT, + GlobalValue::LinkageTypes LT) { + SDNode *&N = TargetSymbols[Sym]; if (N) return SDValue(N, 0); - N = NodeAllocator.Allocate(); - new (N) ExternalSymbolSDNode(true, Sym, VT); + N = NodeAllocator.Allocate(); + new (N) SymbolSDNode(true, Sym, VT, LT); AllNodes.push_back(N); return SDValue(N, 0); } @@ -3098,7 +3099,7 @@ SDValue SelectionDAG::getMemcpy(SDValue Chain, SDValue Dst, std::pair CallResult = TLI.LowerCallTo(Chain, Type::VoidTy, false, false, false, CallingConv::C, false, - getExternalSymbol("memcpy", TLI.getPointerTy()), + getSymbol("memcpy", TLI.getPointerTy()), Args, *this); return CallResult.second; } @@ -3143,7 +3144,7 @@ SDValue SelectionDAG::getMemmove(SDValue Chain, SDValue Dst, std::pair CallResult = TLI.LowerCallTo(Chain, Type::VoidTy, false, false, false, CallingConv::C, false, - getExternalSymbol("memmove", TLI.getPointerTy()), + getSymbol("memmove", TLI.getPointerTy()), Args, *this); return CallResult.second; } @@ -3194,7 +3195,7 @@ SDValue SelectionDAG::getMemset(SDValue Chain, SDValue Dst, std::pair CallResult = TLI.LowerCallTo(Chain, Type::VoidTy, false, false, false, CallingConv::C, false, - getExternalSymbol("memset", TLI.getPointerTy()), + getSymbol("memset", TLI.getPointerTy()), Args, *this); return CallResult.second; } @@ -4610,7 +4611,7 @@ void MemOperandSDNode::ANCHOR() {} void RegisterSDNode::ANCHOR() {} void DbgStopPointSDNode::ANCHOR() {} void LabelSDNode::ANCHOR() {} -void ExternalSymbolSDNode::ANCHOR() {} +void SymbolSDNode::ANCHOR() {} void CondCodeSDNode::ANCHOR() {} void ARG_FLAGSSDNode::ANCHOR() {} void VTSDNode::ANCHOR() {} @@ -4914,14 +4915,14 @@ std::string SDNode::getOperationName(const SelectionDAG *G) const { case ISD::FrameIndex: return "FrameIndex"; case ISD::JumpTable: return "JumpTable"; case ISD::GLOBAL_OFFSET_TABLE: return "GLOBAL_OFFSET_TABLE"; - case ISD::RETURNADDR: return "RETURNADDR"; - case ISD::FRAMEADDR: return "FRAMEADDR"; + case ISD::RETURNADDR: return "RETURNADDR"; + case ISD::FRAMEADDR: return "FRAMEADDR"; case ISD::FRAME_TO_ARGS_OFFSET: return "FRAME_TO_ARGS_OFFSET"; case ISD::EXCEPTIONADDR: return "EXCEPTIONADDR"; - case ISD::EHSELECTION: return "EHSELECTION"; - case ISD::EH_RETURN: return "EH_RETURN"; + case ISD::EHSELECTION: return "EHSELECTION"; + case ISD::EH_RETURN: return "EH_RETURN"; case ISD::ConstantPool: return "ConstantPool"; - case ISD::ExternalSymbol: return "ExternalSymbol"; + case ISD::Symbol: return "Symbol"; case ISD::INTRINSIC_WO_CHAIN: { unsigned IID = cast(getOperand(0))->getZExtValue(); return Intrinsic::getName((Intrinsic::ID)IID); @@ -4940,7 +4941,7 @@ std::string SDNode::getOperationName(const SelectionDAG *G) const { case ISD::TargetFrameIndex: return "TargetFrameIndex"; case ISD::TargetJumpTable: return "TargetJumpTable"; case ISD::TargetConstantPool: return "TargetConstantPool"; - case ISD::TargetExternalSymbol: return "TargetExternalSymbol"; + case ISD::TargetSymbol: return "TargetSymbol"; case ISD::CopyToReg: return "CopyToReg"; case ISD::CopyFromReg: return "CopyFromReg"; @@ -5230,9 +5231,23 @@ void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const { } else { OS << " #" << R->getReg(); } - } else if (const ExternalSymbolSDNode *ES = - dyn_cast(this)) { - OS << "'" << ES->getSymbol() << "'"; + } else if (const SymbolSDNode *S = + dyn_cast(this)) { + OS << "'" << S->getSymbol() << "' "; + + switch (S->getLinkage()) { + default: assert(0 && "Invalid linkage type!"); break; + case GlobalValue::ExternalLinkage: OS << "[external]"; break; + case GlobalValue::LinkOnceLinkage: OS << "[once]"; break; + case GlobalValue::WeakLinkage: OS << "[weak]"; break; + case GlobalValue::AppendingLinkage: OS << "[appending]"; break; + case GlobalValue::InternalLinkage: OS << "[internal]"; break; + case GlobalValue::DLLImportLinkage: OS << "[dllimport]"; break; + case GlobalValue::DLLExportLinkage: OS << "[dllexport]"; break; + case GlobalValue::ExternalWeakLinkage: OS << "[externweak]"; break; + case GlobalValue::GhostLinkage: OS << "[ghost]"; break; + case GlobalValue::CommonLinkage: OS << "[common]"; break; + } } else if (const SrcValueSDNode *M = dyn_cast(this)) { if (M->getValue()) OS << "<" << M->getValue() << ">"; diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp index 62a6b4f1808..f82fd340ff8 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp @@ -4293,7 +4293,7 @@ void SelectionDAGLowering::visitCall(CallInst &I) { if (!RenameFn) Callee = getValue(I.getOperand(0)); else - Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy()); + Callee = DAG.getSymbol(RenameFn, TLI.getPointerTy()); LowerCallTo(&I, Callee, I.isTailCall()); } @@ -4888,7 +4888,7 @@ void SelectionDAGLowering::visitInlineAsm(CallSite CS) { std::vector AsmNodeOperands; AsmNodeOperands.push_back(SDValue()); // reserve space for input chain AsmNodeOperands.push_back( - DAG.getTargetExternalSymbol(IA->getAsmString().c_str(), MVT::Other)); + DAG.getTargetSymbol(IA->getAsmString().c_str(), MVT::Other)); // Loop over all of the inputs, copying the operand values into the @@ -5139,7 +5139,7 @@ void SelectionDAGLowering::visitMalloc(MallocInst &I) { std::pair Result = TLI.LowerCallTo(getRoot(), I.getType(), false, false, false, CallingConv::C, - PerformTailCallOpt, DAG.getExternalSymbol("malloc", IntPtr), + PerformTailCallOpt, DAG.getSymbol("malloc", IntPtr), Args, DAG); setValue(&I, Result.first); // Pointers always fit in registers DAG.setRoot(Result.second); @@ -5155,7 +5155,7 @@ void SelectionDAGLowering::visitFree(FreeInst &I) { std::pair Result = TLI.LowerCallTo(getRoot(), Type::VoidTy, false, false, false, CallingConv::C, PerformTailCallOpt, - DAG.getExternalSymbol("free", IntPtr), Args, DAG); + DAG.getSymbol("free", IntPtr), Args, DAG); DAG.setRoot(Result.second); } diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp index 570caa97016..aca115fd84e 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp @@ -185,9 +185,8 @@ std::string DOTGraphTraits::getNodeLabel(const SDNode *Node, Op += ", isVarArg"; if (C->isTailCall()) Op += ", isTailCall"; - } else if (const ExternalSymbolSDNode *ES = - dyn_cast(Node)) { - Op += "'" + std::string(ES->getSymbol()) + "'"; + } else if (const SymbolSDNode *S = dyn_cast(Node)) { + Op += "'" + std::string(S->getSymbol()) + "'"; } else if (const SrcValueSDNode *M = dyn_cast(Node)) { if (M->getValue()) Op += "<" + M->getValue()->getName() + ">"; diff --git a/lib/Target/ARM/ARMISelLowering.cpp b/lib/Target/ARM/ARMISelLowering.cpp index 2202177e186..4131903edbd 100644 --- a/lib/Target/ARM/ARMISelLowering.cpp +++ b/lib/Target/ARM/ARMISelLowering.cpp @@ -531,9 +531,9 @@ SDValue ARMTargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) { InFlag = Chain.getValue(1); } - // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every - // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol - // node so that legalize doesn't hack it. + // If the callee is a GlobalAddress/Symbol node (quite common, every direct + // call is) turn it into a TargetGlobalAddress/TargetSymbol node so that + // legalize doesn't hack it. bool isDirect = false; bool isARMFunc = false; bool isLocalARMFunc = false; @@ -558,7 +558,7 @@ SDValue ARMTargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) { Callee = DAG.getNode(ARMISD::PIC_ADD, getPointerTy(), Callee, PICLabel); } else Callee = DAG.getTargetGlobalAddress(GV, getPointerTy()); - } else if (ExternalSymbolSDNode *S = dyn_cast(Callee)) { + } else if (SymbolSDNode *S = dyn_cast(Callee)) { isDirect = true; bool isStub = Subtarget->isTargetDarwin() && getTargetMachine().getRelocationModel() != Reloc::Static; @@ -574,7 +574,7 @@ SDValue ARMTargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) { SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex++, MVT::i32); Callee = DAG.getNode(ARMISD::PIC_ADD, getPointerTy(), Callee, PICLabel); } else - Callee = DAG.getTargetExternalSymbol(Sym, getPointerTy()); + Callee = DAG.getTargetSymbol(Sym, getPointerTy(), S->getLinkage()); } // FIXME: handle tail calls differently. @@ -715,12 +715,11 @@ static SDValue LowerRET(SDValue Op, SelectionDAG &DAG) { return DAG.getNode(ARMISD::RET_FLAG, MVT::Other, Copy, Copy.getValue(1)); } -// ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as -// their target countpart wrapped in the ARMISD::Wrapper node. Suppose N is -// one of the above mentioned nodes. It has to be wrapped because otherwise -// Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only -// be used to form addressing mode. These wrapped nodes will be selected -// into MOVi. +// ConstantPool, JumpTable, GlobalAddress, and Symbol are lowered as their +// target countpart wrapped in the ARMISD::Wrapper node. Suppose N is one of the +// above mentioned nodes. It has to be wrapped because otherwise Select(N) +// returns N. So the raw TargetGlobalAddress nodes, etc. can only be used to +// form addressing mode. These wrapped nodes will be selected into MOVi. static SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) { MVT PtrVT = Op.getValueType(); ConstantPoolSDNode *CP = cast(Op); @@ -760,7 +759,7 @@ ARMTargetLowering::LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA, std::pair CallResult = LowerCallTo(Chain, (const Type *) Type::Int32Ty, false, false, false, CallingConv::C, false, - DAG.getExternalSymbol("__tls_get_addr", PtrVT), Args, DAG); + DAG.getSymbol("__tls_get_addr", PtrVT), Args, DAG); return CallResult.first; } diff --git a/lib/Target/Alpha/AlphaISelLowering.cpp b/lib/Target/Alpha/AlphaISelLowering.cpp index 5b7d1251a6e..26bc70a39b5 100644 --- a/lib/Target/Alpha/AlphaISelLowering.cpp +++ b/lib/Target/Alpha/AlphaISelLowering.cpp @@ -125,12 +125,11 @@ AlphaTargetLowering::AlphaTargetLowering(TargetMachine &TM) : TargetLowering(TM) setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand); setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i64, Expand); - // We want to legalize GlobalAddress and ConstantPool and - // ExternalSymbols nodes into the appropriate instructions to - // materialize the address. + // We want to legalize GlobalAddress and ConstantPool and Symbols nodes into + // the appropriate instructions to materialize the address. setOperationAction(ISD::GlobalAddress, MVT::i64, Custom); setOperationAction(ISD::ConstantPool, MVT::i64, Custom); - setOperationAction(ISD::ExternalSymbol, MVT::i64, Custom); + setOperationAction(ISD::Symbol, MVT::i64, Custom); setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom); setOperationAction(ISD::VASTART, MVT::Other, Custom); @@ -491,13 +490,13 @@ SDValue AlphaTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) { return DAG.getNode(AlphaISD::RelLit, MVT::i64, GA, DAG.getNode(ISD::GLOBAL_OFFSET_TABLE, MVT::i64)); } - case ISD::ExternalSymbol: { + case ISD::Symbol: { + SymbolSDNode *S = cast(Op); return DAG.getNode(AlphaISD::RelLit, MVT::i64, - DAG.getTargetExternalSymbol(cast(Op) - ->getSymbol(), MVT::i64), + DAG.getTargetSymbol(S->getSymbol(), MVT::i64, + S->getLinkage()), DAG.getNode(ISD::GLOBAL_OFFSET_TABLE, MVT::i64)); } - case ISD::UREM: case ISD::SREM: //Expand only on constant case @@ -526,7 +525,7 @@ SDValue AlphaTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) { } SDValue Tmp1 = Op.getOperand(0), Tmp2 = Op.getOperand(1), - Addr = DAG.getExternalSymbol(opstr, MVT::i64); + Addr = DAG.getSymbol(opstr, MVT::i64); return DAG.getNode(AlphaISD::DivCall, MVT::i64, Addr, Tmp1, Tmp2); } break; diff --git a/lib/Target/CellSPU/SPUISelLowering.cpp b/lib/Target/CellSPU/SPUISelLowering.cpp index 384755d6657..b97f4c4c2b9 100644 --- a/lib/Target/CellSPU/SPUISelLowering.cpp +++ b/lib/Target/CellSPU/SPUISelLowering.cpp @@ -92,12 +92,12 @@ namespace { || Opc == ISD::GlobalTLSAddress || Opc == ISD::JumpTable || Opc == ISD::ConstantPool - || Opc == ISD::ExternalSymbol + || Opc == ISD::Symbol || Opc == ISD::TargetGlobalAddress || Opc == ISD::TargetGlobalTLSAddress || Opc == ISD::TargetJumpTable || Opc == ISD::TargetConstantPool - || Opc == ISD::TargetExternalSymbol + || Opc == ISD::TargetSymbol || Opc == SPUISD::AFormAddr); } @@ -1201,9 +1201,9 @@ LowerCALL(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST) { SmallVector Ops; unsigned CallOpc = SPUISD::CALL; - // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every - // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol - // node so that legalize doesn't hack it. + // If the callee is a GlobalAddress/Symbol node (quite common, every direct + // call is) turn it into a TargetGlobalAddress/TargetSymbol node so that + // legalize doesn't hack it. if (GlobalAddressSDNode *G = dyn_cast(Callee)) { GlobalValue *GV = G->getGlobal(); MVT CalleeVT = Callee.getValueType(); @@ -1229,8 +1229,9 @@ LowerCALL(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST) { // address pairs: Callee = DAG.getNode(SPUISD::IndirectAddr, PtrVT, GA, Zero); } - } else if (ExternalSymbolSDNode *S = dyn_cast(Callee)) - Callee = DAG.getExternalSymbol(S->getSymbol(), Callee.getValueType()); + } else if (SymbolSDNode *S = dyn_cast(Callee)) + Callee = DAG.getSymbol(S->getSymbol(), Callee.getValueType(), + S->getLinkage()); else if (SDNode *Dest = isLSAAddress(Callee, DAG)) { // If this is an absolute destination address that appears to be a legal // local store address, use the munged value. diff --git a/lib/Target/IA64/IA64ISelDAGToDAG.cpp b/lib/Target/IA64/IA64ISelDAGToDAG.cpp index f79496db77d..19ea4728682 100644 --- a/lib/Target/IA64/IA64ISelDAGToDAG.cpp +++ b/lib/Target/IA64/IA64ISelDAGToDAG.cpp @@ -329,7 +329,7 @@ SDNode *IA64DAGToDAGISel::Select(SDValue Op) { dyn_cast(N->getOperand(1))) { CallOpcode = IA64::BRCALL_IPREL_GA; CallOperand = CurDAG->getTargetGlobalAddress(GASD->getGlobal(), MVT::i64); - } else if (isa(N->getOperand(1))) { + } else if (isa(N->getOperand(1))) { // FIXME: we currently NEED this case for correctness, to avoid // "non-pic code with imm reloc.n against dynamic symbol" errors CallOpcode = IA64::BRCALL_IPREL_ES; @@ -448,9 +448,9 @@ SDNode *IA64DAGToDAGISel::Select(SDValue Op) { } /* XXX - case ISD::ExternalSymbol: { - SDValue EA = CurDAG->getTargetExternalSymbol( - cast(N)->getSymbol(), + case ISD::Symbol: { + SDValue EA = CurDAG->getTargetSymbol( + cast(N)->getSymbol(), MVT::i64); SDValue Tmp = CurDAG->getTargetNode(IA64::ADDL_EA, MVT::i64, CurDAG->getRegister(IA64::r1, diff --git a/lib/Target/Mips/MipsISelDAGToDAG.cpp b/lib/Target/Mips/MipsISelDAGToDAG.cpp index a408a9623ca..82c20f7595f 100644 --- a/lib/Target/Mips/MipsISelDAGToDAG.cpp +++ b/lib/Target/Mips/MipsISelDAGToDAG.cpp @@ -159,7 +159,7 @@ SelectAddr(SDValue Op, SDValue Addr, SDValue &Offset, SDValue &Base) return true; } } else { - if ((Addr.getOpcode() == ISD::TargetExternalSymbol || + if ((Addr.getOpcode() == ISD::TargetSymbol || Addr.getOpcode() == ISD::TargetGlobalAddress)) return false; } @@ -354,7 +354,7 @@ Select(SDValue N) SDValue InFlag(0, 0); if ( (isa(Callee)) || - (isa(Callee)) ) + (isa(Callee)) ) { /// Direct call for global addresses and external symbols SDValue GPReg = CurDAG->getRegister(Mips::GP, MVT::i32); diff --git a/lib/Target/Mips/MipsISelLowering.cpp b/lib/Target/Mips/MipsISelLowering.cpp index 557a1050c6d..b1fe262337d 100644 --- a/lib/Target/Mips/MipsISelLowering.cpp +++ b/lib/Target/Mips/MipsISelLowering.cpp @@ -684,14 +684,14 @@ LowerCALL(SDValue Op, SelectionDAG &DAG) InFlag = Chain.getValue(1); } - // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every - // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol - // node so that legalize doesn't hack it. + // If the callee is a GlobalAddress/Symbol node (quite common, every direct + // call is) turn it into a TargetGlobalAddress/TargetSymbol node so that + // legalize doesn't hack it. if (GlobalAddressSDNode *G = dyn_cast(Callee)) Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy()); - else if (ExternalSymbolSDNode *S = dyn_cast(Callee)) - Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy()); - + else if (SymbolSDNode *S = dyn_cast(Callee)) + Callee = DAG.getTargetSymbol(S->getSymbol(), getPointerTy(), + S->getLinkage()); // MipsJmpLink = #chain, #target_address, #opt_in_flags... // = Chain, Callee, Reg#1, Reg#2, ... diff --git a/lib/Target/PowerPC/PPCISelLowering.cpp b/lib/Target/PowerPC/PPCISelLowering.cpp index 1a891d93f56..6de90d9ec3a 100644 --- a/lib/Target/PowerPC/PPCISelLowering.cpp +++ b/lib/Target/PowerPC/PPCISelLowering.cpp @@ -2462,13 +2462,14 @@ SDValue PPCTargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG, SmallVector Ops; unsigned CallOpc = isMachoABI? PPCISD::CALL_Macho : PPCISD::CALL_ELF; - // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every - // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol - // node so that legalize doesn't hack it. + // If the callee is a GlobalAddress/Symbol node (quite common, every direct + // call is) turn it into a TargetGlobalAddress/TargetSymbol node so that + // legalize doesn't hack it. if (GlobalAddressSDNode *G = dyn_cast(Callee)) Callee = DAG.getTargetGlobalAddress(G->getGlobal(), Callee.getValueType()); - else if (ExternalSymbolSDNode *S = dyn_cast(Callee)) - Callee = DAG.getTargetExternalSymbol(S->getSymbol(), Callee.getValueType()); + else if (SymbolSDNode *S = dyn_cast(Callee)) + Callee = DAG.getTargetSymbol(S->getSymbol(), Callee.getValueType(), + S->getLinkage()); else if (SDNode *Dest = isBLACompatibleAddress(Callee, DAG)) // If this is an absolute destination address, use the munged value. Callee = SDValue(Dest, 0); @@ -2593,7 +2594,7 @@ SDValue PPCTargetLowering::LowerRET(SDValue Op, SelectionDAG &DAG, assert(((TargetAddress.getOpcode() == ISD::Register && cast(TargetAddress)->getReg() == PPC::CTR) || - TargetAddress.getOpcode() == ISD::TargetExternalSymbol || + TargetAddress.getOpcode() == ISD::TargetSymbol || TargetAddress.getOpcode() == ISD::TargetGlobalAddress || isa(TargetAddress)) && "Expecting an global address, external symbol, absolute value or register"); @@ -3414,7 +3415,7 @@ SDValue PPCTargetLowering::LowerBUILD_VECTOR(SDValue Op, static SDValue GeneratePerfectShuffle(unsigned PFEntry, SDValue LHS, SDValue RHS, SelectionDAG &DAG) { unsigned OpNum = (PFEntry >> 26) & 0x0F; - unsigned LHSID = (PFEntry >> 13) & ((1 << 13)-1); + unsigned LHSID = (PFEntry >> 13) & ((1 << 13)-1); unsigned RHSID = (PFEntry >> 0) & ((1 << 13)-1); enum { diff --git a/lib/Target/Sparc/SparcISelDAGToDAG.cpp b/lib/Target/Sparc/SparcISelDAGToDAG.cpp index 4a3ca7fa066..ae1176200ad 100644 --- a/lib/Target/Sparc/SparcISelDAGToDAG.cpp +++ b/lib/Target/Sparc/SparcISelDAGToDAG.cpp @@ -77,7 +77,7 @@ bool SparcDAGToDAGISel::SelectADDRri(SDValue Op, SDValue Addr, Offset = CurDAG->getTargetConstant(0, MVT::i32); return true; } - if (Addr.getOpcode() == ISD::TargetExternalSymbol || + if (Addr.getOpcode() == ISD::TargetSymbol || Addr.getOpcode() == ISD::TargetGlobalAddress) return false; // direct calls. @@ -114,7 +114,7 @@ bool SparcDAGToDAGISel::SelectADDRri(SDValue Op, SDValue Addr, bool SparcDAGToDAGISel::SelectADDRrr(SDValue Op, SDValue Addr, SDValue &R1, SDValue &R2) { if (Addr.getOpcode() == ISD::FrameIndex) return false; - if (Addr.getOpcode() == ISD::TargetExternalSymbol || + if (Addr.getOpcode() == ISD::TargetSymbol || Addr.getOpcode() == ISD::TargetGlobalAddress) return false; // direct calls. diff --git a/lib/Target/Sparc/SparcISelLowering.cpp b/lib/Target/Sparc/SparcISelLowering.cpp index d89b6d44ff5..4584bf68b45 100644 --- a/lib/Target/Sparc/SparcISelLowering.cpp +++ b/lib/Target/Sparc/SparcISelLowering.cpp @@ -407,11 +407,11 @@ static SDValue LowerCALL(SDValue Op, SelectionDAG &DAG) { // If the callee is a GlobalAddress node (quite common, every direct call is) // turn it into a TargetGlobalAddress node so that legalize doesn't hack it. - // Likewise ExternalSymbol -> TargetExternalSymbol. + // Likewise Symbol -> TargetSymbol. if (GlobalAddressSDNode *G = dyn_cast(Callee)) Callee = DAG.getTargetGlobalAddress(G->getGlobal(), MVT::i32); - else if (ExternalSymbolSDNode *E = dyn_cast(Callee)) - Callee = DAG.getTargetExternalSymbol(E->getSymbol(), MVT::i32); + else if (SymbolSDNode *S = dyn_cast(Callee)) + Callee = DAG.getTargetSymbol(S->getSymbol(), MVT::i32, S->getLinkage()); std::vector NodeTys; NodeTys.push_back(MVT::Other); // Returns a chain diff --git a/lib/Target/TargetSelectionDAG.td b/lib/Target/TargetSelectionDAG.td index 230c9565a2f..a3088ba6fcd 100644 --- a/lib/Target/TargetSelectionDAG.td +++ b/lib/Target/TargetSelectionDAG.td @@ -265,10 +265,10 @@ def frameindex : SDNode<"ISD::FrameIndex", SDTPtrLeaf, [], "FrameIndexSDNode">; def tframeindex : SDNode<"ISD::TargetFrameIndex", SDTPtrLeaf, [], "FrameIndexSDNode">; -def externalsym : SDNode<"ISD::ExternalSymbol", SDTPtrLeaf, [], - "ExternalSymbolSDNode">; -def texternalsym: SDNode<"ISD::TargetExternalSymbol", SDTPtrLeaf, [], - "ExternalSymbolSDNode">; +def externalsym : SDNode<"ISD::Symbol", SDTPtrLeaf, [], + "SymbolSDNode">; +def texternalsym: SDNode<"ISD::TargetSymbol", SDTPtrLeaf, [], + "SymbolSDNode">; def add : SDNode<"ISD::ADD" , SDTIntBinOp , [SDNPCommutative, SDNPAssociative]>; diff --git a/lib/Target/X86/X86ISelDAGToDAG.cpp b/lib/Target/X86/X86ISelDAGToDAG.cpp index dedd8908da0..e9664670f84 100644 --- a/lib/Target/X86/X86ISelDAGToDAG.cpp +++ b/lib/Target/X86/X86ISelDAGToDAG.cpp @@ -207,7 +207,7 @@ namespace { Disp = CurDAG->getTargetConstantPool(AM.CP, MVT::i32, AM.Align, AM.Disp); else if (AM.ES) - Disp = CurDAG->getTargetExternalSymbol(AM.ES, MVT::i32); + Disp = CurDAG->getTargetSymbol(AM.ES, MVT::i32); else if (AM.JT != -1) Disp = CurDAG->getTargetJumpTable(AM.JT, MVT::i32); else @@ -835,7 +835,7 @@ DOUT << "AlreadySelected " << AlreadySelected << "\n"; AM.isRIPRel = TM.getRelocationModel() != Reloc::Static && Subtarget->isPICStyleRIPRel(); return false; - } else if (ExternalSymbolSDNode *S =dyn_cast(N0)) { + } else if (SymbolSDNode *S = dyn_cast(N0)) { AM.ES = S->getSymbol(); AM.isRIPRel = TM.getRelocationModel() != Reloc::Static && Subtarget->isPICStyleRIPRel(); @@ -1292,7 +1292,7 @@ SDNode *X86DAGToDAGISel::Select(SDValue N) { N1.getOpcode() == ISD::Constant) { unsigned Offset = (unsigned)cast(N1)->getZExtValue(); SDValue C(0, 0); - // TODO: handle ExternalSymbolSDNode. + // TODO: handle SymbolSDNode. if (GlobalAddressSDNode *G = dyn_cast(N0.getOperand(0))) { C = CurDAG->getTargetGlobalAddress(G->getGlobal(), PtrVT, diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp index 3401a2c4d35..8f7f4ab11a3 100644 --- a/lib/Target/X86/X86ISelLowering.cpp +++ b/lib/Target/X86/X86ISelLowering.cpp @@ -268,12 +268,12 @@ X86TargetLowering::X86TargetLowering(X86TargetMachine &TM) setOperationAction(ISD::GlobalTLSAddress, MVT::i32 , Custom); if (Subtarget->is64Bit()) setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom); - setOperationAction(ISD::ExternalSymbol , MVT::i32 , Custom); + setOperationAction(ISD::Symbol , MVT::i32 , Custom); if (Subtarget->is64Bit()) { setOperationAction(ISD::ConstantPool , MVT::i64 , Custom); setOperationAction(ISD::JumpTable , MVT::i64 , Custom); setOperationAction(ISD::GlobalAddress , MVT::i64 , Custom); - setOperationAction(ISD::ExternalSymbol, MVT::i64 , Custom); + setOperationAction(ISD::Symbol , MVT::i64 , Custom); } // 64-bit addm sub, shl, sra, srl (iff 32-bit x86) setOperationAction(ISD::SHL_PARTS , MVT::i32 , Custom); @@ -892,7 +892,7 @@ SDValue X86TargetLowering::LowerRET(SDValue Op, SelectionDAG &DAG) { assert(((TargetAddress.getOpcode() == ISD::Register && (cast(TargetAddress)->getReg() == X86::ECX || cast(TargetAddress)->getReg() == X86::R9)) || - TargetAddress.getOpcode() == ISD::TargetExternalSymbol || + TargetAddress.getOpcode() == ISD::TargetSymbol || TargetAddress.getOpcode() == ISD::TargetGlobalAddress) && "Expecting an global address, external symbol, or register"); assert(StackAdjustment.getOpcode() == ISD::Constant && @@ -1608,8 +1608,8 @@ SDValue X86TargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) { if (G && !G->getGlobal()->hasHiddenVisibility() && !G->getGlobal()->hasProtectedVisibility()) Callee = LowerGlobalAddress(Callee, DAG); - else if (isa(Callee)) - Callee = LowerExternalSymbol(Callee,DAG); + else if (isa(Callee)) + Callee = LowerExternalSymbol(Callee, DAG); } if (Is64Bit && isVarArg) { @@ -1697,8 +1697,9 @@ SDValue X86TargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) { if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(), getTargetMachine(), true)) Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy()); - } else if (ExternalSymbolSDNode *S = dyn_cast(Callee)) { - Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy()); + } else if (SymbolSDNode *S = dyn_cast(Callee)) { + Callee = DAG.getTargetSymbol(S->getSymbol(), getPointerTy(), + S->getLinkage()); } else if (IsTailCall) { unsigned Opc = Is64Bit ? X86::R9 : X86::ECX; @@ -4286,12 +4287,11 @@ X86TargetLowering::LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) { DAG.getNode(ISD::SCALAR_TO_VECTOR, VT, AnyExt)); } -// ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as -// their target countpart wrapped in the X86ISD::Wrapper node. Suppose N is -// one of the above mentioned nodes. It has to be wrapped because otherwise -// Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only -// be used to form addressing mode. These wrapped nodes will be selected -// into MOV32ri. +// ConstantPool, JumpTable, GlobalAddress, and Symbol are lowered as their +// target countpart wrapped in the X86ISD::Wrapper node. Suppose N is one of the +// above mentioned nodes. It has to be wrapped because otherwise Select(N) +// returns N. So the raw TargetGlobalAddress nodes, etc. can only be used to +// form addressing mode. These wrapped nodes will be selected into MOV32ri. SDValue X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) { ConstantPoolSDNode *CP = cast(Op); @@ -4362,8 +4362,7 @@ LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG, NodeTys = DAG.getVTList(MVT::Other, MVT::Flag); SDValue Ops1[] = { Chain, - DAG.getTargetExternalSymbol("___tls_get_addr", - PtrVT), + DAG.getTargetSymbol("___tls_get_addr", PtrVT), DAG.getRegister(X86::EAX, PtrVT), DAG.getRegister(X86::EBX, PtrVT), InFlag }; @@ -4396,8 +4395,7 @@ LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG, NodeTys = DAG.getVTList(MVT::Other, MVT::Flag); SDValue Ops1[] = { Chain, - DAG.getTargetExternalSymbol("__tls_get_addr", - PtrVT), + DAG.getTargetSymbol("__tls_get_addr", PtrVT), DAG.getRegister(X86::RDI, PtrVT), InFlag }; Chain = DAG.getNode(X86ISD::CALL, NodeTys, Ops1, 4); @@ -4449,8 +4447,9 @@ X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) { SDValue X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) { - const char *Sym = cast(Op)->getSymbol(); - SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy()); + SymbolSDNode *Sym = cast(Op); + SDValue Result = DAG.getTargetSymbol(Sym->getSymbol(), getPointerTy(), + Sym->getLinkage()); Result = DAG.getNode(X86ISD::Wrapper, getPointerTy(), Result); // With PIC, the address is actually $g + Offset. if (getTargetMachine().getRelocationModel() == Reloc::PIC_ && @@ -5054,7 +5053,7 @@ X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op, SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Flag); SDValue Ops[] = { Chain, - DAG.getTargetExternalSymbol("_alloca", IntPtr), + DAG.getTargetSymbol("_alloca", IntPtr), DAG.getRegister(X86::EAX, IntPtr), DAG.getRegister(X86StackPtr, SPTy), Flag }; @@ -5104,7 +5103,7 @@ X86TargetLowering::EmitTargetCodeForMemset(SelectionDAG &DAG, Args.push_back(Entry); std::pair CallResult = LowerCallTo(Chain, Type::VoidTy, false, false, false, CallingConv::C, - false, DAG.getExternalSymbol(bzeroEntry, IntPtr), + false, DAG.getSymbol(bzeroEntry, IntPtr), Args, DAG); return CallResult.second; } @@ -5977,7 +5976,7 @@ SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) { case ISD::ConstantPool: return LowerConstantPool(Op, DAG); case ISD::GlobalAddress: return LowerGlobalAddress(Op, DAG); case ISD::GlobalTLSAddress: return LowerGlobalTLSAddress(Op, DAG); - case ISD::ExternalSymbol: return LowerExternalSymbol(Op, DAG); + case ISD::Symbol: return LowerExternalSymbol(Op, DAG); case ISD::SHL_PARTS: case ISD::SRA_PARTS: case ISD::SRL_PARTS: return LowerShift(Op, DAG); diff --git a/lib/Target/X86/X86ISelLowering.h b/lib/Target/X86/X86ISelLowering.h index 221276743a5..8982f11073d 100644 --- a/lib/Target/X86/X86ISelLowering.h +++ b/lib/Target/X86/X86ISelLowering.h @@ -145,8 +145,8 @@ namespace llvm { /// at function entry, used for PIC code. GlobalBaseReg, - /// Wrapper - A wrapper node for TargetConstantPool, - /// TargetExternalSymbol, and TargetGlobalAddress. + /// Wrapper - A wrapper node for TargetConstantPool, TargetSymbol, and + /// TargetGlobalAddress. Wrapper, /// WrapperRIP - Special wrapper used under X86-64 PIC mode for RIP diff --git a/lib/Target/X86/X86Instr64bit.td b/lib/Target/X86/X86Instr64bit.td index 88a8c0803fa..c02e5357ee3 100644 --- a/lib/Target/X86/X86Instr64bit.td +++ b/lib/Target/X86/X86Instr64bit.td @@ -1192,7 +1192,7 @@ def ATOMUMAX64: I<0, Pseudo, (outs GR64:$dst),(ins i64mem:$ptr, GR64:$val), // Non-Instruction Patterns //===----------------------------------------------------------------------===// -// ConstantPool GlobalAddress, ExternalSymbol, and JumpTable +// ConstantPool GlobalAddress, Symbol, and JumpTable def : Pat<(i64 (X86Wrapper tconstpool :$dst)), (MOV64ri tconstpool :$dst)>, Requires<[NotSmallCode]>; def : Pat<(i64 (X86Wrapper tjumptable :$dst)), diff --git a/lib/Target/X86/X86InstrInfo.td b/lib/Target/X86/X86InstrInfo.td index 1b68dda4484..2f37cc1110e 100644 --- a/lib/Target/X86/X86InstrInfo.td +++ b/lib/Target/X86/X86InstrInfo.td @@ -2703,7 +2703,7 @@ def ATOMNAND8 : I<0, Pseudo,(outs GR8:$dst),(ins i8mem:$ptr, GR8:$val), // Non-Instruction Patterns //===----------------------------------------------------------------------===// -// ConstantPool GlobalAddress, ExternalSymbol, and JumpTable +// ConstantPool GlobalAddress, Symbol, and JumpTable def : Pat<(i32 (X86Wrapper tconstpool :$dst)), (MOV32ri tconstpool :$dst)>; def : Pat<(i32 (X86Wrapper tjumptable :$dst)), (MOV32ri tjumptable :$dst)>; def : Pat<(i32 (X86Wrapper tglobaltlsaddr:$dst)),(MOV32ri tglobaltlsaddr:$dst)>; diff --git a/utils/TableGen/DAGISelEmitter.cpp b/utils/TableGen/DAGISelEmitter.cpp index e4a3f098d35..38c4191986b 100644 --- a/utils/TableGen/DAGISelEmitter.cpp +++ b/utils/TableGen/DAGISelEmitter.cpp @@ -802,11 +802,11 @@ public: NodeOps.push_back(Val); } else if (!N->isLeaf() && N->getOperator()->getName() == "texternalsym"){ Record *Op = OperatorMap[N->getName()]; - // Transform ExternalSymbol to TargetExternalSymbol + // Transform Symbol to TargetSymbol if (Op && Op->getName() == "externalsym") { std::string TmpVar = "Tmp"+utostr(ResNo); emitCode("SDValue " + TmpVar + " = CurDAG->getTarget" - "ExternalSymbol(cast(" + + "Symbol(cast(" + Val + ")->getSymbol(), " + getEnumName(N->getTypeNum(0)) + ");"); // Add Tmp to VariableMap, so that we don't multiply select @@ -1949,7 +1949,7 @@ void DAGISelEmitter::EmitInstructionSelector(std::ostream &OS) { << " case ISD::TargetConstantFP:\n" << " case ISD::TargetConstantPool:\n" << " case ISD::TargetFrameIndex:\n" - << " case ISD::TargetExternalSymbol:\n" + << " case ISD::TargetSymbol:\n" << " case ISD::TargetJumpTable:\n" << " case ISD::TargetGlobalTLSAddress:\n" << " case ISD::TargetGlobalAddress: {\n"