[llvm-commits] [llvm] r91392 - in /llvm/trunk: include/llvm/CodeGen/SelectionDAG.h lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp lib/CodeGen/SelectionDAG/SelectionDAG.cpp lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
Daniel Dunbar
daniel at zuster.org
Wed Dec 16 02:57:29 PST 2009
Hi Bill,
I reverted this, it was one of the patches responsible for the failing
x86_64-apple-darwin10 bootstrap in my testing.
- Daniel
On Mon, Dec 14, 2009 at 5:54 PM, Bill Wendling <isanbard at gmail.com> wrote:
> Author: void
> Date: Mon Dec 14 19:54:51 2009
> New Revision: 91392
>
> URL: http://llvm.org/viewvc/llvm-project?rev=91392&view=rev
> Log:
> Initial work on disabling the scheduler. This is a work in progress, and this
> stuff isn't used just yet.
>
> We want to model the GCC `-fno-schedule-insns' and `-fno-schedule-insns2'
> flags. The hypothesis is that the people who use these flags know what they are
> doing, and have hand-optimized the C code to reduce latencies and other
> conflicts.
>
> The idea behind our scheme to turn off scheduling is to create a map "on the
> side" during DAG generation. It will order the nodes by how they appeared in the
> code. This map is then used during scheduling to get the ordering.
>
> Modified:
> llvm/trunk/include/llvm/CodeGen/SelectionDAG.h
> llvm/trunk/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp
> llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
> llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
>
> Modified: llvm/trunk/include/llvm/CodeGen/SelectionDAG.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/SelectionDAG.h?rev=91392&r1=91391&r2=91392&view=diff
>
> ==============================================================================
> --- llvm/trunk/include/llvm/CodeGen/SelectionDAG.h (original)
> +++ llvm/trunk/include/llvm/CodeGen/SelectionDAG.h Mon Dec 14 19:54:51 2009
> @@ -110,6 +110,46 @@
> /// SelectionDAG.
> BumpPtrAllocator Allocator;
>
> + /// NodeOrdering - Assigns a "line number" value to each SDNode that
> + /// corresponds to the "line number" of the original LLVM instruction. This
> + /// used for turning off scheduling, because we'll forgo the normal scheduling
> + /// algorithm and output the instructions according to this ordering.
> + class NodeOrdering {
> + /// LineNo - The line of the instruction the node corresponds to. A value of
> + /// `0' means it's not assigned.
> + unsigned LineNo;
> + std::map<const SDNode*, unsigned> Order;
> +
> + void operator=(const NodeOrdering&); // Do not implement.
> + NodeOrdering(const NodeOrdering&); // Do not implement.
> + public:
> + NodeOrdering() : LineNo(0) {}
> +
> + void add(const SDNode *Node) {
> + assert(LineNo && "Invalid line number!");
> + Order[Node] = LineNo;
> + }
> + void remove(const SDNode *Node) {
> + std::map<const SDNode*, unsigned>::iterator Itr = Order.find(Node);
> + if (Itr != Order.end())
> + Order.erase(Itr);
> + }
> + void clear() {
> + Order.clear();
> + LineNo = 1;
> + }
> + unsigned getLineNo(const SDNode *Node) {
> + unsigned LN = Order[Node];
> + assert(LN && "Node isn't in ordering map!");
> + return LN;
> + }
> + void newInst() {
> + ++LineNo;
> + }
> +
> + void dump() const;
> + } *Ordering;
> +
> /// VerifyNode - Sanity check the given node. Aborts if it is invalid.
> void VerifyNode(SDNode *N);
>
> @@ -120,6 +160,9 @@
> DenseSet<SDNode *> &visited,
> int level, bool &printed);
>
> + void operator=(const SelectionDAG&); // Do not implement.
> + SelectionDAG(const SelectionDAG&); // Do not implement.
> +
> public:
> SelectionDAG(TargetLowering &tli, FunctionLoweringInfo &fli);
> ~SelectionDAG();
> @@ -199,6 +242,13 @@
> return Root = N;
> }
>
> + /// NewInst - Tell the ordering object that we're processing a new
> + /// instruction.
> + void NewInst() {
> + if (Ordering)
> + Ordering->newInst();
> + }
> +
> /// Combine - This iterates over the nodes in the SelectionDAG, folding
> /// certain types of nodes together, or eliminating superfluous nodes. The
> /// Level argument controls whether Combine is allowed to produce nodes and
>
> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp?rev=91392&r1=91391&r2=91392&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp (original)
> +++ llvm/trunk/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp Mon Dec 14 19:54:51 2009
> @@ -20,10 +20,16 @@
> #include "llvm/Target/TargetInstrInfo.h"
> #include "llvm/Target/TargetRegisterInfo.h"
> #include "llvm/Target/TargetSubtarget.h"
> +#include "llvm/Support/CommandLine.h"
> #include "llvm/Support/Debug.h"
> #include "llvm/Support/raw_ostream.h"
> using namespace llvm;
>
> +cl::opt<bool>
> +DisableInstScheduling("disable-inst-scheduling",
> + cl::init(false),
> + cl::desc("Disable instruction scheduling"));
> +
> ScheduleDAGSDNodes::ScheduleDAGSDNodes(MachineFunction &mf)
> : ScheduleDAG(mf) {
> }
>
> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp?rev=91392&r1=91391&r2=91392&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp (original)
> +++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp Mon Dec 14 19:54:51 2009
> @@ -48,6 +48,8 @@
> #include <cmath>
> using namespace llvm;
>
> +extern cl::opt<bool> DisableInstScheduling;
> +
> /// makeVTList - Return an instance of the SDVTList struct initialized with the
> /// specified members.
> static SDVTList makeVTList(const EVT *VTs, unsigned NumVTs) {
> @@ -552,6 +554,9 @@
> }
>
> DeallocateNode(N);
> +
> + // Remove the ordering of this node.
> + if (Ordering) Ordering->remove(N);
> }
> }
>
> @@ -577,6 +582,9 @@
> N->DropOperands();
>
> DeallocateNode(N);
> +
> + // Remove the ordering of this node.
> + if (Ordering) Ordering->remove(N);
> }
>
> void SelectionDAG::DeallocateNode(SDNode *N) {
> @@ -588,6 +596,9 @@
> N->NodeType = ISD::DELETED_NODE;
>
> NodeAllocator.Deallocate(AllNodes.remove(N));
> +
> + // Remove the ordering of this node.
> + if (Ordering) Ordering->remove(N);
> }
>
> /// RemoveNodeFromCSEMaps - Take the specified node out of the CSE map that
> @@ -691,7 +702,9 @@
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops, 1);
> AddNodeIDCustom(ID, N);
> - return CSEMap.FindNodeOrInsertPos(ID, InsertPos);
> + SDNode *Node = CSEMap.FindNodeOrInsertPos(ID, InsertPos);
> + if (Ordering) Ordering->remove(Node);
> + return Node;
> }
>
> /// FindModifiedNodeSlot - Find a slot for the specified node if its operands
> @@ -708,7 +721,9 @@
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops, 2);
> AddNodeIDCustom(ID, N);
> - return CSEMap.FindNodeOrInsertPos(ID, InsertPos);
> + SDNode *Node = CSEMap.FindNodeOrInsertPos(ID, InsertPos);
> + if (Ordering) Ordering->remove(Node);
> + return Node;
> }
>
>
> @@ -725,7 +740,9 @@
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops, NumOps);
> AddNodeIDCustom(ID, N);
> - return CSEMap.FindNodeOrInsertPos(ID, InsertPos);
> + SDNode *Node = CSEMap.FindNodeOrInsertPos(ID, InsertPos);
> + if (Ordering) Ordering->remove(Node);
> + return Node;
> }
>
> /// VerifyNode - Sanity check the given node. Aborts if it is invalid.
> @@ -778,8 +795,13 @@
> SelectionDAG::SelectionDAG(TargetLowering &tli, FunctionLoweringInfo &fli)
> : TLI(tli), FLI(fli), DW(0),
> EntryNode(ISD::EntryToken, DebugLoc::getUnknownLoc(),
> - getVTList(MVT::Other)), Root(getEntryNode()) {
> + getVTList(MVT::Other)),
> + Root(getEntryNode()), Ordering(0) {
> AllNodes.push_back(&EntryNode);
> + if (DisableInstScheduling) {
> + Ordering = new NodeOrdering();
> + Ordering->add(&EntryNode);
> + }
> }
>
> void SelectionDAG::init(MachineFunction &mf, MachineModuleInfo *mmi,
> @@ -792,6 +814,7 @@
>
> SelectionDAG::~SelectionDAG() {
> allnodes_clear();
> + delete Ordering;
> }
>
> void SelectionDAG::allnodes_clear() {
> @@ -817,6 +840,10 @@
> EntryNode.UseList = 0;
> AllNodes.push_back(&EntryNode);
> Root = getEntryNode();
> + if (DisableInstScheduling) {
> + Ordering = new NodeOrdering();
> + Ordering->add(&EntryNode);
> + }
> }
>
> SDValue SelectionDAG::getSExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT) {
> @@ -877,14 +904,17 @@
> ID.AddPointer(&Val);
> void *IP = 0;
> SDNode *N = NULL;
> - if ((N = CSEMap.FindNodeOrInsertPos(ID, IP)))
> + if ((N = CSEMap.FindNodeOrInsertPos(ID, IP))) {
> + if (Ordering) Ordering->add(N);
> if (!VT.isVector())
> return SDValue(N, 0);
> + }
> if (!N) {
> N = NodeAllocator.Allocate<ConstantSDNode>();
> new (N) ConstantSDNode(isT, &Val, EltVT);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> }
>
> SDValue Result(N, 0);
> @@ -921,14 +951,17 @@
> ID.AddPointer(&V);
> void *IP = 0;
> SDNode *N = NULL;
> - if ((N = CSEMap.FindNodeOrInsertPos(ID, IP)))
> + if ((N = CSEMap.FindNodeOrInsertPos(ID, IP))) {
> + if (Ordering) Ordering->add(N);
> if (!VT.isVector())
> return SDValue(N, 0);
> + }
> if (!N) {
> N = NodeAllocator.Allocate<ConstantFPSDNode>();
> new (N) ConstantFPSDNode(isTarget, &V, EltVT);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> }
>
> SDValue Result(N, 0);
> @@ -983,12 +1016,15 @@
> ID.AddInteger(Offset);
> ID.AddInteger(TargetFlags);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<GlobalAddressSDNode>();
> new (N) GlobalAddressSDNode(Opc, GV, VT, Offset, TargetFlags);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -998,12 +1034,15 @@
> AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
> ID.AddInteger(FI);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<FrameIndexSDNode>();
> new (N) FrameIndexSDNode(FI, VT, isTarget);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1017,12 +1056,15 @@
> ID.AddInteger(JTI);
> ID.AddInteger(TargetFlags);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<JumpTableSDNode>();
> new (N) JumpTableSDNode(JTI, VT, isTarget, TargetFlags);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1042,12 +1084,15 @@
> ID.AddPointer(C);
> ID.AddInteger(TargetFlags);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<ConstantPoolSDNode>();
> new (N) ConstantPoolSDNode(isTarget, C, VT, Offset, Alignment, TargetFlags);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1068,12 +1113,15 @@
> C->AddSelectionDAGCSEId(ID);
> ID.AddInteger(TargetFlags);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<ConstantPoolSDNode>();
> new (N) ConstantPoolSDNode(isTarget, C, VT, Offset, Alignment, TargetFlags);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1082,12 +1130,15 @@
> AddNodeIDNode(ID, ISD::BasicBlock, getVTList(MVT::Other), 0, 0);
> ID.AddPointer(MBB);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<BasicBlockSDNode>();
> new (N) BasicBlockSDNode(MBB);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1103,6 +1154,7 @@
> N = NodeAllocator.Allocate<VTSDNode>();
> new (N) VTSDNode(VT);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1112,6 +1164,7 @@
> N = NodeAllocator.Allocate<ExternalSymbolSDNode>();
> new (N) ExternalSymbolSDNode(false, Sym, 0, VT);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1124,6 +1177,7 @@
> N = NodeAllocator.Allocate<ExternalSymbolSDNode>();
> new (N) ExternalSymbolSDNode(true, Sym, TargetFlags, VT);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1136,6 +1190,7 @@
> new (N) CondCodeSDNode(Cond);
> CondCodeNodes[Cond] = N;
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> }
> return SDValue(CondCodeNodes[Cond], 0);
> }
> @@ -1228,8 +1283,10 @@
> ID.AddInteger(MaskVec[i]);
>
> void* IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
>
> // Allocate the mask array for the node out of the BumpPtrAllocator, since
> // SDNode doesn't have access to it. This memory will be "leaked" when
> @@ -1241,6 +1298,7 @@
> new (N) ShuffleVectorSDNode(VT, dl, N1, N2, MaskAlloc);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1258,12 +1316,15 @@
> SDValue Ops[] = { Val, DTy, STy, Rnd, Sat };
> AddNodeIDNode(ID, ISD::CONVERT_RNDSAT, getVTList(VT), &Ops[0], 5);
> void* IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> CvtRndSatSDNode *N = NodeAllocator.Allocate<CvtRndSatSDNode>();
> new (N) CvtRndSatSDNode(VT, dl, Ops, 5, Code);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1272,12 +1333,15 @@
> AddNodeIDNode(ID, ISD::Register, getVTList(VT), 0, 0);
> ID.AddInteger(RegNo);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<RegisterSDNode>();
> new (N) RegisterSDNode(RegNo, VT);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1289,12 +1353,15 @@
> AddNodeIDNode(ID, Opcode, getVTList(MVT::Other), &Ops[0], 1);
> ID.AddInteger(LabelID);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<LabelSDNode>();
> new (N) LabelSDNode(Opcode, dl, Root, LabelID);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1308,12 +1375,15 @@
> ID.AddPointer(BA);
> ID.AddInteger(TargetFlags);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<BlockAddressSDNode>();
> new (N) BlockAddressSDNode(Opc, VT, BA, TargetFlags);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -1326,13 +1396,16 @@
> ID.AddPointer(V);
>
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
>
> SDNode *N = NodeAllocator.Allocate<SrcValueSDNode>();
> new (N) SrcValueSDNode(V);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -2243,13 +2316,16 @@
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, Opcode, getVTList(VT), 0, 0);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<SDNode>();
> new (N) SDNode(Opcode, DL, getVTList(VT));
> CSEMap.InsertNode(N, IP);
>
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> #ifndef NDEBUG
> VerifyNode(N);
> #endif
> @@ -2473,8 +2549,10 @@
> SDValue Ops[1] = { Operand };
> AddNodeIDNode(ID, Opcode, VTs, Ops, 1);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> N = NodeAllocator.Allocate<UnarySDNode>();
> new (N) UnarySDNode(Opcode, DL, VTs, Operand);
> CSEMap.InsertNode(N, IP);
> @@ -2484,6 +2562,7 @@
> }
>
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> #ifndef NDEBUG
> VerifyNode(N);
> #endif
> @@ -2891,8 +2970,10 @@
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, Opcode, VTs, Ops, 2);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> N = NodeAllocator.Allocate<BinarySDNode>();
> new (N) BinarySDNode(Opcode, DL, VTs, N1, N2);
> CSEMap.InsertNode(N, IP);
> @@ -2902,6 +2983,7 @@
> }
>
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> #ifndef NDEBUG
> VerifyNode(N);
> #endif
> @@ -2968,8 +3050,10 @@
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, Opcode, VTs, Ops, 3);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> N = NodeAllocator.Allocate<TernarySDNode>();
> new (N) TernarySDNode(Opcode, DL, VTs, N1, N2, N3);
> CSEMap.InsertNode(N, IP);
> @@ -2977,7 +3061,9 @@
> N = NodeAllocator.Allocate<TernarySDNode>();
> new (N) TernarySDNode(Opcode, DL, VTs, N1, N2, N3);
> }
> +
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> #ifndef NDEBUG
> VerifyNode(N);
> #endif
> @@ -3573,12 +3659,14 @@
> void* IP = 0;
> if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> cast<AtomicSDNode>(E)->refineAlignment(MMO);
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> }
> SDNode* N = NodeAllocator.Allocate<AtomicSDNode>();
> new (N) AtomicSDNode(Opcode, dl, VTs, MemVT, Chain, Ptr, Cmp, Swp, MMO);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -3636,12 +3724,14 @@
> void* IP = 0;
> if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> cast<AtomicSDNode>(E)->refineAlignment(MMO);
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> }
> SDNode* N = NodeAllocator.Allocate<AtomicSDNode>();
> new (N) AtomicSDNode(Opcode, dl, VTs, MemVT, Chain, Ptr, Val, MMO);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -3714,6 +3804,7 @@
> void *IP = 0;
> if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> cast<MemIntrinsicSDNode>(E)->refineAlignment(MMO);
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> }
>
> @@ -3725,6 +3816,7 @@
> new (N) MemIntrinsicSDNode(Opcode, dl, VTList, Ops, NumOps, MemVT, MMO);
> }
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -3789,12 +3881,14 @@
> void *IP = 0;
> if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> cast<LoadSDNode>(E)->refineAlignment(MMO);
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> }
> SDNode *N = NodeAllocator.Allocate<LoadSDNode>();
> new (N) LoadSDNode(Ops, dl, VTs, AM, ExtType, MemVT, MMO);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -3865,12 +3959,14 @@
> void *IP = 0;
> if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> cast<StoreSDNode>(E)->refineAlignment(MMO);
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> }
> SDNode *N = NodeAllocator.Allocate<StoreSDNode>();
> new (N) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED, false, VT, MMO);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -3925,12 +4021,14 @@
> void *IP = 0;
> if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> cast<StoreSDNode>(E)->refineAlignment(MMO);
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> }
> SDNode *N = NodeAllocator.Allocate<StoreSDNode>();
> new (N) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED, true, SVT, MMO);
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -3947,14 +4045,17 @@
> ID.AddInteger(ST->getMemoryVT().getRawBits());
> ID.AddInteger(ST->getRawSubclassData());
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> SDNode *N = NodeAllocator.Allocate<StoreSDNode>();
> new (N) StoreSDNode(Ops, dl, VTs, AM,
> ST->isTruncatingStore(), ST->getMemoryVT(),
> ST->getMemOperand());
> CSEMap.InsertNode(N, IP);
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> return SDValue(N, 0);
> }
>
> @@ -4020,8 +4121,10 @@
> AddNodeIDNode(ID, Opcode, VTs, Ops, NumOps);
> void *IP = 0;
>
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
>
> N = NodeAllocator.Allocate<SDNode>();
> new (N) SDNode(Opcode, DL, VTs, Ops, NumOps);
> @@ -4032,6 +4135,7 @@
> }
>
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> #ifndef NDEBUG
> VerifyNode(N);
> #endif
> @@ -4087,8 +4191,10 @@
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return SDValue(E, 0);
> + }
> if (NumOps == 1) {
> N = NodeAllocator.Allocate<UnarySDNode>();
> new (N) UnarySDNode(Opcode, DL, VTList, Ops[0]);
> @@ -4119,6 +4225,7 @@
> }
> }
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> #ifndef NDEBUG
> VerifyNode(N);
> #endif
> @@ -4581,8 +4688,10 @@
> if (VTs.VTs[VTs.NumVTs-1] != MVT::Flag) {
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, Opc, VTs, Ops, NumOps);
> - if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(ON);
> return ON;
> + }
> }
>
> if (!RemoveNodeFromCSEMaps(N))
> @@ -4646,6 +4755,7 @@
>
> if (IP)
> CSEMap.InsertNode(N, IP); // Memoize the new node.
> + if (Ordering) Ordering->add(N);
> return N;
> }
>
> @@ -4784,8 +4894,10 @@
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, ~Opcode, VTs, Ops, NumOps);
> IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return cast<MachineSDNode>(E);
> + }
> }
>
> // Allocate a new MachineSDNode.
> @@ -4807,6 +4919,7 @@
> CSEMap.InsertNode(N, IP);
>
> AllNodes.push_back(N);
> + if (Ordering) Ordering->add(N);
> #ifndef NDEBUG
> VerifyNode(N);
> #endif
> @@ -4843,8 +4956,10 @@
> FoldingSetNodeID ID;
> AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
> void *IP = 0;
> - if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
> + if (Ordering) Ordering->add(E);
> return E;
> + }
> }
> return NULL;
> }
> @@ -6011,6 +6126,9 @@
> errs() << "\n\n";
> }
>
> +void SelectionDAG::NodeOrdering::dump() const {
> +}
> +
> void SDNode::printr(raw_ostream &OS, const SelectionDAG *G) const {
> print_types(OS, G);
> print_details(OS, G);
> @@ -6151,4 +6269,3 @@
> return false;
> return true;
> }
> -
>
> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp?rev=91392&r1=91391&r2=91392&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp (original)
> +++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp Mon Dec 14 19:54:51 2009
> @@ -583,6 +583,9 @@
> }
>
> void SelectionDAGBuilder::visit(unsigned Opcode, User &I) {
> + // Tell the DAG that we're processing a new instruction.
> + DAG.NewInst();
> +
> // Note: this doesn't use InstVisitor, because it has to work with
> // ConstantExpr's in addition to instructions.
> switch (Opcode) {
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
More information about the llvm-commits
mailing list