lib/Target/SparcV9/SparcV9InstrSelectionSupport.h

   1 //===-- llvm/CodeGen/SparcInstrSelectionSupport.h ---------------*- C++ -*-===//
   2 //
   3 //
   4 //
   5 //===----------------------------------------------------------------------===//
   6
   7 #ifndef SPARC_INSTR_SELECTION_SUPPORT_h
   8 #define SPARC_INSTR_SELECTION_SUPPORT_h
   9
  10 #include "llvm/DerivedTypes.h"
  11 #include "SparcInternals.h"
  12
  13 inline MachineOpCode
  14 ChooseLoadInstruction(const Type *DestTy)
  15 {
  16   switch (DestTy->getPrimitiveID()) {
  17   case Type::BoolTyID:
  18   case Type::UByteTyID:   return V9::LDUBr;
  19   case Type::SByteTyID:   return V9::LDSBr;
  20   case Type::UShortTyID:  return V9::LDUHr;
  21   case Type::ShortTyID:   return V9::LDSHr;
  22   case Type::UIntTyID:    return V9::LDUWr;
  23   case Type::IntTyID:     return V9::LDSWr;
  24   case Type::PointerTyID:
  25   case Type::ULongTyID:
  26   case Type::LongTyID:    return V9::LDXr;
  27   case Type::FloatTyID:   return V9::LDFr;
  28   case Type::DoubleTyID:  return V9::LDDFr;
  29   default: assert(0 && "Invalid type for Load instruction");
  30   }
  31
  32   return 0;
  33 }
  34
  35 inline MachineOpCode
  36 ChooseStoreInstruction(const Type *DestTy)
  37 {
  38   switch (DestTy->getPrimitiveID()) {
  39   case Type::BoolTyID:
  40   case Type::UByteTyID:
  41   case Type::SByteTyID:   return V9::STBr;
  42   case Type::UShortTyID:
  43   case Type::ShortTyID:   return V9::STHr;
  44   case Type::UIntTyID:
  45   case Type::IntTyID:     return V9::STWr;
  46   case Type::PointerTyID:
  47   case Type::ULongTyID:
  48   case Type::LongTyID:    return V9::STXr;
  49   case Type::FloatTyID:   return V9::STFr;
  50   case Type::DoubleTyID:  return V9::STDFr;
  51   default: assert(0 && "Invalid type for Store instruction");
  52   }
  53
  54   return 0;
  55 }
  56
  57
  58 inline MachineOpCode
  59 ChooseAddInstructionByType(const Type* resultType)
  60 {
  61   MachineOpCode opCode = V9::INVALID_OPCODE;
  62
  63   if (resultType->isIntegral() ||
  64       isa<PointerType>(resultType) ||
  65       isa<FunctionType>(resultType) ||
  66       resultType == Type::LabelTy)
  67   {
  68     opCode = V9::ADDr;
  69   }
  70   else
  71     switch(resultType->getPrimitiveID())
  72     {
  73     case Type::FloatTyID:  opCode = V9::FADDS; break;
  74     case Type::DoubleTyID: opCode = V9::FADDD; break;
  75     default: assert(0 && "Invalid type for ADD instruction"); break;
  76     }
  77
  78   return opCode;
  79 }
  80
  81
  82 static unsigned
  83 convertOpcodeFromRegToImm(unsigned Opcode) {
  84   switch (Opcode) {
  85     /* arithmetic */
  86   case V9::ADDr:     return V9::ADDi;
  87   case V9::ADDccr:   return V9::ADDcci;
  88   case V9::ADDCr:    return V9::ADDCi;
  89   case V9::ADDCccr:  return V9::ADDCcci;
  90   case V9::SUBr:     return V9::SUBi;
  91   case V9::SUBccr:   return V9::SUBcci;
  92   case V9::SUBCr:    return V9::SUBCi;
  93   case V9::SUBCccr:  return V9::SUBCcci;
  94   case V9::MULXr:    return V9::MULXi;
  95   case V9::SDIVXr:   return V9::SDIVXi;
  96   case V9::UDIVXr:   return V9::UDIVXi;
  97
  98     /* logical */
  99   case V9::ANDr:    return V9::ANDi;
 100   case V9::ANDccr:  return V9::ANDcci;
 101   case V9::ANDNr:   return V9::ANDNi;
 102   case V9::ANDNccr: return V9::ANDNcci;
 103   case V9::ORr:     return V9::ORi;
 104   case V9::ORccr:   return V9::ORcci;
 105   case V9::ORNr:    return V9::ORNi;
 106   case V9::ORNccr:  return V9::ORNcci;
 107   case V9::XORr:    return V9::XORi;
 108   case V9::XORccr:  return V9::XORcci;
 109   case V9::XNORr:   return V9::XNORi;
 110   case V9::XNORccr: return V9::XNORcci;
 111
 112     /* shift */
 113   case V9::SLLr5:   return V9::SLLi5;
 114   case V9::SRLr5:   return V9::SRLi5;
 115   case V9::SRAr5:   return V9::SRAi5;
 116   case V9::SLLXr6:  return V9::SLLXi6;
 117   case V9::SRLXr6:  return V9::SRLXi6;
 118   case V9::SRAXr6:  return V9::SRAXi6;
 119
 120     /* Conditional move on int comparison with zero */
 121   case V9::MOVRZr:   return V9::MOVRZi;
 122   case V9::MOVRLEZr: return V9::MOVRLEZi;
 123   case V9::MOVRLZr:  return V9::MOVRLZi;
 124   case V9::MOVRNZr:  return V9::MOVRNZi;
 125   case V9::MOVRGZr:  return V9::MOVRGZi;
 126   case V9::MOVRGEZr: return V9::MOVRGEZi;
 127
 128
 129     /* Conditional move on int condition code */
 130   case V9::MOVAr:   return V9::MOVAi;
 131   case V9::MOVNr:   return V9::MOVNi;
 132   case V9::MOVNEr:  return V9::MOVNEi;
 133   case V9::MOVEr:   return V9::MOVEi;
 134   case V9::MOVGr:   return V9::MOVGi;
 135   case V9::MOVLEr:  return V9::MOVLEi;
 136   case V9::MOVGEr:  return V9::MOVGEi;
 137   case V9::MOVLr:   return V9::MOVLi;
 138   case V9::MOVGUr:  return V9::MOVGUi;
 139   case V9::MOVLEUr: return V9::MOVLEUi;
 140   case V9::MOVCCr:  return V9::MOVCCi;
 141   case V9::MOVCSr:  return V9::MOVCSi;
 142   case V9::MOVPOSr: return V9::MOVPOSi;
 143   case V9::MOVNEGr: return V9::MOVNEGi;
 144   case V9::MOVVCr:  return V9::MOVVCi;
 145   case V9::MOVVSr:  return V9::MOVVSi;
 146
 147     /* Conditional move of int reg on fp condition code */
 148   case V9::MOVFAr:   return V9::MOVFAi;
 149   case V9::MOVFNr:   return V9::MOVFNi;
 150   case V9::MOVFUr:   return V9::MOVFUi;
 151   case V9::MOVFGr:   return V9::MOVFGi;
 152   case V9::MOVFUGr:  return V9::MOVFUGi;
 153   case V9::MOVFLr:   return V9::MOVFLi;
 154   case V9::MOVFULr:  return V9::MOVFULi;
 155   case V9::MOVFLGr:  return V9::MOVFLGi;
 156   case V9::MOVFNEr:  return V9::MOVFNEi;
 157   case V9::MOVFEr:   return V9::MOVFEi;
 158   case V9::MOVFUEr:  return V9::MOVFUEi;
 159   case V9::MOVFGEr:  return V9::MOVFGEi;
 160   case V9::MOVFUGEr: return V9::MOVFUGEi;
 161   case V9::MOVFLEr:  return V9::MOVFLEi;
 162   case V9::MOVFULEr: return V9::MOVFULEi;
 163   case V9::MOVFOr:   return V9::MOVFOi;
 164
 165     /* load */
 166   case V9::LDSBr:   return V9::LDSBi;
 167   case V9::LDSHr:   return V9::LDSHi;
 168   case V9::LDSWr:   return V9::LDSWi;
 169   case V9::LDUBr:   return V9::LDUBi;
 170   case V9::LDUHr:   return V9::LDUHi;
 171   case V9::LDUWr:   return V9::LDUWi;
 172   case V9::LDXr:    return V9::LDXi;
 173   case V9::LDFr:    return V9::LDFi;
 174   case V9::LDDFr:   return V9::LDDFi;
 175   case V9::LDQFr:   return V9::LDQFi;
 176   case V9::LDFSRr:  return V9::LDFSRi;
 177   case V9::LDXFSRr: return V9::LDXFSRi;
 178
 179     /* store */
 180   case V9::STBr:    return V9::STBi;
 181   case V9::STHr:    return V9::STHi;
 182   case V9::STWr:    return V9::STWi;
 183   case V9::STXr:    return V9::STXi;
 184   case V9::STFr:    return V9::STFi;
 185   case V9::STDFr:   return V9::STDFi;
 186   case V9::STFSRr:  return V9::STFSRi;
 187   case V9::STXFSRr: return V9::STXFSRi;
 188
 189     /* jump & return */
 190   case V9::JMPLCALLr: return V9::JMPLCALLi;
 191   case V9::JMPLRETr:  return V9::JMPLRETi;
 192   case V9::RETURNr:   return V9::RETURNi;
 193
 194   /* save and restore */
 195   case V9::SAVEr:     return V9::SAVEi;
 196   case V9::RESTOREr:  return V9::RESTOREi;
 197
 198   default:
 199     // It's already in correct format
 200     // Or, it's just not handled yet, but an assert() would break LLC
 201 #if 0
 202     std::cerr << "Unhandled opcode in convertOpcodeFromRegToImm(): " << Opcode
 203               << "\n";
 204 #endif
 205     return Opcode;
 206   }
 207 }
 208
 209 #endif