[51587aa] | 1 | // |
---|
| 2 | // Cforall Version 1.0.0 Copyright (C) 2015 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 | // |
---|
[ea6332d] | 7 | // ScrubTyVars.h -- |
---|
[51587aa] | 8 | // |
---|
| 9 | // Author : Richard C. Bilson |
---|
| 10 | // Created On : Mon May 18 07:44:20 2015 |
---|
[3606fe4] | 11 | // Last Modified By : Andrew Beach |
---|
| 12 | // Last Modified On : Fri Aug 19 14:14:00 2022 |
---|
| 13 | // Update Count : 3 |
---|
[51587aa] | 14 | // |
---|
[01aeade] | 15 | |
---|
[6b0b624] | 16 | #pragma once |
---|
[51b7345] | 17 | |
---|
[ea6332d] | 18 | #include <cassert> // for assert |
---|
[78dd0da] | 19 | |
---|
[3606fe4] | 20 | #include "AST/Fwd.hpp" // for Node |
---|
[b8a4f47] | 21 | #include "Common/PassVisitor.h" |
---|
[08fc48f] | 22 | #include "GenPoly.h" // for TyVarMap, isPolyType, isDynType |
---|
| 23 | #include "SynTree/Mutator.h" // for Mutator |
---|
| 24 | #include "SynTree/Type.h" // for Type (ptr only), PointerType (ptr only) |
---|
[51b7345] | 25 | |
---|
[08fc48f] | 26 | class AlignofExpr; |
---|
| 27 | class Expression; |
---|
| 28 | class SizeofExpr; |
---|
[51b7345] | 29 | |
---|
| 30 | namespace GenPoly { |
---|
[b8a4f47] | 31 | struct ScrubTyVars : public WithVisitorRef<ScrubTyVars>, public WithShortCircuiting, public WithGuards { |
---|
[5a3ac84] | 32 | /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables |
---|
| 33 | enum ScrubMode { FromMap, DynamicFromMap, All }; |
---|
[f8b961b] | 34 | |
---|
[5a3ac84] | 35 | ScrubTyVars() : tyVars(nullptr), mode( All ) {} |
---|
| 36 | |
---|
| 37 | ScrubTyVars( const TyVarMap &tyVars, ScrubMode mode = FromMap ): tyVars( &tyVars ), mode( mode ) {} |
---|
| 38 | |
---|
| 39 | public: |
---|
[ebe9b3a] | 40 | /// For all polymorphic types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type, |
---|
| 41 | /// and sizeof/alignof expressions with the proper variable |
---|
[01aeade] | 42 | template< typename SynTreeClass > |
---|
| 43 | static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars ); |
---|
[b18b0b5] | 44 | |
---|
[3bb195cb] | 45 | /// For all dynamic-layout types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type, |
---|
| 46 | /// and sizeof/alignof expressions with the proper variable |
---|
| 47 | template< typename SynTreeClass > |
---|
| 48 | static SynTreeClass *scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ); |
---|
| 49 | |
---|
[5a3ac84] | 50 | /// For all polymorphic types, replaces generic types, dtypes, and ftypes with the appropriate void type, |
---|
| 51 | /// and sizeof/alignof expressions with the proper variable |
---|
| 52 | template< typename SynTreeClass > |
---|
| 53 | static SynTreeClass *scrubAll( SynTreeClass *target ); |
---|
| 54 | |
---|
[b8a4f47] | 55 | /// determine if children should be visited based on whether base type should be scrubbed. |
---|
| 56 | void primeBaseScrub( Type * ); |
---|
| 57 | |
---|
| 58 | void premutate( TypeInstType * ) { visit_children = false; } |
---|
| 59 | void premutate( StructInstType * ) { visit_children = false; } |
---|
| 60 | void premutate( UnionInstType * ) { visit_children = false; } |
---|
| 61 | void premutate( SizeofExpr * szeof ) { primeBaseScrub( szeof->type ); } |
---|
| 62 | void premutate( AlignofExpr * algnof ) { primeBaseScrub( algnof->type ); } |
---|
| 63 | void premutate( PointerType * pointer ) { primeBaseScrub( pointer->base ); } |
---|
| 64 | |
---|
| 65 | Type * postmutate( TypeInstType * typeInst ); |
---|
| 66 | Type * postmutate( StructInstType * structInst ); |
---|
| 67 | Type * postmutate( UnionInstType * unionInst ); |
---|
| 68 | Expression * postmutate( SizeofExpr * szeof ); |
---|
| 69 | Expression * postmutate( AlignofExpr * algnof ); |
---|
| 70 | Type * postmutate( PointerType * pointer ); |
---|
[b18b0b5] | 71 | |
---|
[01aeade] | 72 | private: |
---|
[3bb195cb] | 73 | /// Returns the type if it should be scrubbed, NULL otherwise. |
---|
| 74 | Type* shouldScrub( Type *ty ) { |
---|
[5a3ac84] | 75 | switch ( mode ) { |
---|
| 76 | case FromMap: return isPolyType( ty, *tyVars ); |
---|
| 77 | case DynamicFromMap: return isDynType( ty, *tyVars ); |
---|
| 78 | case All: return isPolyType( ty ); |
---|
| 79 | } |
---|
| 80 | assert(false); return nullptr; // unreachable |
---|
| 81 | // return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars ); |
---|
[3bb195cb] | 82 | } |
---|
[ea6332d] | 83 | |
---|
[b18b0b5] | 84 | /// Mutates (possibly generic) aggregate types appropriately |
---|
| 85 | Type* mutateAggregateType( Type *ty ); |
---|
[ea6332d] | 86 | |
---|
[5a3ac84] | 87 | const TyVarMap *tyVars; ///< Type variables to scrub |
---|
| 88 | ScrubMode mode; ///< which type variables to scrub? [FromMap] |
---|
[b8a4f47] | 89 | |
---|
| 90 | Type * dynType = nullptr; ///< result of shouldScrub |
---|
[01aeade] | 91 | }; |
---|
| 92 | |
---|
[bdd516a] | 93 | template< typename SynTreeClass > |
---|
[01aeade] | 94 | SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) { |
---|
[b8a4f47] | 95 | PassVisitor<ScrubTyVars> scrubber( tyVars ); |
---|
[01aeade] | 96 | return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); |
---|
| 97 | } |
---|
| 98 | |
---|
[3bb195cb] | 99 | template< typename SynTreeClass > |
---|
| 100 | SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) { |
---|
[b8a4f47] | 101 | PassVisitor<ScrubTyVars> scrubber( tyVars, ScrubTyVars::DynamicFromMap ); |
---|
[5a3ac84] | 102 | return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); |
---|
| 103 | } |
---|
| 104 | |
---|
| 105 | template< typename SynTreeClass > |
---|
| 106 | SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) { |
---|
[b8a4f47] | 107 | PassVisitor<ScrubTyVars> scrubber; |
---|
[3bb195cb] | 108 | return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) ); |
---|
| 109 | } |
---|
| 110 | |
---|
[3606fe4] | 111 | /// For all polymorphic types, replaces generic types, with the appropriate |
---|
| 112 | /// void type, and sizeof/alignof expressions with the proper variable. |
---|
| 113 | template<typename node_t> |
---|
| 114 | node_t const * scrubAllTypeVars( node_t const * target ) { |
---|
| 115 | return strict_dynamic_cast<node_t const *>( scrubAllTypeVars<ast::Node>( target ) ); |
---|
| 116 | } |
---|
| 117 | |
---|
| 118 | template<> |
---|
| 119 | ast::Node const * scrubAllTypeVars<ast::Node>( const ast::Node * target ); |
---|
| 120 | |
---|
[51b7345] | 121 | } // namespace GenPoly |
---|
| 122 | |
---|
[51587aa] | 123 | // Local Variables: // |
---|
| 124 | // tab-width: 4 // |
---|
| 125 | // mode: c++ // |
---|
| 126 | // compile-command: "make install" // |
---|
| 127 | // End: // |
---|