Rename LegalizeDAGTypes.cpp -> LegalizeTypes.cpp

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

1 files changed, 0 insertions, 2217 deletions

diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAGTypes.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAGTypes.cpp
deleted file mode 100644
index 0fcbd6a907..0000000000
--- a/lib/CodeGen/SelectionDAG/LegalizeDAGTypes.cpp
+++ /dev/null
@@ -1,2217 +0,0 @@
-//===-- LegalizeDAGTypes.cpp - Implement SelectionDAG::LegalizeTypes ------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the SelectionDAG::LegalizeTypes method.  It transforms
-// an arbitrary well-formed SelectionDAG to only consist of legal types.
-//
-//===----------------------------------------------------------------------===//
-
-#include "LegalizeTypes.h"
-#include "llvm/Constants.h"
-#include "llvm/DerivedTypes.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/MathExtras.h"
-using namespace llvm;
-
-/// run - This is the main entry point for the type legalizer.  This does a
-/// top-down traversal of the dag, legalizing types as it goes.
-void DAGTypeLegalizer::run() {
-  // Create a dummy node (which is not added to allnodes), that adds a reference
-  // to the root node, preventing it from being deleted, and tracking any
-  // changes of the root.
-  HandleSDNode Dummy(DAG.getRoot());
-
-  // The root of the dag may dangle to deleted nodes until the type legalizer is
-  // done.  Set it to null to avoid confusion.
-  DAG.setRoot(SDOperand());
-  
-  // Walk all nodes in the graph, assigning them a NodeID of 'ReadyToProcess'
-  // (and remembering them) if they are leaves and assigning 'NewNode' if
-  // non-leaves.
-  for (SelectionDAG::allnodes_iterator I = DAG.allnodes_begin(),
-       E = DAG.allnodes_end(); I != E; ++I) {
-    if (I->getNumOperands() == 0) {
-      I->setNodeId(ReadyToProcess);
-      Worklist.push_back(I);
-    } else {
-      I->setNodeId(NewNode);
-    }
-  }
-  
-  // Now that we have a set of nodes to process, handle them all.
-  while (!Worklist.empty()) {
-    SDNode *N = Worklist.back();
-    Worklist.pop_back();
-    assert(N->getNodeId() == ReadyToProcess &&
-           "Node should be ready if on worklist!");
-    
-    // Scan the values produced by the node, checking to see if any result
-    // types are illegal.
-    unsigned i = 0;
-    unsigned NumResults = N->getNumValues();
-    do {
-      MVT::ValueType ResultVT = N->getValueType(i);
-      LegalizeAction Action = getTypeAction(ResultVT);
-      if (Action == Promote) {
-        PromoteResult(N, i);
-        goto NodeDone;
-      } else if (Action == Expand) {
-        // Expand can mean 1) split integer in half 2) scalarize single-element
-        // vector 3) split vector in half.
-        if (!MVT::isVector(ResultVT))
-          ExpandResult(N, i);
-        else if (MVT::getVectorNumElements(ResultVT) == 1)
-          ScalarizeResult(N, i);     // Scalarize the single-element vector.
-        else         // Split the vector in half.
-          assert(0 && "Vector splitting not implemented");
-        goto NodeDone;
-      } else {
-        assert(Action == Legal && "Unknown action!");
-      }
-    } while (++i < NumResults);
-    
-    // Scan the operand list for the node, handling any nodes with operands that
-    // are illegal.
-    {
-    unsigned NumOperands = N->getNumOperands();
-    bool NeedsRevisit = false;
-    for (i = 0; i != NumOperands; ++i) {
-      MVT::ValueType OpVT = N->getOperand(i).getValueType();
-      LegalizeAction Action = getTypeAction(OpVT);
-      if (Action == Promote) {
-        NeedsRevisit = PromoteOperand(N, i);
-        break;
-      } else if (Action == Expand) {
-        // Expand can mean 1) split integer in half 2) scalarize single-element
-        // vector 3) split vector in half.
-        if (!MVT::isVector(OpVT)) {
-          NeedsRevisit = ExpandOperand(N, i);
-        } else if (MVT::getVectorNumElements(OpVT) == 1) {
-          // Scalarize the single-element vector.
-          NeedsRevisit = ScalarizeOperand(N, i);
-        } else {
-          // Split the vector in half.
-          assert(0 && "Vector splitting not implemented");
-        }
-        break;
-      } else {
-        assert(Action == Legal && "Unknown action!");
-      }
-    }
-
-    // If the node needs revisiting, don't add all users to the worklist etc.
-    if (NeedsRevisit)
-      continue;
-    
-    if (i == NumOperands)
-      DEBUG(cerr << "Legally typed node: "; N->dump(&DAG); cerr << "\n");
-    }
-NodeDone:
-
-    // If we reach here, the node was processed, potentially creating new nodes.
-    // Mark it as processed and add its users to the worklist as appropriate.
-    N->setNodeId(Processed);
-    
-    for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end();
-         UI != E; ++UI) {
-      SDNode *User = *UI;
-      int NodeID = User->getNodeId();
-      assert(NodeID != ReadyToProcess && NodeID != Processed &&
-             "Invalid node id for user of unprocessed node!");
-      
-      // This node has two options: it can either be a new node or its Node ID
-      // may be a count of the number of operands it has that are not ready.
-      if (NodeID > 0) {
-        User->setNodeId(NodeID-1);
-        
-        // If this was the last use it was waiting on, add it to the ready list.
-        if (NodeID-1 == ReadyToProcess)
-          Worklist.push_back(User);
-        continue;
-      }
-      
-      // Otherwise, this node is new: this is the first operand of it that
-      // became ready.  Its new NodeID is the number of operands it has minus 1
-      // (as this node is now processed).
-      assert(NodeID == NewNode && "Unknown node ID!");
-      User->setNodeId(User->getNumOperands()-1);
-      
-      // If the node only has a single operand, it is now ready.
-      if (User->getNumOperands() == 1)
-        Worklist.push_back(User);
-    }
-  }
-  
-  // If the root changed (e.g. it was a dead load, update the root).
-  DAG.setRoot(Dummy.getValue());
-
-  //DAG.viewGraph();
-
-  // Remove dead nodes.  This is important to do for cleanliness but also before
-  // the checking loop below.  Implicit folding by the DAG.getNode operators can
-  // cause unreachable nodes to be around with their flags set to new.
-  DAG.RemoveDeadNodes();
-
-  // In a debug build, scan all the nodes to make sure we found them all.  This
-  // ensures that there are no cycles and that everything got processed.
-#ifndef NDEBUG
-  for (SelectionDAG::allnodes_iterator I = DAG.allnodes_begin(),
-       E = DAG.allnodes_end(); I != E; ++I) {
-    if (I->getNodeId() == Processed)
-      continue;
-    cerr << "Unprocessed node: ";
-    I->dump(&DAG); cerr << "\n";
-
-    if (I->getNodeId() == NewNode)
-      cerr << "New node not 'noticed'?\n";
-    else if (I->getNodeId() > 0)
-      cerr << "Operand not processed?\n";
-    else if (I->getNodeId() == ReadyToProcess)
-      cerr << "Not added to worklist?\n";
-    abort();
-  }
-#endif
-}
-
-/// MarkNewNodes - The specified node is the root of a subtree of potentially
-/// new nodes.  Add the correct NodeId to mark it.
-void DAGTypeLegalizer::MarkNewNodes(SDNode *N) {
-  // If this was an existing node that is already done, we're done.
-  if (N->getNodeId() != NewNode)
-    return;
-
-  // Okay, we know that this node is new.  Recursively walk all of its operands
-  // to see if they are new also.  The depth of this walk is bounded by the size
-  // of the new tree that was constructed (usually 2-3 nodes), so we don't worry
-  // about revisiting of nodes.
-  //
-  // As we walk the operands, keep track of the number of nodes that are
-  // processed.  If non-zero, this will become the new nodeid of this node.
-  unsigned NumProcessed = 0;
-  for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
-    int OpId = N->getOperand(i).Val->getNodeId();
-    if (OpId == NewNode)
-      MarkNewNodes(N->getOperand(i).Val);
-    else if (OpId == Processed)
-      ++NumProcessed;
-  }
-  
-  N->setNodeId(N->getNumOperands()-NumProcessed);
-  if (N->getNodeId() == ReadyToProcess)
-    Worklist.push_back(N);
-}
-
-/// ReplaceValueWith - The specified value was legalized to the specified other
-/// value.  If they are different, update the DAG and NodeIDs replacing any uses
-/// of From to use To instead.
-void DAGTypeLegalizer::ReplaceValueWith(SDOperand From, SDOperand To) {
-  if (From == To) return;
-  
-  // If expansion produced new nodes, make sure they are properly marked.
-  if (To.Val->getNodeId() == NewNode)
-    MarkNewNodes(To.Val);
-  
-  // Anything that used the old node should now use the new one.  Note that this
-  // can potentially cause recursive merging.
-  DAG.ReplaceAllUsesOfValueWith(From, To);
-
-  // The old node may still be present in ExpandedNodes or PromotedNodes.
-  // Inform them about the replacement.
-  ReplacedNodes[From] = To;
-
-  // Since we just made an unstructured update to the DAG, which could wreak
-  // general havoc on anything that once used From and now uses To, walk all
-  // users of the result, updating their flags.
-  for (SDNode::use_iterator I = To.Val->use_begin(), E = To.Val->use_end();
-       I != E; ++I) {
-    SDNode *User = *I;
-    // If the node isn't already processed or in the worklist, mark it as new,
-    // then use MarkNewNodes to recompute its ID.
-    int NodeId = User->getNodeId();
-    if (NodeId != ReadyToProcess && NodeId != Processed) {
-      User->setNodeId(NewNode);
-      MarkNewNodes(User);
-    }
-  }
-}
-
-/// ReplaceNodeWith - Replace uses of the 'from' node's results with the 'to'
-/// node's results.  The from and to node must define identical result types.
-void DAGTypeLegalizer::ReplaceNodeWith(SDNode *From, SDNode *To) {
-  if (From == To) return;
-  assert(From->getNumValues() == To->getNumValues() &&
-         "Node results don't match");
-  
-  // If expansion produced new nodes, make sure they are properly marked.
-  if (To->getNodeId() == NewNode)
-    MarkNewNodes(To);
-  
-  // Anything that used the old node should now use the new one.  Note that this
-  // can potentially cause recursive merging.
-  DAG.ReplaceAllUsesWith(From, To);
-  
-  // The old node may still be present in ExpandedNodes or PromotedNodes.
-  // Inform them about the replacement.
-  for (unsigned i = 0, e = From->getNumValues(); i != e; ++i) {
-    assert(From->getValueType(i) == To->getValueType(i) &&
-           "Node results don't match");
-    ReplacedNodes[SDOperand(From, i)] = SDOperand(To, i);
-  }
-  
-  // Since we just made an unstructured update to the DAG, which could wreak
-  // general havoc on anything that once used From and now uses To, walk all
-  // users of the result, updating their flags.
-  for (SDNode::use_iterator I = To->use_begin(), E = To->use_end();I != E; ++I){
-    SDNode *User = *I;
-    // If the node isn't already processed or in the worklist, mark it as new,
-    // then use MarkNewNodes to recompute its ID.
-    int NodeId = User->getNodeId();
-    if (NodeId != ReadyToProcess && NodeId != Processed) {
-      User->setNodeId(NewNode);
-      MarkNewNodes(User);
-    }
-  }
-}
-
-
-/// RemapNode - If the specified value was already legalized to another value,
-/// replace it by that value.
-void DAGTypeLegalizer::RemapNode(SDOperand &N) {
-  DenseMap<SDOperand, SDOperand>::iterator I = ReplacedNodes.find(N);
-  if (I != ReplacedNodes.end()) {
-    // Use path compression to speed up future lookups if values get multiply
-    // replaced with other values.
-    RemapNode(I->second);
-    N = I->second;
-  }
-}
-
-void DAGTypeLegalizer::SetPromotedOp(SDOperand Op, SDOperand Result) {
-  if (Result.Val->getNodeId() == NewNode) 
-    MarkNewNodes(Result.Val);
-
-  SDOperand &OpEntry = PromotedNodes[Op];
-  assert(OpEntry.Val == 0 && "Node is already promoted!");
-  OpEntry = Result;
-}
-
-void DAGTypeLegalizer::SetScalarizedOp(SDOperand Op, SDOperand Result) {
-  if (Result.Val->getNodeId() == NewNode) 
-    MarkNewNodes(Result.Val);
-  
-  SDOperand &OpEntry = ScalarizedNodes[Op];
-  assert(OpEntry.Val == 0 && "Node is already scalarized!");
-  OpEntry = Result;
-}
-
-
-void DAGTypeLegalizer::GetExpandedOp(SDOperand Op, SDOperand &Lo, 
-                                     SDOperand &Hi) {
-  std::pair<SDOperand, SDOperand> &Entry = ExpandedNodes[Op];
-  RemapNode(Entry.first);
-  RemapNode(Entry.second);
-  assert(Entry.first.Val && "Operand isn't expanded");
-  Lo = Entry.first;
-  Hi = Entry.second;
-}
-
-void DAGTypeLegalizer::SetExpandedOp(SDOperand Op, SDOperand Lo, 
-                                     SDOperand Hi) {
-  // Remember that this is the result of the node.
-  std::pair<SDOperand, SDOperand> &Entry = ExpandedNodes[Op];
-  assert(Entry.first.Val == 0 && "Node already expanded");
-  Entry.first = Lo;
-  Entry.second = Hi;
-  
-  // Lo/Hi may have been newly allocated, if so, add nodeid's as relevant.
-  if (Lo.Val->getNodeId() == NewNode) 
-    MarkNewNodes(Lo.Val);
-  if (Hi.Val->getNodeId() == NewNode) 
-    MarkNewNodes(Hi.Val);
-}
-
-SDOperand DAGTypeLegalizer::CreateStackStoreLoad(SDOperand Op, 
-                                                 MVT::ValueType DestVT) {
-  // Create the stack frame object.
-  SDOperand FIPtr = DAG.CreateStackTemporary(DestVT);
-  
-  // Emit a store to the stack slot.
-  SDOperand Store = DAG.getStore(DAG.getEntryNode(), Op, FIPtr, NULL, 0);
-  // Result is a load from the stack slot.
-  return DAG.getLoad(DestVT, Store, FIPtr, NULL, 0);
-}
-
-/// HandleMemIntrinsic - This handles memcpy/memset/memmove with invalid
-/// operands.  This promotes or expands the operands as required.
-SDOperand DAGTypeLegalizer::HandleMemIntrinsic(SDNode *N) {
-  // The chain and pointer [operands #0 and #1] are always valid types.
-  SDOperand Chain = N->getOperand(0);
-  SDOperand Ptr   = N->getOperand(1);
-  SDOperand Op2   = N->getOperand(2);
-  
-  // Op #2 is either a value (memset) or a pointer.  Promote it if required.
-  switch (getTypeAction(Op2.getValueType())) {
-  default: assert(0 && "Unknown action for pointer/value operand");
-  case Legal: break;
-  case Promote: Op2 = GetPromotedOp(Op2); break;
-  }
-  
-  // The length could have any action required.
-  SDOperand Length = N->getOperand(3);
-  switch (getTypeAction(Length.getValueType())) {
-  default: assert(0 && "Unknown action for memop operand");
-  case Legal: break;
-  case Promote: Length = GetPromotedZExtOp(Length); break;
-  case Expand:
-    SDOperand Dummy;  // discard the high part.
-    GetExpandedOp(Length, Length, Dummy);
-    break;
-  }
-  
-  SDOperand Align = N->getOperand(4);
-  switch (getTypeAction(Align.getValueType())) {
-  default: assert(0 && "Unknown action for memop operand");
-  case Legal: break;
-  case Promote: Align = GetPromotedZExtOp(Align); break;
-  }
-  
-  SDOperand AlwaysInline = N->getOperand(5);
-  switch (getTypeAction(AlwaysInline.getValueType())) {
-  default: assert(0 && "Unknown action for memop operand");
-  case Legal: break;
-  case Promote: AlwaysInline = GetPromotedZExtOp(AlwaysInline); break;
-  }
-  
-  SDOperand Ops[] = { Chain, Ptr, Op2, Length, Align, AlwaysInline };
-  return DAG.UpdateNodeOperands(SDOperand(N, 0), Ops, 6);
-}
-
-/// SplitOp - Return the lower and upper halves of Op's bits in a value type
-/// half the size of Op's.
-void DAGTypeLegalizer::SplitOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi) {
-  unsigned NVTBits = MVT::getSizeInBits(Op.getValueType())/2;
-  assert(MVT::getSizeInBits(Op.getValueType()) == 2*NVTBits &&
-         "Cannot split odd sized integer type");
-  MVT::ValueType NVT = MVT::getIntegerType(NVTBits);
-  Lo = DAG.getNode(ISD::TRUNCATE, NVT, Op);
-  Hi = DAG.getNode(ISD::SRL, Op.getValueType(), Op,
-                   DAG.getConstant(NVTBits, TLI.getShiftAmountTy()));
-  Hi = DAG.getNode(ISD::TRUNCATE, NVT, Hi);
-}
-
-
-//===----------------------------------------------------------------------===//
-//  Result Promotion
-//===----------------------------------------------------------------------===//
-
-/// PromoteResult - This method is called when a result of a node is found to be
-/// in need of promotion to a larger type.  At this point, the node may also
-/// have invalid operands or may have other results that need expansion, we just
-/// know that (at least) one result needs promotion.
-void DAGTypeLegalizer::PromoteResult(SDNode *N, unsigned ResNo) {
-  DEBUG(cerr << "Promote node result: "; N->dump(&DAG); cerr << "\n");
-  SDOperand Result = SDOperand();
-  
-  switch (N->getOpcode()) {
-  default:
-#ifndef NDEBUG
-    cerr << "PromoteResult #" << ResNo << ": ";
-    N->dump(&DAG); cerr << "\n";
-#endif
-    assert(0 && "Do not know how to promote this operator!");
-    abort();
-  case ISD::UNDEF:    Result = PromoteResult_UNDEF(N); break;
-  case ISD::Constant: Result = PromoteResult_Constant(N); break;
-
-  case ISD::TRUNCATE:    Result = PromoteResult_TRUNCATE(N); break;
-  case ISD::SIGN_EXTEND:
-  case ISD::ZERO_EXTEND:
-  case ISD::ANY_EXTEND:  Result = PromoteResult_INT_EXTEND(N); break;
-  case ISD::FP_ROUND:    Result = PromoteResult_FP_ROUND(N); break;
-  case ISD::FP_TO_SINT:
-  case ISD::FP_TO_UINT:  Result = PromoteResult_FP_TO_XINT(N); break;
-  case ISD::SETCC:    Result = PromoteResult_SETCC(N); break;
-  case ISD::LOAD:     Result = PromoteResult_LOAD(cast<LoadSDNode>(N)); break;
-
-  case ISD::AND:
-  case ISD::OR:
-  case ISD::XOR:
-  case ISD::ADD:
-  case ISD::SUB:
-  case ISD::MUL:      Result = PromoteResult_SimpleIntBinOp(N); break;
-
-  case ISD::SDIV:
-  case ISD::SREM:     Result = PromoteResult_SDIV(N); break;
-
-  case ISD::UDIV:
-  case ISD::UREM:     Result = PromoteResult_UDIV(N); break;
-
-  case ISD::SHL:      Result = PromoteResult_SHL(N); break;
-  case ISD::SRA:      Result = PromoteResult_SRA(N); break;
-  case ISD::SRL:      Result = PromoteResult_SRL(N); break;
-
-  case ISD::SELECT:    Result = PromoteResult_SELECT(N); break;
-  case ISD::SELECT_CC: Result = PromoteResult_SELECT_CC(N); break;
-
-  }      
-  
-  // If Result is null, the sub-method took care of registering the result.
-  if (Result.Val)
-    SetPromotedOp(SDOperand(N, ResNo), Result);
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_UNDEF(SDNode *N) {
-  return DAG.getNode(ISD::UNDEF, TLI.getTypeToTransformTo(N->getValueType(0)));
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_Constant(SDNode *N) {
-  MVT::ValueType VT = N->getValueType(0);
-  // Zero extend things like i1, sign extend everything else.  It shouldn't
-  // matter in theory which one we pick, but this tends to give better code?
-  unsigned Opc = VT != MVT::i1 ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND;
-  SDOperand Result = DAG.getNode(Opc, TLI.getTypeToTransformTo(VT),
-                                 SDOperand(N, 0));
-  assert(isa<ConstantSDNode>(Result) && "Didn't constant fold ext?");
-  return Result;
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_TRUNCATE(SDNode *N) {
-  SDOperand Res;
-
-  switch (getTypeAction(N->getOperand(0).getValueType())) {
-  default: assert(0 && "Unknown type action!");
-  case Legal:
-  case Expand:
-    Res = N->getOperand(0);
-    break;
-  case Promote:
-    Res = GetPromotedOp(N->getOperand(0));
-    break;
-  }
-
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(N->getValueType(0));
-  assert(MVT::getSizeInBits(Res.getValueType()) >= MVT::getSizeInBits(NVT) &&
-         "Truncation doesn't make sense!");
-  if (Res.getValueType() == NVT)
-    return Res;
-
-  // Truncate to NVT instead of VT
-  return DAG.getNode(ISD::TRUNCATE, NVT, Res);
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_INT_EXTEND(SDNode *N) {
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(N->getValueType(0));
-
-  if (getTypeAction(N->getOperand(0).getValueType()) == Promote) {
-    SDOperand Res = GetPromotedOp(N->getOperand(0));
-    assert(MVT::getSizeInBits(Res.getValueType()) <= MVT::getSizeInBits(NVT) &&
-           "Extension doesn't make sense!");
-
-    // If the result and operand types are the same after promotion, simplify
-    // to an in-register extension.
-    if (NVT == Res.getValueType()) {
-      // The high bits are not guaranteed to be anything.  Insert an extend.
-      if (N->getOpcode() == ISD::SIGN_EXTEND)
-        return DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Res,
-                           DAG.getValueType(N->getOperand(0).getValueType()));
-      if (N->getOpcode() == ISD::ZERO_EXTEND)
-        return DAG.getZeroExtendInReg(Res, N->getOperand(0).getValueType());
-      assert(N->getOpcode() == ISD::ANY_EXTEND && "Unknown integer extension!");
-      return Res;
-    }
-  }
-
-  // Otherwise, just extend the original operand all the way to the larger type.
-  return DAG.getNode(N->getOpcode(), NVT, N->getOperand(0));
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_FP_ROUND(SDNode *N) {
-  // NOTE: Assumes input is legal.
-  return DAG.getNode(ISD::FP_ROUND_INREG, N->getOperand(0).getValueType(),
-                     N->getOperand(0), DAG.getValueType(N->getValueType(0)));
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_FP_TO_XINT(SDNode *N) {
-  SDOperand Op = N->getOperand(0);
-  // If the operand needed to be promoted, do so now.
-  if (getTypeAction(Op.getValueType()) == Promote)
-    // The input result is prerounded, so we don't have to do anything special.
-    Op = GetPromotedOp(Op);
-  
-  unsigned NewOpc = N->getOpcode();
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(N->getValueType(0));
-  
-  // If we're promoting a UINT to a larger size, check to see if the new node
-  // will be legal.  If it isn't, check to see if FP_TO_SINT is legal, since
-  // we can use that instead.  This allows us to generate better code for
-  // FP_TO_UINT for small destination sizes on targets where FP_TO_UINT is not
-  // legal, such as PowerPC.
-  if (N->getOpcode() == ISD::FP_TO_UINT) {
-    if (!TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) &&
-        (TLI.isOperationLegal(ISD::FP_TO_SINT, NVT) ||
-         TLI.getOperationAction(ISD::FP_TO_SINT, NVT)==TargetLowering::Custom))
-      NewOpc = ISD::FP_TO_SINT;
-  }
-
-  return DAG.getNode(NewOpc, NVT, Op);
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_SETCC(SDNode *N) {
-  assert(isTypeLegal(TLI.getSetCCResultTy()) && "SetCC type is not legal??");
-  return DAG.getNode(ISD::SETCC, TLI.getSetCCResultTy(), N->getOperand(0),
-                     N->getOperand(1), N->getOperand(2));
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_LOAD(LoadSDNode *N) {
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(N->getValueType(0));
-  ISD::LoadExtType ExtType =
-    ISD::isNON_EXTLoad(N) ? ISD::EXTLOAD : N->getExtensionType();
-  SDOperand Res = DAG.getExtLoad(ExtType, NVT, N->getChain(), N->getBasePtr(),
-                                 N->getSrcValue(), N->getSrcValueOffset(),
-                                 N->getLoadedVT(), N->isVolatile(),
-                                 N->getAlignment());
-
-  // Legalized the chain result - switch anything that used the old chain to
-  // use the new one.
-  ReplaceValueWith(SDOperand(N, 1), Res.getValue(1));
-  return Res;
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_SimpleIntBinOp(SDNode *N) {
-  // The input may have strange things in the top bits of the registers, but
-  // these operations don't care.  They may have weird bits going out, but
-  // that too is okay if they are integer operations.
-  SDOperand LHS = GetPromotedOp(N->getOperand(0));
-  SDOperand RHS = GetPromotedOp(N->getOperand(1));
-  return DAG.getNode(N->getOpcode(), LHS.getValueType(), LHS, RHS);
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_SDIV(SDNode *N) {
-  // Sign extend the input.
-  SDOperand LHS = GetPromotedOp(N->getOperand(0));
-  SDOperand RHS = GetPromotedOp(N->getOperand(1));
-  MVT::ValueType VT = N->getValueType(0);
-  LHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, LHS.getValueType(), LHS,
-                    DAG.getValueType(VT));
-  RHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, RHS.getValueType(), RHS,
-                    DAG.getValueType(VT));
-
-  return DAG.getNode(N->getOpcode(), LHS.getValueType(), LHS, RHS);
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_UDIV(SDNode *N) {
-  // Zero extend the input.
-  SDOperand LHS = GetPromotedOp(N->getOperand(0));
-  SDOperand RHS = GetPromotedOp(N->getOperand(1));
-  MVT::ValueType VT = N->getValueType(0);
-  LHS = DAG.getZeroExtendInReg(LHS, VT);
-  RHS = DAG.getZeroExtendInReg(RHS, VT);
-
-  return DAG.getNode(N->getOpcode(), LHS.getValueType(), LHS, RHS);
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_SHL(SDNode *N) {
-  return DAG.getNode(ISD::SHL, TLI.getTypeToTransformTo(N->getValueType(0)),
-                     GetPromotedOp(N->getOperand(0)), N->getOperand(1));
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_SRA(SDNode *N) {
-  // The input value must be properly sign extended.
-  MVT::ValueType VT = N->getValueType(0);
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(VT);
-  SDOperand Res = GetPromotedOp(N->getOperand(0));
-  Res = DAG.getNode(ISD::SIGN_EXTEND_INREG, NVT, Res, DAG.getValueType(VT));
-  return DAG.getNode(ISD::SRA, NVT, Res, N->getOperand(1));
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_SRL(SDNode *N) {
-  // The input value must be properly zero extended.
-  MVT::ValueType VT = N->getValueType(0);
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(VT);
-  SDOperand Res = GetPromotedZExtOp(N->getOperand(0));
-  return DAG.getNode(ISD::SRL, NVT, Res, N->getOperand(1));
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_SELECT(SDNode *N) {
-  SDOperand LHS = GetPromotedOp(N->getOperand(1));
-  SDOperand RHS = GetPromotedOp(N->getOperand(2));
-  return DAG.getNode(ISD::SELECT, LHS.getValueType(), N->getOperand(0),LHS,RHS);
-}
-
-SDOperand DAGTypeLegalizer::PromoteResult_SELECT_CC(SDNode *N) {
-  SDOperand LHS = GetPromotedOp(N->getOperand(2));
-  SDOperand RHS = GetPromotedOp(N->getOperand(3));
-  return DAG.getNode(ISD::SELECT_CC, LHS.getValueType(), N->getOperand(0),
-                     N->getOperand(1), LHS, RHS, N->getOperand(4));
-}
-
-
-//===----------------------------------------------------------------------===//
-//  Result Expansion
-//===----------------------------------------------------------------------===//
-
-/// ExpandResult - This method is called when the specified result of the
-/// specified node is found to need expansion.  At this point, the node may also
-/// have invalid operands or may have other results that need promotion, we just
-/// know that (at least) one result needs expansion.
-void DAGTypeLegalizer::ExpandResult(SDNode *N, unsigned ResNo) {
-  DEBUG(cerr << "Expand node result: "; N->dump(&DAG); cerr << "\n");
-  SDOperand Lo, Hi;
-  Lo = Hi = SDOperand();
-
-  // See if the target wants to custom expand this node.
-  if (TLI.getOperationAction(N->getOpcode(), N->getValueType(0)) == 
-          TargetLowering::Custom) {
-    // If the target wants to, allow it to lower this itself.
-    if (SDNode *P = TLI.ExpandOperationResult(N, DAG)) {
-      // Everything that once used N now uses P.  We are guaranteed that the
-      // result value types of N and the result value types of P match.
-      ReplaceNodeWith(N, P);
-      return;
-    }
-  }
-
-  switch (N->getOpcode()) {
-  default:
-#ifndef NDEBUG
-    cerr << "ExpandResult #" << ResNo << ": ";
-    N->dump(&DAG); cerr << "\n";
-#endif
-    assert(0 && "Do not know how to expand the result of this operator!");
-    abort();
-      
-  case ISD::UNDEF:       ExpandResult_UNDEF(N, Lo, Hi); break;
-  case ISD::Constant:    ExpandResult_Constant(N, Lo, Hi); break;
-  case ISD::BUILD_PAIR:  ExpandResult_BUILD_PAIR(N, Lo, Hi); break;
-  case ISD::MERGE_VALUES: ExpandResult_MERGE_VALUES(N, Lo, Hi); break;
-  case ISD::ANY_EXTEND:  ExpandResult_ANY_EXTEND(N, Lo, Hi); break;
-  case ISD::ZERO_EXTEND: ExpandResult_ZERO_EXTEND(N, Lo, Hi); break;
-  case ISD::SIGN_EXTEND: ExpandResult_SIGN_EXTEND(N, Lo, Hi); break;
-  case ISD::BIT_CONVERT: ExpandResult_BIT_CONVERT(N, Lo, Hi); break;
-  case ISD::SIGN_EXTEND_INREG: ExpandResult_SIGN_EXTEND_INREG(N, Lo, Hi); break;
-  case ISD::LOAD:        ExpandResult_LOAD(cast<LoadSDNode>(N), Lo, Hi); break;
-    
-  case ISD::AND:
-  case ISD::OR:
-  case ISD::XOR:         ExpandResult_Logical(N, Lo, Hi); break;
-  case ISD::BSWAP:       ExpandResult_BSWAP(N, Lo, Hi); break;
-  case ISD::ADD:
-  case ISD::SUB:         ExpandResult_ADDSUB(N, Lo, Hi); break;
-  case ISD::ADDC:
-  case ISD::SUBC:        ExpandResult_ADDSUBC(N, Lo, Hi); break;
-  case ISD::ADDE:
-  case ISD::SUBE:        ExpandResult_ADDSUBE(N, Lo, Hi); break;
-  case ISD::SELECT:      ExpandResult_SELECT(N, Lo, Hi); break;
-  case ISD::SELECT_CC:   ExpandResult_SELECT_CC(N, Lo, Hi); break;
-  case ISD::MUL:         ExpandResult_MUL(N, Lo, Hi); break;
-  case ISD::SHL:
-  case ISD::SRA:
-  case ISD::SRL:         ExpandResult_Shift(N, Lo, Hi); break;
-  }
-  
-  // If Lo/Hi is null, the sub-method took care of registering results etc.
-  if (Lo.Val)
-    SetExpandedOp(SDOperand(N, ResNo), Lo, Hi);
-}
-
-void DAGTypeLegalizer::ExpandResult_UNDEF(SDNode *N,
-                                          SDOperand &Lo, SDOperand &Hi) {
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(N->getValueType(0));
-  Lo = Hi = DAG.getNode(ISD::UNDEF, NVT);
-}
-
-void DAGTypeLegalizer::ExpandResult_Constant(SDNode *N,
-                                             SDOperand &Lo, SDOperand &Hi) {
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(N->getValueType(0));
-  uint64_t Cst = cast<ConstantSDNode>(N)->getValue();
-  Lo = DAG.getConstant(Cst, NVT);
-  Hi = DAG.getConstant(Cst >> MVT::getSizeInBits(NVT), NVT);
-}
-
-void DAGTypeLegalizer::ExpandResult_BUILD_PAIR(SDNode *N,
-                                               SDOperand &Lo, SDOperand &Hi) {
-  // Return the operands.
-  Lo = N->getOperand(0);
-  Hi = N->getOperand(1);
-}
-
-void DAGTypeLegalizer::ExpandResult_MERGE_VALUES(SDNode *N,
-                                                 SDOperand &Lo, SDOperand &Hi) {
-  // A MERGE_VALUES node can produce any number of values.  We know that the
-  // first illegal one needs to be expanded into Lo/Hi.
-  unsigned i;
-  
-  // The string of legal results gets turns into the input operands, which have
-  // the same type.
-  for (i = 0; isTypeLegal(N->getValueType(i)); ++i)
-    ReplaceValueWith(SDOperand(N, i), SDOperand(N->getOperand(i)));
-
-  // The first illegal result must be the one that needs to be expanded.
-  GetExpandedOp(N->getOperand(i), Lo, Hi);
-
-  // Legalize the rest of the results into the input operands whether they are
-  // legal or not.
-  unsigned e = N->getNumValues();
-  for (++i; i != e; ++i)
-    ReplaceValueWith(SDOperand(N, i), SDOperand(N->getOperand(i)));
-}
-
-void DAGTypeLegalizer::ExpandResult_ANY_EXTEND(SDNode *N,
-                                               SDOperand &Lo, SDOperand &Hi) {
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(N->getValueType(0));
-  SDOperand Op = N->getOperand(0);
-  if (MVT::getSizeInBits(Op.getValueType()) <= MVT::getSizeInBits(NVT)) {
-    // The low part is any extension of the input (which degenerates to a copy).
-    Lo = DAG.getNode(ISD::ANY_EXTEND, NVT, Op);
-    Hi = DAG.getNode(ISD::UNDEF, NVT);   // The high part is undefined.
-  } else {
-    // For example, extension of an i48 to an i64.  The operand type necessarily
-    // promotes to the result type, so will end up being expanded too.
-    assert(getTypeAction(Op.getValueType()) == Promote &&
-           "Don't know how to expand this result!");
-    SDOperand Res = GetPromotedOp(Op);
-    assert(Res.getValueType() == N->getValueType(0) &&
-           "Operand over promoted?");
-    // Split the promoted operand.  This will simplify when it is expanded.
-    SplitOp(Res, Lo, Hi);
-  }
-}
-
-void DAGTypeLegalizer::ExpandResult_ZERO_EXTEND(SDNode *N,
-                                                SDOperand &Lo, SDOperand &Hi) {
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(N->getValueType(0));
-  SDOperand Op = N->getOperand(0);
-  if (MVT::getSizeInBits(Op.getValueType()) <= MVT::getSizeInBits(NVT)) {
-    // The low part is zero extension of the input (which degenerates to a copy).
-    Lo = DAG.getNode(ISD::ZERO_EXTEND, NVT, N->getOperand(0));
-    Hi = DAG.getConstant(0, NVT);   // The high part is just a zero.
-  } else {
-    // For example, extension of an i48 to an i64.  The operand type necessarily
-    // promotes to the result type, so will end up being expanded too.
-    assert(getTypeAction(Op.getValueType()) == Promote &&
-           "Don't know how to expand this result!");
-    SDOperand Res = GetPromotedOp(Op);
-    assert(Res.getValueType() == N->getValueType(0) &&
-           "Operand over promoted?");
-    // Split the promoted operand.  This will simplify when it is expanded.
-    SplitOp(Res, Lo, Hi);
-    unsigned ExcessBits =
-      MVT::getSizeInBits(Op.getValueType()) - MVT::getSizeInBits(NVT);
-    Hi = DAG.getZeroExtendInReg(Hi, MVT::getIntegerType(ExcessBits));
-  }
-}
-
-void DAGTypeLegalizer::ExpandResult_SIGN_EXTEND(SDNode *N,
-                                                SDOperand &Lo, SDOperand &Hi) {
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(N->getValueType(0));
-  SDOperand Op = N->getOperand(0);
-  if (MVT::getSizeInBits(Op.getValueType()) <= MVT::getSizeInBits(NVT)) {
-    // The low part is sign extension of the input (which degenerates to a copy).
-    Lo = DAG.getNode(ISD::SIGN_EXTEND, NVT, N->getOperand(0));
-    // The high part is obtained by SRA'ing all but one of the bits of low part.
-    unsigned LoSize = MVT::getSizeInBits(NVT);
-    Hi = DAG.getNode(ISD::SRA, NVT, Lo,
-                     DAG.getConstant(LoSize-1, TLI.getShiftAmountTy()));
-  } else {
-    // For example, extension of an i48 to an i64.  The operand type necessarily
-    // promotes to the result type, so will end up being expanded too.
-    assert(getTypeAction(Op.getValueType()) == Promote &&
-           "Don't know how to expand this result!");
-    SDOperand Res = GetPromotedOp(Op);
-    assert(Res.getValueType() == N->getValueType(0) &&
-           "Operand over promoted?");
-    // Split the promoted operand.  This will simplify when it is expanded.
-    SplitOp(Res, Lo, Hi);
-    unsigned ExcessBits =
-      MVT::getSizeInBits(Op.getValueType()) - MVT::getSizeInBits(NVT);
-    Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, Hi.getValueType(), Hi,
-                     DAG.getValueType(MVT::getIntegerType(ExcessBits)));
-  }
-}
-
-void DAGTypeLegalizer::ExpandResult_BIT_CONVERT(SDNode *N,
-                                                SDOperand &Lo, SDOperand &Hi) {
-  // Lower the bit-convert to a store/load from the stack, then expand the load.
-  SDOperand Op = CreateStackStoreLoad(N->getOperand(0), N->getValueType(0));
-  ExpandResult_LOAD(cast<LoadSDNode>(Op.Val), Lo, Hi);
-}
-
-void DAGTypeLegalizer::
-ExpandResult_SIGN_EXTEND_INREG(SDNode *N, SDOperand &Lo, SDOperand &Hi) {
-  GetExpandedOp(N->getOperand(0), Lo, Hi);
-  MVT::ValueType EVT = cast<VTSDNode>(N->getOperand(1))->getVT();
-
-  if (MVT::getSizeInBits(EVT) <= MVT::getSizeInBits(Lo.getValueType())) {
-    // sext_inreg the low part if needed.
-    Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, Lo.getValueType(), Lo,
-                     N->getOperand(1));
-
-    // The high part gets the sign extension from the lo-part.  This handles
-    // things like sextinreg V:i64 from i8.
-    Hi = DAG.getNode(ISD::SRA, Hi.getValueType(), Lo,
-                     DAG.getConstant(MVT::getSizeInBits(Hi.getValueType())-1,
-                                     TLI.getShiftAmountTy()));
-  } else {
-    // For example, extension of an i48 to an i64.  Leave the low part alone,
-    // sext_inreg the high part.
-    unsigned ExcessBits =
-      MVT::getSizeInBits(EVT) - MVT::getSizeInBits(Lo.getValueType());
-    Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, Hi.getValueType(), Hi,
-                     DAG.getValueType(MVT::getIntegerType(ExcessBits)));
-  }
-}
-
-void DAGTypeLegalizer::ExpandResult_LOAD(LoadSDNode *N,
-                                         SDOperand &Lo, SDOperand &Hi) {
-  MVT::ValueType VT = N->getValueType(0);
-  MVT::ValueType NVT = TLI.getTypeToTransformTo(VT);
-  SDOperand Ch  = N->getChain();    // Legalize the chain.
-  SDOperand Ptr = N->getBasePtr();  // Legalize the pointer.
-  ISD::LoadExtType Ext