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