lib/Target/PIC16/PIC16InstrInfo.cpp

   1 //===- PIC16InstrInfo.cpp - PIC16 Instruction Information -----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains the PIC16 implementation of the TargetInstrInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "PIC16.h"
  15 #include "PIC16InstrInfo.h"
  16 #include "PIC16TargetMachine.h"
  17 #include "PIC16GenInstrInfo.inc"
  18 #include "llvm/Function.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/CodeGen/MachineInstrBuilder.h"
  22 #include "llvm/CodeGen/MachineRegisterInfo.h"
  23
  24
  25 using namespace llvm;
  26
  27 // FIXME: Add the subtarget support on this constructor.
  28 PIC16InstrInfo::PIC16InstrInfo(PIC16TargetMachine &tm)
  29   : TargetInstrInfoImpl(PIC16Insts, array_lengthof(PIC16Insts)),
  30     TM(tm),
  31     RegInfo(*this, *TM.getSubtargetImpl()) {}
  32
  33
  34 /// isStoreToStackSlot - If the specified machine instruction is a direct
  35 /// store to a stack slot, return the virtual or physical register number of
  36 /// the source reg along with the FrameIndex of the loaded stack slot.
  37 /// If not, return 0.  This predicate must return 0 if the instruction has
  38 /// any side effects other than storing to the stack slot.
  39 unsigned PIC16InstrInfo::isStoreToStackSlot(const MachineInstr *MI,
  40                                             int &FrameIndex) const {
  41   if (MI->getOpcode() == PIC16::movwf
  42       && MI->getOperand(0).isReg()
  43       && MI->getOperand(1).isSymbol()) {
  44     FrameIndex = MI->getOperand(1).getIndex();
  45     return MI->getOperand(0).getReg();
  46   }
  47   return 0;
  48 }
  49
  50 /// isLoadFromStackSlot - If the specified machine instruction is a direct
  51 /// load from a stack slot, return the virtual or physical register number of
  52 /// the dest reg along with the FrameIndex of the stack slot.
  53 /// If not, return 0.  This predicate must return 0 if the instruction has
  54 /// any side effects other than storing to the stack slot.
  55 unsigned PIC16InstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
  56                                             int &FrameIndex) const {
  57   if (MI->getOpcode() == PIC16::movf
  58       && MI->getOperand(0).isReg()
  59       && MI->getOperand(1).isSymbol()) {
  60     FrameIndex = MI->getOperand(1).getIndex();
  61     return MI->getOperand(0).getReg();
  62   }
  63   return 0;
  64 }
  65
  66
  67 void PIC16InstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
  68                                          MachineBasicBlock::iterator I,
  69                                          unsigned SrcReg, bool isKill, int FI,
  70                                          const TargetRegisterClass *RC) const {
  71
  72   const Function *Func = MBB.getParent()->getFunction();
  73   const std::string FuncName = Func->getName();
  74
  75   char *tmpName = new char [strlen(FuncName.c_str()) +  6];
  76   sprintf(tmpName, "%s.tmp", FuncName.c_str());
  77
  78   // On the order of operands here: think "movwf SrcReg, tmp_slot, offset".
  79   if (RC == PIC16::GPRRegisterClass) {
  80     //MachineFunction &MF = *MBB.getParent();
  81     //MachineRegisterInfo &RI = MF.getRegInfo();
  82     BuildMI(MBB, I, get(PIC16::movwf))
  83       .addReg(SrcReg, false, false, isKill)
  84       .addImm(FI)
  85       .addExternalSymbol(tmpName)
  86       .addImm(1); // Emit banksel for it.
  87   }
  88   else if (RC == PIC16::FSR16RegisterClass)
  89     assert(0 && "Don't know yet how to store a FSR16 to stack slot");
  90   else
  91     assert(0 && "Can't store this register to stack slot");
  92 }
  93
  94 void PIC16InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
  95                                           MachineBasicBlock::iterator I,
  96                                           unsigned DestReg, int FI,
  97                                           const TargetRegisterClass *RC) const {
  98
  99   const Function *Func = MBB.getParent()->getFunction();
 100   const std::string FuncName = Func->getName();
 101
 102   char *tmpName = new char [strlen(FuncName.c_str()) +  6];
 103   sprintf(tmpName, "%s.tmp", FuncName.c_str());
 104
 105   // On the order of operands here: think "movf FrameIndex, W".
 106   if (RC == PIC16::GPRRegisterClass) {
 107     //MachineFunction &MF = *MBB.getParent();
 108     //MachineRegisterInfo &RI = MF.getRegInfo();
 109     BuildMI(MBB, I, get(PIC16::movf), DestReg)
 110       .addImm(FI)
 111       .addExternalSymbol(tmpName)
 112       .addImm(1); // Emit banksel for it.
 113   }
 114   else if (RC == PIC16::FSR16RegisterClass)
 115     assert(0 && "Don't know yet how to load an FSR16 from stack slot");
 116   else
 117     assert(0 && "Can't load this register from stack slot");
 118 }
 119
 120 bool PIC16InstrInfo::copyRegToReg (MachineBasicBlock &MBB,
 121                                    MachineBasicBlock::iterator I,
 122                                    unsigned DestReg, unsigned SrcReg,
 123                                    const TargetRegisterClass *DestRC,
 124                                    const TargetRegisterClass *SrcRC) const {
 125   if (DestRC == PIC16::FSR16RegisterClass) {
 126     BuildMI(MBB, I, get(PIC16::copy_fsr), DestReg).addReg(SrcReg);
 127   }
 128
 129   return true;
 130 }
 131
 132 bool PIC16InstrInfo::isMoveInstr(const MachineInstr &MI,
 133                                          unsigned &SrcReg,
 134                                          unsigned &DestReg) const {
 135
 136   if (MI.getOpcode() == PIC16::copy_fsr) {
 137     DestReg = MI.getOperand(0).getReg();
 138     SrcReg = MI.getOperand(1).getReg();
 139     return true;
 140   }
 141   return false;
 142 }
 143