LLVM  9.0.0svn
EHStreamer.h
Go to the documentation of this file.
1 //===- EHStreamer.h - Exception Handling Directive Streamer -----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains support for writing exception info into assembly files.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_EHSTREAMER_H
14 #define LLVM_LIB_CODEGEN_ASMPRINTER_EHSTREAMER_H
15 
16 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/Support/Compiler.h"
19 
20 namespace llvm {
21 
22 class AsmPrinter;
23 struct LandingPadInfo;
24 class MachineInstr;
25 class MachineModuleInfo;
26 class MCSymbol;
27 template <typename T> class SmallVectorImpl;
28 
29 /// Emits exception handling directives.
31 protected:
32  /// Target of directive emission.
34 
35  /// Collected machine module information.
37 
38  /// How many leading type ids two landing pads have in common.
39  static unsigned sharedTypeIDs(const LandingPadInfo *L,
40  const LandingPadInfo *R);
41 
42  /// Structure holding a try-range and the associated landing pad.
43  struct PadRange {
44  // The index of the landing pad.
45  unsigned PadIndex;
46 
47  // The index of the begin and end labels in the landing pad's label lists.
48  unsigned RangeIndex;
49  };
50 
52 
53  /// Structure describing an entry in the actions table.
54  struct ActionEntry {
55  int ValueForTypeID; // The value to write - may not be equal to the type id.
57  unsigned Previous;
58  };
59 
60  /// Structure describing an entry in the call-site table.
61  struct CallSiteEntry {
62  // The 'try-range' is BeginLabel .. EndLabel.
63  MCSymbol *BeginLabel; // Null indicates the start of the function.
64  MCSymbol *EndLabel; // Null indicates the end of the function.
65 
66  // LPad contains the landing pad start labels.
67  const LandingPadInfo *LPad; // Null indicates that there is no landing pad.
68 
69  unsigned Action;
70  };
71 
72  /// Compute the actions table and gather the first action index for each
73  /// landing pad site.
74  void computeActionsTable(const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
76  SmallVectorImpl<unsigned> &FirstActions);
77 
78  void computePadMap(const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
79  RangeMapType &PadMap);
80 
81  /// Compute the call-site table. The entry for an invoke has a try-range
82  /// containing the call, a non-zero landing pad and an appropriate action.
83  /// The entry for an ordinary call has a try-range containing the call and
84  /// zero for the landing pad and the action. Calls marked 'nounwind' have
85  /// no entry and must not be contained in the try-range of any entry - they
86  /// form gaps in the table. Entries must be ordered by try-range address.
87  virtual void computeCallSiteTable(
89  const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
90  const SmallVectorImpl<unsigned> &FirstActions);
91 
92  /// Emit landing pads and actions.
93  ///
94  /// The general organization of the table is complex, but the basic concepts
95  /// are easy. First there is a header which describes the location and
96  /// organization of the three components that follow.
97  /// 1. The landing pad site information describes the range of code covered
98  /// by the try. In our case it's an accumulation of the ranges covered
99  /// by the invokes in the try. There is also a reference to the landing
100  /// pad that handles the exception once processed. Finally an index into
101  /// the actions table.
102  /// 2. The action table, in our case, is composed of pairs of type ids
103  /// and next action offset. Starting with the action index from the
104  /// landing pad site, each type Id is checked for a match to the current
105  /// exception. If it matches then the exception and type id are passed
106  /// on to the landing pad. Otherwise the next action is looked up. This
107  /// chain is terminated with a next action of zero. If no type id is
108  /// found the frame is unwound and handling continues.
109  /// 3. Type id table contains references to all the C++ typeinfo for all
110  /// catches in the function. This tables is reversed indexed base 1.
111  ///
112  /// Returns the starting symbol of an exception table.
113  MCSymbol *emitExceptionTable();
114 
115  virtual void emitTypeInfos(unsigned TTypeEncoding, MCSymbol *TTBaseLabel);
116 
117  // Helpers for identifying what kind of clause an EH typeid or selector
118  // corresponds to. Negative selectors are for filter clauses, the zero
119  // selector is for cleanups, and positive selectors are for catch clauses.
120  static bool isFilterEHSelector(int Selector) { return Selector < 0; }
121  static bool isCleanupEHSelector(int Selector) { return Selector == 0; }
122  static bool isCatchEHSelector(int Selector) { return Selector > 0; }
123 
124 public:
126  ~EHStreamer() override;
127 
128  // Unused.
129  void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {}
130  void beginInstruction(const MachineInstr *MI) override {}
131  void endInstruction() override {}
132 
133  /// Return `true' if this is a call to a function marked `nounwind'. Return
134  /// `false' otherwise.
135  static bool callToNoUnwindFunction(const MachineInstr *MI);
136 };
137 
138 } // end namespace llvm
139 
140 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_EHSTREAMER_H
Structure describing an entry in the call-site table.
Definition: EHStreamer.h:61
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override
For symbols that have a size designated (e.g.
Definition: EHStreamer.h:129
Collects and handles AsmPrinter objects required to build debug or EH information.
Structure describing an entry in the actions table.
Definition: EHStreamer.h:54
static bool isFilterEHSelector(int Selector)
Definition: EHStreamer.h:120
const LandingPadInfo * LPad
Definition: EHStreamer.h:67
MachineModuleInfo * MMI
Collected machine module information.
Definition: EHStreamer.h:36
Emits exception handling directives.
Definition: EHStreamer.h:30
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
This structure is used to retain landing pad info for the current function.
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
Definition: EHStreamer.h:130
static bool isCatchEHSelector(int Selector)
Definition: EHStreamer.h:122
static bool isCleanupEHSelector(int Selector)
Definition: EHStreamer.h:121
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library...
Definition: Compiler.h:107
AsmPrinter * Asm
Target of directive emission.
Definition: EHStreamer.h:33
void endInstruction() override
Process end of an instruction.
Definition: EHStreamer.h:131
Representation of each machine instruction.
Definition: MachineInstr.h:63
uint32_t Size
Definition: Profile.cpp:46
IRTranslator LLVM IR MI
Structure holding a try-range and the associated landing pad.
Definition: EHStreamer.h:43
This class contains meta information specific to a module.