lib/Target/SparcV9/SparcV9InstrInfo.cpp

   1 // $Id$
   2 //***************************************************************************
   3 // File:
   4 //      SparcInstrInfo.cpp
   5 //
   6 // Purpose:
   7 //
   8 // History:
   9 //      10/15/01         -  Vikram Adve  -  Created
  10 //**************************************************************************/
  11
  12
  13 #include "SparcInternals.h"
  14 #include "SparcInstrSelectionSupport.h"
  15 #include "llvm/Target/Sparc.h"
  16 #include "llvm/CodeGen/InstrSelection.h"
  17 #include "llvm/CodeGen/InstrSelectionSupport.h"
  18 #include "llvm/CodeGen/MachineInstr.h"
  19 #include "llvm/CodeGen/MachineCodeForMethod.h"
  20 #include "llvm/Method.h"
  21 #include "llvm/ConstantVals.h"
  22 #include "llvm/DerivedTypes.h"
  23
  24
  25 //************************ Internal Functions ******************************/
  26
  27
  28 static inline MachineInstr*
  29 CreateIntSetInstruction(int64_t C, Value* dest,
  30                         std::vector<TmpInstruction*>& tempVec)
  31 {
  32   MachineInstr* minstr;
  33   uint64_t absC = (C >= 0)? C : -C;
  34   if (absC > (unsigned int) ~0)
  35     { // C does not fit in 32 bits
  36       TmpInstruction* tmpReg = new TmpInstruction(Type::IntTy);
  37       tempVec.push_back(tmpReg);
  38
  39       minstr = new MachineInstr(SETX);
  40       minstr->SetMachineOperandConst(0, MachineOperand::MO_SignExtendedImmed, C);
  41       minstr->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, tmpReg,
  42                                    /*isdef*/ true);
  43       minstr->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister,dest);
  44     }
  45   else
  46     {
  47       minstr = new MachineInstr(SETSW);
  48       minstr->SetMachineOperandConst(0, MachineOperand::MO_SignExtendedImmed, C);
  49       minstr->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, dest);
  50     }
  51
  52   return minstr;
  53 }
  54
  55 static inline MachineInstr*
  56 CreateUIntSetInstruction(uint64_t C, Value* dest,
  57                          std::vector<TmpInstruction*>& tempVec)
  58 {
  59   MachineInstr* minstr;
  60   if (C > (unsigned int) ~0)
  61     { // C does not fit in 32 bits
  62       TmpInstruction *tmpReg = new TmpInstruction(Type::IntTy);
  63       tempVec.push_back(tmpReg);
  64
  65       minstr = new MachineInstr(SETX);
  66       minstr->SetMachineOperandConst(0, MachineOperand::MO_SignExtendedImmed, C);
  67       minstr->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, tmpReg,
  68                                    /*isdef*/ true);
  69       minstr->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister,dest);
  70     }
  71   else
  72     {
  73       minstr = new MachineInstr(SETUW);
  74       minstr->SetMachineOperandConst(0, MachineOperand::MO_UnextendedImmed, C);
  75       minstr->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, dest);
  76     }
  77
  78   return minstr;
  79 }
  80
  81 //************************* External Classes *******************************/
  82
  83 //---------------------------------------------------------------------------
  84 // class UltraSparcInstrInfo
  85 //
  86 // Purpose:
  87 //   Information about individual instructions.
  88 //   Most information is stored in the SparcMachineInstrDesc array above.
  89 //   Other information is computed on demand, and most such functions
  90 //   default to member functions in base class MachineInstrInfo.
  91 //---------------------------------------------------------------------------
  92
  93 /*ctor*/
  94 UltraSparcInstrInfo::UltraSparcInstrInfo(const TargetMachine& tgt)
  95   : MachineInstrInfo(tgt, SparcMachineInstrDesc,
  96                      /*descSize = */ NUM_TOTAL_OPCODES,
  97                      /*numRealOpCodes = */ NUM_REAL_OPCODES)
  98 {
  99 }
 100
 101 //
 102 // Create an instruction sequence to put the constant `val' into
 103 // the virtual register `dest'.  `val' may be a Constant or a
 104 // GlobalValue, viz., the constant address of a global variable or function.
 105 // The generated instructions are returned in `minstrVec'.
 106 // Any temp. registers (TmpInstruction) created are returned in `tempVec'.
 107 //
 108 void
 109 UltraSparcInstrInfo::CreateCodeToLoadConst(Method* method,
 110                                            Value* val,
 111                                            Instruction* dest,
 112                                            std::vector<MachineInstr*>& minstrVec,
 113                                            std::vector<TmpInstruction*>& tempVec) const
 114 {
 115   MachineInstr* minstr;
 116
 117   assert(isa<Constant>(val) || isa<GlobalValue>(val) &&
 118          "I only know about constant values and global addresses");
 119
 120   // Use a "set" instruction for known constants that can go in an integer reg.
 121   // Use a "load" instruction for all other constants, in particular,
 122   // floating point constants and addresses of globals.
 123   //
 124   const Type* valType = val->getType();
 125
 126   if (valType->isIntegral() || valType == Type::BoolTy)
 127     {
 128       if (ConstantUInt* uval = dyn_cast<ConstantUInt>(val))
 129         {
 130           uint64_t C = uval->getValue();
 131           minstr = CreateUIntSetInstruction(C, dest, tempVec);
 132         }
 133       else
 134         {
 135           bool isValidConstant;
 136           int64_t C = GetConstantValueAsSignedInt(val, isValidConstant);
 137           assert(isValidConstant && "Unrecognized constant");
 138           minstr = CreateIntSetInstruction(C, dest, tempVec);
 139         }
 140       minstrVec.push_back(minstr);
 141     }
 142   else
 143     {
 144       // Make an instruction sequence to load the constant, viz:
 145       //            SETX <addr-of-constant>, tmpReg, addrReg
 146       //            LOAD  /*addr*/ addrReg, /*offset*/ 0, dest
 147       // Only the SETX is needed if `val' is a GlobalValue, i.e,. it is
 148       // itself a constant address.  Otherwise, both are needed.
 149
 150       Value* addrVal;
 151       int64_t zeroOffset = 0; // to avoid ambiguity with (Value*) 0
 152
 153       TmpInstruction* tmpReg =
 154         new TmpInstruction(PointerType::get(val->getType()), val);
 155       tempVec.push_back(tmpReg);
 156
 157       if (isa<Constant>(val))
 158         {
 159           // Create another TmpInstruction for the hidden integer register
 160           TmpInstruction* addrReg =
 161             new TmpInstruction(PointerType::get(val->getType()), val);
 162           tempVec.push_back(addrReg);
 163           addrVal = addrReg;
 164         }
 165       else
 166         addrVal = dest;
 167
 168       minstr = new MachineInstr(SETX);
 169       minstr->SetMachineOperandVal(0, MachineOperand::MO_PCRelativeDisp, val);
 170       minstr->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, tmpReg,
 171                                    /*isdef*/ true);
 172       minstr->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister,addrVal);
 173       minstrVec.push_back(minstr);
 174
 175       if (isa<Constant>(val))
 176         {
 177           // Make sure constant is emitted to constant pool in assembly code.
 178           MachineCodeForMethod& mcinfo = MachineCodeForMethod::get(method);
 179           mcinfo.addToConstantPool(cast<Constant>(val));
 180
 181           // Generate the load instruction
 182           minstr = new MachineInstr(ChooseLoadInstruction(val->getType()));
 183           minstr->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister,
 184                                        addrVal);
 185           minstr->SetMachineOperandConst(1, MachineOperand::MO_SignExtendedImmed,
 186                                        zeroOffset);
 187           minstr->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister,
 188                                        dest);
 189           minstrVec.push_back(minstr);
 190         }
 191     }
 192 }
 193
 194
 195 // Create an instruction sequence to copy an integer value `val'
 196 // to a floating point value `dest' by copying to memory and back.
 197 // val must be an integral type.  dest must be a Float or Double.
 198 // The generated instructions are returned in `minstrVec'.
 199 // Any temp. registers (TmpInstruction) created are returned in `tempVec'.
 200 //
 201 void
 202 UltraSparcInstrInfo::CreateCodeToCopyIntToFloat(Method* method,
 203                                          Value* val,
 204                                          Instruction* dest,
 205                                          std::vector<MachineInstr*>& minstrVec,
 206                                          std::vector<TmpInstruction*>& tempVec,
 207                                          TargetMachine& target) const
 208 {
 209   assert((val->getType()->isIntegral() || val->getType()->isPointerType())
 210          && "Source type must be integral");
 211   assert((dest->getType() ==Type::FloatTy || dest->getType() ==Type::DoubleTy)
 212          && "Dest type must be float/double");
 213
 214   MachineCodeForMethod& mcinfo = MachineCodeForMethod::get(method);
 215   int offset = mcinfo.allocateLocalVar(target, val);
 216
 217   // Store instruction stores `val' to [%fp+offset].
 218   // The store and load opCodes are based on the value being copied, and
 219   // they use integer and float types that accomodate the
 220   // larger of the source type and the destination type:
 221   // On SparcV9: int for float, long for double.
 222   //
 223   Type* tmpType = (dest->getType() == Type::FloatTy)? Type::IntTy
 224                                                     : Type::LongTy;
 225   MachineInstr* store = new MachineInstr(ChooseStoreInstruction(tmpType));
 226   store->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, val);
 227   store->SetMachineOperandReg(1, target.getRegInfo().getFramePointer());
 228   store->SetMachineOperandConst(2, MachineOperand::MO_SignExtendedImmed, offset);
 229   minstrVec.push_back(store);
 230
 231   // Load instruction loads [%fp+offset] to `dest'.
 232   //
 233   MachineInstr* load =new MachineInstr(ChooseLoadInstruction(dest->getType()));
 234   load->SetMachineOperandReg(0, target.getRegInfo().getFramePointer());
 235   load->SetMachineOperandConst(1, MachineOperand::MO_SignExtendedImmed,offset);
 236   load->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister, dest);
 237   minstrVec.push_back(load);
 238 }
 239
 240
 241 // Similarly, create an instruction sequence to copy an FP value
 242 // `val' to an integer value `dest' by copying to memory and back.
 243 // See the previous function for information about return values.
 244 //
 245 void
 246 UltraSparcInstrInfo::CreateCodeToCopyFloatToInt(Method* method,
 247                                         Value* val,
 248                                         Instruction* dest,
 249                                         std::vector<MachineInstr*>& minstrVec,
 250                                         std::vector<TmpInstruction*>& tempVec,
 251                                         TargetMachine& target) const
 252 {
 253   assert((val->getType() ==Type::FloatTy || val->getType() ==Type::DoubleTy)
 254          && "Source type must be float/double");
 255   assert((dest->getType()->isIntegral() || dest->getType()->isPointerType())
 256          && "Dest type must be integral");
 257
 258   MachineCodeForMethod& mcinfo = MachineCodeForMethod::get(method);
 259   int offset = mcinfo.allocateLocalVar(target, val);
 260
 261   // Store instruction stores `val' to [%fp+offset].
 262   // The store and load opCodes are based on the value being copied, and
 263   // they use the integer type that matches the source type in size:
 264   // On SparcV9: int for float, long for double.
 265   //
 266   Type* tmpType = (val->getType() == Type::FloatTy)? Type::IntTy
 267                                                    : Type::LongTy;
 268   MachineInstr* store=new MachineInstr(ChooseStoreInstruction(val->getType()));
 269   store->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, val);
 270   store->SetMachineOperandReg(1, target.getRegInfo().getFramePointer());
 271   store->SetMachineOperandConst(2,MachineOperand::MO_SignExtendedImmed,offset);
 272   minstrVec.push_back(store);
 273
 274   // Load instruction loads [%fp+offset] to `dest'.
 275   //
 276   MachineInstr* load = new MachineInstr(ChooseLoadInstruction(tmpType));
 277   load->SetMachineOperandReg(0, target.getRegInfo().getFramePointer());
 278   load->SetMachineOperandConst(1, MachineOperand::MO_SignExtendedImmed, offset);
 279   load->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister, dest);
 280   minstrVec.push_back(load);
 281 }