include/llvm/CodeGen/MachineInstrBuilder.h

   1 //===-- CodeGen/MachineInstBuilder.h - Simplify creation of MIs -*- 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 exposes a function named BuildMI, which is useful for dramatically
  11 // simplifying how MachineInstr's are created.  It allows use of code like this:
  12 //
  13 //   M = BuildMI(X86::ADDrr8, 2).addReg(argVal1).addReg(argVal2);
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_CODEGEN_MACHINEINSTRBUILDER_H
  18 #define LLVM_CODEGEN_MACHINEINSTRBUILDER_H
  19
  20 #include "llvm/CodeGen/MachineBasicBlock.h"
  21 #include "llvm/CodeGen/MachineFunction.h"
  22 #include "llvm/Target/TargetMachine.h"
  23
  24 namespace llvm {
  25
  26 class MachineInstrBuilder {
  27   MachineInstr *MI;
  28 public:
  29   MachineInstrBuilder(MachineInstr *mi) : MI(mi) {}
  30
  31   /// Allow automatic conversion to the machine instruction we are working on.
  32   ///
  33   operator MachineInstr*() const { return MI; }
  34   operator MachineBasicBlock::iterator() const { return MI; }
  35
  36   /// addReg - Add a new virtual register operand...
  37   ///
  38   const
  39   MachineInstrBuilder &addReg(int RegNo, bool isDef = false, bool isImp = false,
  40                               bool isKill = false, bool isDead = false) const {
  41     MI->addRegOperand(RegNo, isDef, isImp);
  42     return *this;
  43   }
  44
  45   /// addImm - Add a new immediate operand.
  46   ///
  47   const MachineInstrBuilder &addImm(int64_t Val) const {
  48     MI->addImmOperand(Val);
  49     return *this;
  50   }
  51
  52   const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB) const {
  53     MI->addMachineBasicBlockOperand(MBB);
  54     return *this;
  55   }
  56
  57   const MachineInstrBuilder &addFrameIndex(unsigned Idx) const {
  58     MI->addFrameIndexOperand(Idx);
  59     return *this;
  60   }
  61
  62   const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx,
  63                                                   int Offset = 0) const {
  64     MI->addConstantPoolIndexOperand(Idx, Offset);
  65     return *this;
  66   }
  67
  68   const MachineInstrBuilder &addJumpTableIndex(unsigned Idx) const {
  69     MI->addJumpTableIndexOperand(Idx);
  70     return *this;
  71   }
  72
  73   const MachineInstrBuilder &addGlobalAddress(GlobalValue *GV,
  74                                               int Offset = 0) const {
  75     MI->addGlobalAddressOperand(GV, Offset);
  76     return *this;
  77   }
  78
  79   const MachineInstrBuilder &addExternalSymbol(const char *FnName) const{
  80     MI->addExternalSymbolOperand(FnName);
  81     return *this;
  82   }
  83 };
  84
  85 /// BuildMI - Builder interface.  Specify how to create the initial instruction
  86 /// itself.  NumOperands is the number of operands to the machine instruction to
  87 /// allow for memory efficient representation of machine instructions.
  88 ///
  89 inline MachineInstrBuilder BuildMI(const TargetInstrInfo &TII, int Opcode,
  90                                    unsigned NumOperands) {
  91   return MachineInstrBuilder(new MachineInstr(TII, Opcode, NumOperands));
  92 }
  93
  94 /// BuildMI - This version of the builder sets up the first operand as a
  95 /// destination virtual register.  NumOperands is the number of additional add*
  96 /// calls that are expected, not including the destination register.
  97 ///
  98 inline MachineInstrBuilder  BuildMI(const TargetInstrInfo &TII, int Opcode,
  99                                     unsigned NumOperands, unsigned DestReg) {
 100   return MachineInstrBuilder(new MachineInstr(TII, Opcode, NumOperands+1))
 101                .addReg(DestReg, true);
 102 }
 103
 104 /// BuildMI - This version of the builder inserts the newly-built
 105 /// instruction before the given position in the given MachineBasicBlock, and
 106 /// sets up the first operand as a destination virtual register.
 107 /// NumOperands is the number of additional add* calls that are expected,
 108 /// not including the destination register.
 109 ///
 110 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
 111                                    MachineBasicBlock::iterator I,
 112                                    int Opcode, unsigned NumOperands,
 113                                    unsigned DestReg) {
 114   MachineInstr *MI = new MachineInstr(*BB.getParent()->getTarget().
 115                                       getInstrInfo(), Opcode, NumOperands+1);
 116   BB.insert(I, MI);
 117   return MachineInstrBuilder(MI).addReg(DestReg, true);
 118 }
 119
 120 /// BuildMI - This version of the builder inserts the newly-built
 121 /// instruction before the given position in the given MachineBasicBlock, and
 122 /// does NOT take a destination register.
 123 ///
 124 inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
 125                                    MachineBasicBlock::iterator I,
 126                                    int Opcode, unsigned NumOperands) {
 127   MachineInstr *MI = new MachineInstr(*BB.getParent()->getTarget().
 128                                       getInstrInfo(), Opcode, NumOperands);
 129   BB.insert(I, MI);
 130   return MachineInstrBuilder(MI);
 131 }
 132
 133 /// BuildMI - This version of the builder inserts the newly-built
 134 /// instruction at the end of the given MachineBasicBlock, and does NOT take a
 135 /// destination register.
 136 ///
 137 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, int Opcode,
 138                                    unsigned NumOperands) {
 139   return BuildMI(*BB, BB->end(), Opcode, NumOperands);
 140 }
 141
 142 /// BuildMI - This version of the builder inserts the newly-built
 143 /// instruction at the end of the given MachineBasicBlock, and sets up the first
 144 /// operand as a destination virtual register. NumOperands is the number of
 145 /// additional add* calls that are expected, not including the destination
 146 /// register.
 147 ///
 148 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, int Opcode,
 149                                    unsigned NumOperands, unsigned DestReg) {
 150   return BuildMI(*BB, BB->end(), Opcode, NumOperands, DestReg);
 151 }
 152
 153 } // End llvm namespace
 154
 155 #endif