LLVM 17.0.0git
WebAssemblyExceptionInfo.h
Go to the documentation of this file.
1//===-- WebAssemblyExceptionInfo.h - WebAssembly Exception Info -*- 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/// \file
10/// \brief This file implements WebAssemblyException information analysis.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYEXCEPTIONINFO_H
15#define LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYEXCEPTIONINFO_H
16
17#include "WebAssembly.h"
19
20namespace llvm {
21
22class MachineDominatorTree;
23class MachineDominanceFrontier;
24
25// WebAssembly instructions for exception handling are structured as follows:
26// try
27// instructions*
28// catch ----|
29// instructions* | -> A WebAssemblyException consists of this region
30// end ----|
31//
32// A WebAssemblyException object contains BBs that belong to a 'catch' part of
33// the try-catch-end structure to be created later. 'try' and 'end' markers
34// are not present at this stage and will be generated in CFGStackify pass.
35// Because CFGSort requires all the BBs within a catch part to be sorted
36// together as it does for loops, this pass calculates the nesting structure of
37// catch part of exceptions in a function.
38//
39// An exception catch part is defined as a BB with catch instruction and all
40// other BBs dominated by this BB.
42 MachineBasicBlock *EHPad = nullptr;
43
44 WebAssemblyException *ParentException = nullptr;
45 std::vector<std::unique_ptr<WebAssemblyException>> SubExceptions;
46 std::vector<MachineBasicBlock *> Blocks;
48
49public:
50 WebAssemblyException(MachineBasicBlock *EHPad) : EHPad(EHPad) {}
53
54 MachineBasicBlock *getEHPad() const { return EHPad; }
55 MachineBasicBlock *getHeader() const { return EHPad; }
56 WebAssemblyException *getParentException() const { return ParentException; }
57 void setParentException(WebAssemblyException *WE) { ParentException = WE; }
58
59 bool contains(const WebAssemblyException *WE) const {
60 if (WE == this)
61 return true;
62 if (!WE)
63 return false;
64 return contains(WE->getParentException());
65 }
66 bool contains(const MachineBasicBlock *MBB) const {
67 return BlockSet.count(MBB);
68 }
69
72 void addToBlocksVector(MachineBasicBlock *MBB) { Blocks.push_back(MBB); }
74 Blocks.push_back(MBB);
75 BlockSet.insert(MBB);
76 }
77 ArrayRef<MachineBasicBlock *> getBlocks() const { return Blocks; }
79 block_iterator block_begin() const { return getBlocks().begin(); }
80 block_iterator block_end() const { return getBlocks().end(); }
82 return make_range(block_begin(), block_end());
83 }
84 unsigned getNumBlocks() const { return Blocks.size(); }
85 std::vector<MachineBasicBlock *> &getBlocksVector() { return Blocks; }
87
88 const std::vector<std::unique_ptr<WebAssemblyException>> &
90 return SubExceptions;
91 }
92 std::vector<std::unique_ptr<WebAssemblyException>> &getSubExceptions() {
93 return SubExceptions;
94 }
95 void addSubException(std::unique_ptr<WebAssemblyException> E) {
96 SubExceptions.push_back(std::move(E));
97 }
98 using iterator = typename decltype(SubExceptions)::const_iterator;
99 iterator begin() const { return SubExceptions.begin(); }
100 iterator end() const { return SubExceptions.end(); }
101
102 void reserveBlocks(unsigned Size) { Blocks.reserve(Size); }
103 void reverseBlock(unsigned From = 0) {
104 std::reverse(Blocks.begin() + From, Blocks.end());
105 }
106
107 // Return the nesting level. An outermost one has depth 1.
108 unsigned getExceptionDepth() const {
109 unsigned D = 1;
110 for (const WebAssemblyException *CurException = ParentException;
111 CurException; CurException = CurException->ParentException)
112 ++D;
113 return D;
114 }
115
116 void print(raw_ostream &OS, unsigned Depth = 0) const;
117 void dump() const;
118};
119
121
123 // Mapping of basic blocks to the innermost exception they occur in
125 std::vector<std::unique_ptr<WebAssemblyException>> TopLevelExceptions;
126
127 void discoverAndMapException(WebAssemblyException *WE,
128 const MachineDominatorTree &MDT,
129 const MachineDominanceFrontier &MDF);
130 WebAssemblyException *getOutermostException(MachineBasicBlock *MBB) const;
131
132public:
133 static char ID;
136 }
141
142 bool runOnMachineFunction(MachineFunction &) override;
143 void releaseMemory() override;
145 const MachineDominanceFrontier &MDF);
146 void getAnalysisUsage(AnalysisUsage &AU) const override;
147
148 bool empty() const { return TopLevelExceptions.empty(); }
149
150 // Return the innermost exception that MBB lives in. If the block is not in an
151 // exception, null is returned.
153 return BBMap.lookup(MBB);
154 }
155
158 if (!WE) {
159 BBMap.erase(MBB);
160 return;
161 }
162 BBMap[MBB] = WE;
163 }
164
165 void addTopLevelException(std::unique_ptr<WebAssemblyException> WE) {
166 assert(!WE->getParentException() && "Not a top level exception!");
167 TopLevelExceptions.push_back(std::move(WE));
168 }
169
170 void print(raw_ostream &OS, const Module *M = nullptr) const override;
171};
172
173} // end namespace llvm
174
175#endif
MachineBasicBlock & MBB
BlockVerifier::State From
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
uint64_t Size
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This file contains the entry points for global functions defined in the LLVM WebAssembly back-end.
Represent the analysis usage information of a pass.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:344
bool erase(PtrType Ptr)
erase - If the set contains the specified pointer, remove it and return true, otherwise return false.
Definition: SmallPtrSet.h:379
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:383
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:365
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
void changeExceptionFor(const MachineBasicBlock *MBB, WebAssemblyException *WE)
bool runOnMachineFunction(MachineFunction &) override
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
void addTopLevelException(std::unique_ptr< WebAssemblyException > WE)
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
void recalculate(MachineFunction &MF, MachineDominatorTree &MDT, const MachineDominanceFrontier &MDF)
WebAssemblyException * getExceptionFor(const MachineBasicBlock *MBB) const
void print(raw_ostream &OS, const Module *M=nullptr) const override
print - Print out the internal state of the pass.
WebAssemblyExceptionInfo & operator=(const WebAssemblyExceptionInfo &)=delete
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
WebAssemblyExceptionInfo(const WebAssemblyExceptionInfo &)=delete
block_iterator block_end() const
void print(raw_ostream &OS, unsigned Depth=0) const
bool contains(const WebAssemblyException *WE) const
WebAssemblyException(const WebAssemblyException &)=delete
MachineBasicBlock * getEHPad() const
void addToBlocksSet(MachineBasicBlock *MBB)
bool contains(const MachineBasicBlock *MBB) const
iterator_range< block_iterator > blocks() const
const std::vector< std::unique_ptr< WebAssemblyException > > & getSubExceptions() const
SmallPtrSetImpl< MachineBasicBlock * > & getBlocksSet()
block_iterator block_begin() const
std::vector< std::unique_ptr< WebAssemblyException > > & getSubExceptions()
typename ArrayRef< MachineBasicBlock * >::const_iterator block_iterator
void addSubException(std::unique_ptr< WebAssemblyException > E)
ArrayRef< MachineBasicBlock * > getBlocks() const
std::vector< MachineBasicBlock * > & getBlocksVector()
WebAssemblyException * getParentException() const
void removeFromBlocksSet(MachineBasicBlock *MBB)
WebAssemblyException(MachineBasicBlock *EHPad)
void addBlock(MachineBasicBlock *MBB)
MachineBasicBlock * getHeader() const
void setParentException(WebAssemblyException *WE)
typename decltype(SubExceptions)::const_iterator iterator
void addToBlocksVector(MachineBasicBlock *MBB)
const WebAssemblyException & operator=(const WebAssemblyException &)=delete
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void initializeWebAssemblyExceptionInfoPass(PassRegistry &)
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292