2003f860bc01c26cf007af0403a2feb3b4c6504c
[oota-llvm.git] / 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 class MachineInstrBuilder {
22   MachineInstr *MI;
23 public:
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, MOTy::Def);
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   const MachineInstrBuilder &addFrameIndex(unsigned Idx) const {
91     MI->addFrameIndexOperand(Idx);
92     return *this;
93   }
94
95   const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx) const {
96     MI->addConstantPoolIndexOperand(Idx);
97     return *this;
98   }
99
100   const MachineInstrBuilder &addGlobalAddress(GlobalValue *GV,
101                                               bool isPCRelative = false) const {
102     MI->addGlobalAddressOperand(GV, isPCRelative);
103     return *this;
104   }
105
106   const MachineInstrBuilder &addExternalSymbol(const std::string &Name,
107                                                bool isPCRelative = false) const{
108     MI->addExternalSymbolOperand(Name, isPCRelative);
109     return *this;
110   }
111 };
112
113 /// BuildMI - Builder interface.  Specify how to create the initial instruction
114 /// itself.  NumOperands is the number of operands to the machine instruction to
115 /// allow for memory efficient representation of machine instructions.
116 ///
117 inline MachineInstrBuilder BuildMI(MachineOpCode Opcode, unsigned NumOperands) {
118   return MachineInstrBuilder(new MachineInstr(Opcode, NumOperands, true, true));
119 }
120
121 /// BuildMI - This version of the builder also sets up the first "operand" as a
122 /// destination virtual register.  NumOperands is the number of additional add*
123 /// calls that are expected, it does not include the destination register.
124 ///
125 inline MachineInstrBuilder BuildMI(MachineOpCode Opcode, unsigned NumOperands,
126                                    unsigned DestReg) {
127   return MachineInstrBuilder(new MachineInstr(Opcode, NumOperands+1,
128                                    true, true)).addReg(DestReg, MOTy::Def);
129 }
130
131
132 /// BuildMI - This version of the builder inserts the built MachineInstr into
133 /// the specified MachineBasicBlock.
134 ///
135 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, MachineOpCode Opcode,
136                                    unsigned NumOperands) {
137   return MachineInstrBuilder(new MachineInstr(BB, Opcode, NumOperands));
138 }
139
140 /// BuildMI - This version of the builder inserts the built MachineInstr into
141 /// the specified MachineBasicBlock, and also sets up the first "operand" as a
142 /// destination virtual register.  NumOperands is the number of additional add*
143 /// calls that are expected, it does not include the destination register.
144 ///
145 inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, MachineOpCode Opcode,
146                                    unsigned NumOperands, unsigned DestReg) {
147   return MachineInstrBuilder(new MachineInstr(BB, Opcode,
148                                               NumOperands+1)).addReg(DestReg,
149                                                                      MOTy::Def);
150 }
151
152 #endif