MachineModuleInfo.cpp revision 5febcae0d24fc09d90564a46e23645b2443f4304 
1//===-- llvm/CodeGen/MachineModuleInfo.cpp ----------------------*- 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#include "llvm/CodeGen/MachineModuleInfo.h"
11
12#include "llvm/Constants.h"
13#include "llvm/Analysis/ValueTracking.h"
14#include "llvm/CodeGen/MachineFunctionPass.h"
15#include "llvm/CodeGen/MachineFunction.h"
16#include "llvm/CodeGen/Passes.h"
17#include "llvm/Target/TargetInstrInfo.h"
18#include "llvm/Target/TargetMachine.h"
19#include "llvm/Target/TargetOptions.h"
20#include "llvm/DerivedTypes.h"
21#include "llvm/GlobalVariable.h"
22#include "llvm/Intrinsics.h"
23#include "llvm/Instructions.h"
24#include "llvm/Module.h"
25#include "llvm/Support/Dwarf.h"
26#include "llvm/Support/ErrorHandling.h"
27using namespace llvm;
28using namespace llvm::dwarf;
29
30// Handle the Pass registration stuff necessary to use TargetData's.
31static RegisterPass<MachineModuleInfo>
32X("machinemoduleinfo", "Module Information");
33char MachineModuleInfo::ID = 0;
34
35//===----------------------------------------------------------------------===//
36
37MachineModuleInfo::MachineModuleInfo()
38: ImmutablePass(&ID)
39, LabelIDList()
40, FrameMoves()
41, LandingPads()
42, Personalities()
43, CallsEHReturn(0)
44, CallsUnwindInit(0)
45, DbgInfoAvailable(false)
46{
47  // Always emit "no personality" info
48  Personalities.push_back(NULL);
49}
50MachineModuleInfo::~MachineModuleInfo() {
51
52}
53
54/// doInitialization - Initialize the state for a new module.
55///
56bool MachineModuleInfo::doInitialization() {
57  return false;
58}
59
60/// doFinalization - Tear down the state after completion of a module.
61///
62bool MachineModuleInfo::doFinalization() {
63  return false;
64}
65
66/// BeginFunction - Begin gathering function meta information.
67///
68void MachineModuleInfo::BeginFunction(MachineFunction *MF) {
69  // Coming soon.
70}
71
72/// EndFunction - Discard function meta information.
73///
74void MachineModuleInfo::EndFunction() {
75  // Clean up frame info.
76  FrameMoves.clear();
77
78  // Clean up exception info.
79  LandingPads.clear();
80  TypeInfos.clear();
81  FilterIds.clear();
82  FilterEnds.clear();
83  CallsEHReturn = 0;
84  CallsUnwindInit = 0;
85}
86
87/// AnalyzeModule - Scan the module for global debug information.
88///
89void MachineModuleInfo::AnalyzeModule(Module &M) {
90  // Insert functions in the llvm.used array (but not llvm.compiler.used) into
91  // UsedFunctions.
92  GlobalVariable *GV = M.getGlobalVariable("llvm.used");
93  if (!GV || !GV->hasInitializer()) return;
94
95  // Should be an array of 'i8*'.
96  ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
97  if (InitList == 0) return;
98
99  for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
100    if (Function *F =
101          dyn_cast<Function>(InitList->getOperand(i)->stripPointerCasts()))
102      UsedFunctions.insert(F);
103}
104
105//===-EH-------------------------------------------------------------------===//
106
107/// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the
108/// specified MachineBasicBlock.
109LandingPadInfo &MachineModuleInfo::getOrCreateLandingPadInfo
110    (MachineBasicBlock *LandingPad) {
111  unsigned N = LandingPads.size();
112  for (unsigned i = 0; i < N; ++i) {
113    LandingPadInfo &LP = LandingPads[i];
114    if (LP.LandingPadBlock == LandingPad)
115      return LP;
116  }
117
118  LandingPads.push_back(LandingPadInfo(LandingPad));
119  return LandingPads[N];
120}
121
122/// addInvoke - Provide the begin and end labels of an invoke style call and
123/// associate it with a try landing pad block.
124void MachineModuleInfo::addInvoke(MachineBasicBlock *LandingPad,
125                                  unsigned BeginLabel, unsigned EndLabel) {
126  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
127  LP.BeginLabels.push_back(BeginLabel);
128  LP.EndLabels.push_back(EndLabel);
129}
130
131/// addLandingPad - Provide the label of a try LandingPad block.
132///
133unsigned MachineModuleInfo::addLandingPad(MachineBasicBlock *LandingPad) {
134  unsigned LandingPadLabel = NextLabelID();
135  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
136  LP.LandingPadLabel = LandingPadLabel;
137  return LandingPadLabel;
138}
139
140/// addPersonality - Provide the personality function for the exception
141/// information.
142void MachineModuleInfo::addPersonality(MachineBasicBlock *LandingPad,
143                                       Function *Personality) {
144  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
145  LP.Personality = Personality;
146
147  for (unsigned i = 0; i < Personalities.size(); ++i)
148    if (Personalities[i] == Personality)
149      return;
150
151  Personalities.push_back(Personality);
152}
153
154/// addCatchTypeInfo - Provide the catch typeinfo for a landing pad.
155///
156void MachineModuleInfo::addCatchTypeInfo(MachineBasicBlock *LandingPad,
157                                        std::vector<GlobalVariable *> &TyInfo) {
158  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
159  for (unsigned N = TyInfo.size(); N; --N)
160    LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
161}
162
163/// addFilterTypeInfo - Provide the filter typeinfo for a landing pad.
164///
165void MachineModuleInfo::addFilterTypeInfo(MachineBasicBlock *LandingPad,
166                                        std::vector<GlobalVariable *> &TyInfo) {
167  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
168  std::vector<unsigned> IdsInFilter(TyInfo.size());
169  for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)
170    IdsInFilter[I] = getTypeIDFor(TyInfo[I]);
171  LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
172}
173
174/// addCleanup - Add a cleanup action for a landing pad.
175///
176void MachineModuleInfo::addCleanup(MachineBasicBlock *LandingPad) {
177  LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad);
178  LP.TypeIds.push_back(0);
179}
180
181/// TidyLandingPads - Remap landing pad labels and remove any deleted landing
182/// pads.
183void MachineModuleInfo::TidyLandingPads() {
184  for (unsigned i = 0; i != LandingPads.size(); ) {
185    LandingPadInfo &LandingPad = LandingPads[i];
186    LandingPad.LandingPadLabel = MappedLabel(LandingPad.LandingPadLabel);
187
188    // Special case: we *should* emit LPs with null LP MBB. This indicates
189    // "nounwind" case.
190    if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) {
191      LandingPads.erase(LandingPads.begin() + i);
192      continue;
193    }
194
195    for (unsigned j=0; j != LandingPads[i].BeginLabels.size(); ) {
196      unsigned BeginLabel = MappedLabel(LandingPad.BeginLabels[j]);
197      unsigned EndLabel = MappedLabel(LandingPad.EndLabels[j]);
198
199      if (!BeginLabel || !EndLabel) {
200        LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j);
201        LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j);
202        continue;
203      }
204
205      LandingPad.BeginLabels[j] = BeginLabel;
206      LandingPad.EndLabels[j] = EndLabel;
207      ++j;
208    }
209
210    // Remove landing pads with no try-ranges.
211    if (LandingPads[i].BeginLabels.empty()) {
212      LandingPads.erase(LandingPads.begin() + i);
213      continue;
214    }
215
216    // If there is no landing pad, ensure that the list of typeids is empty.
217    // If the only typeid is a cleanup, this is the same as having no typeids.
218    if (!LandingPad.LandingPadBlock ||
219        (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0]))
220      LandingPad.TypeIds.clear();
221
222    ++i;
223  }
224}
225
226/// getTypeIDFor - Return the type id for the specified typeinfo.  This is
227/// function wide.
228unsigned MachineModuleInfo::getTypeIDFor(GlobalVariable *TI) {
229  for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
230    if (TypeInfos[i] == TI) return i + 1;
231
232  TypeInfos.push_back(TI);
233  return TypeInfos.size();
234}
235
236/// getFilterIDFor - Return the filter id for the specified typeinfos.  This is
237/// function wide.
238int MachineModuleInfo::getFilterIDFor(std::vector<unsigned> &TyIds) {
239  // If the new filter coincides with the tail of an existing filter, then
240  // re-use the existing filter.  Folding filters more than this requires
241  // re-ordering filters and/or their elements - probably not worth it.
242  for (std::vector<unsigned>::iterator I = FilterEnds.begin(),
243       E = FilterEnds.end(); I != E; ++I) {
244    unsigned i = *I, j = TyIds.size();
245
246    while (i && j)
247      if (FilterIds[--i] != TyIds[--j])
248        goto try_next;
249
250    if (!j)
251      // The new filter coincides with range [i, end) of the existing filter.
252      return -(1 + i);
253
254try_next:;
255  }
256
257  // Add the new filter.
258  int FilterID = -(1 + FilterIds.size());
259  FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
260  for (unsigned I = 0, N = TyIds.size(); I != N; ++I)
261    FilterIds.push_back(TyIds[I]);
262  FilterEnds.push_back(FilterIds.size());
263  FilterIds.push_back(0); // terminator
264  return FilterID;
265}
266
267/// getPersonality - Return the personality function for the current function.
268Function *MachineModuleInfo::getPersonality() const {
269  // FIXME: Until PR1414 will be fixed, we're using 1 personality function per
270  // function
271  return !LandingPads.empty() ? LandingPads[0].Personality : NULL;
272}
273
274/// getPersonalityIndex - Return unique index for current personality
275/// function. NULL personality function should always get zero index.
276unsigned MachineModuleInfo::getPersonalityIndex() const {
277  const Function* Personality = NULL;
278
279  // Scan landing pads. If there is at least one non-NULL personality - use it.
280  for (unsigned i = 0; i != LandingPads.size(); ++i)
281    if (LandingPads[i].Personality) {
282      Personality = LandingPads[i].Personality;
283      break;
284    }
285
286  for (unsigned i = 0; i < Personalities.size(); ++i) {
287    if (Personalities[i] == Personality)
288      return i;
289  }
290
291  // This should never happen
292  llvm_unreachable("Personality function should be set!");
293  return 0;
294}
295
296//===----------------------------------------------------------------------===//
297/// DebugLabelFolding pass - This pass prunes out redundant labels.  This allows
298/// a info consumer to determine if the range of two labels is empty, by seeing
299/// if the labels map to the same reduced label.
300
301namespace llvm {
302
303struct DebugLabelFolder : public MachineFunctionPass {
304  static char ID;
305  DebugLabelFolder() : MachineFunctionPass(&ID) {}
306
307  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
308    AU.setPreservesCFG();
309    AU.addPreservedID(MachineLoopInfoID);
310    AU.addPreservedID(MachineDominatorsID);
311    MachineFunctionPass::getAnalysisUsage(AU);
312  }
313
314  virtual bool runOnMachineFunction(MachineFunction &MF);
315  virtual const char *getPassName() const { return "Label Folder"; }
316};
317
318char DebugLabelFolder::ID = 0;
319
320bool DebugLabelFolder::runOnMachineFunction(MachineFunction &MF) {
321  // Get machine module info.
322  MachineModuleInfo *MMI = getAnalysisIfAvailable<MachineModuleInfo>();
323  if (!MMI) return false;
324
325  // Track if change is made.
326  bool MadeChange = false;
327  // No prior label to begin.
328  unsigned PriorLabel = 0;
329
330  // Iterate through basic blocks.
331  for (MachineFunction::iterator BB = MF.begin(), E = MF.end();
332       BB != E; ++BB) {
333    // Iterate through instructions.
334    for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
335      // Is it a label.
336      if (I->isDebugLabel() && !MMI->isDbgLabelUsed(I->getOperand(0).getImm())){
337        // The label ID # is always operand #0, an immediate.
338        unsigned NextLabel = I->getOperand(0).getImm();
339
340        // If there was an immediate prior label.
341        if (PriorLabel) {
342          // Remap the current label to prior label.
343          MMI->RemapLabel(NextLabel, PriorLabel);
344          // Delete the current label.
345          I = BB->erase(I);
346          // Indicate a change has been made.
347          MadeChange = true;
348          continue;
349        } else {
350          // Start a new round.
351          PriorLabel = NextLabel;
352        }
353       } else {
354        // No consecutive labels.
355        PriorLabel = 0;
356      }
357
358      ++I;
359    }
360  }
361
362  return MadeChange;
363}
364
365FunctionPass *createDebugLabelFoldingPass() { return new DebugLabelFolder(); }
366
367}
368
369