MachineInstrBuilder.h revision c76909abfec876c6b751d693ebd3df07df686aa0 
1//===-- CodeGen/MachineInstBuilder.h - Simplify creation of MIs -*- C++ -*-===//
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 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/MachineFunction.h"
21
22namespace llvm {
23
24class TargetInstrDesc;
25
26namespace RegState {
27  enum {
28    Define         = 0x2,
29    Implicit       = 0x4,
30    Kill           = 0x8,
31    Dead           = 0x10,
32    Undef          = 0x20,
33    EarlyClobber   = 0x40,
34    ImplicitDefine = Implicit | Define,
35    ImplicitKill   = Implicit | Kill
36  };
37}
38
39class MachineInstrBuilder {
40  MachineInstr *MI;
41public:
42  MachineInstrBuilder() : MI(0) {}
43  explicit MachineInstrBuilder(MachineInstr *mi) : MI(mi) {}
44
45  /// Allow automatic conversion to the machine instruction we are working on.
46  ///
47  operator MachineInstr*() const { return MI; }
48  operator MachineBasicBlock::iterator() const { return MI; }
49
50  /// addReg - Add a new virtual register operand...
51  ///
52  const
53  MachineInstrBuilder &addReg(unsigned RegNo, unsigned flags = 0,
54                              unsigned SubReg = 0) const {
55    assert((flags & 0x1) == 0 &&
56           "Passing in 'true' to addReg is forbidden! Use enums instead.");
57    MI->addOperand(MachineOperand::CreateReg(RegNo,
58                                             flags & RegState::Define,
59                                             flags & RegState::Implicit,
60                                             flags & RegState::Kill,
61                                             flags & RegState::Dead,
62                                             flags & RegState::Undef,
63                                             flags & RegState::EarlyClobber,
64                                             SubReg));
65    return *this;
66  }
67
68  /// addImm - Add a new immediate operand.
69  ///
70  const MachineInstrBuilder &addImm(int64_t Val) const {
71    MI->addOperand(MachineOperand::CreateImm(Val));
72    return *this;
73  }
74
75  const MachineInstrBuilder &addFPImm(const ConstantFP *Val) const {
76    MI->addOperand(MachineOperand::CreateFPImm(Val));
77    return *this;
78  }
79
80  const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB,
81                                    unsigned char TargetFlags = 0) const {
82    MI->addOperand(MachineOperand::CreateMBB(MBB, TargetFlags));
83    return *this;
84  }
85
86  const MachineInstrBuilder &addFrameIndex(unsigned Idx) const {
87    MI->addOperand(MachineOperand::CreateFI(Idx));
88    return *this;
89  }
90
91  const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx,
92                                                  int Offset = 0,
93                                          unsigned char TargetFlags = 0) const {
94    MI->addOperand(MachineOperand::CreateCPI(Idx, Offset, TargetFlags));
95    return *this;
96  }
97
98  const MachineInstrBuilder &addJumpTableIndex(unsigned Idx,
99                                          unsigned char TargetFlags = 0) const {
100    MI->addOperand(MachineOperand::CreateJTI(Idx, TargetFlags));
101    return *this;
102  }
103
104  const MachineInstrBuilder &addGlobalAddress(GlobalValue *GV,
105                                              int64_t Offset = 0,
106                                          unsigned char TargetFlags = 0) const {
107    MI->addOperand(MachineOperand::CreateGA(GV, Offset, TargetFlags));
108    return *this;
109  }
110
111  const MachineInstrBuilder &addMetadata(MDNode *N,
112                                         int64_t Offset = 0,
113                                         unsigned char TargetFlags = 0) const {
114    MI->addOperand(MachineOperand::CreateMDNode(N, Offset, TargetFlags));
115    return *this;
116  }
117
118  const MachineInstrBuilder &addExternalSymbol(const char *FnName,
119                                          unsigned char TargetFlags = 0) const {
120    MI->addOperand(MachineOperand::CreateES(FnName, TargetFlags));
121    return *this;
122  }
123
124  const MachineInstrBuilder &addMemOperand(MachineMemOperand *MMO) const {
125    MI->addMemOperand(*MI->getParent()->getParent(), MMO);
126    return *this;
127  }
128
129  const MachineInstrBuilder &addOperand(const MachineOperand &MO) const {
130    MI->addOperand(MO);
131    return *this;
132  }
133};
134
135/// BuildMI - Builder interface.  Specify how to create the initial instruction
136/// itself.
137///
138inline MachineInstrBuilder BuildMI(MachineFunction &MF,
139                                   DebugLoc DL,
140                                   const TargetInstrDesc &TID) {
141  return MachineInstrBuilder(MF.CreateMachineInstr(TID, DL));
142}
143
144/// BuildMI - This version of the builder sets up the first operand as a
145/// destination virtual register.
146///
147inline MachineInstrBuilder BuildMI(MachineFunction &MF,
148                                   DebugLoc DL,
149                                   const TargetInstrDesc &TID,
150                                   unsigned DestReg) {
151  return MachineInstrBuilder(MF.CreateMachineInstr(TID, DL))
152           .addReg(DestReg, RegState::Define);
153}
154
155/// BuildMI - This version of the builder inserts the newly-built
156/// instruction before the given position in the given MachineBasicBlock, and
157/// sets up the first operand as a destination virtual register.
158///
159inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
160                                   MachineBasicBlock::iterator I,
161                                   DebugLoc DL,
162                                   const TargetInstrDesc &TID,
163                                   unsigned DestReg) {
164  MachineInstr *MI = BB.getParent()->CreateMachineInstr(TID, DL);
165  BB.insert(I, MI);
166  return MachineInstrBuilder(MI).addReg(DestReg, RegState::Define);
167}
168
169/// BuildMI - This version of the builder inserts the newly-built
170/// instruction before the given position in the given MachineBasicBlock, and
171/// does NOT take a destination register.
172///
173inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
174                                   MachineBasicBlock::iterator I,
175                                   DebugLoc DL,
176                                   const TargetInstrDesc &TID) {
177  MachineInstr *MI = BB.getParent()->CreateMachineInstr(TID, DL);
178  BB.insert(I, MI);
179  return MachineInstrBuilder(MI);
180}
181
182/// BuildMI - This version of the builder inserts the newly-built
183/// instruction at the end of the given MachineBasicBlock, and does NOT take a
184/// destination register.
185///
186inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB,
187                                   DebugLoc DL,
188                                   const TargetInstrDesc &TID) {
189  return BuildMI(*BB, BB->end(), DL, TID);
190}
191
192/// BuildMI - This version of the builder inserts the newly-built
193/// instruction at the end of the given MachineBasicBlock, and sets up the first
194/// operand as a destination virtual register.
195///
196inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB,
197                                   DebugLoc DL,
198                                   const TargetInstrDesc &TID,
199                                   unsigned DestReg) {
200  return BuildMI(*BB, BB->end(), DL, TID, DestReg);
201}
202
203inline unsigned getDefRegState(bool B) {
204  return B ? RegState::Define : 0;
205}
206inline unsigned getImplRegState(bool B) {
207  return B ? RegState::Implicit : 0;
208}
209inline unsigned getKillRegState(bool B) {
210  return B ? RegState::Kill : 0;
211}
212inline unsigned getDeadRegState(bool B) {
213  return B ? RegState::Dead : 0;
214}
215inline unsigned getUndefRegState(bool B) {
216  return B ? RegState::Undef : 0;
217}
218
219} // End llvm namespace
220
221#endif
222