RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-02 08:26:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Reverting r56249. On further investigation, this functionality isn't needed.

Browse Source 
Apologies for the thrashing.

llvm-svn: 56251
This commit is contained in:
Bill Wendling 2008-09-16 21:48:12 +00:00
parent 6da3227304
commit 932818c75a
25 changed files with 151 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/CodeGen/ScheduleDAG.h
View File

@ -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<SymbolSDNode>(Node)) return true;
if (isa<ExternalSymbolSDNode>(Node)) return true;
if (isa<MemOperandSDNode>(Node)) return true;
if (Node->getOpcode() == ISD::EntryToken) return true;
return false;

11
include/llvm/CodeGen/SelectionDAG.h
View File

@ -282,11 +282,8 @@ public:
return getConstantPool(C, VT, Align, Offset, true);
}
SDValue getBasicBlock(MachineBasicBlock *MBB);
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 getExternalSymbol(const char *Sym, MVT VT);
SDValue getTargetExternalSymbol(const char *Sym, MVT VT);
SDValue getArgFlags(ISD::ArgFlagsTy Flags);
SDValue getValueType(MVT);
SDValue getRegister(unsigned Reg, MVT VT);
@ -761,8 +758,8 @@ private:
std::vector<SDNode*> ValueTypeNodes;
std::map<MVT, SDNode*, MVT::compareRawBits> ExtendedValueTypeNodes;
StringMap<SDNode*> Symbols;
StringMap<SDNode*> TargetSymbols;
StringMap<SDNode*> ExternalSymbols;
StringMap<SDNode*> TargetExternalSymbols;
};
template <> struct GraphTraits<SelectionDAG*> : public GraphTraits<SDNode*> {

28
include/llvm/CodeGen/SelectionDAGNodes.h
View File

@ -21,7 +21,6 @@
#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"
@ -90,7 +89,7 @@ namespace ISD {
BasicBlock, VALUETYPE, ARG_FLAGS, CONDCODE, Register,
Constant, ConstantFP,
GlobalAddress, GlobalTLSAddress, FrameIndex,
JumpTable, ConstantPool, Symbol,
JumpTable, ConstantPool, ExternalSymbol,
// The address of the GOT
GLOBAL_OFFSET_TABLE,
@ -134,7 +133,7 @@ namespace ISD {
TargetFrameIndex,
TargetJumpTable,
TargetConstantPool,
TargetSymbol,
TargetExternalSymbol,
/// RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...)
/// This node represents a target intrinsic function with no side effects.
@ -488,7 +487,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 SymbolSDNode with a pointer to the asm string.
// Operand #1 : a ExternalSymbolSDNode 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.
@ -2046,24 +2045,23 @@ public:
}
};
class SymbolSDNode : public SDNode {
class ExternalSymbolSDNode : 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;
SymbolSDNode(bool isTarget, const char *Sym, MVT VT,
GlobalValue::LinkageTypes L)
: SDNode(isTarget ? ISD::TargetSymbol : ISD::Symbol,
getSDVTList(VT)), Symbol(Sym), Linkage(L) {}
ExternalSymbolSDNode(bool isTarget, const char *Sym, MVT VT)
: SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol,
getSDVTList(VT)), Symbol(Sym) {
}
public:
const char *getSymbol() const { return Symbol; }
GlobalValue::LinkageTypes getLinkage() const { return Linkage; }
static bool classof(const SymbolSDNode *) { return true; }
const char *getSymbol() const { return Symbol; }
static bool classof(const ExternalSymbolSDNode *) { return true; }
static bool classof(const SDNode *N) {
return N->getOpcode() == ISD::Symbol ||
N->getOpcode() == ISD::TargetSymbol;
return N->getOpcode() == ISD::ExternalSymbol ||
N->getOpcode() == ISD::TargetExternalSymbol;
}
};

11
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
View File

