include/llvm/CodeGen/MachineInstrBuilder.h

   1 //===-- CodeGen/MachineInstBuilder.h - Simplify creation of MIs -*- C++ -*-===//
   2 //
   3 // This file exposes a function named BuildMI, which is useful for dramatically
   4 // simplifying how MachineInstr's are created.  Instead of using code like this:
   5 //
   6 //   M = new MachineInstr(X86::ADDrr32);
   7 //   M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1);
   8 //   M->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, argVal2);
   9 //
  10 // we can now use code like this:
  11 //
  12 //   M = BuildMI(X86::ADDrr8, 2).addReg(argVal1).addReg(argVal2);
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_CODEGEN_MACHINEINSTRBUILDER_H
  17 #define LLVM_CODEGEN_MACHINEINSTRBUILDER_H
  18
  19 #include "llvm/CodeGen/MachineInstr.h"
  20
  21 struct MachineInstrBuilder {
  22   MachineInstr *MI;
  23
  24   MachineInstrBuilder(MachineInstr *mi) : MI(mi) {}
  25
  26   /// Allow automatic conversion to the machine instruction we are working on.
  27   ///
  28   operator MachineInstr*() const { return MI; }
  29
  30   /// addReg - Add a new virtual register operand...
  31   ///
  32   const MachineInstrBuilder &addReg(int RegNo,
  33                                     MOTy::UseType Ty = MOTy::Use) const {
  34     MI->addRegOperand(RegNo, Ty);
  35     return *this;
  36   }
  37
  38   /// addReg - Add an LLVM value that is to be used as a register...
  39   ///
  40   const MachineInstrBuilder &addReg(Value *V,
  41                                     MOTy::UseType Ty = MOTy::Use) const {
  42     MI->addRegOperand(V, Ty);
  43     return *this;
  44   }
  45
  46   /// addClobber - Assert that this MI is going to clobber a specific
  47   /// register. Useful for instructions that always clobber certain hard regs.
  48   /// (Same as addReg(RegNo, true) but shorter and more obvious).
  49   ///
  50   const MachineInstrBuilder &addClobber(int RegNo) const {
  51     MI->addRegOperand(RegNo, true);
  52     return *this;
  53   }
  54
  55   /// addPCDisp - Add an LLVM value to be treated as a PC relative
  56   /// displacement...
  57   ///
  58   const MachineInstrBuilder &addPCDisp(Value *V) const {
  59     MI->addPCDispOperand(V);
  60     return *this;
  61   }
  62
  63   /// addMReg - Add a machine register operand...
  64   ///
  65   const MachineInstrBuilder &addMReg(int Reg,
  66                                      MOTy::UseType Ty = MOTy::Use) const {
  67     MI->addMachineRegOperand(Reg, Ty);
  68     return *this;
  69   }
  70
  71   /// addSImm - Add a new sign extended immediate operand...
  72   ///
  73   const MachineInstrBuilder &addSImm(int64_t val) const {
  74     MI->addSignExtImmOperand(val);
  75     return *this;
  76   }
  77
  78   /// addZImm - Add a new zero extended immediate operand...
  79   ///
  80   const MachineInstrBuilder &addZImm(int64_t Val) const {
  81     MI->addZeroExtImmOperand(Val);
  82     return *this;
  83   }
  84
  85   const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB) const {
  86     MI->addMachineBasicBlockOperand(MBB);
  87     return *this;
  88   }
  89 };
  90
  91 /// BuildMI - Builder interface.  Specify how to create the initial instruction
  92 /// itself.  NumOperands is the number of operands to the machine instruction to
  93 /// allow for memory efficient representation of machine instructions.
  94 ///
  95 inline MachineInstrBuilder BuildMI(MachineOpCode Opcode, unsigned NumOperands) {
  96   return MachineInstrBuilder(new MachineInstr(Opcode, NumOperands, true, true));
  97 }
  98
  99 /// BuildMI - This version of the builder also sets up the first "operand" as a
 100 /// destination virtual register.  NumOperands is the number of additional add*
 101 /// calls that are expected, it does not include the destination register.
 102 ///
 103 inline MachineInstrBuilder BuildMI(MachineOpCode Opcode, unsigned NumOperands,
 104                                    unsigned DestReg) {
 105   return MachineInstrBuilder(new MachineInstr(Opcode, NumOperands+1,
 106                                    true, true)).addReg(DestReg, MOTy::Def);
 107 }
 108
 109
 110 /// BuildMI - This version of the builder inserts the built MachineInstr into
 111 /// the specified MachineBasicBlock.
 112 ///
 113 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, MachineOpCode Opcode,
 114                                    unsigned NumOperands) {
 115   return MachineInstrBuilder(new MachineInstr(BB, Opcode, NumOperands));
 116 }
 117
 118 /// BuildMI - This version of the builder inserts the built MachineInstr into
 119 /// the specified MachineBasicBlock, and also sets up the first "operand" as a
 120 /// destination virtual register.  NumOperands is the number of additional add*
 121 /// calls that are expected, it does not include the destination register.
 122 ///
 123 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, MachineOpCode Opcode,
 124                                    unsigned NumOperands, unsigned DestReg) {
 125   return MachineInstrBuilder(new MachineInstr(BB, Opcode,
 126                                               NumOperands+1)).addReg(DestReg,
 127                                                                      MOTy::Def);
 128 }
 129
 130 #endif