Changes in src/InitTweak/FixInit.cc [1be845b:b54ad9c]
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
src/InitTweak/FixInit.cc
r1be845b rb54ad9c 54 54 #include "SynTree/Type.h" // for Type, Type::StorageClasses 55 55 #include "SynTree/TypeSubstitution.h" // for TypeSubstitution, operator<< 56 #include "SynTree/DeclReplacer.h" // for DeclReplacer 56 57 #include "SynTree/Visitor.h" // for acceptAll, maybeAccept 57 58 … … 162 163 using Parent::previsit; 163 164 164 void previsit( ObjectDecl * objDecl );165 165 void previsit( FunctionDecl * funcDecl ); 166 166 167 void previsit( CompoundStmt * compoundStmt );168 void postvisit( CompoundStmt * compoundStmt );169 void previsit( ReturnStmt * returnStmt );170 167 void previsit( BranchStmt * stmt ); 171 168 private: … … 207 204 static void generate( std::list< Declaration * > & translationUnit ); 208 205 206 void premutate( StructDecl * structDecl ); 207 209 208 void premutate( FunctionDecl * funcDecl ); 210 209 DeclarationWithType * postmutate( FunctionDecl * funcDecl ); … … 228 227 bool isCtor = false; // true if current function is a constructor 229 228 StructDecl * structDecl = nullptr; 229 230 // special built-in functions necessary for this to work 231 StructDecl * dtorStruct = nullptr; 232 FunctionDecl * dtorStructDestroy = nullptr; 230 233 }; 231 234 … … 732 735 } 733 736 737 DeclarationWithType * getDtorFunc( ObjectDecl * objDecl, Statement * input, std::list< Statement * > & stmtsToAdd ) { 738 // unwrap implicit statement wrapper 739 Statement * dtor = input; 740 if ( ImplicitCtorDtorStmt * implicit = dynamic_cast< ImplicitCtorDtorStmt * >( input ) ) { 741 // dtor = implicit->callStmt; 742 // implicit->callStmt = nullptr; 743 } 744 assert( dtor ); 745 std::list< Expression * > matches; 746 collectCtorDtorCalls( dtor, matches ); 747 748 if ( dynamic_cast< ExprStmt * >( dtor ) ) { 749 // only one destructor call in the expression 750 if ( matches.size() == 1 ) { 751 DeclarationWithType * func = getFunction( matches.front() ); 752 assertf( func, "getFunction failed to find function in %s", toString( matches.front() ).c_str() ); 753 754 // cleanup argument must be a function, not an object (including function pointer) 755 if ( FunctionDecl * dtorFunc = dynamic_cast< FunctionDecl * > ( func ) ) { 756 if ( dtorFunc->type->forall.empty() ) { 757 // simple case where the destructor is a monomorphic function call - can simply 758 // use that function as the cleanup function. 759 delete dtor; 760 return func; 761 } 762 } 763 } 764 } 765 766 // otherwise the cleanup is more complicated - need to build a single argument cleanup function that 767 // wraps the more complicated code. 768 static UniqueName dtorNamer( "__cleanup_dtor" ); 769 FunctionDecl * dtorFunc = FunctionDecl::newFunction( dtorNamer.newName(), SymTab::genDefaultType( objDecl->type->stripReferences(), false ), new CompoundStmt() ); 770 stmtsToAdd.push_back( new DeclStmt( dtorFunc ) ); 771 772 // the original code contains uses of objDecl - replace them with the newly generated 'this' parameter. 773 ObjectDecl * thisParam = getParamThis( dtorFunc->type ); 774 Expression * replacement = new VariableExpr( thisParam ); 775 776 Type * base = replacement->result->stripReferences(); 777 if ( dynamic_cast< ArrayType * >( base ) || dynamic_cast< TupleType * > ( base ) ) { 778 // need to cast away reference for array types, since the destructor is generated without the reference type, 779 // and for tuple types since tuple indexing does not work directly on a reference 780 replacement = new CastExpr( replacement, base->clone() ); 781 } 782 DeclReplacer::replace( dtor, { std::make_pair( objDecl, replacement ) } ); 783 dtorFunc->statements->push_back( strict_dynamic_cast<Statement *>( dtor ) ); 784 785 return dtorFunc; 786 } 787 734 788 DeclarationWithType * FixInit::postmutate( ObjectDecl *objDecl ) { 735 789 // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate) … … 844 898 ctorInit->ctor = nullptr; 845 899 } 900 901 Statement * dtor = ctorInit->dtor; 902 if ( dtor ) { 903 ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * >( dtor ); 904 Statement * dtorStmt = implicit->callStmt; 905 906 // don't need to call intrinsic dtor, because it does nothing, but 907 // non-intrinsic dtors must be called 908 if ( ! isIntrinsicSingleArgCallStmt( dtorStmt ) ) { 909 // set dtor location to the object's location for error messages 910 DeclarationWithType * dtorFunc = getDtorFunc( objDecl, dtorStmt, stmtsToAddBefore ); 911 objDecl->attributes.push_back( new Attribute( "cleanup", { new VariableExpr( dtorFunc ) } ) ); 912 ctorInit->dtor = nullptr; 913 } // if 914 } 846 915 } // if 847 916 } else if ( Initializer * init = ctorInit->init ) { … … 886 955 887 956 888 template<typename Iterator, typename OutputIterator>889 void insertDtors( Iterator begin, Iterator end, OutputIterator out ) {890 for ( Iterator it = begin ; it != end ; ++it ) {891 // extract destructor statement from the object decl and insert it into the output. Note that this is892 // only called on lists of non-static objects with implicit non-intrinsic dtors, so if the user manually893 // calls an intrinsic dtor then the call must (and will) still be generated since the argument may894 // contain side effects.895 ObjectDecl * objDecl = *it;896 ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() );897 assert( ctorInit && ctorInit->get_dtor() );898 *out++ = ctorInit->get_dtor()->clone();899 } // for900 }901 902 void InsertDtors::previsit( ObjectDecl * objDecl ) {903 // remember non-static destructed objects so that their destructors can be inserted later904 if ( ! objDecl->get_storageClasses().is_static ) {905 if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {906 // a decision should have been made by the resolver, so ctor and init are not both non-NULL907 assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );908 Statement * dtor = ctorInit->get_dtor();909 // don't need to call intrinsic dtor, because it does nothing, but910 // non-intrinsic dtors must be called911 if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {912 // set dtor location to the object's location for error messages913 ctorInit->dtor->location = objDecl->location;914 reverseDeclOrder.front().push_front( objDecl );915 } // if916 } // if917 } // if918 }919 920 957 void InsertDtors::previsit( FunctionDecl * funcDecl ) { 921 958 // each function needs to have its own set of labels … … 930 967 } 931 968 932 void InsertDtors::previsit( CompoundStmt * compoundStmt ) {933 // visit statements - this will also populate reverseDeclOrder list. don't want to dump all destructors934 // when block is left, just the destructors associated with variables defined in this block, so push a new935 // list to the top of the stack so that we can differentiate scopes936 reverseDeclOrder.push_front( OrderedDecls() );937 Parent::previsit( compoundStmt );938 }939 940 void InsertDtors::postvisit( CompoundStmt * compoundStmt ) {941 // add destructors for the current scope that we're exiting, unless the last statement is a return, which942 // causes unreachable code warnings943 std::list< Statement * > & statements = compoundStmt->get_kids();944 if ( ! statements.empty() && ! dynamic_cast< ReturnStmt * >( statements.back() ) ) {945 insertDtors( reverseDeclOrder.front().begin(), reverseDeclOrder.front().end(), back_inserter( statements ) );946 }947 reverseDeclOrder.pop_front();948 }949 950 void InsertDtors::previsit( ReturnStmt * ) {951 // return exits all scopes, so dump destructors for all scopes952 for ( OrderedDecls & od : reverseDeclOrder ) {953 insertDtors( od.begin(), od.end(), back_inserter( stmtsToAddBefore ) );954 } // for955 }956 957 969 // Handle break/continue/goto in the same manner as C++. Basic idea: any objects that are in scope at the 958 970 // BranchStmt but not at the labelled (target) statement must be destructed. If there are any objects in scope … … 982 994 if ( ! diff.empty() ) { 983 995 SemanticError( stmt, std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " " ); 984 } // if985 // S_G-S_L results in set of objects that must be destructed986 diff.clear();987 std::set_difference( curVars.begin(), curVars.end(), lvars.begin(), lvars.end(), std::inserter( diff, diff.end() ) );988 DTOR_PRINT(989 std::cerr << "S_G-S_L = " << printSet( diff ) << std::endl;990 )991 if ( ! diff.empty() ) {992 // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.993 std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );994 995 // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor996 OrderedDecls ordered;997 for ( OrderedDecls & rdo : reverseDeclOrder ) {998 // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.999 copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );1000 } // for1001 insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAddBefore ) );1002 996 } // if 1003 997 } … … 1025 1019 } 1026 1020 1021 void GenStructMemberCalls::premutate( StructDecl * structDecl ) { 1022 if ( ! dtorStruct && structDecl->name == "__Destructor" ) { 1023 dtorStruct = structDecl; 1024 } 1025 } 1026 1027 1027 void GenStructMemberCalls::premutate( FunctionDecl * funcDecl ) { 1028 1028 GuardValue( function ); … … 1037 1037 unhandled.clear(); 1038 1038 usedUninit.clear(); 1039 1040 if ( ! dtorStructDestroy && funcDecl->name == "__destroy_Destructor" ) { 1041 dtorStructDestroy = funcDecl; 1042 return; 1043 } 1039 1044 1040 1045 function = funcDecl; … … 1048 1053 if ( structType ) { 1049 1054 structDecl = structType->get_baseStruct(); 1055 if ( structDecl == dtorStruct ) return; 1050 1056 for ( Declaration * member : structDecl->get_members() ) { 1051 1057 if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) { … … 1116 1122 callStmt->acceptMutator( *visitor ); 1117 1123 if ( isCtor ) { 1118 function-> get_statements()->push_front( callStmt );1119 } else { 1124 function->statements->push_front( callStmt ); 1125 } else { // TODO: don't generate destructor function/object for intrinsic calls 1120 1126 // destructor statements should be added at the end 1121 function->get_statements()->push_back( callStmt ); 1127 // function->get_statements()->push_back( callStmt ); 1128 1129 // __Destructor _dtor0 = { (void *)&b.a1, (void (*)(void *)_destroy_A }; 1130 std::list< Statement * > stmtsToAdd; 1131 1132 static UniqueName memberDtorNamer = { "__memberDtor" }; 1133 assertf( dtorStruct, "builtin __Destructor not found." ); 1134 assertf( dtorStructDestroy, "builtin __destroy_Destructor not found." ); 1135 1136 Expression * thisExpr = new CastExpr( new AddressExpr( new VariableExpr( thisParam ) ), new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ) ); 1137 Expression * dtorExpr = new VariableExpr( getDtorFunc( thisParam, callStmt, stmtsToAdd ) ); 1138 1139 // cast destructor pointer to void (*)(void *), to silence GCC incompatible pointer warnings 1140 FunctionType * dtorFtype = new FunctionType( Type::Qualifiers(), false ); 1141 dtorFtype->parameters.push_back( ObjectDecl::newObject( "", new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), nullptr ) ); 1142 Type * dtorType = new PointerType( Type::Qualifiers(), dtorFtype ); 1143 1144 ObjectDecl * destructor = ObjectDecl::newObject( memberDtorNamer.newName(), new StructInstType( Type::Qualifiers(), dtorStruct ), new ListInit( { new SingleInit( thisExpr ), new SingleInit( new CastExpr( dtorExpr, dtorType ) ) } ) ); 1145 function->statements->push_front( new DeclStmt( destructor ) ); 1146 destructor->attributes.push_back( new Attribute( "cleanup", { new VariableExpr( dtorStructDestroy ) } ) ); 1147 1148 function->statements->kids.splice( function->statements->kids.begin(), stmtsToAdd ); 1122 1149 } 1123 1150 } catch ( SemanticErrorException & error ) {
Note: See TracChangeset
for help on using the changeset viewer.