← Back to branch summary

~ubuntu-branches/ubuntu/quantal/llvm-3.1/quantal

« back to all changes in this revision

Viewing changes to lib/CodeGen/AsmPrinter/DwarfException.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2012-03-29 19:09:51 UTC
  • Revision ID: package-import@ubuntu.com-20120329190951-aq83ivog4cg8bxun
Tags: upstream-3.1~svn153643
Import upstream version 3.1~svn153643

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/CodeGen/AsmPrinter/DwarfException.h
 
1
//===-- DwarfException.h - Dwarf Exception Framework -----------*- 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
// This file contains support for writing dwarf exception info into asm files.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef LLVM_CODEGEN_ASMPRINTER_DWARFEXCEPTION_H
 
15
#define LLVM_CODEGEN_ASMPRINTER_DWARFEXCEPTION_H
 
16
 
 
17
#include "llvm/ADT/DenseMap.h"
 
18
#include "llvm/CodeGen/AsmPrinter.h"
 
19
#include <vector>
 
20
 
 
21
namespace llvm {
 
22
 
 
23
template <typename T> class SmallVectorImpl;
 
24
struct LandingPadInfo;
 
25
class MachineModuleInfo;
 
26
class MachineMove;
 
27
class MachineInstr;
 
28
class MachineFunction;
 
29
class MCAsmInfo;
 
30
class MCExpr;
 
31
class MCSymbol;
 
32
class Function;
 
33
class AsmPrinter;
 
34
 
 
35
//===----------------------------------------------------------------------===//
 
36
/// DwarfException - Emits Dwarf exception handling directives.
 
37
///
 
38
class DwarfException {
 
39
protected:
 
40
  /// Asm - Target of Dwarf emission.
 
41
  AsmPrinter *Asm;
 
42
 
 
43
  /// MMI - Collected machine module information.
 
44
  MachineModuleInfo *MMI;
 
45
 
 
46
  /// EmitExceptionTable - Emit landing pads and actions.
 
47
  ///
 
48
  /// The general organization of the table is complex, but the basic concepts
 
49
  /// are easy.  First there is a header which describes the location and
 
50
  /// organization of the three components that follow.
 
51
  ///  1. The landing pad site information describes the range of code covered
 
52
  ///     by the try.  In our case it's an accumulation of the ranges covered
 
53
  ///     by the invokes in the try.  There is also a reference to the landing
 
54
  ///     pad that handles the exception once processed.  Finally an index into
 
55
  ///     the actions table.
 
56
  ///  2. The action table, in our case, is composed of pairs of type ids
 
57
  ///     and next action offset.  Starting with the action index from the
 
58
  ///     landing pad site, each type Id is checked for a match to the current
 
59
  ///     exception.  If it matches then the exception and type id are passed
 
60
  ///     on to the landing pad.  Otherwise the next action is looked up.  This
 
61
  ///     chain is terminated with a next action of zero.  If no type id is
 
62
  ///     found the frame is unwound and handling continues.
 
63
  ///  3. Type id table contains references to all the C++ typeinfo for all
 
64
  ///     catches in the function.  This tables is reversed indexed base 1.
 
65
 
 
66
  /// SharedTypeIds - How many leading type ids two landing pads have in common.
 
67
  static unsigned SharedTypeIds(const LandingPadInfo *L,
 
68
                                const LandingPadInfo *R);
 
69
 
 
70
  /// PadLT - Order landing pads lexicographically by type id.
 
71
  static bool PadLT(const LandingPadInfo *L, const LandingPadInfo *R);
 
72
 
 
73
  /// PadRange - Structure holding a try-range and the associated landing pad.
 
74
  struct PadRange {
 
75
    // The index of the landing pad.
 
76
    unsigned PadIndex;
 
77
    // The index of the begin and end labels in the landing pad's label lists.
 
78
    unsigned RangeIndex;
 
79
  };
 
80
 
 
81
  typedef DenseMap<MCSymbol *, PadRange> RangeMapType;
 
82
 
 
83
  /// ActionEntry - Structure describing an entry in the actions table.
 
84
  struct ActionEntry {
 
85
    int ValueForTypeID; // The value to write - may not be equal to the type id.
 
86
    int NextAction;
 
87
    unsigned Previous;
 
88
  };
 
89
 
 
90
  /// CallSiteEntry - Structure describing an entry in the call-site table.
 
91
  struct CallSiteEntry {
 
92
    // The 'try-range' is BeginLabel .. EndLabel.
 
93
    MCSymbol *BeginLabel; // zero indicates the start of the function.
 
94
    MCSymbol *EndLabel;   // zero indicates the end of the function.
 
95
 
 
96
    // The landing pad starts at PadLabel.
 
97
    MCSymbol *PadLabel;   // zero indicates that there is no landing pad.
 
98
    unsigned Action;
 
99
  };
 
100
 
 
101
  /// ComputeActionsTable - Compute the actions table and gather the first
 
102
  /// action index for each landing pad site.
 
103
  unsigned ComputeActionsTable(const SmallVectorImpl<const LandingPadInfo*>&LPs,
 
104
                               SmallVectorImpl<ActionEntry> &Actions,
 
105
                               SmallVectorImpl<unsigned> &FirstActions);
 
106
 
 
107
  /// CallToNoUnwindFunction - Return `true' if this is a call to a function
 
108
  /// marked `nounwind'. Return `false' otherwise.
 
109
  bool CallToNoUnwindFunction(const MachineInstr *MI);
 
110
 
 
111
  /// ComputeCallSiteTable - Compute the call-site table.  The entry for an
 
112
  /// invoke has a try-range containing the call, a non-zero landing pad and an
 
113
  /// appropriate action.  The entry for an ordinary call has a try-range
 
114
  /// containing the call and zero for the landing pad and the action.  Calls
 
115
  /// marked 'nounwind' have no entry and must not be contained in the try-range
 
116
  /// of any entry - they form gaps in the table.  Entries must be ordered by
 
117
  /// try-range address.
 
118
  void ComputeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
 
119
                            const RangeMapType &PadMap,
 
120
                            const SmallVectorImpl<const LandingPadInfo *> &LPs,
 
121
                            const SmallVectorImpl<unsigned> &FirstActions);
 
122
  void EmitExceptionTable();
 
123
 
 
124
public:
 
125
  //===--------------------------------------------------------------------===//
 
126
  // Main entry points.
 
127
  //
 
128
  DwarfException(AsmPrinter *A);
 
129
  virtual ~DwarfException();
 
130
 
 
131
  /// EndModule - Emit all exception information that should come after the
 
132
  /// content.
 
133
  virtual void EndModule();
 
134
 
 
135
  /// BeginFunction - Gather pre-function exception information.  Assumes being
 
136
  /// emitted immediately after the function entry point.
 
137
  virtual void BeginFunction(const MachineFunction *MF);
 
138
 
 
139
  /// EndFunction - Gather and emit post-function exception information.
 
140
  virtual void EndFunction();
 
141
};
 
