- Change "ExternalSymbolSDNode" to "SymbolSDNode".

- Add linkage to SymbolSDNode (default to external).
- Change ISD::ExternalSymbol to ISD::Symbol.
- Change ISD::TargetExternalSymbol to ISD::TargetSymbol

These changes pave the way to allowing SymbolSDNodes with non-external linkage.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@56249 91177308-0d34-0410-b5e6-96231b3b80d8

25 files changed, 168 insertions, 150 deletions

diff --git a/include/llvm/CodeGen/ScheduleDAG.h b/include/llvm/CodeGen/ScheduleDAG.h
index 67f3dbb69f..bca5712737 100644
--- a/include/llvm/CodeGen/ScheduleDAG.h
+++ b/include/llvm/CodeGen/ScheduleDAG.h
@@ -278,7 +278,7 @@ namespace llvm {
       if (isa<FrameIndexSDNode>(Node))     return true;
       if (isa<ConstantPoolSDNode>(Node))   return true;
       if (isa<JumpTableSDNode>(Node))      return true;
-      if (isa<ExternalSymbolSDNode>(Node)) return true;
+      if (isa<SymbolSDNode>(Node))         return true;
       if (isa<MemOperandSDNode>(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 15d0edc3d8..b2611dfa79 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<SDNode*> ValueTypeNodes;
   std::map<MVT, SDNode*, MVT::compareRawBits> ExtendedValueTypeNodes;
-  StringMap<SDNode*> ExternalSymbols;
-  StringMap<SDNode*> TargetExternalSymbols;
+  StringMap<SDNode*> Symbols;
+  StringMap<SDNode*> TargetSymbols;
 };
 
 template <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> {
diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h
index 7cd9eef2ab..4ba5603fab 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 ba78b8166a..741e3f78c6 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<SDValue,SDValue> 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 640392f26c..9a05501234 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<SDValue,SDValue> CallInfo =
diff --git a/lib/CodeGen/SelectionDAG/ScheduleDAGEmit.cpp b/lib/CodeGen/SelectionDAG/ScheduleDAGEmit.cpp
index 156905a708..52428cb425 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<ExternalSymbolSDNode>(Op)) {
+  } else if (SymbolSDNode *ES = dyn_cast<SymbolSDNode>(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<ExternalSymbolSDNode>(Node->getOperand(1))->getSymbol();
+    const char *AsmStr = cast<SymbolSDNode>(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 793f5c9997..9e42307fbe 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<CondCodeSDNode>(N)->get()] != 0;
     CondCodeNodes[cast<CondCodeSDNode>(N)->get()] = 0;
     break;
-  case ISD::ExternalSymbol:
-    Erased = ExternalSymbols.erase(cast<ExternalSymbolSDNode>(N)->getSymbol());
+  case ISD::Symbol:
+    Erased = Symbols.erase(cast<SymbolSDNode>(N)->getSymbol());
     break;
-  case ISD::TargetExternalSymbol:
-    Erased =
-      TargetExternalSymbols.erase(cast<ExternalSymbolSDNode>(N)->getSymbol());
+  case ISD::TargetSymbol:
+    Erased = TargetSymbols.erase(cast<SymbolSDNode>(N)->getSymbol());
     break;
   case ISD::VALUETYPE: {
     MVT VT = cast<VTSDNode>(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<CondCodeSDNode*>(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<ExternalSymbolSDNode>();
-  new (N) ExternalSymbolSDNode(false, Sym, VT);
+  N = NodeAllocator.Allocate<SymbolSDNode>();
+  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<ExternalSymbolSDNode>();
-  new (N) ExternalSymbolSDNode(true, Sym, VT);
+  N = NodeAllocator.Allocate<SymbolSDNode>();
+  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<SDValue,SDValue> 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<SDValue,SDValue> 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<SDValue,SDValue> 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<ConstantSDNode>(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<ExternalSymbolSDNode>(this)) {
-    OS << "'" << ES->getSymbol() << "'";
+  } else if (const SymbolSDNode *S =
+             dyn_cast<SymbolSDNode>(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<SrcValueSDNode>(this)) {
     if (M->getValue())
       OS << "<" << M->getValue() << ">";
diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp
index 62a6b4f180..f82fd340ff 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<SDValue> 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<SDValue,SDValue> 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<SDValue,SDValue> 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 570caa9701..aca115fd84 100644
--- a/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp
@@ -185,9 +185,8 @@ std::string DOTGraphTraits<SelectionDAG*>::getNodeLabel(const SDNode *Node,
       Op += ", isVarArg";
     if (C->isTailCall())
       Op += ", isTailCall";
-  } else if (const ExternalSymbolSDNode *ES =
-             dyn_cast<ExternalSymbolSDNode>(Node)) {
-    Op += "'" + std::string(ES->getSymbol()) + "'";
+  } else if (const SymbolSDNode *S = dyn_cast<SymbolSDNode>(Node)) {
+    Op += "'" + std::string(S->getSymbol()) + "'";
   } else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(Node)) {
     if (M->getValue())
       Op += "<" + M->getValue()->getName() + ">";
diff --git a/lib/Target/ARM/ARMISelLowering.cpp b/lib/Target/ARM/ARMISelLowering.cpp
index 2202177e18..4131903edb 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<ExternalSymbolSDNode>(Callee)) {
+  } else if (SymbolSDNode *S = dyn_cast<SymbolSDNode>(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<ConstantPoolSDNode>(Op);
@@ -760,7 +759,7 @@ ARMTargetLowering::LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
   std::pair<SDValue, SDValue> 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 5b7d1251a6..26bc70a39b 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<SymbolSDNode>(Op);
     return DAG.getNode(AlphaISD::RelLit, MVT::i64, 
-                       DAG.getTargetExternalSymbol(cast<ExternalSymbolSDNode>(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 384755d665..b97f4c4c2b 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<SDValue, 8> 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<GlobalAddressSDNode>(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<ExternalSymbolSDNode>(Callee))
-    Callee = DAG.getExternalSymbol(S->getSymbol(), Callee.getValueType());
+  } else if (SymbolSDNode *S = dyn_cast<SymbolSDNode>(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 f79496db77..19ea472868 100644
--- a/lib/Target/IA64/IA64ISelDAGToDAG.cpp
+++ b/lib/Target/IA64/IA64ISelDAGToDAG.cpp
@@ -329,7 +329,7 @@ SDNode *IA64DAGToDAGISel::Select(SDValue Op) {
       dyn_cast<GlobalAddressSDNode>(N->getOperand(1))) {
       CallOpcode = IA64::BRCALL_IPREL_GA;
       CallOperand = CurDAG->getTargetGlobalAddress(GASD->getGlobal(), MVT::i64);
-    } else if (isa<ExternalSymbolSDNode>(N->getOperand(1))) {
+    } else if (isa<SymbolSDNode>(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<ExternalSymbolSDNode>(N)->getSymbol(),
+   case ISD::Symbol: {
+     SDValue EA = CurDAG->getTargetSymbol(
+       cast<SymbolSDNode>(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 a408a9623c..82c20f7595 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<GlobalAddressSDNode>(Callee)) ||
-             (isa<ExternalSymbolSDNode>(Callee)) )
+             (isa<SymbolSDNode>(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 557a1050c6..b1fe262337 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<GlobalAddressSDNode>(Callee)) 
     Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
-  else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
-    Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());
-
+  else if (SymbolSDNode *S = dyn_cast<SymbolSDNode>(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 1a891d93f5..6de90d9ec3 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<SDValue, 8> Op