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