[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 |
---|
| 10 | // Created On : Thu May 09 15::37::05 2019 |
---|
| 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" |
---|
| 31 | |
---|
[04124c4] | 32 | #include "AST/Visitor.hpp" |
---|
| 33 | |
---|
| 34 | #include "SymTab/Indexer.h" |
---|
[f47f887] | 35 | |
---|
| 36 | // Private prelude header, needed for some of the magic tricks this class pulls off |
---|
[04124c4] | 37 | #include "AST/Pass.proto.hpp" |
---|
[f47f887] | 38 | |
---|
| 39 | namespace ast { |
---|
| 40 | //------------------------------------------------------------------------------------------------- |
---|
| 41 | // Templated visitor type |
---|
| 42 | // To use declare a Pass< YOUR VISITOR TYPE > |
---|
| 43 | // The visitor type should specify the previsit/postvisit for types that are desired. |
---|
| 44 | // Note: previsit/postvisit must be **public** members |
---|
| 45 | // |
---|
| 46 | // Several additional features are available through inheritance |
---|
[04124c4] | 47 | // | WithTypeSubstitution - provides polymorphic const TypeSubstitution * env for the |
---|
| 48 | // current expression |
---|
[f47f887] | 49 | // | WithStmtsToAdd - provides the ability to insert statements before or after the current |
---|
| 50 | // statement by adding new statements into stmtsToAddBefore or |
---|
| 51 | // stmtsToAddAfter respectively. |
---|
[04124c4] | 52 | // | WithDeclsToAdd - provides the ability to insert declarations before or after the current |
---|
| 53 | // declarations by adding new DeclStmt into declsToAddBefore or |
---|
| 54 | // declsToAddAfter respectively. |
---|
[f47f887] | 55 | // | WithShortCircuiting - provides the ability to skip visiting child nodes; set visit_children |
---|
| 56 | // to false in pre{visit,visit} to skip visiting children |
---|
| 57 | // | WithGuards - provides the ability to save/restore data like a LIFO stack; to save, |
---|
| 58 | // call GuardValue with the variable to save, the variable will |
---|
| 59 | // automatically be restored to its previous value after the corresponding |
---|
| 60 | // postvisit/postmutate teminates. |
---|
[04124c4] | 61 | // | WithVisitorRef - provides an pointer to the templated visitor wrapper |
---|
| 62 | // | WithIndexer - provides indexer functionality (i.e. up-to-date symbol table) |
---|
[f47f887] | 63 | //------------------------------------------------------------------------------------------------- |
---|
| 64 | template< typename pass_t > |
---|
| 65 | class Pass final : public ast::Visitor { |
---|
| 66 | public: |
---|
[04124c4] | 67 | /// Forward any arguments to the pass constructor |
---|
| 68 | /// Propagate 'this' if necessary |
---|
[f47f887] | 69 | template< typename... Args > |
---|
| 70 | Pass( Args &&... args) |
---|
[04124c4] | 71 | : pass( std::forward<Args>( args )... ) |
---|
[f47f887] | 72 | { |
---|
| 73 | // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor |
---|
| 74 | typedef Pass<pass_t> this_t; |
---|
[04124c4] | 75 | this_t * const * visitor = __pass::visitor(pass, 0); |
---|
[f47f887] | 76 | if(visitor) { |
---|
| 77 | *const_cast<this_t **>( visitor ) = this; |
---|
| 78 | } |
---|
| 79 | } |
---|
| 80 | |
---|
| 81 | virtual ~Pass() = default; |
---|
| 82 | |
---|
[04124c4] | 83 | /// Storage for the actual pass |
---|
| 84 | pass_t pass; |
---|
[f47f887] | 85 | |
---|
[04124c4] | 86 | /// Visit function declarations |
---|
[23f99e1] | 87 | const ast::DeclWithType * visit( const ast::ObjectDecl * ) override final; |
---|
| 88 | const ast::DeclWithType * visit( const ast::FunctionDecl * ) override final; |
---|
| 89 | const ast::Decl * visit( const ast::StructDecl * ) override final; |
---|
| 90 | const ast::Decl * visit( const ast::UnionDecl * ) override final; |
---|
| 91 | const ast::Decl * visit( const ast::EnumDecl * ) override final; |
---|
| 92 | const ast::Decl * visit( const ast::TraitDecl * ) override final; |
---|
| 93 | const ast::Decl * visit( const ast::TypeDecl * ) override final; |
---|
| 94 | const ast::Decl * visit( const ast::TypedefDecl * ) override final; |
---|
| 95 | const ast::AsmDecl * visit( const ast::AsmDecl * ) override final; |
---|
| 96 | const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl * ) override final; |
---|
| 97 | const ast::CompoundStmt * visit( const ast::CompoundStmt * ) override final; |
---|
| 98 | const ast::Stmt * visit( const ast::ExprStmt * ) override final; |
---|
| 99 | const ast::Stmt * visit( const ast::AsmStmt * ) override final; |
---|
| 100 | const ast::Stmt * visit( const ast::DirectiveStmt * ) override final; |
---|
| 101 | const ast::Stmt * visit( const ast::IfStmt * ) override final; |
---|
| 102 | const ast::Stmt * visit( const ast::WhileStmt * ) override final; |
---|
| 103 | const ast::Stmt * visit( const ast::ForStmt * ) override final; |
---|
| 104 | const ast::Stmt * visit( const ast::SwitchStmt * ) override final; |
---|
| 105 | const ast::Stmt * visit( const ast::CaseStmt * ) override final; |
---|
| 106 | const ast::Stmt * visit( const ast::BranchStmt * ) override final; |
---|
| 107 | const ast::Stmt * visit( const ast::ReturnStmt * ) override final; |
---|
| 108 | const ast::Stmt * visit( const ast::ThrowStmt * ) override final; |
---|
| 109 | const ast::Stmt * visit( const ast::TryStmt * ) override final; |
---|
| 110 | const ast::Stmt * visit( const ast::CatchStmt * ) override final; |
---|
| 111 | const ast::Stmt * visit( const ast::FinallyStmt * ) override final; |
---|
| 112 | const ast::Stmt * visit( const ast::WaitForStmt * ) override final; |
---|
| 113 | const ast::Stmt * visit( const ast::WithStmt * ) override final; |
---|
| 114 | const ast::NullStmt * visit( const ast::NullStmt * ) override final; |
---|
| 115 | const ast::Stmt * visit( const ast::DeclStmt * ) override final; |
---|
| 116 | const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * ) override final; |
---|
| 117 | const ast::Expr * visit( const ast::ApplicationExpr * ) override final; |
---|
| 118 | const ast::Expr * visit( const ast::UntypedExpr * ) override final; |
---|
| 119 | const ast::Expr * visit( const ast::NameExpr * ) override final; |
---|
| 120 | const ast::Expr * visit( const ast::AddressExpr * ) override final; |
---|
| 121 | const ast::Expr * visit( const ast::LabelAddressExpr * ) override final; |
---|
| 122 | const ast::Expr * visit( const ast::CastExpr * ) override final; |
---|
| 123 | const ast::Expr * visit( const ast::KeywordCastExpr * ) override final; |
---|
| 124 | const ast::Expr * visit( const ast::VirtualCastExpr * ) override final; |
---|
| 125 | const ast::Expr * visit( const ast::UntypedMemberExpr * ) override final; |
---|
| 126 | const ast::Expr * visit( const ast::MemberExpr * ) override final; |
---|
| 127 | const ast::Expr * visit( const ast::VariableExpr * ) override final; |
---|
| 128 | const ast::Expr * visit( const ast::ConstantExpr * ) override final; |
---|
| 129 | const ast::Expr * visit( const ast::SizeofExpr * ) override final; |
---|
| 130 | const ast::Expr * visit( const ast::AlignofExpr * ) override final; |
---|
| 131 | const ast::Expr * visit( const ast::UntypedOffsetofExpr * ) override final; |
---|
| 132 | const ast::Expr * visit( const ast::OffsetofExpr * ) override final; |
---|
| 133 | const ast::Expr * visit( const ast::OffsetPackExpr * ) override final; |
---|
| 134 | const ast::Expr * visit( const ast::AttrExpr * ) override final; |
---|
| 135 | const ast::Expr * visit( const ast::LogicalExpr * ) override final; |
---|
| 136 | const ast::Expr * visit( const ast::ConditionalExpr * ) override final; |
---|
| 137 | const ast::Expr * visit( const ast::CommaExpr * ) override final; |
---|
| 138 | const ast::Expr * visit( const ast::TypeExpr * ) override final; |
---|
| 139 | const ast::Expr * visit( const ast::AsmExpr * ) override final; |
---|
| 140 | const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * ) override final; |
---|
| 141 | const ast::Expr * visit( const ast::ConstructorExpr * ) override final; |
---|
| 142 | const ast::Expr * visit( const ast::CompoundLiteralExpr * ) override final; |
---|
| 143 | const ast::Expr * visit( const ast::RangeExpr * ) override final; |
---|
| 144 | const ast::Expr * visit( const ast::UntypedTupleExpr * ) override final; |
---|
| 145 | const ast::Expr * visit( const ast::TupleExpr * ) override final; |
---|
| 146 | const ast::Expr * visit( const ast::TupleIndexExpr * ) override final; |
---|
| 147 | const ast::Expr * visit( const ast::TupleAssignExpr * ) override final; |
---|
| 148 | const ast::Expr * visit( const ast::StmtExpr * ) override final; |
---|
| 149 | const ast::Expr * visit( const ast::UniqueExpr * ) override final; |
---|
| 150 | const ast::Expr * visit( const ast::UntypedInitExpr * ) override final; |
---|
| 151 | const ast::Expr * visit( const ast::InitExpr * ) override final; |
---|
| 152 | const ast::Expr * visit( const ast::DeletedExpr * ) override final; |
---|
| 153 | const ast::Expr * visit( const ast::DefaultArgExpr * ) override final; |
---|
| 154 | const ast::Expr * visit( const ast::GenericExpr * ) override final; |
---|
| 155 | const ast::Type * visit( const ast::VoidType * ) override final; |
---|
| 156 | const ast::Type * visit( const ast::BasicType * ) override final; |
---|
| 157 | const ast::Type * visit( const ast::PointerType * ) override final; |
---|
| 158 | const ast::Type * visit( const ast::ArrayType * ) override final; |
---|
| 159 | const ast::Type * visit( const ast::ReferenceType * ) override final; |
---|
| 160 | const ast::Type * visit( const ast::QualifiedType * ) override final; |
---|
| 161 | const ast::Type * visit( const ast::FunctionType * ) override final; |
---|
| 162 | const ast::Type * visit( const ast::StructInstType * ) override final; |
---|
| 163 | const ast::Type * visit( const ast::UnionInstType * ) override final; |
---|
| 164 | const ast::Type * visit( const ast::EnumInstType * ) override final; |
---|
| 165 | const ast::Type * visit( const ast::TraitInstType * ) override final; |
---|
| 166 | const ast::Type * visit( const ast::TypeInstType * ) override final; |
---|
| 167 | const ast::Type * visit( const ast::TupleType * ) override final; |
---|
| 168 | const ast::Type * visit( const ast::TypeofType * ) override final; |
---|
| 169 | const ast::Type * visit( const ast::AttrType * ) override final; |
---|
| 170 | const ast::Type * visit( const ast::VarArgsType * ) override final; |
---|
| 171 | const ast::Type * visit( const ast::ZeroType * ) override final; |
---|
| 172 | const ast::Type * visit( const ast::OneType * ) override final; |
---|
| 173 | const ast::Type * visit( const ast::GlobalScopeType * ) override final; |
---|
| 174 | const ast::Designation * visit( const ast::Designation * ) override final; |
---|
| 175 | const ast::Init * visit( const ast::SingleInit * ) override final; |
---|
| 176 | const ast::Init * visit( const ast::ListInit * ) override final; |
---|
| 177 | const ast::Init * visit( const ast::ConstructorInit * ) override final; |
---|
| 178 | const ast::Constant * visit( const ast::Constant * ) override final; |
---|
| 179 | const ast::Attribute * visit( const ast::Attribute * ) override final; |
---|
| 180 | const ast::TypeSubstitution * visit( const ast::TypeSubstitution * ) override final; |
---|
[f47f887] | 181 | |
---|
[04124c4] | 182 | friend void acceptAll( std::list< ptr<Decl> > & decls, Pass<pass_t>& visitor ); |
---|
[f47f887] | 183 | private: |
---|
| 184 | |
---|
[04124c4] | 185 | bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(pass, 0); return ptr ? *ptr : true; } |
---|
[f47f887] | 186 | |
---|
| 187 | private: |
---|
[6d51bd7] | 188 | const ast::Stmt * call_accept( const ast::Stmt * ); |
---|
| 189 | const ast::Expr * call_accept( const ast::Expr * ); |
---|
[f47f887] | 190 | |
---|
[6d51bd7] | 191 | template< typename node_t > |
---|
| 192 | auto call_accept( const node_t * node ) -> decltype( node->accept(*this) ); |
---|
[f47f887] | 193 | |
---|
[6d51bd7] | 194 | template< template <class...> class container_t > |
---|
[04124c4] | 195 | container_t< ptr<Stmt> > call_accept( const container_t< ptr<Stmt> > & ); |
---|
[f47f887] | 196 | |
---|
[6d51bd7] | 197 | template< template <class...> class container_t, typename node_t > |
---|
[04124c4] | 198 | container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container ); |
---|
[f47f887] | 199 | |
---|
[6d51bd7] | 200 | /// Logic to call the accept and mutate the parent if needed, delegates call to accept |
---|
| 201 | template<typename node_t, typename parent_t, typename child_t> |
---|
| 202 | void maybe_accept(const node_t * &, child_t parent_t::* child); |
---|
| 203 | |
---|
[f47f887] | 204 | private: |
---|
[04124c4] | 205 | /// Internal RAII guard for indexer features |
---|
| 206 | struct guard_indexer { |
---|
| 207 | guard_indexer( Pass<pass_t> & pass ): pass( pass ) { __pass::indexer::enter(pass, 0); } |
---|
| 208 | ~guard_indexer() { __pass::indexer::leave(pass, 0); } |
---|
[f47f887] | 209 | Pass<pass_t> & pass; |
---|
| 210 | }; |
---|
| 211 | |
---|
[04124c4] | 212 | /// Internal RAII guard for scope features |
---|
| 213 | struct guard_scope { |
---|
| 214 | guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass, 0); } |
---|
| 215 | ~guard_scope() { __pass::scope::leave(pass, 0); } |
---|
[f47f887] | 216 | Pass<pass_t> & pass; |
---|
| 217 | }; |
---|
[23f99e1] | 218 | |
---|
| 219 | private: |
---|
| 220 | bool inFunction = false; |
---|
[f47f887] | 221 | }; |
---|
| 222 | |
---|
[04124c4] | 223 | template<typename pass_t> |
---|
[6d51bd7] | 224 | void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<pass_t> & visitor ); |
---|
[f47f887] | 225 | |
---|
[04124c4] | 226 | //------------------------------------------------------------------------------------------------- |
---|
[f47f887] | 227 | // PASS ACCESSORIES |
---|
[04124c4] | 228 | //------------------------------------------------------------------------------------------------- |
---|
[f47f887] | 229 | |
---|
[04124c4] | 230 | /// Keep track of the polymorphic const TypeSubstitution * env for the current expression |
---|
| 231 | struct WithConstTypeSubstitution { |
---|
| 232 | const TypeSubstitution * env = nullptr; |
---|
| 233 | }; |
---|
| 234 | |
---|
| 235 | /// Used if visitor requires added statements before or after the current node. |
---|
| 236 | /// The Pass template handles what *before* and *after* means automatically |
---|
[6d51bd7] | 237 | template< template<class...> class container_t = std::list > |
---|
[f47f887] | 238 | struct WithStmtsToAdd { |
---|
[04124c4] | 239 | container_t< ptr<Stmt> > stmtsToAddBefore; |
---|
| 240 | container_t< ptr<Stmt> > stmtsToAddAfter; |
---|
[f47f887] | 241 | }; |
---|
| 242 | |
---|
[04124c4] | 243 | /// Used if visitor requires added declarations before or after the current node. |
---|
| 244 | /// The Pass template handles what *before* and *after* means automatically |
---|
[6d51bd7] | 245 | template< template<class...> class container_t = std::list > |
---|
[f47f887] | 246 | struct WithDeclsToAdd { |
---|
[04124c4] | 247 | container_t< ptr<Decl> > declsToAddBefore; |
---|
| 248 | container_t< ptr<Decl> > declsToAddAfter; |
---|
[f47f887] | 249 | }; |
---|
| 250 | |
---|
[04124c4] | 251 | /// Use if visitation should stop at certain levels |
---|
| 252 | /// set visit_children false of all child nodes should be ignored |
---|
[f47f887] | 253 | struct WithShortCircuiting { |
---|
| 254 | __pass::bool_ref visit_children; |
---|
| 255 | }; |
---|
| 256 | |
---|
[04124c4] | 257 | /// Used to restore values/functions/etc. when the Pass finishes visiting this node |
---|
| 258 | class WithGuards { |
---|
| 259 | __pass::at_cleanup_t at_cleanup; |
---|
[f47f887] | 260 | |
---|
[04124c4] | 261 | public: |
---|
| 262 | /// When this node is finished being visited, restore the value of a variable |
---|
| 263 | template< typename T > |
---|
| 264 | void GuardValue( T& val ) { |
---|
| 265 | at_cleanup( [ val ]( void * newVal ) { |
---|
| 266 | * static_cast< T * >( newVal ) = val; |
---|
| 267 | }, static_cast< void * >( & val ) ); |
---|
| 268 | } |
---|
[f47f887] | 269 | |
---|
[04124c4] | 270 | /// On the object, all beginScope now and endScope when the current node is finished being visited |
---|
| 271 | template< typename T > |
---|
| 272 | void GuardScope( T& val ) { |
---|
| 273 | val.beginScope(); |
---|
| 274 | at_cleanup( []( void * val ) { |
---|
| 275 | static_cast< T * >( val )->endScope(); |
---|
| 276 | }, static_cast< void * >( & val ) ); |
---|
| 277 | } |
---|
[f47f887] | 278 | |
---|
[04124c4] | 279 | /// When this node is finished being visited, call a function |
---|
| 280 | template< typename Func > |
---|
| 281 | void GuardAction( Func func ) { |
---|
| 282 | at_cleanup( [func](void *) { func(); }, nullptr ); |
---|
| 283 | } |
---|
| 284 | }; |
---|
[f47f887] | 285 | |
---|
[04124c4] | 286 | /// Used to get a pointer to the pass with its wrapped type |
---|
| 287 | template<typename pass_t> |
---|
| 288 | struct WithVisitorRef { |
---|
| 289 | Pass<pass_t> * const visitor = nullptr; |
---|
| 290 | }; |
---|
[f47f887] | 291 | |
---|
[04124c4] | 292 | /// Use when the templated visitor should update the indexer |
---|
[f47f887] | 293 | struct WithIndexer { |
---|
| 294 | SymTab::Indexer indexer; |
---|
| 295 | }; |
---|
[6d51bd7] | 296 | } |
---|
| 297 | |
---|
| 298 | #include "Common/Stats.h" |
---|
| 299 | |
---|
| 300 | extern struct PassVisitorStats { |
---|
| 301 | size_t depth = 0; |
---|
| 302 | Stats::Counters::MaxCounter<double> * max = nullptr; |
---|
| 303 | Stats::Counters::AverageCounter<double> * avg = nullptr; |
---|
| 304 | } pass_visitor_stats; |
---|
| 305 | |
---|
| 306 | #include "AST/Pass.impl.hpp" |
---|