lib/Target/X86/X86RegisterInfo.cpp

   1 //===- X86RegisterInfo.cpp - X86 Register Information -----------*- C++ -*-===//
   2 //
   3 // This file contains the X86 implementation of the MRegisterInfo class.
   4 //
   5 //===----------------------------------------------------------------------===//
   6
   7 #include "X86.h"
   8 #include "X86RegisterInfo.h"
   9 #include "X86InstrBuilder.h"
  10 #include "llvm/Constants.h"
  11 #include "llvm/Type.h"
  12 #include "llvm/CodeGen/MachineInstrBuilder.h"
  13 #include "llvm/CodeGen/MachineFunction.h"
  14
  15 unsigned getIdx(unsigned dataSize) {
  16   switch (dataSize) {
  17   default: assert(0 && "Invalid data size!");
  18   case 1: return 0;
  19   case 2: return 1;
  20   case 4: return 2;
  21     // FIXME: longs handled as ints
  22   case 8: return 2;
  23   }
  24 }
  25
  26 MachineBasicBlock::iterator
  27 X86RegisterInfo::storeReg2RegOffset(MachineBasicBlock &MBB,
  28                                     MachineBasicBlock::iterator MBBI,
  29                                     unsigned SrcReg, unsigned DestReg,
  30                                     unsigned ImmOffset, unsigned dataSize)
  31   const
  32 {
  33   static const unsigned Opcode[] = { X86::MOVrm8, X86::MOVrm16, X86::MOVrm32 };
  34   MachineInstr *MI = addRegOffset(BuildMI(Opcode[getIdx(dataSize)], 5),
  35                                   DestReg, ImmOffset).addReg(SrcReg);
  36   return ++MBB.insert(MBBI, MI);
  37 }
  38
  39 MachineBasicBlock::iterator
  40 X86RegisterInfo::loadRegOffset2Reg(MachineBasicBlock &MBB,
  41                                    MachineBasicBlock::iterator MBBI,
  42                                    unsigned DestReg, unsigned SrcReg,
  43                                    unsigned ImmOffset, unsigned dataSize)
  44   const
  45 {
  46   static const unsigned Opcode[] = { X86::MOVmr8, X86::MOVmr16, X86::MOVmr32 };
  47   MachineInstr *MI = addRegOffset(BuildMI(Opcode[getIdx(dataSize)], 4, DestReg),
  48                                   SrcReg, ImmOffset);
  49   return ++MBB.insert(MBBI, MI);
  50 }
  51
  52 MachineBasicBlock::iterator
  53 X86RegisterInfo::moveReg2Reg(MachineBasicBlock &MBB,
  54                              MachineBasicBlock::iterator MBBI,
  55                              unsigned DestReg, unsigned SrcReg,
  56                              unsigned dataSize) const
  57 {
  58   static const unsigned Opcode[] = { X86::MOVrr8, X86::MOVrr16, X86::MOVrr32 };
  59   MachineInstr *MI = BuildMI(Opcode[getIdx(dataSize)],1,DestReg).addReg(SrcReg);
  60   return ++MBB.insert(MBBI, MI);
  61 }
  62
  63 MachineBasicBlock::iterator
  64 X86RegisterInfo::moveImm2Reg(MachineBasicBlock &MBB,
  65                              MachineBasicBlock::iterator MBBI,
  66                              unsigned DestReg, unsigned Imm, unsigned dataSize)
  67   const
  68 {
  69   static const unsigned Opcode[] = { X86::MOVir8, X86::MOVir16, X86::MOVir32 };
  70   MachineInstr *MI = BuildMI(Opcode[getIdx(dataSize)], 1, DestReg).addReg(Imm);
  71   return ++MBB.insert(MBBI, MI);
  72 }
  73
  74
  75 unsigned X86RegisterInfo::getFramePointer() const {
  76   return X86::EBP;
  77 }
  78
  79 unsigned X86RegisterInfo::getStackPointer() const {
  80   return X86::ESP;
  81 }
  82
  83 const unsigned* X86RegisterInfo::getCalleeSaveRegs() const {
  84   static const unsigned CalleeSaveRegs[] = { X86::ESI, X86::EDI, X86::EBX,
  85                                              MRegisterInfo::NoRegister };
  86   return CalleeSaveRegs;
  87 }
  88
  89
  90 const unsigned* X86RegisterInfo::getCallerSaveRegs() const {
  91   static const unsigned CallerSaveRegs[] = { X86::EAX, X86::ECX, X86::EDX,
  92                                              MRegisterInfo::NoRegister };
  93   return CallerSaveRegs;
  94 }
  95
  96 void X86RegisterInfo::emitPrologue(MachineFunction &MF,
  97                                    unsigned NumBytes) const {
  98   MachineBasicBlock &MBB = MF.front();   // Prolog goes in entry BB
  99   MachineBasicBlock::iterator MBBI = MBB.begin();
 100
 101   // Round stack allocation up to a nice alignment to keep the stack aligned
 102   NumBytes = (NumBytes + 3) & ~3;
 103
 104   // PUSH ebp
 105   MachineInstr *MI = BuildMI(X86::PUSHr32, 1).addReg(X86::EBP);
 106   MBBI = ++MBB.insert(MBBI, MI);
 107
 108   // MOV ebp, esp
 109   MI = BuildMI(X86::MOVrr32, 1, X86::EBP).addReg(X86::ESP);
 110   MBBI = ++MBB.insert(MBBI, MI);
 111
 112   // adjust stack pointer: ESP -= numbytes
 113   MI  = BuildMI(X86::SUBri32, 2, X86::ESP).addReg(X86::ESP).addZImm(NumBytes);
 114   MBBI = ++MBB.insert(MBBI, MI);
 115 }
 116
 117 void X86RegisterInfo::emitEpilogue(MachineBasicBlock &MBB,
 118                                    unsigned numBytes) const {
 119   MachineBasicBlock::iterator MBBI = --MBB.end();
 120   assert((*MBBI)->getOpcode() == X86::RET &&
 121          "Can only insert epilog into returning blocks");
 122
 123   // insert LEAVE: mov ESP, EBP; pop EBP
 124   MBBI = ++MBB.insert(MBBI, BuildMI(X86::MOVrr32, 1,X86::ESP).addReg(X86::EBP));
 125   MBBI = ++MBB.insert(MBBI, BuildMI(X86::POPr32, 1).addReg(X86::EBP));
 126 }