[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

Bill Wendling isanbard at gmail.com
Wed Dec 16 11:00:44 PST 2009


Hi Daniel,

Okay. It really shouldn't have had an effect on code gen at all (the flag isn't used by anything at the moment). I'll wait until the tree is healthy and check it in again.

-bw

On Dec 16, 2009, at 2:57 AM, Daniel Dunbar wrote:

> 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
>> 
> 
> _______________________________________________
> 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