1 //===-- InstSelectPattern.cpp - A pattern matching inst selector for X86 --===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines a pattern matching instruction selector for X86.
12 // FIXME: we could allocate one big array of unsigneds to use as the backing
13 // store for all of the nodes costs arrays.
15 //===----------------------------------------------------------------------===//
18 #include "llvm/Pass.h"
19 #include "llvm/Function.h"
20 #include "llvm/DerivedTypes.h"
21 #include "llvm/CodeGen/SelectionDAG.h"
22 #include "llvm/CodeGen/MachineFunction.h"
23 #include "llvm/CodeGen/MachineFrameInfo.h"
24 #include "llvm/CodeGen/SSARegMap.h"
26 #include "X86RegisterInfo.h"
28 // Include the generated instruction selector...
29 #include "X86GenInstrSelector.inc"
34 struct ISel : public FunctionPass, SelectionDAGTargetBuilder {
36 ISel(TargetMachine &tm) : TM(tm) {}
37 int VarArgsFrameIndex; // FrameIndex for start of varargs area
39 bool runOnFunction(Function &Fn) {
40 MachineFunction &MF = MachineFunction::construct(&Fn, TM);
41 SelectionDAG DAG(MF, TM, *this);
43 std::cerr << "\n\n\n=== "
44 << DAG.getMachineFunction().getFunction()->getName() << "\n";
47 X86ISel(DAG).generateCode();
48 std::cerr << "\n\n\n";
52 public: // Implementation of the SelectionDAGTargetBuilder class...
53 /// expandArguments - Add nodes to the DAG to indicate how to load arguments
54 /// off of the X86 stack.
55 void expandArguments(SelectionDAG &SD);
56 void expandCall(SelectionDAG &SD, CallInst &CI);
61 void ISel::expandArguments(SelectionDAG &SD) {
63 // Add DAG nodes to load the arguments... On entry to a function on the X86,
64 // the stack frame looks like this:
66 // [ESP] -- return address
67 // [ESP + 4] -- first argument (leftmost lexically)
68 // [ESP + 8] -- second argument, if first argument is four bytes in size
71 MachineFunction &F = SD.getMachineFunction();
72 MachineFrameInfo *MFI = F.getFrameInfo();
73 const Function &Fn = *F.getFunction();
75 unsigned ArgOffset = 0; // Frame mechanisms handle retaddr slot
76 for (Function::const_aiterator I = Fn.abegin(), E = Fn.aend(); I != E; ++I) {
77 MVT::ValueType ObjectVT = SD.getValueType(I->getType());
78 unsigned ArgIncrement = 4;
81 default: assert(0 && "Unhandled argument type!");
82 case MVT::i8: ObjSize = 1; break;
83 case MVT::i16: ObjSize = 2; break;
84 case MVT::i32: ObjSize = 4; break;
85 case MVT::i64: ObjSize = ArgIncrement = 8; break;
86 case MVT::f32: ObjSize = 4; break;
87 case MVT::f64: ObjSize = ArgIncrement = 8; break;
89 // Create the frame index object for this incoming parameter...
90 int FI = MFI->CreateFixedObject(ObjSize, ArgOffset);
92 // Create the SelectionDAG nodes corresponding to a load from this parameter
93 SelectionDAGNode *FIN = new SelectionDAGNode(ISD::FrameIndex, MVT::i32);
94 FIN->addValue(new ReducedValue_FrameIndex_i32(FI));
97 = new SelectionDAGNode(ISD::Load, ObjectVT, F.begin(), FIN);
99 // Add the SelectionDAGNodes to the SelectionDAG... note that there is no
100 // reason to add chain nodes here. We know that no loads ore stores will
101 // ever alias these loads, so we are free to perform the load at any time in
104 SD.addNodeForValue(Arg, I);
106 ArgOffset += ArgIncrement; // Move on to the next argument...
109 // If the function takes variable number of arguments, make a frame index for
110 // the start of the first vararg value... for expansion of llvm.va_start.
111 if (Fn.getFunctionType()->isVarArg())
112 VarArgsFrameIndex = MFI->CreateFixedObject(1, ArgOffset);
115 void ISel::expandCall(SelectionDAG &SD, CallInst &CI) {
116 assert(0 && "ISel::expandCall not implemented!");
119 /// createX86PatternInstructionSelector - This pass converts an LLVM function
120 /// into a machine code representation using pattern matching and a machine
121 /// description file.
123 FunctionPass *createX86PatternInstructionSelector(TargetMachine &TM) {
127 } // End llvm namespace