lib/Target/CellSPU/SPUInstrInfo.cpp

   1 //===- SPUInstrInfo.cpp - Cell SPU Instruction Information ------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by a team from the Computer Systems Research
   6 // Department at The Aerospace Corporation.
   7 //
   8 // See README.txt for details.
   9 //
  10 //===----------------------------------------------------------------------===//
  11 //
  12 // This file contains the Cell SPU implementation of the TargetInstrInfo class.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "SPURegisterNames.h"
  17 #include "SPUInstrInfo.h"
  18 #include "SPUTargetMachine.h"
  19 #include "SPUGenInstrInfo.inc"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include <iostream>
  22
  23 using namespace llvm;
  24
  25 SPUInstrInfo::SPUInstrInfo(SPUTargetMachine &tm)
  26   : TargetInstrInfo(SPUInsts, sizeof(SPUInsts)/sizeof(SPUInsts[0])),
  27     TM(tm),
  28     RI(*TM.getSubtargetImpl(), *this)
  29 {
  30   /* NOP */
  31 }
  32
  33 /// getPointerRegClass - Return the register class to use to hold pointers.
  34 /// This is used for addressing modes.
  35 const TargetRegisterClass *
  36 SPUInstrInfo::getPointerRegClass() const
  37 {
  38   return &SPU::R32CRegClass;
  39 }
  40
  41 bool
  42 SPUInstrInfo::isMoveInstr(const MachineInstr& MI,
  43                           unsigned& sourceReg,
  44                           unsigned& destReg) const {
  45   // Primarily, ORI and OR are generated by copyRegToReg. But, there are other
  46   // cases where we can safely say that what's being done is really a move
  47   // (see how PowerPC does this -- it's the model for this code too.)
  48   switch (MI.getOpcode()) {
  49   default:
  50     break;
  51   case SPU::ORIv4i32:
  52   case SPU::ORIr32:
  53   case SPU::ORIf64:
  54   case SPU::ORIf32:
  55   case SPU::ORIr64:
  56   case SPU::ORHIv8i16:
  57   case SPU::ORHIr16:
  58     // case SPU::ORHI1To2:
  59   case SPU::ORBIv16i8:
  60     //case SPU::ORBIr8:
  61   case SPU::ORI2To4:
  62     // case SPU::ORI1To4:
  63   case SPU::AHIvec:
  64   case SPU::AHIr16:
  65   case SPU::AIvec:
  66   case SPU::AIr32:
  67     assert(MI.getNumOperands() == 3 &&
  68            MI.getOperand(0).isRegister() &&
  69            MI.getOperand(1).isRegister() &&
  70            MI.getOperand(2).isImmediate() &&
  71            "invalid SPU ORI/ORHI/ORBI/AHI/AI/SFI/SFHI instruction!");
  72     if (MI.getOperand(2).getImmedValue() == 0) {
  73       sourceReg = MI.getOperand(1).getReg();
  74       destReg = MI.getOperand(0).getReg();
  75       return true;
  76     }
  77     break;
  78 #if 0
  79   case SPU::ORIf64:
  80   case SPU::ORIf32:
  81     // Special case because there's no third immediate operand to the
  82     // instruction (the constant is embedded in the instruction)
  83     assert(MI.getOperand(0).isRegister() &&
  84            MI.getOperand(1).isRegister() &&
  85            "ORIf32/f64: operands not registers");
  86     sourceReg = MI.getOperand(1).getReg();
  87     destReg = MI.getOperand(0).getReg();
  88     return true;
  89 #endif
  90     // case SPU::ORv16i8_i8:
  91   case SPU::ORv8i16_i16:
  92   case SPU::ORv4i32_i32:
  93   case SPU::ORv2i64_i64:
  94   case SPU::ORv4f32_f32:
  95   case SPU::ORv2f64_f64:
  96     // case SPU::ORi8_v16i8:
  97   case SPU::ORi16_v8i16:
  98   case SPU::ORi32_v4i32:
  99   case SPU::ORi64_v2i64:
 100   case SPU::ORf32_v4f32:
 101   case SPU::ORf64_v2f64:
 102   case SPU::ORv16i8:
 103   case SPU::ORv8i16:
 104   case SPU::ORv4i32:
 105   case SPU::ORr32:
 106   case SPU::ORr64:
 107   case SPU::ORgprc:
 108     assert(MI.getNumOperands() == 3 &&
 109            MI.getOperand(0).isRegister() &&
 110            MI.getOperand(1).isRegister() &&
 111            MI.getOperand(2).isRegister() &&
 112            "invalid SPU OR(vec|r32|r64|gprc) instruction!");
 113     if (MI.getOperand(1).getReg() == MI.getOperand(2).getReg()) {
 114       sourceReg = MI.getOperand(1).getReg();
 115       destReg = MI.getOperand(0).getReg();
 116       return true;
 117     }
 118     break;
 119   }
 120
 121   return false;
 122 }
 123
 124 unsigned
 125 SPUInstrInfo::isLoadFromStackSlot(MachineInstr *MI, int &FrameIndex) const {
 126   switch (MI->getOpcode()) {
 127   default: break;
 128   case SPU::LQDv16i8:
 129   case SPU::LQDv8i16:
 130   case SPU::LQDv4i32:
 131   case SPU::LQDv4f32:
 132   case SPU::LQDv2f64:
 133   case SPU::LQDr128:
 134   case SPU::LQDr64:
 135   case SPU::LQDr32:
 136   case SPU::LQDr16:
 137   case SPU::LQXv4i32:
 138   case SPU::LQXr128:
 139   case SPU::LQXr64:
 140   case SPU::LQXr32:
 141   case SPU::LQXr16:
 142     if (MI->getOperand(1).isImmediate() && !MI->getOperand(1).getImmedValue() &&
 143         MI->getOperand(2).isFrameIndex()) {
 144       FrameIndex = MI->getOperand(2).getFrameIndex();
 145       return MI->getOperand(0).getReg();
 146     }
 147     break;
 148   }
 149   return 0;
 150 }
 151
 152 unsigned
 153 SPUInstrInfo::isStoreToStackSlot(MachineInstr *MI, int &FrameIndex) const {
 154   switch (MI->getOpcode()) {
 155   default: break;
 156   case SPU::STQDv16i8:
 157   case SPU::STQDv8i16:
 158   case SPU::STQDv4i32:
 159   case SPU::STQDv4f32:
 160   case SPU::STQDv2f64:
 161   case SPU::STQDr128:
 162   case SPU::STQDr64:
 163   case SPU::STQDr32:
 164   case SPU::STQDr16:
 165     // case SPU::STQDr8:
 166   case SPU::STQXv16i8:
 167   case SPU::STQXv8i16:
 168   case SPU::STQXv4i32:
 169   case SPU::STQXv4f32:
 170   case SPU::STQXv2f64:
 171   case SPU::STQXr128:
 172   case SPU::STQXr64:
 173   case SPU::STQXr32:
 174   case SPU::STQXr16:
 175     // case SPU::STQXr8:
 176     if (MI->getOperand(1).isImmediate() && !MI->getOperand(1).getImmedValue() &&
 177         MI->getOperand(2).isFrameIndex()) {
 178       FrameIndex = MI->getOperand(2).getFrameIndex();
 179       return MI->getOperand(0).getReg();
 180     }
 181     break;
 182   }
 183   return 0;
 184 }