1 //===-- InstSelectSimple.cpp - A simple instruction selector for x86 ------===//
3 // This file defines a simple peephole instruction selector for the x86 platform
5 //===----------------------------------------------------------------------===//
8 #include "X86InstrInfo.h"
9 #include "llvm/Function.h"
10 #include "llvm/iTerminators.h"
11 #include "llvm/Type.h"
12 #include "llvm/Constants.h"
13 #include "llvm/Pass.h"
14 #include "llvm/CodeGen/MachineFunction.h"
15 #include "llvm/CodeGen/MachineInstrBuilder.h"
16 #include "llvm/Support/InstVisitor.h"
20 struct ISel : public FunctionPass, InstVisitor<ISel> {
22 MachineFunction *F; // The function we are compiling into
23 MachineBasicBlock *BB; // The current MBB we are compiling
26 std::map<Value*, unsigned> RegMap; // Mapping between Val's and SSA Regs
28 ISel(TargetMachine &tm)
29 : TM(tm), F(0), BB(0), CurReg(MRegisterInfo::FirstVirtualRegister) {}
31 /// runOnFunction - Top level implementation of instruction selection for
32 /// the entire function.
34 bool runOnFunction(Function &Fn) {
35 F = &MachineFunction::construct(&Fn, TM);
39 return false; // We never modify the LLVM itself.
42 /// visitBasicBlock - This method is called when we are visiting a new basic
43 /// block. This simply creates a new MachineBasicBlock to emit code into
44 /// and adds it to the current MachineFunction. Subsequent visit* for
45 /// instructions will be invoked for all instructions in the basic block.
47 void visitBasicBlock(BasicBlock &LLVM_BB) {
48 BB = new MachineBasicBlock(&LLVM_BB);
49 // FIXME: Use the auto-insert form when it's available
50 F->getBasicBlockList().push_back(BB);
53 // Visitation methods for various instructions. These methods simply emit
54 // fixed X86 code for each instruction.
56 void visitReturnInst(ReturnInst &RI);
57 void visitAdd(BinaryOperator &B);
59 void visitInstruction(Instruction &I) {
60 std::cerr << "Cannot instruction select: " << I;
65 /// copyConstantToRegister - Output the instructions required to put the
66 /// specified constant into the specified register.
68 void copyConstantToRegister(Constant *C, unsigned Reg);
70 /// getReg - This method turns an LLVM value into a register number. This
71 /// is guaranteed to produce the same register number for a particular value
72 /// every time it is queried.
74 unsigned getReg(Value &V) { return getReg(&V); } // Allow references
75 unsigned getReg(Value *V) {
76 unsigned &Reg = RegMap[V];
80 // If this operand is a constant, emit the code to copy the constant into
81 // the register here...
83 if (Constant *C = dyn_cast<Constant>(V))
84 copyConstantToRegister(C, Reg);
93 /// copyConstantToRegister - Output the instructions required to put the
94 /// specified constant into the specified register.
96 void ISel::copyConstantToRegister(Constant *C, unsigned R) {
97 assert (!isa<ConstantExpr>(C) && "Constant expressions not yet handled!\n");
99 switch (C->getType()->getPrimitiveID()) {
100 case Type::SByteTyID:
101 BuildMI(BB, X86::MOVir8, R).addSImm(cast<ConstantSInt>(C)->getValue());
103 case Type::UByteTyID:
104 BuildMI(BB, X86::MOVir8, R).addZImm(cast<ConstantUInt>(C)->getValue());
106 case Type::ShortTyID:
107 BuildMI(BB, X86::MOVir16, R).addSImm(cast<ConstantSInt>(C)->getValue());
109 case Type::UShortTyID:
110 BuildMI(BB, X86::MOVir16, R).addZImm(cast<ConstantUInt>(C)->getValue());
113 BuildMI(BB, X86::MOVir32, R).addSImm(cast<ConstantSInt>(C)->getValue());
116 BuildMI(BB, X86::MOVir32, R).addZImm(cast<ConstantUInt>(C)->getValue());
118 default: assert(0 && "Type not handled yet!");
123 /// 'ret' instruction - Here we are interested in meeting the x86 ABI. As such,
124 /// we have the following possibilities:
126 /// ret void: No return value, simply emit a 'ret' instruction
127 /// ret sbyte, ubyte : Extend value into EAX and return
128 /// ret short, ushort: Extend value into EAX and return
129 /// ret int, uint : Move value into EAX and return
130 /// ret pointer : Move value into EAX and return
131 /// ret long, ulong : Move value into EAX/EDX (?) and return
132 /// ret float/double : ? Top of FP stack? XMM0?
134 void ISel::visitReturnInst(ReturnInst &I) {
135 if (I.getNumOperands() != 0) { // Not 'ret void'?
136 // Move result into a hard register... then emit a ret
137 visitInstruction(I); // abort
140 // Emit a simple 'ret' instruction... appending it to the end of the basic
142 BuildMI(BB, X86::RET, 0);
146 /// 'add' instruction - Simply turn this into an x86 reg,reg add instruction.
147 void ISel::visitAdd(BinaryOperator &B) {
148 unsigned Op0r = getReg(B.getOperand(0)), Op1r = getReg(B.getOperand(1));
149 unsigned DestReg = getReg(B);
151 switch (B.getType()->getPrimitiveSize()) {
152 case 1: // UByte, SByte
153 BuildMI(BB, X86::ADDrr8, DestReg).addReg(Op0r).addReg(Op1r);
155 case 2: // UShort, Short
156 BuildMI(BB, X86::ADDrr16, DestReg).addReg(Op0r).addReg(Op1r);
159 BuildMI(BB, X86::ADDrr32, DestReg).addReg(Op0r).addReg(Op1r);
162 case 8: // ULong, Long
164 visitInstruction(B); // abort
168 /// createSimpleX86InstructionSelector - This pass converts an LLVM function
169 /// into a machine code representation is a very simple peep-hole fashion. The
170 /// generated code sucks but the implementation is nice and simple.
172 Pass *createSimpleX86InstructionSelector(TargetMachine &TM) {