LLVM  10.0.0svn
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"
18 #include "llvm/ADT/SetVector.h"
20 
21 namespace llvm {
22 
23 class MachineDominatorTree;
24 class MachineDominanceFrontier;
25 
26 // WebAssembly instructions for exception handling are structured as follows:
27 // try
28 // instructions*
29 // catch ----|
30 // instructions* | -> A WebAssemblyException consists of this region
31 // end ----|
32 //
33 // A WebAssemblyException object contains BBs that belong to a 'catch' part of
34 // the try-catch-end structure to be created later. 'try' and 'end' markers
35 // are not present at this stage and will be generated in CFGStackify pass.
36 // Because CFGSort requires all the BBs within a catch part to be sorted
37 // together as it does for loops, this pass calculates the nesting structure of
38 // catch part of exceptions in a function.
39 //
40 // An exception catch part is defined as a BB with catch instruction and all
41 // other BBs dominated by this BB.
43  MachineBasicBlock *EHPad = nullptr;
44 
45  WebAssemblyException *ParentException = nullptr;
46  std::vector<WebAssemblyException *> SubExceptions;
47  std::vector<MachineBasicBlock *> Blocks;
49 
50 public:
51  WebAssemblyException(MachineBasicBlock *EHPad) : EHPad(EHPad) {}
54  const WebAssemblyException &operator=(const WebAssemblyException &) = delete;
55 
56  MachineBasicBlock *getEHPad() const { return EHPad; }
57  MachineBasicBlock *getHeader() const { return EHPad; }
58  WebAssemblyException *getParentException() const { return ParentException; }
59  void setParentException(WebAssemblyException *WE) { ParentException = WE; }
60 
61  bool contains(const WebAssemblyException *WE) const {
62  if (WE == this)
63  return true;
64  if (!WE)
65  return false;
66  return contains(WE->getParentException());
67  }
68  bool contains(const MachineBasicBlock *MBB) const {
69  return BlockSet.count(MBB);
70  }
71 
73  Blocks.push_back(MBB);
74  BlockSet.insert(MBB);
75  }
76  ArrayRef<MachineBasicBlock *> getBlocks() const { return Blocks; }
78  block_iterator block_begin() const { return getBlocks().begin(); }
79  block_iterator block_end() const { return getBlocks().end(); }
81  return make_range(block_begin(), block_end());
82  }
83  unsigned getNumBlocks() const { return Blocks.size(); }
84  std::vector<MachineBasicBlock *> &getBlocksVector() { return Blocks; }
85 
86  const std::vector<WebAssemblyException *> &getSubExceptions() const {
87  return SubExceptions;
88  }
89  std::vector<WebAssemblyException *> &getSubExceptions() {
90  return SubExceptions;
91  }
92  void addSubException(WebAssemblyException *E) { SubExceptions.push_back(E); }
93  using iterator = typename std::vector<WebAssemblyException *>::const_iterator;
94  iterator begin() const { return SubExceptions.begin(); }
95  iterator end() const { return SubExceptions.end(); }
96 
97  void reserveBlocks(unsigned Size) { Blocks.reserve(Size); }
98  void reverseBlock(unsigned From = 0) {
99  std::reverse(Blocks.begin() + From, Blocks.end());
100  }
101 
102  // Return the nesting level. An outermost one has depth 1.
103  unsigned getExceptionDepth() const {
104  unsigned D = 1;
105  for (const WebAssemblyException *CurException = ParentException;
106  CurException; CurException = CurException->ParentException)
107  ++D;
108  return D;
109  }
110 
111  void print(raw_ostream &OS, unsigned Depth = 0) const;
112  void dump() const;
113 };
114 
116 
118  // Mapping of basic blocks to the innermost exception they occur in
120  std::vector<WebAssemblyException *> TopLevelExceptions;
121 
122  void discoverAndMapException(WebAssemblyException *WE,
123  const MachineDominatorTree &MDT,
124  const MachineDominanceFrontier &MDF);
125  WebAssemblyException *getOutermostException(MachineBasicBlock *MBB) const;
126 
127 public:
128  static char ID;
131  }
132  ~WebAssemblyExceptionInfo() override { releaseMemory(); }
135  operator=(const WebAssemblyExceptionInfo &) = delete;
136 
137  bool runOnMachineFunction(MachineFunction &) override;
138  void releaseMemory() override;
139  void recalculate(MachineDominatorTree &MDT,
140  const MachineDominanceFrontier &MDF);
141  void getAnalysisUsage(AnalysisUsage &AU) const override;
142 
143  bool empty() const { return TopLevelExceptions.empty(); }
144 
145  // Return the innermost exception that MBB lives in. If the block is not in an
146  // exception, null is returned.
148  return BBMap.lookup(MBB);
149  }
150 
152  if (!WE) {
153  BBMap.erase(MBB);
154  return;
155  }
156  BBMap[MBB] = WE;
157  }
158 
160  assert(!WE->getParentException() && "Not a top level exception!");
161  TopLevelExceptions.push_back(WE);
162  }
163 
164  void print(raw_ostream &OS, const Module *M = nullptr) const override;
165 };
166 
167 } // end namespace llvm
168 
169 #endif
void DeleteContainerPointers(Container &C)
For a container of pointers, deletes the pointers and then clears the container.
Definition: STLExtras.h:1128
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
void reverseBlock(unsigned From=0)
std::vector< WebAssemblyException * > & getSubExceptions()
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:66
void print(raw_ostream &OS, unsigned Depth=0) const
MachineBasicBlock * getHeader() const
block_iterator block_begin() const
This file contains the entry points for global functions defined in the LLVM WebAssembly back-end...
iterator_range< block_iterator > blocks() const
WebAssemblyException(MachineBasicBlock *EHPad)
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
const WebAssemblyException & operator=(const WebAssemblyException &)=delete
std::vector< MachineBasicBlock * > & getBlocksVector()
void initializeWebAssemblyExceptionInfoPass(PassRegistry &)
void addSubException(WebAssemblyException *E)
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:261
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
void addBlock(MachineBasicBlock *MBB)
ArrayRef< MachineBasicBlock * > getBlocks() const
void changeExceptionFor(MachineBasicBlock *MBB, WebAssemblyException *WE)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
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:370
MachineBasicBlock * getEHPad() const
Represent the analysis usage information of a pass.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:381
void addTopLevelException(WebAssemblyException *WE)
WebAssemblyException * getExceptionFor(const MachineBasicBlock *MBB) const
block_iterator block_end() const
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
BlockVerifier::State From
bool contains(const MachineBasicBlock *MBB) const
void setParentException(WebAssemblyException *WE)
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
WebAssemblyException * getParentException() const
A range adaptor for a pair of iterators.
typename std::vector< WebAssemblyException * >::const_iterator iterator
bool contains(const WebAssemblyException *WE) const
const std::vector< WebAssemblyException * > & getSubExceptions() const
uint32_t Size
Definition: Profile.cpp:46
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2047
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
typename ArrayRef< MachineBasicBlock * >::const_iterator block_iterator
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...