1 //===-- FastISel.h - Definition of the FastISel class ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the FastISel class.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CODEGEN_FASTISEL_H
15 #define LLVM_CODEGEN_FASTISEL_H
17 #include "llvm/BasicBlock.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/CodeGen/SelectionDAGNodes.h"
23 class MachineBasicBlock;
24 class MachineFunction;
25 class MachineRegisterInfo;
27 class TargetInstrInfo;
30 class TargetRegisterClass;
32 /// FastISel - This is a fast-path instruction selection class that
33 /// generates poor code and doesn't support illegal types or non-trivial
34 /// lowering, but runs quickly.
37 MachineBasicBlock *MBB;
39 MachineRegisterInfo &MRI;
40 const TargetMachine &TM;
42 const TargetInstrInfo &TII;
43 const TargetLowering &TLI;
46 /// SelectInstructions - Do "fast" instruction selection over the
47 /// LLVM IR instructions in the range [Begin, N) where N is either
48 /// End or the first unsupported instruction. Return N.
49 /// ValueMap is filled in with a mapping of LLVM IR Values to
50 /// virtual register numbers. MBB is a block to which to append
51 /// the generated MachineInstrs.
53 SelectInstructions(BasicBlock::iterator Begin, BasicBlock::iterator End,
54 DenseMap<const Value*, unsigned> &ValueMap,
55 DenseMap<const BasicBlock*, MachineBasicBlock *> &MBBMap,
56 MachineBasicBlock *MBB);
61 explicit FastISel(MachineFunction &mf);
63 /// FastEmit_r - This method is called by target-independent code
64 /// to request that an instruction with the given type and opcode
66 virtual unsigned FastEmit_(MVT::SimpleValueType VT,
67 MVT::SimpleValueType RetVT,
68 ISD::NodeType Opcode);
70 /// FastEmit_r - This method is called by target-independent code
71 /// to request that an instruction with the given type, opcode, and
72 /// register operand be emitted.
74 virtual unsigned FastEmit_r(MVT::SimpleValueType VT,
75 MVT::SimpleValueType RetVT,
76 ISD::NodeType Opcode, unsigned Op0);
78 /// FastEmit_rr - This method is called by target-independent code
79 /// to request that an instruction with the given type, opcode, and
80 /// register operands be emitted.
82 virtual unsigned FastEmit_rr(MVT::SimpleValueType VT,
83 MVT::SimpleValueType RetVT,
85 unsigned Op0, unsigned Op1);
87 /// FastEmit_ri - This method is called by target-independent code
88 /// to request that an instruction with the given type, opcode, and
89 /// register and immediate operands be emitted.
91 virtual unsigned FastEmit_ri(MVT::SimpleValueType VT,
92 MVT::SimpleValueType RetVT,
94 unsigned Op0, uint64_t Imm);
96 /// FastEmit_rri - This method is called by target-independent code
97 /// to request that an instruction with the given type, opcode, and
98 /// register and immediate operands be emitted.
100 virtual unsigned FastEmit_rri(MVT::SimpleValueType VT,
101 MVT::SimpleValueType RetVT,
102 ISD::NodeType Opcode,
103 unsigned Op0, unsigned Op1, uint64_t Imm);
105 /// FastEmit_ri_ - This method is a wrapper of FastEmit_ri. It first tries
106 /// to emit an instruction with an immediate operand using FastEmit_ri.
107 /// If that fails, it materializes the immediate into a register and try
108 /// FastEmit_rr instead.
109 unsigned FastEmit_ri_(MVT::SimpleValueType VT,
110 ISD::NodeType Opcode,
111 unsigned Op0, uint64_t Imm,
112 MVT::SimpleValueType ImmType);
114 /// FastEmit_i - This method is called by target-independent code
115 /// to request that an instruction with the given type, opcode, and
116 /// immediate operand be emitted.
117 virtual unsigned FastEmit_i(MVT::SimpleValueType VT,
118 MVT::SimpleValueType RetVT,
119 ISD::NodeType Opcode,
122 /// FastEmitInst_ - Emit a MachineInstr with no operands and a
123 /// result register in the given register class.
125 unsigned FastEmitInst_(unsigned MachineInstOpcode,
126 const TargetRegisterClass *RC);
128 /// FastEmitInst_r - Emit a MachineInstr with one register operand
129 /// and a result register in the given register class.
131 unsigned FastEmitInst_r(unsigned MachineInstOpcode,
132 const TargetRegisterClass *RC,
135 /// FastEmitInst_rr - Emit a MachineInstr with two register operands
136 /// and a result register in the given register class.
138 unsigned FastEmitInst_rr(unsigned MachineInstOpcode,
139 const TargetRegisterClass *RC,
140 unsigned Op0, unsigned Op1);
142 /// FastEmitInst_ri - Emit a MachineInstr with two register operands
143 /// and a result register in the given register class.
145 unsigned FastEmitInst_ri(unsigned MachineInstOpcode,
146 const TargetRegisterClass *RC,
147 unsigned Op0, uint64_t Imm);
149 /// FastEmitInst_rri - Emit a MachineInstr with two register operands,
150 /// an immediate, and a result register in the given register class.
152 unsigned FastEmitInst_rri(unsigned MachineInstOpcode,
153 const TargetRegisterClass *RC,
154 unsigned Op0, unsigned Op1, uint64_t Imm);
156 /// FastEmitInst_i - Emit a MachineInstr with a single immediate
157 /// operand, and a result register in the given register class.
158 unsigned FastEmitInst_i(unsigned MachineInstrOpcode,
159 const TargetRegisterClass *RC,
163 unsigned createResultReg(const TargetRegisterClass *RC);
165 bool SelectBinaryOp(Instruction *I, ISD::NodeType ISDOpcode,
166 DenseMap<const Value*, unsigned> &ValueMap);
168 bool SelectGetElementPtr(Instruction *I,
169 DenseMap<const Value*, unsigned> &ValueMap);
171 bool SelectBitCast(Instruction *I,
172 DenseMap<const Value*, unsigned> &ValueMap);
174 bool SelectCast(Instruction *I, ISD::NodeType Opcode,
175 DenseMap<const Value*, unsigned> &ValueMap);
177 bool SelectConstantCast(Instruction *I, ISD::NodeType Opcode,
178 DenseMap<const Value*, unsigned> &ValueMap);
179 bool SelectConstantFPCast(Instruction *I, ISD::NodeType Opcode,
180 DenseMap<const Value*, unsigned> &ValueMap);