[04124c4] | 1 | // |
---|
| 2 | // Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo |
---|
| 3 | // |
---|
| 4 | // The contents of this file are covered under the licence agreement in the |
---|
| 5 | // file "LICENCE" distributed with Cforall. |
---|
| 6 | // |
---|
| 7 | // Pass.hpp -- |
---|
| 8 | // |
---|
| 9 | // Author : Thierry Delisle |
---|
[a86b2ca6] | 10 | // Created On : Thu May 09 15:37:05 2019 |
---|
[04124c4] | 11 | // Last Modified By : |
---|
| 12 | // Last Modified On : |
---|
| 13 | // Update Count : |
---|
| 14 | // |
---|
| 15 | |
---|
[f47f887] | 16 | #pragma once |
---|
[04124c4] | 17 | // IWYU pragma: private, include "AST/Pass.hpp" |
---|
[f47f887] | 18 | |
---|
| 19 | #include <functional> |
---|
| 20 | #include <list> |
---|
| 21 | #include <stack> |
---|
| 22 | |
---|
[04124c4] | 23 | #include "AST/Fwd.hpp" |
---|
| 24 | #include "AST/Node.hpp" |
---|
[6d51bd7] | 25 | |
---|
| 26 | #include "AST/Attribute.hpp" |
---|
[04124c4] | 27 | #include "AST/Decl.hpp" |
---|
[6d51bd7] | 28 | #include "AST/Expr.hpp" |
---|
| 29 | #include "AST/Init.hpp" |
---|
| 30 | #include "AST/Stmt.hpp" |
---|
[8a5530c] | 31 | #include "AST/Type.hpp" |
---|
[6d51bd7] | 32 | |
---|
[04124c4] | 33 | #include "AST/Visitor.hpp" |
---|
| 34 | |
---|
[0e42794] | 35 | #include "AST/SymbolTable.hpp" |
---|
[f47f887] | 36 | |
---|
| 37 | // Private prelude header, needed for some of the magic tricks this class pulls off |
---|
[04124c4] | 38 | #include "AST/Pass.proto.hpp" |
---|
[f47f887] | 39 | |
---|
| 40 | namespace ast { |
---|
| 41 | //------------------------------------------------------------------------------------------------- |
---|
| 42 | // Templated visitor type |
---|
| 43 | // To use declare a Pass< YOUR VISITOR TYPE > |
---|
| 44 | // The visitor type should specify the previsit/postvisit for types that are desired. |
---|
| 45 | // Note: previsit/postvisit must be **public** members |
---|
| 46 | // |
---|
| 47 | // Several additional features are available through inheritance |
---|
[73f1b1c] | 48 | // | PureVisitor - makes the visitor pure, it never modifies nodes in place and always |
---|
| 49 | // clones nodes it needs to make changes to |
---|
[b2a11ba] | 50 | // | WithConstTypeSubstitution - provides polymorphic const TypeSubstitution * typeSubs for the |
---|
[e0e9a0b] | 51 | // current expression |
---|
| 52 | // | WithStmtsToAdd - provides the ability to insert statements before or after the current |
---|
| 53 | // statement by adding new statements into stmtsToAddBefore or |
---|
| 54 | // stmtsToAddAfter respectively. |
---|
| 55 | // | WithDeclsToAdd - provides the ability to insert declarations before or after the |
---|
| 56 | // current declarations by adding new DeclStmt into declsToAddBefore or |
---|
| 57 | // declsToAddAfter respectively. |
---|
| 58 | // | WithShortCircuiting - provides the ability to skip visiting child nodes; set visit_children |
---|
| 59 | // to false in pre{visit,visit} to skip visiting children |
---|
| 60 | // | WithGuards - provides the ability to save/restore data like a LIFO stack; to save, |
---|
| 61 | // call GuardValue with the variable to save, the variable will |
---|
| 62 | // automatically be restored to its previous value after the |
---|
| 63 | // corresponding postvisit/postmutate teminates. |
---|
| 64 | // | WithVisitorRef - provides an pointer to the templated visitor wrapper |
---|
| 65 | // | WithSymbolTable - provides symbol table functionality |
---|
[e6b42e7] | 66 | // |
---|
| 67 | // Other Special Members: |
---|
| 68 | // | result - Either a method that takes no parameters or a field. If a method (or |
---|
| 69 | // callable field) get_result calls it, otherwise the value is returned. |
---|
[f47f887] | 70 | //------------------------------------------------------------------------------------------------- |
---|
[7ff3e522] | 71 | template< typename core_t > |
---|
[f47f887] | 72 | class Pass final : public ast::Visitor { |
---|
| 73 | public: |
---|
[7ff3e522] | 74 | using core_type = core_t; |
---|
| 75 | using type = Pass<core_t>; |
---|
| 76 | |
---|
[04124c4] | 77 | /// Forward any arguments to the pass constructor |
---|
| 78 | /// Propagate 'this' if necessary |
---|
[f47f887] | 79 | template< typename... Args > |
---|
| 80 | Pass( Args &&... args) |
---|
[7ff3e522] | 81 | : core( std::forward<Args>( args )... ) |
---|
[f47f887] | 82 | { |
---|
| 83 | // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor |
---|
[7ff3e522] | 84 | type * const * visitor = __pass::visitor(core, 0); |
---|
[f47f887] | 85 | if(visitor) { |
---|
[7ff3e522] | 86 | *const_cast<type **>( visitor ) = this; |
---|
[f47f887] | 87 | } |
---|
| 88 | } |
---|
| 89 | |
---|
| 90 | virtual ~Pass() = default; |
---|
| 91 | |
---|
[e6b42e7] | 92 | /// Storage for the actual pass. |
---|
| 93 | core_t core; |
---|
| 94 | |
---|
| 95 | /// If the core defines a result, call it if possible, otherwise return it. |
---|
| 96 | inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) { |
---|
| 97 | return __pass::get_result( core, '0' ); |
---|
| 98 | } |
---|
| 99 | |
---|
[a86b2ca6] | 100 | /// Construct and run a pass on a translation unit. |
---|
| 101 | template< typename... Args > |
---|
[293dc1c] | 102 | static void run( TranslationUnit & decls, Args &&... args ) { |
---|
[7ff3e522] | 103 | Pass<core_t> visitor( std::forward<Args>( args )... ); |
---|
[a86b2ca6] | 104 | accept_all( decls, visitor ); |
---|
| 105 | } |
---|
| 106 | |
---|
[e6b42e7] | 107 | /// Contruct and run a pass on a pointer to extract a value. |
---|
| 108 | template< typename node_type, typename... Args > |
---|
| 109 | static auto read( node_type const * node, Args&&... args ) { |
---|
| 110 | Pass<core_t> visitor( std::forward<Args>( args )... ); |
---|
[ce36b55] | 111 | auto const * temp = node->accept( visitor ); |
---|
[e6b42e7] | 112 | assert( temp == node ); |
---|
| 113 | return visitor.get_result(); |
---|
| 114 | } |
---|
| 115 | |
---|
| 116 | // Versions of the above for older compilers. |
---|
[b9fa85b] | 117 | template< typename... Args > |
---|
[293dc1c] | 118 | static void run( TranslationUnit & decls ) { |
---|
[0240cd69] | 119 | Pass<core_t> visitor; |
---|
| 120 | accept_all( decls, visitor ); |
---|
| 121 | } |
---|
| 122 | |
---|
[b9fa85b] | 123 | template< typename node_type, typename... Args > |
---|
| 124 | static auto read( node_type const * node ) { |
---|
[e6b42e7] | 125 | Pass<core_t> visitor; |
---|
[ce36b55] | 126 | auto const * temp = node->accept( visitor ); |
---|
[e6b42e7] | 127 | assert( temp == node ); |
---|
| 128 | return visitor.get_result(); |
---|
| 129 | } |
---|
[f47f887] | 130 | |
---|
[04124c4] | 131 | /// Visit function declarations |
---|
[23f99e1] | 132 | const ast::DeclWithType * visit( const ast::ObjectDecl * ) override final; |
---|
| 133 | const ast::DeclWithType * visit( const ast::FunctionDecl * ) override final; |
---|
| 134 | const ast::Decl * visit( const ast::StructDecl * ) override final; |
---|
| 135 | const ast::Decl * visit( const ast::UnionDecl * ) override final; |
---|
| 136 | const ast::Decl * visit( const ast::EnumDecl * ) override final; |
---|
| 137 | const ast::Decl * visit( const ast::TraitDecl * ) override final; |
---|
| 138 | const ast::Decl * visit( const ast::TypeDecl * ) override final; |
---|
| 139 | const ast::Decl * visit( const ast::TypedefDecl * ) override final; |
---|
| 140 | const ast::AsmDecl * visit( const ast::AsmDecl * ) override final; |
---|
[2d019af] | 141 | const ast::DirectiveDecl * visit( const ast::DirectiveDecl * ) override final; |
---|
[23f99e1] | 142 | const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl * ) override final; |
---|
| 143 | const ast::CompoundStmt * visit( const ast::CompoundStmt * ) override final; |
---|
| 144 | const ast::Stmt * visit( const ast::ExprStmt * ) override final; |
---|
| 145 | const ast::Stmt * visit( const ast::AsmStmt * ) override final; |
---|
| 146 | const ast::Stmt * visit( const ast::DirectiveStmt * ) override final; |
---|
| 147 | const ast::Stmt * visit( const ast::IfStmt * ) override final; |
---|
[3b0bc16] | 148 | const ast::Stmt * visit( const ast::WhileDoStmt * ) override final; |
---|
[23f99e1] | 149 | const ast::Stmt * visit( const ast::ForStmt * ) override final; |
---|
| 150 | const ast::Stmt * visit( const ast::SwitchStmt * ) override final; |
---|
[400b8be] | 151 | const ast::CaseClause * visit( const ast::CaseClause * ) override final; |
---|
[23f99e1] | 152 | const ast::Stmt * visit( const ast::BranchStmt * ) override final; |
---|
| 153 | const ast::Stmt * visit( const ast::ReturnStmt * ) override final; |
---|
| 154 | const ast::Stmt * visit( const ast::ThrowStmt * ) override final; |
---|
| 155 | const ast::Stmt * visit( const ast::TryStmt * ) override final; |
---|
[400b8be] | 156 | const ast::CatchClause * visit( const ast::CatchClause * ) override final; |
---|
| 157 | const ast::FinallyClause * visit( const ast::FinallyClause * ) override final; |
---|
[37cdd97] | 158 | const ast::Stmt * visit( const ast::SuspendStmt * ) override final; |
---|
[23f99e1] | 159 | const ast::Stmt * visit( const ast::WaitForStmt * ) override final; |
---|
[f6e6a55] | 160 | const ast::WaitForClause * visit( const ast::WaitForClause * ) override final; |
---|
[e67991f] | 161 | const ast::Decl * visit( const ast::WithStmt * ) override final; |
---|
[23f99e1] | 162 | const ast::NullStmt * visit( const ast::NullStmt * ) override final; |
---|
| 163 | const ast::Stmt * visit( const ast::DeclStmt * ) override final; |
---|
| 164 | const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * ) override final; |
---|
[6cebfef] | 165 | const ast::Stmt * visit( const ast::MutexStmt * ) override final; |
---|
[23f99e1] | 166 | const ast::Expr * visit( const ast::ApplicationExpr * ) override final; |
---|
| 167 | const ast::Expr * visit( const ast::UntypedExpr * ) override final; |
---|
| 168 | const ast::Expr * visit( const ast::NameExpr * ) override final; |
---|
[b0d9ff7] | 169 | const ast::Expr * visit( const ast::QualifiedNameExpr * ) override final; |
---|
[23f99e1] | 170 | const ast::Expr * visit( const ast::AddressExpr * ) override final; |
---|
| 171 | const ast::Expr * visit( const ast::LabelAddressExpr * ) override final; |
---|
| 172 | const ast::Expr * visit( const ast::CastExpr * ) override final; |
---|
| 173 | const ast::Expr * visit( const ast::KeywordCastExpr * ) override final; |
---|
| 174 | const ast::Expr * visit( const ast::VirtualCastExpr * ) override final; |
---|
| 175 | const ast::Expr * visit( const ast::UntypedMemberExpr * ) override final; |
---|
| 176 | const ast::Expr * visit( const ast::MemberExpr * ) override final; |
---|
| 177 | const ast::Expr * visit( const ast::VariableExpr * ) override final; |
---|
| 178 | const ast::Expr * visit( const ast::ConstantExpr * ) override final; |
---|
| 179 | const ast::Expr * visit( const ast::SizeofExpr * ) override final; |
---|
| 180 | const ast::Expr * visit( const ast::AlignofExpr * ) override final; |
---|
| 181 | const ast::Expr * visit( const ast::UntypedOffsetofExpr * ) override final; |
---|
| 182 | const ast::Expr * visit( const ast::OffsetofExpr * ) override final; |
---|
| 183 | const ast::Expr * visit( const ast::OffsetPackExpr * ) override final; |
---|
| 184 | const ast::Expr * visit( const ast::LogicalExpr * ) override final; |
---|
| 185 | const ast::Expr * visit( const ast::ConditionalExpr * ) override final; |
---|
| 186 | const ast::Expr * visit( const ast::CommaExpr * ) override final; |
---|
| 187 | const ast::Expr * visit( const ast::TypeExpr * ) override final; |
---|
[4ec9513] | 188 | const ast::Expr * visit( const ast::DimensionExpr * ) override final; |
---|
[23f99e1] | 189 | const ast::Expr * visit( const ast::AsmExpr * ) override final; |
---|
| 190 | const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * ) override final; |
---|
| 191 | const ast::Expr * visit( const ast::ConstructorExpr * ) override final; |
---|
| 192 | const ast::Expr * visit( const ast::CompoundLiteralExpr * ) override final; |
---|
| 193 | const ast::Expr * visit( const ast::RangeExpr * ) override final; |
---|
| 194 | const ast::Expr * visit( const ast::UntypedTupleExpr * ) override final; |
---|
| 195 | const ast::Expr * visit( const ast::TupleExpr * ) override final; |
---|
| 196 | const ast::Expr * visit( const ast::TupleIndexExpr * ) override final; |
---|
| 197 | const ast::Expr * visit( const ast::TupleAssignExpr * ) override final; |
---|
| 198 | const ast::Expr * visit( const ast::StmtExpr * ) override final; |
---|
| 199 | const ast::Expr * visit( const ast::UniqueExpr * ) override final; |
---|
| 200 | const ast::Expr * visit( const ast::UntypedInitExpr * ) override final; |
---|
| 201 | const ast::Expr * visit( const ast::InitExpr * ) override final; |
---|
| 202 | const ast::Expr * visit( const ast::DeletedExpr * ) override final; |
---|
| 203 | const ast::Expr * visit( const ast::DefaultArgExpr * ) override final; |
---|
| 204 | const ast::Expr * visit( const ast::GenericExpr * ) override final; |
---|
| 205 | const ast::Type * visit( const ast::VoidType * ) override final; |
---|
| 206 | const ast::Type * visit( const ast::BasicType * ) override final; |
---|
| 207 | const ast::Type * visit( const ast::PointerType * ) override final; |
---|
| 208 | const ast::Type * visit( const ast::ArrayType * ) override final; |
---|
| 209 | const ast::Type * visit( const ast::ReferenceType * ) override final; |
---|
| 210 | const ast::Type * visit( const ast::QualifiedType * ) override final; |
---|
| 211 | const ast::Type * visit( const ast::FunctionType * ) override final; |
---|
| 212 | const ast::Type * visit( const ast::StructInstType * ) override final; |
---|
| 213 | const ast::Type * visit( const ast::UnionInstType * ) override final; |
---|
| 214 | const ast::Type * visit( const ast::EnumInstType * ) override final; |
---|
| 215 | const ast::Type * visit( const ast::TraitInstType * ) override final; |
---|
| 216 | const ast::Type * visit( const ast::TypeInstType * ) override final; |
---|
| 217 | const ast::Type * visit( const ast::TupleType * ) override final; |
---|
| 218 | const ast::Type * visit( const ast::TypeofType * ) override final; |
---|
[3945abe] | 219 | const ast::Type * visit( const ast::VTableType * ) override final; |
---|
[23f99e1] | 220 | const ast::Type * visit( const ast::VarArgsType * ) override final; |
---|
| 221 | const ast::Type * visit( const ast::ZeroType * ) override final; |
---|
| 222 | const ast::Type * visit( const ast::OneType * ) override final; |
---|
| 223 | const ast::Type * visit( const ast::GlobalScopeType * ) override final; |
---|
| 224 | const ast::Designation * visit( const ast::Designation * ) override final; |
---|
| 225 | const ast::Init * visit( const ast::SingleInit * ) override final; |
---|
| 226 | const ast::Init * visit( const ast::ListInit * ) override final; |
---|
| 227 | const ast::Init * visit( const ast::ConstructorInit * ) override final; |
---|
| 228 | const ast::Attribute * visit( const ast::Attribute * ) override final; |
---|
| 229 | const ast::TypeSubstitution * visit( const ast::TypeSubstitution * ) override final; |
---|
[f47f887] | 230 | |
---|
[7ff3e522] | 231 | template<typename core_type> |
---|
| 232 | friend void accept_all( std::list< ptr<Decl> > & decls, Pass<core_type>& visitor ); |
---|
[53d55b6] | 233 | |
---|
| 234 | bool isInFunction() const { |
---|
| 235 | return inFunction; |
---|
| 236 | } |
---|
| 237 | |
---|
[f47f887] | 238 | private: |
---|
| 239 | |
---|
[7ff3e522] | 240 | bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(core, 0); return ptr ? *ptr : true; } |
---|
[f47f887] | 241 | |
---|
| 242 | private: |
---|
| 243 | |
---|
[eb211bf] | 244 | __pass::result1<ast::Stmt> call_accept( const ast::Stmt * ); |
---|
| 245 | __pass::result1<ast::Expr> call_accept( const ast::Expr * ); |
---|
[490fb92e] | 246 | |
---|
[eb211bf] | 247 | /// This has a `type` member that is the return type for the |
---|
| 248 | /// generic call_accept if the generic call_accept is defined. |
---|
[6d51bd7] | 249 | template< typename node_t > |
---|
[eb211bf] | 250 | using generic_call_accept_result = |
---|
| 251 | std::enable_if< |
---|
[8a5530c] | 252 | !std::is_base_of<ast::Expr, node_t>::value && |
---|
| 253 | !std::is_base_of<ast::Stmt, node_t>::value |
---|
[eb211bf] | 254 | , __pass::result1< |
---|
| 255 | typename std::remove_pointer< typename std::result_of< |
---|
| 256 | decltype(&node_t::accept)(node_t*, type&) >::type >::type |
---|
[f8143a6] | 257 | > |
---|
[eb211bf] | 258 | >; |
---|
[f8143a6] | 259 | |
---|
[eb211bf] | 260 | template< typename node_t > |
---|
| 261 | auto call_accept( const node_t * node ) |
---|
| 262 | -> typename generic_call_accept_result<node_t>::type; |
---|
[f8143a6] | 263 | |
---|
[eb211bf] | 264 | // requests WithStmtsToAdd directly add to this statement, as if it is a compound. |
---|
| 265 | __pass::result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *); |
---|
[f8143a6] | 266 | |
---|
[9e23b446] | 267 | // requests type environment to be updated (why is it implemented like this?) |
---|
| 268 | __pass::result1<ast::Expr> call_accept_top(const ast::Expr *); |
---|
| 269 | |
---|
[f8143a6] | 270 | template< template <class...> class container_t > |
---|
[eb211bf] | 271 | __pass::resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & ); |
---|
[f47f887] | 272 | |
---|
[6d51bd7] | 273 | template< template <class...> class container_t, typename node_t > |
---|
[eb211bf] | 274 | __pass::resultN< container_t, node_t > call_accept( const container_t< ptr<node_t> > & container ); |
---|
[f47f887] | 275 | |
---|
[2b59f55] | 276 | public: |
---|
[6d51bd7] | 277 | /// Logic to call the accept and mutate the parent if needed, delegates call to accept |
---|
[f8143a6] | 278 | template<typename node_t, typename parent_t, typename field_t> |
---|
| 279 | void maybe_accept(const node_t * &, field_t parent_t::* field); |
---|
[6d51bd7] | 280 | |
---|
[f8143a6] | 281 | template<typename node_t, typename parent_t, typename field_t> |
---|
| 282 | void maybe_accept_as_compound(const node_t * &, field_t parent_t::* field); |
---|
[490fb92e] | 283 | |
---|
[9e23b446] | 284 | template<typename node_t, typename parent_t, typename field_t> |
---|
| 285 | void maybe_accept_top(const node_t * &, field_t parent_t::* field); |
---|
| 286 | |
---|
[f47f887] | 287 | private: |
---|
[0e42794] | 288 | /// Internal RAII guard for symbol table features |
---|
| 289 | struct guard_symtab { |
---|
[7ff3e522] | 290 | guard_symtab( Pass<core_t> & pass ): pass( pass ) { __pass::symtab::enter(pass.core, 0); } |
---|
| 291 | ~guard_symtab() { __pass::symtab::leave(pass.core, 0); } |
---|
| 292 | Pass<core_t> & pass; |
---|
[f47f887] | 293 | }; |
---|
| 294 | |
---|
[04124c4] | 295 | /// Internal RAII guard for scope features |
---|
| 296 | struct guard_scope { |
---|
[7ff3e522] | 297 | guard_scope( Pass<core_t> & pass ): pass( pass ) { __pass::scope::enter(pass.core, 0); } |
---|
| 298 | ~guard_scope() { __pass::scope::leave(pass.core, 0); } |
---|
| 299 | Pass<core_t> & pass; |
---|
[f47f887] | 300 | }; |
---|
[23f99e1] | 301 | |
---|
[e0e9a0b] | 302 | /// Internal RAII guard for forall substitutions |
---|
| 303 | struct guard_forall_subs { |
---|
[361bf01] | 304 | guard_forall_subs( Pass<core_t> & pass, const FunctionType * type ) |
---|
[7ff3e522] | 305 | : pass( pass ), type( type ) { __pass::forall::enter(pass.core, 0, type ); } |
---|
| 306 | ~guard_forall_subs() { __pass::forall::leave(pass.core, 0, type ); } |
---|
| 307 | Pass<core_t> & pass; |
---|
[361bf01] | 308 | const FunctionType * type; |
---|
[e0e9a0b] | 309 | }; |
---|
| 310 | |
---|
[23f99e1] | 311 | private: |
---|
| 312 | bool inFunction = false; |
---|
[c6c682cf] | 313 | bool atFunctionTop = false; |
---|
[f47f887] | 314 | }; |
---|
| 315 | |
---|
[d8938622] | 316 | /// Apply a pass to an entire translation unit |
---|
[7ff3e522] | 317 | template<typename core_t> |
---|
| 318 | void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<core_t> & visitor ); |
---|
[f47f887] | 319 | |
---|
[293dc1c] | 320 | template<typename core_t> |
---|
| 321 | void accept_all( ast::TranslationUnit &, ast::Pass<core_t> & visitor ); |
---|
| 322 | |
---|
[04124c4] | 323 | //------------------------------------------------------------------------------------------------- |
---|
[f47f887] | 324 | // PASS ACCESSORIES |
---|
[04124c4] | 325 | //------------------------------------------------------------------------------------------------- |
---|
[f47f887] | 326 | |
---|
[73f1b1c] | 327 | /// If used the visitor will always clone nodes. |
---|
[d3aa64f1] | 328 | struct PureVisitor {}; |
---|
| 329 | |
---|
[e9e9f56] | 330 | /// Keep track of the nearest parent node's location field. |
---|
[a9762dc] | 331 | struct WithCodeLocation { |
---|
| 332 | const CodeLocation * location = nullptr; |
---|
| 333 | }; |
---|
| 334 | |
---|
[b2a11ba] | 335 | /// Keep track of the polymorphic const TypeSubstitution * typeSubs for the current expression. |
---|
[04124c4] | 336 | struct WithConstTypeSubstitution { |
---|
[b2a11ba] | 337 | const TypeSubstitution * typeSubs = nullptr; |
---|
[04124c4] | 338 | }; |
---|
| 339 | |
---|
| 340 | /// Used if visitor requires added statements before or after the current node. |
---|
| 341 | /// The Pass template handles what *before* and *after* means automatically |
---|
[6d51bd7] | 342 | template< template<class...> class container_t = std::list > |
---|
[f47f887] | 343 | struct WithStmtsToAdd { |
---|
[04124c4] | 344 | container_t< ptr<Stmt> > stmtsToAddBefore; |
---|
| 345 | container_t< ptr<Stmt> > stmtsToAddAfter; |
---|
[f47f887] | 346 | }; |
---|
| 347 | |
---|
[04124c4] | 348 | /// Used if visitor requires added declarations before or after the current node. |
---|
| 349 | /// The Pass template handles what *before* and *after* means automatically |
---|
[6d51bd7] | 350 | template< template<class...> class container_t = std::list > |
---|
[f47f887] | 351 | struct WithDeclsToAdd { |
---|
[04124c4] | 352 | container_t< ptr<Decl> > declsToAddBefore; |
---|
| 353 | container_t< ptr<Decl> > declsToAddAfter; |
---|
[f47f887] | 354 | }; |
---|
| 355 | |
---|
[04124c4] | 356 | /// Use if visitation should stop at certain levels |
---|
| 357 | /// set visit_children false of all child nodes should be ignored |
---|
[f47f887] | 358 | struct WithShortCircuiting { |
---|
| 359 | __pass::bool_ref visit_children; |
---|
| 360 | }; |
---|
| 361 | |
---|
[04124c4] | 362 | /// Used to restore values/functions/etc. when the Pass finishes visiting this node |
---|
| 363 | class WithGuards { |
---|
[e16e27e1] | 364 | __pass::at_cleanup_t at_cleanup = [](__pass::cleanup_func_t, void*) { |
---|
| 365 | std::cerr << "No cleanup function was set" << std::endl; |
---|
| 366 | abort(); |
---|
| 367 | }; |
---|
[f47f887] | 368 | |
---|
[7ff3e522] | 369 | template< typename core_t> |
---|
| 370 | friend auto __pass::at_cleanup( core_t & core, int ) -> decltype( &core.at_cleanup ); |
---|
[04124c4] | 371 | public: |
---|
[e16e27e1] | 372 | |
---|
[04124c4] | 373 | /// When this node is finished being visited, restore the value of a variable |
---|
[148ba7d] | 374 | /// You may assign to the return value to set the new value in the same statement. |
---|
[04124c4] | 375 | template< typename T > |
---|
[148ba7d] | 376 | T& GuardValue( T& val ) { |
---|
[04124c4] | 377 | at_cleanup( [ val ]( void * newVal ) { |
---|
| 378 | * static_cast< T * >( newVal ) = val; |
---|
| 379 | }, static_cast< void * >( & val ) ); |
---|
[148ba7d] | 380 | return val; |
---|
[04124c4] | 381 | } |
---|
[f47f887] | 382 | |
---|
[04124c4] | 383 | /// On the object, all beginScope now and endScope when the current node is finished being visited |
---|
| 384 | template< typename T > |
---|
| 385 | void GuardScope( T& val ) { |
---|
| 386 | val.beginScope(); |
---|
| 387 | at_cleanup( []( void * val ) { |
---|
| 388 | static_cast< T * >( val )->endScope(); |
---|
| 389 | }, static_cast< void * >( & val ) ); |
---|
| 390 | } |
---|
[f47f887] | 391 | |
---|
[04124c4] | 392 | /// When this node is finished being visited, call a function |
---|
| 393 | template< typename Func > |
---|
| 394 | void GuardAction( Func func ) { |
---|
| 395 | at_cleanup( [func](void *) { func(); }, nullptr ); |
---|
| 396 | } |
---|
[be8518f] | 397 | |
---|
| 398 | /// When this node is finished being visited, call a member of an object. |
---|
| 399 | template<typename T> |
---|
| 400 | void GuardMethod( T * obj, void (T::*method)() ) { |
---|
| 401 | at_cleanup( [ method ]( void * object ) { |
---|
| 402 | static_cast< T * >( object )->method(); |
---|
| 403 | }, static_cast< void * >( obj ) ); |
---|
| 404 | } |
---|
[04124c4] | 405 | }; |
---|
[f47f887] | 406 | |
---|
[04124c4] | 407 | /// Used to get a pointer to the pass with its wrapped type |
---|
[7ff3e522] | 408 | template<typename core_t> |
---|
[04124c4] | 409 | struct WithVisitorRef { |
---|
[7ff3e522] | 410 | Pass<core_t> * const visitor = nullptr; |
---|
[f47f887] | 411 | |
---|
[53d55b6] | 412 | bool isInFunction() const { |
---|
| 413 | return visitor->isInFunction(); |
---|
[cb25fc9] | 414 | } |
---|
| 415 | }; |
---|
| 416 | |
---|
[0e42794] | 417 | /// Use when the templated visitor should update the symbol table |
---|
| 418 | struct WithSymbolTable { |
---|
| 419 | SymbolTable symtab; |
---|
[f47f887] | 420 | }; |
---|
[e0e9a0b] | 421 | |
---|
[c600df1] | 422 | /// Used to get a pointer to the wrapping TranslationUnit. |
---|
| 423 | struct WithConstTranslationUnit { |
---|
| 424 | const TranslationUnit * translationUnit = nullptr; |
---|
| 425 | |
---|
| 426 | const TranslationUnit & transUnit() const { |
---|
| 427 | assertf( translationUnit, "WithConstTranslationUnit not set-up." ); |
---|
| 428 | return *translationUnit; |
---|
| 429 | } |
---|
| 430 | }; |
---|
| 431 | |
---|
[6d51bd7] | 432 | } |
---|
| 433 | |
---|
| 434 | #include "Common/Stats.h" |
---|
| 435 | |
---|
[172d9342] | 436 | namespace ast { |
---|
[6d51bd7] | 437 | extern struct PassVisitorStats { |
---|
| 438 | size_t depth = 0; |
---|
[c408483] | 439 | Stats::Counters::MaxCounter<double> * max; |
---|
| 440 | Stats::Counters::AverageCounter<double> * avg; |
---|
[6d51bd7] | 441 | } pass_visitor_stats; |
---|
[172d9342] | 442 | } |
---|
[6d51bd7] | 443 | |
---|
[be8518f] | 444 | #include "AST/Pass.impl.hpp" |
---|