1 //===-- FunctionLoweringInfo.h - Lower functions from LLVM IR to CodeGen --===//
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 implements routines for translating functions from LLVM IR into
13 //===----------------------------------------------------------------------===//
15 #ifndef FUNCTIONLOWERINGINFO_H
16 #define FUNCTIONLOWERINGINFO_H
18 #include "llvm/InlineAsm.h"
19 #include "llvm/Instructions.h"
20 #include "llvm/ADT/APInt.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/SmallVector.h"
24 #include "llvm/ADT/SmallSet.h"
26 #include "llvm/CodeGen/ValueTypes.h"
27 #include "llvm/CodeGen/ISDOpcodes.h"
28 #include "llvm/Support/CallSite.h"
40 class MachineBasicBlock;
41 class MachineFunction;
42 class MachineModuleInfo;
43 class MachineRegisterInfo;
47 //===--------------------------------------------------------------------===//
48 /// FunctionLoweringInfo - This contains information that is global to a
49 /// function that is used when lowering a region of the function.
51 class FunctionLoweringInfo {
53 const TargetLowering &TLI;
56 MachineRegisterInfo *RegInfo;
58 /// CanLowerReturn - true iff the function's return value can be lowered to
62 /// DemoteRegister - if CanLowerReturn is false, DemoteRegister is a vreg
63 /// allocated to hold a pointer to the hidden sret parameter.
64 unsigned DemoteRegister;
66 /// MBBMap - A mapping from LLVM basic blocks to their machine code entry.
67 DenseMap<const BasicBlock*, MachineBasicBlock *> MBBMap;
69 /// ValueMap - Since we emit code for the function a basic block at a time,
70 /// we must remember which virtual registers hold the values for
71 /// cross-basic-block values.
72 DenseMap<const Value*, unsigned> ValueMap;
74 /// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in
75 /// the entry block. This allows the allocas to be efficiently referenced
76 /// anywhere in the function.
77 DenseMap<const AllocaInst*, int> StaticAllocaMap;
79 /// ArgDbgValues - A list of DBG_VALUE instructions created during isel for
80 /// function arguments that are inserted after scheduling is completed.
81 SmallVector<MachineInstr*, 8> ArgDbgValues;
84 SmallSet<const Instruction *, 8> CatchInfoLost;
85 SmallSet<const Instruction *, 8> CatchInfoFound;
90 APInt KnownOne, KnownZero;
91 LiveOutInfo() : NumSignBits(0), KnownOne(1, 0), KnownZero(1, 0) {}
94 /// LiveOutRegInfo - Information about live out vregs, indexed by their
95 /// register number offset by 'FirstVirtualRegister'.
96 std::vector<LiveOutInfo> LiveOutRegInfo;
98 /// PHINodesToUpdate - A list of phi instructions whose operand list will
99 /// be updated after processing the current basic block.
100 /// TODO: This isn't per-function state, it's per-basic-block state. But
101 /// there's no other convenient place for it to live right now.
102 std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate;
104 explicit FunctionLoweringInfo(const TargetLowering &TLI);
106 /// set - Initialize this FunctionLoweringInfo with the given Function
107 /// and its associated MachineFunction.
109 void set(const Function &Fn, MachineFunction &MF, bool EnableFastISel);
111 /// clear - Clear out all the function-specific state. This returns this
112 /// FunctionLoweringInfo to an empty state, ready to be used for a
113 /// different function.
116 unsigned MakeReg(EVT VT);
118 /// isExportedInst - Return true if the specified value is an instruction
119 /// exported from its block.
120 bool isExportedInst(const Value *V) {
121 return ValueMap.count(V);
124 unsigned CreateRegForValue(const Value *V);
126 unsigned InitializeRegForValue(const Value *V) {
127 unsigned &R = ValueMap[V];
128 assert(R == 0 && "Already initialized this value register!");
129 return R = CreateRegForValue(V);
133 /// AddCatchInfo - Extract the personality and type infos from an eh.selector
134 /// call, and add them to the specified machine basic block.
135 void AddCatchInfo(const CallInst &I,
136 MachineModuleInfo *MMI, MachineBasicBlock *MBB);
138 /// CopyCatchInfo - Copy catch information from DestBB to SrcBB.
139 void CopyCatchInfo(const BasicBlock *SrcBB, const BasicBlock *DestBB,
140 MachineModuleInfo *MMI, FunctionLoweringInfo &FLI);
142 } // end namespace llvm