This file is obsolete

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

1 files changed, 0 insertions, 278 deletions

diff --git a/lib/CodeGen/SelectionDAG/DAGBuilder.cpp b/lib/CodeGen/SelectionDAG/DAGBuilder.cpp
deleted file mode 100644
index c6c1c90619..0000000000
--- a/lib/CodeGen/SelectionDAG/DAGBuilder.cpp
+++ /dev/null
@@ -1,278 +0,0 @@
-//===-- DAGBuilder.cpp - Turn an LLVM BasicBlock into a DAG for selection -===//
-// 
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
-//===----------------------------------------------------------------------===//
-//
-// This file turns an LLVM BasicBlock into a target-independent SelectionDAG in
-// preparation for target-specific optimizations and instruction selection.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/CodeGen/SelectionDAG.h"
-#include "llvm/Constants.h"
-#include "llvm/Function.h"
-#include "llvm/Instructions.h"
-#include "llvm/Type.h"
-#include "llvm/CodeGen/MachineFunction.h"
-#include "llvm/Target/TargetMachine.h"
-#include "llvm/Support/InstVisitor.h"
-#include <iostream>
-
-using namespace llvm;
-
-namespace llvm {
-struct SelectionDAGBuilder : public InstVisitor<SelectionDAGBuilder> {
-  // DAG - the current dag we are building.
-  SelectionDAG &DAG;
-
-  // SDTB - The target-specific builder interface, which indicates how to expand
-  // extremely target-specific aspects of the representation, such as function
-  // calls and arguments.
-  SelectionDAGTargetBuilder &SDTB;
-
-  // BB - The current machine basic block we are working on.
-  MachineBasicBlock *BB;
-
-  // CurRoot - The root built for the current basic block.
-  SelectionDAGNode *CurRoot;
-
-  SelectionDAGBuilder(SelectionDAG &dag, SelectionDAGTargetBuilder &sdtb)
-    : DAG(dag), SDTB(sdtb), BB(0), CurRoot(0) {}
-
-  void visitBB(BasicBlock &bb);
-
-  // Visitation methods for instructions: Create the appropriate DAG nodes for
-  // the instruction.
-  void visitAdd(BinaryOperator &BO);
-  void visitSub(BinaryOperator &BO);
-  void visitMul(BinaryOperator &BO);
-
-  void visitAnd(BinaryOperator &BO);
-  void visitOr (BinaryOperator &BO);
-  void visitXor(BinaryOperator &BO);
-
-  void visitSetEQ(BinaryOperator &BO);
-
-  void visitLoad(LoadInst &LI);
-  void visitCall(CallInst &CI);
-
-  void visitBr(BranchInst &BI);
-  void visitRet(ReturnInst &RI);
-
-  void visitInstruction(Instruction &I) {
-    std::cerr << "DAGBuilder: Cannot instruction select: " << I;
-    abort();
-  }
-
-private:
-  SelectionDAGNode *getNodeFor(Value *V);
-  SelectionDAGNode *getNodeFor(Value &V) { return getNodeFor(&V); }
-  
-  SelectionDAGNode *addSeqNode(SelectionDAGNode *N);
-};
-}  // end llvm namespace
-
-/// addSeqNode - The same as addNode, but the node is also included in the
-/// sequence nodes for this block.  This method should be called for any
-/// instructions which have a specified sequence they must be evaluated in.
-///
-SelectionDAGNode *SelectionDAGBuilder::addSeqNode(SelectionDAGNode *N) {
-  DAG.addNode(N);   // First, add the node to the selection DAG
-  
-  if (!CurRoot)
-    CurRoot = N;
-  else {
-    // Create and add a new chain node for the existing root and this node...
-    CurRoot = DAG.addNode(new SelectionDAGNode(ISD::ChainNode, MVT::isVoid,
-                                               BB, CurRoot, N));
-  }
-  return N;
-}
-
-/// getNodeFor - This method returns the SelectionDAGNode for the specified LLVM
-/// value, creating a node as necessary.
-///
-SelectionDAGNode *SelectionDAGBuilder::getNodeFor(Value *V) {
-  // If we already have the entry, return it.
-  SelectionDAGNode*& Entry = DAG.ValueMap[V];
-  if (Entry) return Entry;
-  
-  // Otherwise, we need to create a node to return now... start by figuring out
-  // which type the node will be...
-  MVT::ValueType ValueType = DAG.getValueType(V->getType());
-
-  if (Instruction *I = dyn_cast<Instruction>(V))
-    // Instructions will be filled in later.  For now, just create and return a
-    // dummy node.
-    return Entry = new SelectionDAGNode(ISD::ProtoNode, ValueType);
-
-  if (Constant *C = dyn_cast<Constant>(V)) {
-    if (ConstantBool *CB = dyn_cast<ConstantBool>(C)) {
-      Entry = new SelectionDAGNode(ISD::Constant, ValueType);
-      Entry->addValue(new ReducedValue_Constant_i1(CB->getValue()));
-    } else if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
-      Entry = new SelectionDAGNode(ISD::Constant, ValueType);
-      switch (ValueType) {
-      case MVT::i8:
-        Entry->addValue(new ReducedValue_Constant_i8(CI->getRawValue()));
-        break;
-      case MVT::i16:
-        Entry->addValue(new ReducedValue_Constant_i16(CI->getRawValue()));
-        break;
-      case MVT::i32:
-        Entry->addValue(new ReducedValue_Constant_i32(CI->getRawValue()));
-        break;
-      case MVT::i64:
-        Entry->addValue(new ReducedValue_Constant_i64(CI->getRawValue()));
-        break;
-      default:
-        assert(0 && "Invalid ValueType for an integer constant!");
-      }
-
-    } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
-      Entry = new SelectionDAGNode(ISD::Constant, ValueType);
-      if (ValueType == MVT::f32)
-        Entry->addValue(new ReducedValue_Constant_f32(CFP->getValue()));
-      else
-        Entry->addValue(new ReducedValue_Constant_f64(CFP->getValue()));
-    }
-    if (Entry) return Entry;
-  } else if (BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
-    Entry = new SelectionDAGNode(ISD::BasicBlock, ValueType);
-    Entry->addValue(new ReducedValue_BasicBlock_i32(DAG.BlockMap[BB]));
-    return Entry;
-  }
-
-  std::cerr << "Unhandled LLVM value in DAG Builder!: " << *V << "\n";
-  abort();
-  return 0;
-}
-
-
-// visitBB - This method is used to visit a basic block in the program.  It
-// manages the CurRoot instance variable so that all of the visit(Instruction)
-// methods can be written to assume that there is only one basic block being
-// constructed.
-//
-void SelectionDAGBuilder::visitBB(BasicBlock &bb) {
-  BB = DAG.BlockMap[&bb];       // Update BB instance var
-  
-  // Save the current global DAG...
-  SelectionDAGNode *OldRoot = CurRoot;
-  CurRoot = 0;
-  
-  visit(bb.begin(), bb.end());  // Visit all of the instructions...
-  
-  if (OldRoot) {
-    if (!CurRoot)
-      CurRoot = OldRoot;   // This block had no root of its own..
-    else {
-      // The previous basic block AND this basic block had roots, insert a
-      // block chain node now...
-      CurRoot = DAG.addNode(new SelectionDAGNode(ISD::BlockChainNode,
-                                                 MVT::isVoid,
-                                                 BB, OldRoot, CurRoot));
-    }
-  }
-}
-
-//===----------------------------------------------------------------------===//
-//                         ...Visitation Methods...
-//===----------------------------------------------------------------------===//
-
-void SelectionDAGBuilder::visitAdd(BinaryOperator &BO) {
-  getNodeFor(BO)->setNode(ISD::Plus, BB, getNodeFor(BO.getOperand(0)),
-                          getNodeFor(BO.getOperand(1)));
-}
-void SelectionDAGBuilder::visitSub(BinaryOperator &BO) {
-  getNodeFor(BO)->setNode(ISD::Minus, BB, getNodeFor(BO.getOperand(0)),
-                          getNodeFor(BO.getOperand(1)));
-}
-void SelectionDAGBuilder::visitMul(BinaryOperator &BO) {
-  getNodeFor(BO)->setNode(ISD::Times, BB, getNodeFor(BO.getOperand(0)),
-                          getNodeFor(BO.getOperand(1)));
-}
-
-void SelectionDAGBuilder::visitAnd(BinaryOperator &BO) {
-  getNodeFor(BO)->setNode(ISD::And, BB, getNodeFor(BO.getOperand(0)),
-                          getNodeFor(BO.getOperand(1)));
-}
-void SelectionDAGBuilder::visitOr(BinaryOperator &BO) {
-  getNodeFor(BO)->setNode(ISD::Or, BB, getNodeFor(BO.getOperand(0)),
-                          getNodeFor(BO.getOperand(1)));
-}
-void SelectionDAGBuilder::visitXor(BinaryOperator &BO) {
-  getNodeFor(BO)->setNode(ISD::Xor, BB, getNodeFor(BO.getOperand(0)),
-                          getNodeFor(BO.getOperand(1)));
-}
-void SelectionDAGBuilder::visitSetEQ(BinaryOperator &BO) {
-  getNodeFor(BO)->setNode(ISD::SetEQ, BB, getNodeFor(BO.getOperand(0)),
-                          getNodeFor(BO.getOperand(1)));
-}
-
-
-void SelectionDAGBuilder::visitRet(ReturnInst &RI) {
-  if (RI.getNumOperands()) {         // Value return
-    addSeqNode(new SelectionDAGNode(ISD::Ret, MVT::isVoid, BB,
-                                    getNodeFor(RI.getOperand(0))));
-  } else {                           // Void return
-    addSeqNode(new SelectionDAGNode(ISD::RetVoid, MVT::isVoid, BB));
-  }
-}
-
-
-void SelectionDAGBuilder::visitBr(BranchInst &BI) {
-  if (BI.isUnconditional())
-    addSeqNode(new SelectionDAGNode(ISD::Br, MVT::isVoid, BB,
-                                    getNodeFor(BI.getOperand(0))));
-  else
-    addSeqNode(new SelectionDAGNode(ISD::BrCond, MVT::isVoid, BB,
-                                    getNodeFor(BI.getCondition()),
-                                    getNodeFor(BI.getSuccessor(0)),
-                                    getNodeFor(BI.getSuccessor(1))));
-}
-
-
-void SelectionDAGBuilder::visitLoad(LoadInst &LI) {
-  // FIXME: this won't prevent reordering of loads!
-  getNodeFor(LI)->setNode(ISD::Load, BB, getNodeFor(LI.getOperand(0)));  
-}
-
-void SelectionDAGBuilder::visitCall(CallInst &CI) {
-  SDTB.expandCall(DAG, CI);
-}
-
-
-
-// SelectionDAG constructor - Just use the SelectionDAGBuilder to do all of the
-// dirty work...
-SelectionDAG::SelectionDAG(MachineFunction &f, const TargetMachine &tm,
-                           SelectionDAGTargetBuilder &SDTB)
-  : F(f), TM(tm) {
-
-  switch (TM.getTargetData().getPointerSize()) {
-  default: assert(0 && "Unknown pointer size!"); abort();
-  case 1: PointerType = MVT::i8;  break;
-  case 2: PointerType = MVT::i16; break;
-  case 3: PointerType = MVT::i32; break;
-  case 4: PointerType = MVT::i64; break;
-  }
-
-  // Create all of the machine basic blocks for the function... building the
-  // BlockMap.  This map is used for PHI node conversion.
-  const Function &Fn = *F.getFunction();
-  for (Function::const_iterator I = Fn.begin(), E = Fn.end(); I != E; ++I)
-    F.getBasicBlockList().push_back(BlockMap[I] = new MachineBasicBlock(I));
-
-  SDTB.expandArguments(*this);
-
-  SelectionDAGBuilder SDB(*this, SDTB);
-  for (Function::const_iterator I = Fn.begin(), E = Fn.end(); I != E; ++I)
-    SDB.visitBB(const_cast<BasicBlock&>(*I));
-  Root = SDB.CurRoot;
-}
-