lib/Target/SparcV8/SparcV8ISelSimple.cpp

   1 //===-- InstSelectSimple.cpp - A simple instruction selector for SparcV8 --===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines a simple peephole instruction selector for the V8 target
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "SparcV8.h"
  15 #include "SparcV8InstrInfo.h"
  16 #include "llvm/Instructions.h"
  17 #include "llvm/IntrinsicLowering.h"
  18 #include "llvm/Pass.h"
  19 #include "llvm/Constants.h"
  20 #include "llvm/CodeGen/MachineInstrBuilder.h"
  21 #include "llvm/CodeGen/MachineFunction.h"
  22 #include "llvm/CodeGen/SSARegMap.h"
  23 #include "llvm/Target/TargetMachine.h"
  24 #include "llvm/Support/GetElementPtrTypeIterator.h"
  25 #include "llvm/Support/InstVisitor.h"
  26 #include "llvm/Support/CFG.h"
  27 using namespace llvm;
  28
  29 namespace {
  30   struct V8ISel : public FunctionPass, public InstVisitor<V8ISel> {
  31     TargetMachine &TM;
  32     MachineFunction *F;                 // The function we are compiling into
  33     MachineBasicBlock *BB;              // The current MBB we are compiling
  34
  35     std::map<Value*, unsigned> RegMap;  // Mapping between Val's and SSA Regs
  36
  37     // MBBMap - Mapping between LLVM BB -> Machine BB
  38     std::map<const BasicBlock*, MachineBasicBlock*> MBBMap;
  39
  40     V8ISel(TargetMachine &tm) : TM(tm), F(0), BB(0) {}
  41
  42     /// runOnFunction - Top level implementation of instruction selection for
  43     /// the entire function.
  44     ///
  45     bool runOnFunction(Function &Fn);
  46
  47     virtual const char *getPassName() const {
  48       return "SparcV8 Simple Instruction Selection";
  49     }
  50
  51     /// visitBasicBlock - This method is called when we are visiting a new basic
  52     /// block.  This simply creates a new MachineBasicBlock to emit code into
  53     /// and adds it to the current MachineFunction.  Subsequent visit* for
  54     /// instructions will be invoked for all instructions in the basic block.
  55     ///
  56     void visitBasicBlock(BasicBlock &LLVM_BB) {
  57       BB = MBBMap[&LLVM_BB];
  58     }
  59
  60         void visitBinaryOperator(BinaryOperator &I);
  61         void visitCallInst(CallInst &I);
  62         void visitReturnInst(ReturnInst &RI);
  63
  64     void visitInstruction(Instruction &I) {
  65       std::cerr << "Unhandled instruction: " << I;
  66       abort();
  67     }
  68
  69     /// LowerUnknownIntrinsicFunctionCalls - This performs a prepass over the
  70     /// function, lowering any calls to unknown intrinsic functions into the
  71     /// equivalent LLVM code.
  72     void LowerUnknownIntrinsicFunctionCalls(Function &F);
  73     void visitIntrinsicCall(Intrinsic::ID ID, CallInst &CI);
  74
  75     /// copyConstantToRegister - Output the instructions required to put the
  76     /// specified constant into the specified register.
  77     ///
  78     void copyConstantToRegister(MachineBasicBlock *MBB,
  79                                 MachineBasicBlock::iterator IP,
  80                                 Constant *C, unsigned R);
  81
  82     /// makeAnotherReg - This method returns the next register number we haven't
  83     /// yet used.
  84     ///
  85     /// Long values are handled somewhat specially.  They are always allocated
  86     /// as pairs of 32 bit integer values.  The register number returned is the
  87     /// lower 32 bits of the long value, and the regNum+1 is the upper 32 bits
  88     /// of the long value.
  89     ///
  90     unsigned makeAnotherReg(const Type *Ty) {
  91       assert(dynamic_cast<const SparcV8RegisterInfo*>(TM.getRegisterInfo()) &&
  92              "Current target doesn't have SparcV8 reg info??");
  93       const SparcV8RegisterInfo *MRI =
  94         static_cast<const SparcV8RegisterInfo*>(TM.getRegisterInfo());
  95       if (Ty == Type::LongTy || Ty == Type::ULongTy) {
  96         const TargetRegisterClass *RC = MRI->getRegClassForType(Type::IntTy);
  97         // Create the lower part
  98         F->getSSARegMap()->createVirtualRegister(RC);
  99         // Create the upper part.
 100         return F->getSSARegMap()->createVirtualRegister(RC)-1;
 101       }
 102
 103       // Add the mapping of regnumber => reg class to MachineFunction
 104       const TargetRegisterClass *RC = MRI->getRegClassForType(Ty);
 105       return F->getSSARegMap()->createVirtualRegister(RC);
 106     }
 107
 108     unsigned getReg(Value &V) { return getReg (&V); } // allow refs.
 109     unsigned getReg(Value *V) {
 110       // Just append to the end of the current bb.
 111       MachineBasicBlock::iterator It = BB->end();
 112       return getReg(V, BB, It);
 113     }
 114     unsigned getReg(Value *V, MachineBasicBlock *MBB,
 115                     MachineBasicBlock::iterator IPt) {
 116       unsigned &Reg = RegMap[V];
 117       if (Reg == 0) {
 118         Reg = makeAnotherReg(V->getType());
 119         RegMap[V] = Reg;
 120       }
 121       // If this operand is a constant, emit the code to copy the constant into
 122       // the register here...
 123       //
 124       if (Constant *C = dyn_cast<Constant>(V)) {
 125         copyConstantToRegister(MBB, IPt, C, Reg);
 126         RegMap.erase(V);  // Assign a new name to this constant if ref'd again
 127       } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
 128         // Move the address of the global into the register
 129         unsigned TmpReg = makeAnotherReg(V->getType());
 130         BuildMI (*MBB, IPt, V8::SETHIi, 1, TmpReg).addGlobalAddress (GV);
 131         BuildMI (*MBB, IPt, V8::ORri, 2, Reg).addReg (TmpReg)
 132           .addGlobalAddress (GV);
 133         RegMap.erase(V);  // Assign a new name to this address if ref'd again
 134       }
 135
 136       return Reg;
 137     }
 138
 139   };
 140 }
 141
 142 FunctionPass *llvm::createSparcV8SimpleInstructionSelector(TargetMachine &TM) {
 143   return new V8ISel(TM);
 144 }
 145
 146 enum TypeClass {
 147   cByte, cShort, cInt, cLong, cFloat, cDouble
 148 };
 149
 150 static TypeClass getClass (const Type *T) {
 151   switch (T->getPrimitiveID ()) {
 152     case Type::UByteTyID:  case Type::SByteTyID:  return cByte;
 153     case Type::UShortTyID: case Type::ShortTyID:  return cShort;
 154     case Type::UIntTyID:   case Type::IntTyID:    return cInt;
 155     case Type::ULongTyID:  case Type::LongTyID:   return cLong;
 156     case Type::FloatTyID:                         return cFloat;
 157     case Type::DoubleTyID:                        return cDouble;
 158     default:
 159       assert (0 && "Type of unknown class passed to getClass?");
 160       return cByte;
 161   }
 162 }
 163
 164 /// copyConstantToRegister - Output the instructions required to put the
 165 /// specified constant into the specified register.
 166 ///
 167 void V8ISel::copyConstantToRegister(MachineBasicBlock *MBB,
 168                                     MachineBasicBlock::iterator IP,
 169                                     Constant *C, unsigned R) {
 170   if (ConstantInt *CI = dyn_cast<ConstantInt> (C)) {
 171     unsigned Class = getClass(C->getType());
 172     switch (Class) {
 173       case cByte:
 174         BuildMI (*MBB, IP, V8::ORri, 2, R).addReg (V8::G0).addImm ((uint8_t) CI->getRawValue ());
 175         return;
 176       case cShort: {
 177         unsigned TmpReg = makeAnotherReg (C->getType ());
 178         BuildMI (*MBB, IP, V8::SETHIi, 1, TmpReg).addImm (((uint16_t) CI->getRawValue ()) >> 10);
 179         BuildMI (*MBB, IP, V8::ORri, 2, R).addReg (TmpReg).addImm (((uint16_t) CI->getRawValue ()) & 0x03ff);
 180         return;
 181       }
 182       case cInt: {
 183         unsigned TmpReg = makeAnotherReg (C->getType ());
 184         BuildMI (*MBB, IP, V8::SETHIi, 1, TmpReg).addImm (((uint32_t) CI->getRawValue ()) >> 10);
 185         BuildMI (*MBB, IP, V8::ORri, 2, R).addReg (TmpReg).addImm (((uint32_t) CI->getRawValue ()) & 0x03ff);
 186         return;
 187       }
 188       case cLong: {
 189         unsigned TmpReg = makeAnotherReg (Type::UIntTy);
 190         uint32_t topHalf, bottomHalf;
 191         topHalf = (uint32_t) (CI->getRawValue () >> 32);
 192         bottomHalf = (uint32_t) (CI->getRawValue () & 0x0ffffffffULL);
 193         BuildMI (*MBB, IP, V8::SETHIi, 1, TmpReg).addImm (topHalf >> 10);
 194         BuildMI (*MBB, IP, V8::ORri, 2, R).addReg (TmpReg).addImm (topHalf & 0x03ff);
 195         BuildMI (*MBB, IP, V8::SETHIi, 1, TmpReg).addImm (bottomHalf >> 10);
 196         BuildMI (*MBB, IP, V8::ORri, 2, R).addReg (TmpReg).addImm (bottomHalf & 0x03ff);
 197         return;
 198       }
 199       default:
 200         std::cerr << "Offending constant: " << *C << "\n";
 201         assert (0 && "Can't copy this kind of constant into register yet");
 202         return;
 203     }
 204   }
 205
 206   std::cerr << "Offending constant: " << *C << "\n";
 207   assert (0 && "Can't copy this kind of constant into register yet");
 208 }
 209
 210 bool V8ISel::runOnFunction(Function &Fn) {
 211   // First pass over the function, lower any unknown intrinsic functions
 212   // with the IntrinsicLowering class.
 213   LowerUnknownIntrinsicFunctionCalls(Fn);
 214
 215   F = &MachineFunction::construct(&Fn, TM);
 216
 217   // Create all of the machine basic blocks for the function...
 218   for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I)
 219     F->getBasicBlockList().push_back(MBBMap[I] = new MachineBasicBlock(I));
 220
 221   BB = &F->front();
 222
 223   // Set up a frame object for the return address.  This is used by the
 224   // llvm.returnaddress & llvm.frameaddress intrinisics.
 225   //ReturnAddressIndex = F->getFrameInfo()->CreateFixedObject(4, -4);
 226
 227   // Copy incoming arguments off of the stack and out of fixed registers.
 228   //LoadArgumentsToVirtualRegs(Fn);
 229
 230   // Instruction select everything except PHI nodes
 231   visit(Fn);
 232
 233   // Select the PHI nodes
 234   //SelectPHINodes();
 235
 236   RegMap.clear();
 237   MBBMap.clear();
 238   F = 0;
 239   // We always build a machine code representation for the function
 240   return true;
 241 }
 242
 243 void V8ISel::visitCallInst(CallInst &I) {
 244   assert (I.getNumOperands () == 1 && "Can't handle call args yet");
 245   unsigned DestReg = getReg (I);
 246   BuildMI (BB, V8::CALL, 1).addPCDisp (I.getOperand (0));
 247   if (I.getType ()->getPrimitiveID () == Type::VoidTyID)
 248     return;
 249   // Deal w/ return value
 250   switch (getClass (I.getType ())) {
 251     case cByte:
 252     case cShort:
 253     case cInt:
 254       // Schlep it over into the destination register
 255       BuildMI (BB, V8::ORrr, 2, DestReg).addReg(V8::G0).addReg(V8::O0);
 256       break;
 257     default:
 258       visitInstruction (I);
 259       return;
 260   }
 261 }
 262
 263 void V8ISel::visitReturnInst(ReturnInst &I) {
 264   if (I.getNumOperands () == 1) {
 265     unsigned RetValReg = getReg (I.getOperand (0));
 266     switch (getClass (I.getOperand (0)->getType ())) {
 267       case cByte:
 268       case cShort:
 269       case cInt:
 270         // Schlep it over into i0 (where it will become o0 after restore).
 271         BuildMI (BB, V8::ORrr, 2, V8::I0).addReg(V8::G0).addReg(RetValReg);
 272         break;
 273       default:
 274         visitInstruction (I);
 275         return;
 276     }
 277   } else if (I.getNumOperands () != 1) {
 278     visitInstruction (I);
 279   }
 280   // Just emit a 'retl' instruction to return.
 281   BuildMI(BB, V8::RETL, 0);
 282   return;
 283 }
 284
 285 void V8ISel::visitBinaryOperator (BinaryOperator &I) {
 286   unsigned DestReg = getReg (I);
 287   unsigned Op0Reg = getReg (I.getOperand (0));
 288   unsigned Op1Reg = getReg (I.getOperand (1));
 289
 290   unsigned ResultReg = makeAnotherReg (I.getType ());
 291
 292   // FIXME: support long, ulong, fp.
 293   switch (I.getOpcode ()) {
 294     case Instruction::Add:
 295       BuildMI (BB, V8::ADDrr, 2, ResultReg).addReg (Op0Reg).addReg (Op1Reg);
 296       break;
 297     case Instruction::Sub:
 298       BuildMI (BB, V8::SUBrr, 2, ResultReg).addReg (Op0Reg).addReg (Op1Reg);
 299       break;
 300     case Instruction::Mul: {
 301       unsigned Opcode = I.getType ()->isSigned () ? V8::SMULrr : V8::UMULrr;
 302       BuildMI (BB, Opcode, 2, ResultReg).addReg (Op0Reg).addReg (Op1Reg);
 303       break;
 304     }
 305     case Instruction::Div: {
 306       unsigned Opcode = I.getType ()->isSigned () ? V8::SDIVrr : V8::UDIVrr;
 307       // Clear out the Y register (top half of LHS of divide)
 308       BuildMI (BB, V8::WRYrr, 2, V8::Y).addReg (V8::G0).addReg (V8::G0);
 309       BuildMI (BB, V8::NOP, 0); // WR may take up to 4 cycles to finish
 310       BuildMI (BB, V8::NOP, 0);
 311       BuildMI (BB, V8::NOP, 0);
 312       BuildMI (BB, Opcode, 2, ResultReg).addReg (Op0Reg).addReg (Op1Reg);
 313       break;
 314     }
 315     default:
 316       visitInstruction (I);
 317       return;
 318   }
 319
 320   switch (getClass (I.getType ())) {
 321     case cByte:
 322       if (I.getType ()->isSigned ()) { // add byte
 323         BuildMI (BB, V8::ANDri, 2, DestReg).addReg (ResultReg).addZImm (0xff);
 324       } else { // add ubyte
 325         unsigned TmpReg = makeAnotherReg (I.getType ());
 326         BuildMI (BB, V8::SLLri, 2, TmpReg).addReg (ResultReg).addZImm (24);
 327         BuildMI (BB, V8::SRAri, 2, DestReg).addReg (TmpReg).addZImm (24);
 328       }
 329       break;
 330     case cShort:
 331       if (I.getType ()->isSigned ()) { // add short
 332         unsigned TmpReg = makeAnotherReg (I.getType ());
 333         BuildMI (BB, V8::SLLri, 2, TmpReg).addReg (ResultReg).addZImm (16);
 334         BuildMI (BB, V8::SRAri, 2, DestReg).addReg (TmpReg).addZImm (16);
 335       } else { // add ushort
 336         unsigned TmpReg = makeAnotherReg (I.getType ());
 337         BuildMI (BB, V8::SLLri, 2, TmpReg).addReg (ResultReg).addZImm (16);
 338         BuildMI (BB, V8::SRLri, 2, DestReg).addReg (TmpReg).addZImm (16);
 339       }
 340       break;
 341     case cInt:
 342       BuildMI (BB, V8::ORrr, 2, DestReg).addReg (V8::G0).addReg (ResultReg);
 343       break;
 344     default:
 345       visitInstruction (I);
 346       return;
 347   }
 348 }
 349
 350
 351 /// LowerUnknownIntrinsicFunctionCalls - This performs a prepass over the
 352 /// function, lowering any calls to unknown intrinsic functions into the
 353 /// equivalent LLVM code.
 354 void V8ISel::LowerUnknownIntrinsicFunctionCalls(Function &F) {
 355   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
 356     for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; )
 357       if (CallInst *CI = dyn_cast<CallInst>(I++))
 358         if (Function *F = CI->getCalledFunction())
 359           switch (F->getIntrinsicID()) {
 360           case Intrinsic::not_intrinsic: break;
 361           default:
 362             // All other intrinsic calls we must lower.
 363             Instruction *Before = CI->getPrev();
 364             TM.getIntrinsicLowering().LowerIntrinsicCall(CI);
 365             if (Before) {        // Move iterator to instruction after call
 366               I = Before;  ++I;
 367             } else {
 368               I = BB->begin();
 369             }
 370           }
 371 }
 372
 373
 374 void V8ISel::visitIntrinsicCall(Intrinsic::ID ID, CallInst &CI) {
 375   unsigned TmpReg1, TmpReg2;
 376   switch (ID) {
 377   default: assert(0 && "Intrinsic not supported!");
 378   }
 379 }