lib/Target/Sparc/SparcInstrInfo.cpp

   1 //===- SparcV8InstrInfo.cpp - SparcV8 Instruction Information ---*- C++ -*-===//
   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 contains the SparcV8 implementation of the TargetInstrInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "SparcV8InstrInfo.h"
  15 #include "SparcV8.h"
  16 #include "llvm/CodeGen/MachineInstrBuilder.h"
  17 #include "SparcV8GenInstrInfo.inc"
  18 using namespace llvm;
  19
  20 SparcV8InstrInfo::SparcV8InstrInfo()
  21   : TargetInstrInfo(SparcV8Insts, sizeof(SparcV8Insts)/sizeof(SparcV8Insts[0])){
  22 }
  23
  24 static bool isZeroImmed (const MachineOperand &op) {
  25   return (op.isImmediate() && op.getImmedValue() == 0);
  26 }
  27
  28 /// Return true if the instruction is a register to register move and
  29 /// leave the source and dest operands in the passed parameters.
  30 ///
  31 bool SparcV8InstrInfo::isMoveInstr(const MachineInstr &MI,
  32                                    unsigned &SrcReg, unsigned &DstReg) const {
  33   // We look for 3 kinds of patterns here:
  34   // or with G0 or 0
  35   // add with G0 or 0
  36   // fmovs or FpMOVD (pseudo double move).
  37   if (MI.getOpcode() == V8::ORrr || MI.getOpcode() == V8::ADDrr) {
  38     if (MI.getOperand(1).getReg() == V8::G0) {
  39       DstReg = MI.getOperand(0).getReg();
  40       SrcReg = MI.getOperand(2).getReg();
  41       return true;
  42     } else if (MI.getOperand (2).getReg() == V8::G0) {
  43       DstReg = MI.getOperand(0).getReg();
  44       SrcReg = MI.getOperand(1).getReg();
  45       return true;
  46     }
  47   } else if (MI.getOpcode() == V8::ORri || MI.getOpcode() == V8::ADDri) {
  48     if (isZeroImmed(MI.getOperand(2)) && MI.getOperand(1).isRegister()) {
  49       DstReg = MI.getOperand(0).getReg();
  50       SrcReg = MI.getOperand(1).getReg();
  51       return true;
  52     }
  53   } else if (MI.getOpcode() == V8::FMOVS || MI.getOpcode() == V8::FpMOVD) {
  54     SrcReg = MI.getOperand(1).getReg();
  55     DstReg = MI.getOperand(0).getReg();
  56     return true;
  57   }
  58   return false;
  59 }
  60
  61 /// isLoadFromStackSlot - If the specified machine instruction is a direct
  62 /// load from a stack slot, return the virtual or physical register number of
  63 /// the destination along with the FrameIndex of the loaded stack slot.  If
  64 /// not, return 0.  This predicate must return 0 if the instruction has
  65 /// any side effects other than loading from the stack slot.
  66 unsigned SparcV8InstrInfo::isLoadFromStackSlot(MachineInstr *MI,
  67                                                int &FrameIndex) const {
  68   if (MI->getOpcode() == V8::LDri ||
  69       MI->getOpcode() == V8::LDFri ||
  70       MI->getOpcode() == V8::LDDFri) {
  71     if (MI->getOperand(1).isFrameIndex() && MI->getOperand(2).isImmediate() &&
  72         MI->getOperand(2).getImmedValue() == 0) {
  73       FrameIndex = MI->getOperand(1).getFrameIndex();
  74       return MI->getOperand(0).getReg();
  75     }
  76   }
  77   return 0;
  78 }
  79
  80 /// isStoreToStackSlot - If the specified machine instruction is a direct
  81 /// store to a stack slot, return the virtual or physical register number of
  82 /// the source reg along with the FrameIndex of the loaded stack slot.  If
  83 /// not, return 0.  This predicate must return 0 if the instruction has
  84 /// any side effects other than storing to the stack slot.
  85 unsigned SparcV8InstrInfo::isStoreToStackSlot(MachineInstr *MI,
  86                                               int &FrameIndex) const {
  87   if (MI->getOpcode() == V8::STri ||
  88       MI->getOpcode() == V8::STFri ||
  89       MI->getOpcode() == V8::STDFri) {
  90     if (MI->getOperand(0).isFrameIndex() && MI->getOperand(1).isImmediate() &&
  91         MI->getOperand(1).getImmedValue() == 0) {
  92       FrameIndex = MI->getOperand(0).getFrameIndex();
  93       return MI->getOperand(2).getReg();
  94     }
  95   }
  96   return 0;
  97 }