@ -799,7 +799,7 @@ SDValue SelectionDAGLegalize::LegalizeOp(SDValue Op) {
case ISD::TargetConstantPool:
case ISD::TargetGlobalAddress:
case ISD::TargetGlobalTLSAddress:
case ISD::TargetSymbol:
case ISD::TargetExternalSymbol:
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::Symbol:
case ISD::ExternalSymbol:
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.getSymbol("abort", TLI.getPointerTy()),
DAG.getExternalSymbol("abort", TLI.getPointerTy()),
Args, DAG);
Result = CallResult.second;
break;
@ -5293,9 +5293,8 @@ SDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, SDNode *Node,
Entry.isZExt = !isSigned;
Args.push_back(Entry);
}
SDValue Callee = DAG.getSymbol(TLI.getLibcallName(LC),
TLI.getPointerTy());
SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
TLI.getPointerTy());
// Splice the libcall in wherever FindInputOutputChains tells us to.
const Type *RetTy = Node->getValueType(0).getTypeForMVT();

4
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp
View File

@ -623,8 +623,8 @@ SDValue DAGTypeLegalizer::MakeLibCall(RTLIB::Libcall LC, MVT RetVT,
Entry.isZExt = !isSigned;
Args.push_back(Entry);
}
SDValue Callee = DAG.getSymbol(TLI.getLibcallName(LC), TLI.getPointerTy());
SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
TLI.getPointerTy());
const Type *RetTy = RetVT.getTypeForMVT();
std::pair<SDValue,SDValue> CallInfo =

5
lib/CodeGen/SelectionDAG/ScheduleDAGEmit.cpp
View File