142
 
 
143
class DwarfCFIException : public DwarfException {
 
144
  /// shouldEmitPersonality - Per-function flag to indicate if .cfi_personality
 
145
  /// should be emitted.
 
146
  bool shouldEmitPersonality;
 
147
 
 
148
  /// shouldEmitLSDA - Per-function flag to indicate if .cfi_lsda
 
149
  /// should be emitted.
 
150
  bool shouldEmitLSDA;
 
151
 
 
152
  /// shouldEmitMoves - Per-function flag to indicate if frame moves info
 
153
  /// should be emitted.
 
154
  bool shouldEmitMoves;
 
155
 
 
156
  AsmPrinter::CFIMoveType moveTypeModule;
 
157
 
 
158
public:
 
159
  //===--------------------------------------------------------------------===//
 
160
  // Main entry points.
 
161
  //
 
162
  DwarfCFIException(AsmPrinter *A);
 
163
  virtual ~DwarfCFIException();
 
164
 
 
165
  /// EndModule - Emit all exception information that should come after the
 
166
  /// content.
 
167
  virtual void EndModule();
 
168
 
 
169
  /// BeginFunction - Gather pre-function exception information.  Assumes being
 
170
  /// emitted immediately after the function entry point.
 
171
  virtual void BeginFunction(const MachineFunction *MF);
 
172
 
 
173
  /// EndFunction - Gather and emit post-function exception information.
 
174
  virtual void EndFunction();
 
175
};
 
176
 
 
177
class ARMException : public DwarfException {
 
178
  /// shouldEmitTable - Per-function flag to indicate if EH tables should
 
179
  /// be emitted.
 
180
  bool shouldEmitTable;
 
181
 
 
182
  /// shouldEmitMoves - Per-function flag to indicate if frame moves info
 
183
  /// should be emitted.
 
184
  bool shouldEmitMoves;
 
185
 
 
186
  /// shouldEmitTableModule - Per-module flag to indicate if EH tables
 
187
  /// should be emitted.
 
188
  bool shouldEmitTableModule;
 
189
public:
 
190
  //===--------------------------------------------------------------------===//
 
191
  // Main entry points.
 
192
  //
 
193
  ARMException(AsmPrinter *A);
 
194
  virtual ~ARMException();
 
195
 
 
196
  /// EndModule - Emit all exception information that should come after the
 
197
  /// content.
 
198
  virtual void EndModule();
 
199
 
 
200
  /// BeginFunction - Gather pre-function exception information.  Assumes being
 
201
  /// emitted immediately after the function entry point.
 
202
  virtual void BeginFunction(const MachineFunction *MF);
 
203
 
 
204
  /// EndFunction - Gather and emit post-function exception information.
 
205
  virtual void EndFunction();
 
206
};
 
207
 
 
208
class Win64Exception : public DwarfException {
 
209
  /// shouldEmitPersonality - Per-function flag to indicate if personality
 
210
  /// info should be emitted.
 
211
  bool shouldEmitPersonality;
 
212
 
 
213
  /// shouldEmitLSDA - Per-function flag to indicate if the LSDA
 
214
  /// should be emitted.
 
215
  bool shouldEmitLSDA;
 
216
 
 
217
  /// shouldEmitMoves - Per-function flag to indicate if frame moves info
 
218
  /// should be emitted.
 
219
  bool shouldEmitMoves;
 
220
 
 
221
public:
 
222
  //===--------------------------------------------------------------------===//
 
223
  // Main entry points.
 
224
  //
 
225
  Win64Exception(AsmPrinter *A);
 
226
  virtual ~Win64Exception();
 
227
 
 
228
  /// EndModule - Emit all exception information that should come after the
 
229
  /// content.
 
230
  virtual void EndModule();
 
231
 
 
232
  /// BeginFunction - Gather pre-function exception information.  Assumes being
 
233
  /// emitted immediately after the function entry point.
 
234
  virtual void BeginFunction(const MachineFunction *MF);
 
235
 
 
236
  /// EndFunction - Gather and emit post-function exception information.
 
237
  virtual void EndFunction();
 
238
};
 
239
 
 
240
} // End of namespace llvm
 
241
 
 
242
#endif