lib/CodeGen/SelectionDAG/SelectionDAG.cpp

   1 //===-- SelectionDAG.cpp - Implement the SelectionDAG* classes ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the SelectionDAG* classes, which are used to perform
  11 // DAG-based instruction selection in a target-specific manner.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/CodeGen/SelectionDAG.h"
  16 #include "llvm/Type.h"
  17 #include <iostream>
  18
  19 using namespace llvm;
  20
  21 SelectionDAG::~SelectionDAG() {
  22   for (unsigned i = 0, e = AllNodes.size(); i != e; ++i)
  23     delete AllNodes[i];
  24 }
  25
  26
  27 /// dump - Print out the current Selection DAG...
  28 void SelectionDAG::dump() const {
  29   Root->dump();  // Print from the root...
  30 }
  31
  32 /// getValueType - Return the ValueType for the specified LLVM type.  This
  33 /// method works on all scalar LLVM types.
  34 ///
  35 MVT::ValueType SelectionDAG::getValueType(const Type *Ty) const {
  36   switch (Ty->getTypeID()) {
  37   case Type::VoidTyID: assert(0 && "Void type object in getValueType!");
  38   default: assert(0 && "Unknown type in DAGBuilder!\n");
  39   case Type::BoolTyID:    return MVT::i1;
  40   case Type::SByteTyID:
  41   case Type::UByteTyID:   return MVT::i8;
  42   case Type::ShortTyID:
  43   case Type::UShortTyID:  return MVT::i16;
  44   case Type::IntTyID:
  45   case Type::UIntTyID:    return MVT::i32;
  46   case Type::LongTyID:
  47   case Type::ULongTyID:   return MVT::i64;
  48   case Type::FloatTyID:   return MVT::f32;
  49   case Type::DoubleTyID:  return MVT::f64;
  50   case Type::LabelTyID:
  51   case Type::PointerTyID: return PointerType;
  52   }
  53 }
  54
  55 void SelectionDAGNode::dump() const {
  56   // Print out the DAG in post-order
  57   std::map<const SelectionDAGNode*, unsigned> NodeIDs;
  58   unsigned ID = 0;
  59   printit(0, ID, NodeIDs);
  60 }
  61
  62 void SelectionDAGNode::printit(unsigned Offset, unsigned &LastID,
  63                                std::map<const SelectionDAGNode*,
  64                                         unsigned> &NodeIDs) const {
  65   if (!NodeIDs.count(this)) {
  66     // Emit all of the uses first...
  67     for (unsigned i = 0, e = Uses.size(); i != e; ++i)
  68       Uses[i]->printit(Offset+1, LastID, NodeIDs);
  69
  70     NodeIDs[this] = LastID++;
  71
  72     std::cerr << std::string(Offset, ' ') << "#" << LastID-1 << " ";
  73   } else {
  74     // Node has already been emitted...
  75     std::cerr << std::string(Offset, ' ') << "#" << NodeIDs[this] << " ";
  76   }
  77
  78   switch (ValueType) {
  79   case MVT::isVoid: std::cerr << "V:"; break;
  80   case MVT::i1:   std::cerr << "i1:"; break;
  81   case MVT::i8:   std::cerr << "i8:"; break;
  82   case MVT::i16:  std::cerr << "i16:"; break;
  83   case MVT::i32:  std::cerr << "i32:"; break;
  84   case MVT::i64:  std::cerr << "i64:"; break;
  85   case MVT::f32:  std::cerr << "f32:"; break;
  86   case MVT::f64:  std::cerr << "f64:"; break;
  87   default: assert(0 && "Invalid node ValueType!");
  88   }
  89   switch (NodeType) {
  90   case ISD::ChainNode:      std::cerr << "ChainNode"; break;
  91   case ISD::BlockChainNode: std::cerr << "BlockChainNode"; break;
  92   case ISD::ProtoNode:      std::cerr << "ProtoNode"; break;
  93
  94   case ISD::Constant:       std::cerr << "Constant"; break;
  95   case ISD::FrameIndex:     std::cerr << "FrameIndex"; break;
  96   case ISD::BasicBlock:     std::cerr << "BasicBlock"; break;
  97
  98   case ISD::Plus:           std::cerr << "Plus"; break;
  99   case ISD::Minus:          std::cerr << "Minus"; break;
 100   case ISD::Times:          std::cerr << "Times"; break;
 101   case ISD::SDiv:           std::cerr << "SDiv"; break;
 102   case ISD::UDiv:           std::cerr << "UDiv"; break;
 103   case ISD::SRem:           std::cerr << "SRem"; break;
 104   case ISD::URem:           std::cerr << "URem"; break;
 105   case ISD::And:            std::cerr << "And"; break;
 106   case ISD::Or:             std::cerr << "Or"; break;
 107   case ISD::Xor:            std::cerr << "Xor"; break;
 108
 109   case ISD::SetEQ:          std::cerr << "SetEQ"; break;
 110   case ISD::SetNE:          std::cerr << "SetNE"; break;
 111   case ISD::SetLT:          std::cerr << "SetLT"; break;
 112   case ISD::SetLE:          std::cerr << "SetLE"; break;
 113   case ISD::SetGT:          std::cerr << "SetGT"; break;
 114   case ISD::SetGE:          std::cerr << "SetGE"; break;
 115
 116   case ISD::Br:             std::cerr << "Br"; break;
 117   case ISD::BrCond:         std::cerr << "BrCond"; break;
 118   case ISD::Switch:         std::cerr << "Switch"; break;
 119   case ISD::Ret:            std::cerr << "Ret"; break;
 120   case ISD::RetVoid:        std::cerr << "RetVoid"; break;
 121   case ISD::Load:           std::cerr << "Load"; break;
 122   case ISD::Store:          std::cerr << "Store"; break;
 123   case ISD::PHI:            std::cerr << "PHI"; break;
 124   case ISD::Call:           std::cerr << "Call"; break;
 125
 126   case ISD::Unspec1:        std::cerr << "Unspec1"; break;
 127   case ISD::Unspec2:        std::cerr << "Unspec2"; break;
 128   }
 129
 130   std::cerr << "\n";
 131 }