@ -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 (SymbolSDNode *ES = dyn_cast<SymbolSDNode>(Op)) {
} else if (ExternalSymbolSDNode *ES = dyn_cast<ExternalSymbolSDNode>(Op)) {
MI->addOperand(MachineOperand::CreateES(ES->getSymbol()));
} else {
assert(Op.getValueType() != MVT::Other &&
@ -571,7 +571,8 @@ 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<SymbolSDNode>(Node->getOperand(1))->getSymbol();
const char *AsmStr =
cast<ExternalSymbolSDNode>(Node->getOperand(1))->getSymbol();
MI->addOperand(MachineOperand::CreateES(AsmStr));
// Add all of the operand registers to the instruction.

71
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -614,11 +614,12 @@ bool SelectionDAG::RemoveNodeFromCSEMaps(SDNode *N) {
Erased = CondCodeNodes[cast<CondCodeSDNode>(N)->get()] != 0;
CondCodeNodes[cast<CondCodeSDNode>(N)->get()] = 0;
break;
case ISD::Symbol:
Erased = Symbols.erase(cast<SymbolSDNode>(N)->getSymbol());
case ISD::ExternalSymbol:
Erased = ExternalSymbols.erase(cast<ExternalSymbolSDNode>(N)->getSymbol());
break;
case ISD::TargetSymbol:
Erased = TargetSymbols.erase(cast<SymbolSDNode>(N)->getSymbol());
case ISD::TargetExternalSymbol:
Erased =
TargetExternalSymbols.erase(cast<ExternalSymbolSDNode>(N)->getSymbol());
break;
case ISD::VALUETYPE: {
MVT VT = cast<VTSDNode>(N)->getVT();
@ -841,8 +842,8 @@ void SelectionDAG::clear() {
CSEMap.clear();
ExtendedValueTypeNodes.clear();
Symbols.clear();
TargetSymbols.clear();
ExternalSymbols.clear();
TargetExternalSymbols.clear();
std::fill(CondCodeNodes.begin(), CondCodeNodes.end(),
static_cast<CondCodeSDNode*>(0));
std::fill(ValueTypeNodes.begin(), ValueTypeNodes.end(),
@ -1097,22 +1098,20 @@ SDValue SelectionDAG::getValueType(MVT VT) {
return SDValue(N, 0);
}
SDValue SelectionDAG::getSymbol(const char *Sym, MVT VT,
GlobalValue::LinkageTypes LT) {
SDNode *&N = Symbols[Sym];
SDValue SelectionDAG::getExternalSymbol(const char *Sym, MVT VT) {
SDNode *&N = ExternalSymbols[Sym];
if (N) return SDValue(N, 0);
N = NodeAllocator.Allocate<SymbolSDNode>();
new (N) SymbolSDNode(false, Sym, VT, LT);
N = NodeAllocator.Allocate<ExternalSymbolSDNode>();
new (N) ExternalSymbolSDNode(false, Sym, VT);
AllNodes.push_back(N);
return SDValue(N, 0);
}
SDValue SelectionDAG::getTargetSymbol(const char *Sym, MVT VT,
GlobalValue::LinkageTypes LT) {
SDNode *&N = TargetSymbols[Sym];
SDValue SelectionDAG::getTargetExternalSymbol(const char *Sym, MVT VT) {
SDNode *&N = TargetExternalSymbols[Sym];
if (N) return SDValue(N, 0);
N = NodeAllocator.Allocate<SymbolSDNode>();
new (N) SymbolSDNode(true, Sym, VT, LT);
N = NodeAllocator.Allocate<ExternalSymbolSDNode>();
new (N) ExternalSymbolSDNode(true, Sym, VT);
AllNodes.push_back(N);
return SDValue(N, 0);
}
@ -3099,7 +3098,7 @@ SDValue SelectionDAG::getMemcpy(SDValue Chain, SDValue Dst,
std::pair<SDValue,SDValue> CallResult =
TLI.LowerCallTo(Chain, Type::VoidTy,
false, false, false, CallingConv::C, false,
getSymbol("memcpy", TLI.getPointerTy()),
getExternalSymbol("memcpy", TLI.getPointerTy()),
Args, *this);
return CallResult.second;
}
@ -3144,7 +3143,7 @@ SDValue SelectionDAG::getMemmove(SDValue Chain, SDValue Dst,
std::pair<SDValue,SDValue> CallResult =
TLI.LowerCallTo(Chain, Type::VoidTy,
false, false, false, CallingConv::C, false,
getSymbol("memmove", TLI.getPointerTy()),
getExternalSymbol("memmove", TLI.getPointerTy()),
Args, *this);
return CallResult.second;
}
@ -3195,7 +3194,7 @@ SDValue SelectionDAG::getMemset(SDValue Chain, SDValue Dst,
std::pair<SDValue,SDValue> CallResult =
TLI.LowerCallTo(Chain, Type::VoidTy,
false, false, false, CallingConv::C, false,
getSymbol("memset", TLI.getPointerTy()),
getExternalSymbol("memset", TLI.getPointerTy()),
Args, *this);
return CallResult.second;
}
@ -4611,7 +4610,7 @@ void MemOperandSDNode::ANCHOR() {}
void RegisterSDNode::ANCHOR() {}
void DbgStopPointSDNode::ANCHOR() {}
void LabelSDNode::ANCHOR() {}
void SymbolSDNode::ANCHOR() {}
void ExternalSymbolSDNode::ANCHOR() {}
void CondCodeSDNode::ANCHOR() {}
void ARG_FLAGSSDNode::ANCHOR() {}
void VTSDNode::ANCHOR() {}
@ -4915,14 +4914,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::Symbol: return "Symbol";
case ISD::ExternalSymbol: return "ExternalSymbol";
case ISD::INTRINSIC_WO_CHAIN: {
unsigned IID = cast<ConstantSDNode>(getOperand(0))->getZExtValue();
return Intrinsic::getName((Intrinsic::ID)IID);
@ -4941,7 +4940,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::TargetSymbol: return "TargetSymbol";
case ISD::TargetExternalSymbol: return "TargetExternalSymbol";
case ISD::CopyToReg: return "CopyToReg";
case ISD::CopyFromReg: return "CopyFromReg";
@ -5231,23 +5230,9 @@ void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
} else {
OS << " #" << R->getReg();
}
} 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 ExternalSymbolSDNode *ES =
dyn_cast<ExternalSymbolSDNode>(this)) {
OS << "'" << ES->getSymbol() << "'";
} else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
if (M->getValue())
OS << "<" << M->getValue() << ">";

8
lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp
View File

@ -4293,7 +4293,7 @@ void SelectionDAGLowering::visitCall(CallInst &I) {
if (!RenameFn)
Callee = getValue(I.getOperand(0));
else
Callee = DAG.getSymbol(RenameFn, TLI.getPointerTy());
Callee = DAG.getExternalSymbol(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.getTargetSymbol(IA->getAsmString().c_str(), MVT::Other));
DAG.getTargetExternalSymbol(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.getSymbol("malloc", IntPtr),
PerformTailCallOpt, DAG.getExternalSymbol("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.getSymbol("free", IntPtr), Args, DAG);
DAG.getExternalSymbol("free", IntPtr), Args, DAG);
DAG.setRoot(Result.second);
}

5
lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp
View File

@ -186,8 +186,9 @@ std::string DOTGraphTraits<SelectionDAG*>::getNodeLabel(const SDNode *Node,
Op += ", isVarArg";
if (C->isTailCall())
Op += ", isTailCall";
} else if (const SymbolSDNode *S = dyn_cast<SymbolSDNode>(Node)) {
Op += "'" + std::string(S->getSymbol()) + "'";
} else if (const ExternalSymbolSDNode *ES =
dyn_cast<ExternalSymbolSDNode>(Node)) {
Op += "'" + std::string(ES->getSymbol()) + "'";
} else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(Node)) {
if (M->getValue())
Op += "<" + M->getValue()->getName() + ">";

23
lib/Target/ARM/ARMISelLowering.cpp
View File

@ -531,9 +531,9 @@ SDValue ARMTargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) {
InFlag = Chain.getValue(1);
}
// 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 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.
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 (SymbolSDNode *S = dyn_cast<SymbolSDNode>(Callee)) {
} else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(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.getTargetSymbol(Sym, getPointerTy(), S->getLinkage());
Callee = DAG.getTargetExternalSymbol(Sym, getPointerTy());
}
// FIXME: handle tail calls differently.
@ -715,11 +715,12 @@ static SDValue LowerRET(SDValue Op, SelectionDAG &DAG) {
return DAG.getNode(ARMISD::RET_FLAG, MVT::Other, Copy, Copy.getValue(1));
}
// 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.
// 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.
static SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) {
MVT PtrVT = Op.getValueType();
ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
@ -759,7 +760,7 @@ ARMTargetLowering::LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
std::pair<SDValue, SDValue> CallResult =
LowerCallTo(Chain, (const Type *) Type::Int32Ty, false, false, false,
CallingConv::C, false,
DAG.getSymbol("__tls_get_addr", PtrVT), Args, DAG);
DAG.getExternalSymbol("__tls_get_addr", PtrVT), Args, DAG);
return CallResult.first;
}

17
lib/Target/Alpha/AlphaISelLowering.cpp
View File

@ -125,11 +125,12 @@ 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 Symbols nodes into
// the appropriate instructions to materialize the address.
// We want to legalize GlobalAddress and ConstantPool and
// ExternalSymbols nodes into the appropriate instructions to
// materialize the address.
setOperationAction(ISD::GlobalAddress, MVT::i64, Custom);
setOperationAction(ISD::ConstantPool, MVT::i64, Custom);
setOperationAction(ISD::Symbol, MVT::i64, Custom);
setOperationAction(ISD::ExternalSymbol, MVT::i64, Custom);
setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
setOperationAction(ISD::VASTART, MVT::Other, Custom);
@ -490,13 +491,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::Symbol: {
SymbolSDNode *S = cast<SymbolSDNode>(Op);
case ISD::ExternalSymbol: {
return DAG.getNode(AlphaISD::RelLit, MVT::i64,
DAG.getTargetSymbol(S->getSymbol(), MVT::i64,
S->getLinkage()),
DAG.getTargetExternalSymbol(cast<ExternalSymbolSDNode>(Op)
->getSymbol(), MVT::i64),
DAG.getNode(ISD::GLOBAL_OFFSET_TABLE, MVT::i64));
}
case ISD::UREM:
case ISD::SREM:
//Expand only on constant case
@ -525,7 +526,7 @@ SDValue AlphaTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) {
}
SDValue Tmp1 = Op.getOperand(0),
Tmp2 = Op.getOperand(1),
Addr = DAG.getSymbol(opstr, MVT::i64);
Addr = DAG.getExternalSymbol(opstr, MVT::i64);
return DAG.getNode(AlphaISD::DivCall, MVT::i64, Addr, Tmp1, Tmp2);
}
break;

15
lib/Target/CellSPU/SPUISelLowering.cpp
View File

@ -92,12 +92,12 @@ namespace {
|| Opc == ISD::GlobalTLSAddress
|| Opc == ISD::JumpTable
|| Opc == ISD::ConstantPool
|| Opc == ISD::Symbol
|| Opc == ISD::ExternalSymbol
|| Opc == ISD::TargetGlobalAddress
|| Opc == ISD::TargetGlobalTLSAddress
|| Opc == ISD::TargetJumpTable
|| Opc == ISD::TargetConstantPool
|| Opc == ISD::TargetSymbol
|| Opc == ISD::TargetExternalSymbol
|| 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/Symbol node (quite common, every direct
// call is) turn it into a TargetGlobalAddress/TargetSymbol node so that
// legalize doesn't hack it.
// 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 (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
GlobalValue *GV = G->getGlobal();
MVT CalleeVT = Callee.getValueType();
@ -1229,9 +1229,8 @@ LowerCALL(SDValue Op, SelectionDAG &DAG, const SPUSubtarget *ST) {
// address pairs:
Callee = DAG.getNode(SPUISD::IndirectAddr, PtrVT, GA, Zero);
}
} else if (SymbolSDNode *S = dyn_cast<SymbolSDNode>(Callee))
Callee = DAG.getSymbol(S->getSymbol(), Callee.getValueType(),
S->getLinkage());
} else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
Callee = DAG.getExternalSymbol(S->getSymbol(), Callee.getValueType());
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.

8
lib/Target/IA64/IA64ISelDAGToDAG.cpp
View File

@ -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<SymbolSDNode>(N->getOperand(1))) {
} else if (isa<ExternalSymbolSDNode>(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::Symbol: {
SDValue EA = CurDAG->getTargetSymbol(
cast<SymbolSDNode>(N)->getSymbol(),
case ISD::ExternalSymbol: {
SDValue EA = CurDAG->getTargetExternalSymbol(
cast<ExternalSymbolSDNode>(N)->getSymbol(),
MVT::i64);
SDValue Tmp = CurDAG->getTargetNode(IA64::ADDL_EA, MVT::i64,
CurDAG->getRegister(IA64::r1,

4
lib/Target/Mips/MipsISelDAGToDAG.cpp
View File

@ -159,7 +159,7 @@ SelectAddr(SDValue Op, SDValue Addr, SDValue &Offset, SDValue &Base)
return true;
}
} else {
if ((Addr.getOpcode() == ISD::TargetSymbol ||
if ((Addr.getOpcode() == ISD::TargetExternalSymbol ||
Addr.getOpcode() == ISD::TargetGlobalAddress))
return false;
}
@ -354,7 +354,7 @@ Select(SDValue N)
SDValue InFlag(0, 0);
if ( (isa<GlobalAddressSDNode>(Callee)) ||
(isa<SymbolSDNode>(Callee)) )
(isa<ExternalSymbolSDNode>(Callee)) )
{
/// Direct call for global addresses and external symbols
SDValue GPReg = CurDAG->getRegister(Mips::GP, MVT::i32);

12
lib/Target/Mips/MipsISelLowering.cpp
View File

@ -684,14 +684,14 @@ LowerCALL(SDValue Op, SelectionDAG &DAG)
InFlag = Chain.getValue(1);
}
// 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 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 (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
else if (SymbolSDNode *S = dyn_cast<SymbolSDNode>(Callee))
Callee = DAG.getTargetSymbol(S->getSymbol(), getPointerTy(),
S->getLinkage());
else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());
// MipsJmpLink = #chain, #target_address, #opt_in_flags...
// = Chain, Callee, Reg#1, Reg#2, ...

15
lib/Target/PowerPC/PPCISelLowering.cpp
View File

@ -2462,14 +2462,13 @@ SDValue PPCTargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG,
SmallVector<SDValue, 8> Ops;
unsigned CallOpc = isMachoABI? PPCISD::CALL_Macho : PPCISD::CALL_ELF;
// 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 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 (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
Callee = DAG.getTargetGlobalAddress(G->getGlobal(), Callee.getValueType());
else if (SymbolSDNode *S = dyn_cast<SymbolSDNode>(Callee))
Callee = DAG.getTargetSymbol(S->getSymbol(), Callee.getValueType(),
S->getLinkage());
else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
Callee = DAG.getTargetExternalSymbol(S->getSymbol(), Callee.getValueType());
else if (SDNode *Dest = isBLACompatibleAddress(Callee, DAG))
// If this is an absolute destination address, use the munged value.
Callee = SDValue(Dest, 0);
@ -2594,7 +2593,7 @@ SDValue PPCTargetLowering::LowerRET(SDValue Op, SelectionDAG &DAG,
assert(((TargetAddress.getOpcode() == ISD::Register &&
cast<RegisterSDNode>(TargetAddress)->getReg() == PPC::CTR) ||
TargetAddress.getOpcode() == ISD::TargetSymbol ||
TargetAddress.getOpcode() == ISD::TargetExternalSymbol ||
TargetAddress.getOpcode() == ISD::TargetGlobalAddress ||
isa<ConstantSDNode>(TargetAddress)) &&
"Expecting an global address, external symbol, absolute value or register");
@ -3415,7 +3414,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 {

4
lib/Target/Sparc/SparcISelDAGToDAG.cpp
View File

@ -77,7 +77,7 @@ bool SparcDAGToDAGISel::SelectADDRri(SDValue Op, SDValue Addr,
Offset = CurDAG->getTargetConstant(0, MVT::i32);
return true;
}
if (Addr.getOpcode() == ISD::TargetSymbol ||
if (Addr.getOpcode() == ISD::TargetExternalSymbol ||
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::TargetSymbol ||
if (Addr.getOpcode() == ISD::TargetExternalSymbol ||
Addr.getOpcode() == ISD::TargetGlobalAddress)
return false; // direct calls.

6
lib/Target/Sparc/SparcISelLowering.cpp
View File

@ -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 Symbol -> TargetSymbol.
// Likewise ExternalSymbol -> TargetExternalSymbol.
if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
Callee = DAG.getTargetGlobalAddress(G->getGlobal(), MVT::i32);
else if (SymbolSDNode *S = dyn_cast<SymbolSDNode>(Callee))
Callee = DAG.getTargetSymbol(S->getSymbol(), MVT::i32, S->getLinkage());
else if (ExternalSymbolSDNode *E = dyn_cast<ExternalSymbolSDNode>(Callee))
Callee = DAG.getTargetExternalSymbol(E->getSymbol(), MVT::i32);
std::vector<MVT> NodeTys;
NodeTys.push_back(MVT::Other); // Returns a chain

8
lib/Target/TargetSelectionDAG.td
View File

@ -265,10 +265,10 @@ def frameindex : SDNode<"ISD::FrameIndex", SDTPtrLeaf, [],
"FrameIndexSDNode">;
def tframeindex : SDNode<"ISD::TargetFrameIndex", SDTPtrLeaf, [],
"FrameIndexSDNode">;
def externalsym : SDNode<"ISD::Symbol", SDTPtrLeaf, [],
"SymbolSDNode">;
def texternalsym: SDNode<"ISD::TargetSymbol", SDTPtrLeaf, [],
"SymbolSDNode">;
def externalsym : SDNode<"ISD::ExternalSymbol", SDTPtrLeaf, [],
"ExternalSymbolSDNode">;
def texternalsym: SDNode<"ISD::TargetExternalSymbol", SDTPtrLeaf, [],
"ExternalSymbolSDNode">;
def add : SDNode<"ISD::ADD" , SDTIntBinOp ,
[SDNPCommutative, SDNPAssociative]>;

6
lib/Target/X86/X86ISelDAGToDAG.cpp
View File

@ -207,7 +207,7 @@ namespace {
Disp = CurDAG->getTargetConstantPool(AM.CP, MVT::i32,
AM.Align, AM.Disp);
else if (AM.ES)
Disp = CurDAG->getTargetSymbol(AM.ES, MVT::i32);
Disp = CurDAG->getTargetExternalSymbol(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 (SymbolSDNode *S = dyn_cast<SymbolSDNode>(N0)) {
} else if (ExternalSymbolSDNode *S =dyn_cast<ExternalSymbolSDNode>(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<ConstantSDNode>(N1)->getZExtValue();
SDValue C(0, 0);
// TODO: handle SymbolSDNode.
// TODO: handle ExternalSymbolSDNode.
if (GlobalAddressSDNode *G =
dyn_cast<GlobalAddressSDNode>(N0.getOperand(0))) {
C = CurDAG->getTargetGlobalAddress(G->getGlobal(), PtrVT,

43
lib/Target/X86/X86ISelLowering.cpp
View File

@ -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::Symbol , MVT::i32 , Custom);
setOperationAction(ISD::ExternalSymbol , 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::Symbol , MVT::i64 , Custom);
setOperationAction(ISD::ExternalSymbol, 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<RegisterSDNode>(TargetAddress)->getReg() == X86::ECX ||
cast<RegisterSDNode>(TargetAddress)->getReg() == X86::R9)) ||
TargetAddress.getOpcode() == ISD::TargetSymbol ||
TargetAddress.getOpcode() == ISD::TargetExternalSymbol ||
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<SymbolSDNode>(Callee))
Callee = LowerExternalSymbol(Callee, DAG);
else if (isa<ExternalSymbolSDNode>(Callee))
Callee = LowerExternalSymbol(Callee,DAG);
}
if (Is64Bit && isVarArg) {
@ -1697,9 +1697,8 @@ SDValue X86TargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) {
if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(),
getTargetMachine(), true))
Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
} else if (SymbolSDNode *S = dyn_cast<SymbolSDNode>(Callee)) {
Callee = DAG.getTargetSymbol(S->getSymbol(), getPointerTy(),
S->getLinkage());
} else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());
} else if (IsTailCall) {
unsigned Opc = Is64Bit ? X86::R9 : X86::ECX;
@ -4287,11 +4286,12 @@ X86TargetLowering::LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) {
DAG.getNode(ISD::SCALAR_TO_VECTOR, VT, AnyExt));
}
// 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.
// 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.
SDValue
X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) {
ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
@ -4362,7 +4362,8 @@ LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG,
NodeTys = DAG.getVTList(MVT::Other, MVT::Flag);
SDValue Ops1[] = { Chain,
DAG.getTargetSymbol("___tls_get_addr", PtrVT),
DAG.getTargetExternalSymbol("___tls_get_addr",
PtrVT),
DAG.getRegister(X86::EAX, PtrVT),
DAG.getRegister(X86::EBX, PtrVT),
InFlag };
@ -4395,7 +4396,8 @@ LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG,
NodeTys = DAG.getVTList(MVT::Other, MVT::Flag);
SDValue Ops1[] = { Chain,
DAG.getTargetSymbol("__tls_get_addr", PtrVT),
DAG.getTargetExternalSymbol("__tls_get_addr",
PtrVT),
DAG.getRegister(X86::RDI, PtrVT),
InFlag };
Chain = DAG.getNode(X86ISD::CALL, NodeTys, Ops1, 4);
@ -4447,9 +4449,8 @@ X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) {
SDValue
X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) {
SymbolSDNode *Sym = cast<SymbolSDNode>(Op);
SDValue Result = DAG.getTargetSymbol(Sym->getSymbol(), getPointerTy(),
Sym->getLinkage());
const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy());
Result = DAG.getNode(X86ISD::Wrapper, getPointerTy(), Result);
// With PIC, the address is actually $g + Offset.
if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
@ -5053,7 +5054,7 @@ X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Flag);
SDValue Ops[] = { Chain,
DAG.getTargetSymbol("_alloca", IntPtr),
DAG.getTargetExternalSymbol("_alloca", IntPtr),
DAG.getRegister(X86::EAX, IntPtr),
DAG.getRegister(X86StackPtr, SPTy),
Flag };
@ -5103,7 +5104,7 @@ X86TargetLowering::EmitTargetCodeForMemset(SelectionDAG &DAG,
Args.push_back(Entry);
std::pair<SDValue,SDValue> CallResult =
LowerCallTo(Chain, Type::VoidTy, false, false, false, CallingConv::C,
false, DAG.getSymbol(bzeroEntry, IntPtr),
false, DAG.getExternalSymbol(bzeroEntry, IntPtr),
Args, DAG);
return CallResult.second;
}
@ -5976,7 +5977,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::Symbol: return LowerExternalSymbol(Op, DAG);
case ISD::ExternalSymbol: return LowerExternalSymbol(Op, DAG);
case ISD::SHL_PARTS:
case ISD::SRA_PARTS:
case ISD::SRL_PARTS: return LowerShift(Op, DAG);

4
lib/Target/X86/X86ISelLowering.h
View File

@ -145,8 +145,8 @@ namespace llvm {
/// at function entry, used for PIC code.
GlobalBaseReg,
/// Wrapper - A wrapper node for TargetConstantPool, TargetSymbol, and
/// TargetGlobalAddress.
/// Wrapper - A wrapper node for TargetConstantPool,
/// TargetExternalSymbol, and TargetGlobalAddress.
Wrapper,
/// WrapperRIP - Special wrapper used under X86-64 PIC mode for RIP

2
lib/Target/X86/X86Instr64bit.td
View File

@ -1192,7 +1192,7 @@ def ATOMUMAX64: I<0, Pseudo, (outs GR64:$dst),(ins i64mem:$ptr, GR64:$val),
// Non-Instruction Patterns
//===----------------------------------------------------------------------===//
// ConstantPool GlobalAddress, Symbol, and JumpTable
// ConstantPool GlobalAddress, ExternalSymbol, and JumpTable
def : Pat<(i64 (X86Wrapper tconstpool :$dst)),
(MOV64ri tconstpool :$dst)>, Requires<[NotSmallCode]>;
def : Pat<(i64 (X86Wrapper tjumptable :$dst)),

2
lib/Target/X86/X86InstrInfo.td
View File

@ -2703,7 +2703,7 @@ def ATOMNAND8 : I<0, Pseudo,(outs GR8:$dst),(ins i8mem:$ptr, GR8:$val),
// Non-Instruction Patterns
//===----------------------------------------------------------------------===//
// ConstantPool GlobalAddress, Symbol, and JumpTable
// ConstantPool GlobalAddress, ExternalSymbol, 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)>;

6
utils/TableGen/DAGISelEmitter.cpp
View File

@ -802,11 +802,11 @@ public:
NodeOps.push_back(Val);
} else if (!N->isLeaf() && N->getOperator()->getName() == "texternalsym"){
Record *Op = OperatorMap[N->getName()];
// Transform Symbol to TargetSymbol
// Transform ExternalSymbol to TargetExternalSymbol
if (Op && Op->getName() == "externalsym") {
std::string TmpVar = "Tmp"+utostr(ResNo);
emitCode("SDValue " + TmpVar + " = CurDAG->getTarget"
"Symbol(cast<SymbolSDNode>(" +
"ExternalSymbol(cast<ExternalSymbolSDNode>(" +
Val + ")->getSymbol(), " +
getEnumName(N->getTypeNum(0)) + ");");
// Add Tmp<ResNo> 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::TargetSymbol:\n"
<< " case ISD::TargetExternalSymbol:\n"
<< " case ISD::TargetJumpTable:\n"
<< " case ISD::TargetGlobalTLSAddress:\n"
<< " case ISD::TargetGlobalAddress: {\n"