Index: configure =================================================================== --- configure (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ configure (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -2496,10 +2496,4 @@ -if test "x${CXXFLAGS}" = "x"; then - export CXXFLAGS="-std=c++11 -g ${CXXFLAGS}" # defaults, no -O2 for debugging and failures -else - export CXXFLAGS="-std=c++11 ${CXXFLAGS}" # flags from configure command -fi - am__api_version='1.11' Index: configure.ac =================================================================== --- configure.ac (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ configure.ac (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -8,10 +8,4 @@ AC_CONFIG_HEADERS([config.h]) AM_SILENT_RULES([no]) - -if test "x${CXXFLAGS}" = "x"; then - export CXXFLAGS="-std=c++11 -g ${CXXFLAGS}" # defaults, no -O2 for debugging and failures -else - export CXXFLAGS="-std=c++11 ${CXXFLAGS}" # flags from configure command -fi AM_INIT_AUTOMAKE Index: doc/working/exception/impl/except.c =================================================================== --- doc/working/exception/impl/except.c (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ doc/working/exception/impl/except.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -97,8 +97,9 @@ //is way more expansive than we might like //The information we have is : - // - The GR (???) + // - The GR (Series of registers) + // GR1=GP Global Pointer of frame ref by context // - The instruction pointer // - The instruction pointer info (???) - // - The CFA (???) + // - The CFA (Canonical Frame Address) // - The BSP (Probably the base stack pointer) Index: doc/working/exception/impl/main.c =================================================================== --- doc/working/exception/impl/main.c (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ doc/working/exception/impl/main.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -33,4 +33,5 @@ //libcfa but there is one problem left, see the exception table //for details +__attribute__((noinline)) void try( void (*try_block)(), void (*catch_block)() ) { @@ -129,5 +130,5 @@ raii_t a = { "Main dtor" }; - foo(); + for (unsigned int i = 0 ; i < 100000000 ; ++i) foo(); printf("End of program reached\n"); Index: doc/working/exception/impl/resume-main.c =================================================================== --- doc/working/exception/impl/resume-main.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ doc/working/exception/impl/resume-main.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,152 @@ +#include +#include + +// Proof of concept for resumption exception handling. +// Names, checks promises and so on all would have to be improved. + +struct resume_group; + +// Stackwise information (global for single stack) +struct code_stack_data { + struct resume_group * top_resume; + struct resume_group * current_resume; +} stack = {NULL, NULL}; + +// private exception header begin ============================================ + +struct resume_group { + struct resume_group * next; + bool (*try_to_handle)(int); +}; + +void __resume_group_dtor(struct resume_group * this) { + stack.top_resume = this->next; +} + +void __cfa_eh__throw_resume(int except) { + struct resume_group * original_head = stack.current_resume; + struct resume_group * current = + (original_head) ? original_head->next : stack.top_resume; + + for ( ; current ; current = current->next) { + stack.current_resume = current; + if (current->try_to_handle(except)) { + stack.current_resume = original_head; + return; + } + } + + printf("Unhandled exception %d\n", except); +} + +// private exception header end ============================================== + +// Set up of unwind checker type. +struct type_raii_t { + char * msg; +}; + +void dtor( struct type_raii_t * this ) { + printf("%s\n", this->msg); +} + +#define raii_t __attribute__((cleanup(dtor))) struct type_raii_t + +void bar() { + raii_t a = { "Bar dtor" }; + + __cfa_eh__throw_resume( 3 ); +} + +void foo() { + raii_t a = { "Foo dtor" }; + + { + bool foo_catch_resume(int exception_id) { + if (exception_id == 3) { + printf("Exception caught\n"); + return true; + } + return false; + } + struct resume_group __attribute__((cleanup(__resume_group_dtor))) + foo_try_resume = {stack.top_resume, foo_catch_resume}; + stack.top_resume = &foo_try_resume; + { + raii_t b = { "Foo try dtor" }; + + bar(); + + printf("Called bar successfully\n"); + } + } + printf( "Foo exited normally\n" ); +} + +// Not in main.cfa +void foe() { + raii_t a = { "Foe dtor" }; + + printf("Foe throws\n"); + __cfa_eh__throw_resume( 4 ); + + printf("Foe exits normally\n"); +} + +void fy() { + raii_t a = { "Fy dtor" }; + + { + bool fy_catch_resume(int exception_id) { + if (4 == exception_id) { + printf("Rethrow in fy\n"); + __cfa_eh__throw_resume(exception_id); + return true; + } + return false; + } + struct resume_group __attribute__((cleanup(__resume_group_dtor))) + fy_try_resume = {stack.top_resume, fy_catch_resume}; + stack.top_resume = &fy_try_resume; + { + raii_t b = { "Fy try dtor" }; + foe(); + } + } + + printf("Fy exits normally\n"); +} + +void fee() { + raii_t a = { "Fee dtor" }; + + { + bool fee_catch_resume(int exception_id) { + if (4 == exception_id) { + printf("fee caught exception\n"); + return true; + } + return false; + } + struct resume_group __attribute__((cleanup(__resume_group_dtor))) + fee_try_resume = {stack.top_resume, fee_catch_resume}; + stack.top_resume = &fee_try_resume; + { + raii_t b = { "Fee try dtor" }; + fy(); + } + } + + printf("Fee exits normally\n"); +} +// End not in main.cfa + +int main() { + raii_t a = { "Main dtor" }; + + foo(); + + fee(); + + printf("End of program reached\n"); +} Index: doc/working/exception/reference.c =================================================================== --- doc/working/exception/reference.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ doc/working/exception/reference.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,125 @@ +// Reference to all sorts of information for exception handling. + +// C++ Interface to exception handlers. + +void * __cxa_allocate_exception(size_t thrown_size); +// Creates space for the exception. + +void __cxa_free_exception(void * thrown_exception); + +void __cxa_throw(void * thrown_exception, struct type_info * tinfo, + void (*dest)(void*)); +// Throws the exception, is not supposed to return but ours should, +// to handle resumption exceptions. + +void __cxa_begin_catch(); -> void * __cxa_begin_catch(void * exceptionObject); +void __cxa_end_catch(); +// Not sure, beginning and end of catch block maybe? + + +/* Unwind Module + * Full list: https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html + * Avaible at: /usr/lib/gcc/x86_64-linux-gnu/{5}/include/unwind.h + */ + +typedef _Unwind_Reason_Code (*_Unwind_Personality_Fn) + (int, _Unwind_Action, _Unwind_Exception_Class, + struct _Unwind_Exception *, struct _Unwind_Context *); +/* Type of the personality function, which does not have a set name. + * So far `__gcfa_personality_v0` has been used. + * Called by _Unwind_RaiseException (called by __cxa_throw) + * or by _Unwind_ForcedUnwind's personality wrapper. + * Params: + * int version: Repersents unwind convention standard. + * _Unwind_Action actions: Set of actions, used as instructions. + * _Unwind_Exception_Class: 8-byte identifer: high 4 vendor, low 4 language. + * _Unwind_Exception unwind_exception: Pointer to exception data. + * _Unwind_Context context: Information on the current stack frame. + * Return: + * _Unwind_Reason_Code: Requests an action from the unwinder. + */ + + +// _Unwind_Action flags (multiple may be set): +_UA_SEARCH_PHASE // Seaching for the handler +_UA_CLEANUP_PHASE // Cleanup until handler found. +_UA_HANDLER_FRAME // Previous search found handler here. +_UA_FORCE_UNWIND // Unwind, do not decide if we have reached the handler. +_UA_END_OF_STACK // We have reached the end of the stack. + + +// _Unwind_Reason_Code values (one may be selected): +_URC_NO_REASON // Containues force unwind. +_URC_FOREIGN_EXCEPTION_CAUGHT // Cross between runtime environments. +_URC_FATAL_PHASE2_ERROR // Error in cleanup, not otherwise defined. (Rare?) +_URC_FATAL_PHASE1_ERROR // Error in search, not otherwise defined. +_URC_NORMAL_STOP +_URC_END_OF_STACK // eos found before a handler. +_URC_HANDLER_FOUND // Just the signal (search?) +_URC_INSTALL_CONTEXT // Handler found, resume execution (cleanup?) +_URC_CONTINUE_UNWIND // No handler found (search&cleanup) + + +// Exception Header: (?) +typedef void (*_Unwind_Exception_Cleanup_Fn) + (_Unwind_Reason_Code reason, struct _Unwind_Exception *exc); + +struct _Unwind_Exception { + uint64 exception_class; + _Unwind_Exception_Cleanup_Fn exception_cleanup; + uint64 private_1; // Do not access. + uint64 private_2; // Do not access. +}; + + +// There are two functions to access the unwind "operation". +// The standard exception handler, uses the personality function. +_Unwind_Reason_Code _Unwind_RaiseException( + struct _Unwind_Exception * exception_object); + +// Helper for force unwind. +typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn)( + int version, + _Unwind_Action actions, + uint64 exceptionClass, + struct _Unwind_Exception * exceptionObject, + struct _Unwind_Context * context, + void * stop_parameter); + +// Special unwinder, wraps the personality function. +_Unwind_Reason_Code _Unwind_ForcedUnwind( + struct _Unwind_Exception * exception_object, + _Unwind_Stop_Fn stop, + void * stop_parameter); + +// Continues unwinding +void _Unwind_Resume(struct _Unwind_Exception * exception_object); +// Seems to be for finally and deconstrctors, not so much rethrow. +// However I haven't figured out the difference. + + +/* _Unwind Helper functions: + * + * _Unwind_GetLanguageSpecificData - LSDA (destructors and landing pads) + * _Unwind_GetRegionStart - Function pointer to current stack frame. + * _Unwind_GetIP - Get frame's instruction pointer + * This might be the actual function pointer or the call site up stack. + * + * All three have the same signature. */ +uint64 _Unwind_Get*(struct _Unwind_Context * context); + +void _Unwind_SetIP(struct _Unwind_Context * context, uint64 new_value); +uint64 _Unwind_GetGR(struct _Unwind_Context * context, int index); +void _Unwind_SetGR(struct _Unwind_Context * <>, int index, uint64 <>); +// __builtin_eh_return_data_regno(^) ^=[0..3]? gives index. + + +// GCC (Dwarf2 ?) Frame Layout Macros +// https://gcc.gnu.org/onlinedocs/gccint/Frame-Layout.html + +FIRST_PARAM_OFFSET(fundecl) +// Offset from argument pointer to first arguments address, or above that +// address if ARGS_GROW_DOWNWARD. + +ARG_POINTER_CFA_OFFSET(fundecl) +// Default: FIRST_PARM_OFFSET(fundecl) + crtl->args.pretend_args_size Index: src/CodeTools/TrackLoc.cc =================================================================== --- src/CodeTools/TrackLoc.cc (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/CodeTools/TrackLoc.cc (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -16,10 +16,14 @@ #include "TrackLoc.h" +#include + #include #include +#include #include -#include +#include #include "Common/utility.h" +#include "Common/PassVisitor.h" #include "Common/VectorMap.h" #include "GenPoly/GenPoly.h" @@ -27,157 +31,66 @@ #include "SynTree/Declaration.h" #include "SynTree/Initializer.h" -#include "SynTree/Visitor.h" namespace CodeTools { - std::ostream & operator<<(std::ostream & out, CodeLocation const & loc) { - return out << loc.filename << '[' << loc.linenumber << ']'; - } + std::ostream & operator<<(std::ostream & out, CodeLocation const & loc) { + return out << loc.filename << '[' << loc.linenumber << ']'; + } - class LocationPrinter : public Visitor { - unsigned int printLevel; - unsigned int currentLevel; + class LocationPrinter { + size_t printLevel; - CodeLocation *parent; CodeLocation *lastNode; - public: - LocationPrinter(unsigned int printLevel) : - Visitor(), printLevel(printLevel), currentLevel(0), - parent(nullptr), lastNode(nullptr) - {} + std::stack< CodeLocation * > parents; + public: + LocationPrinter(size_t printLevel) : + printLevel(printLevel), lastNode(nullptr) + {} - void print(char const * name, BaseSyntaxNode *node) { - for (unsigned int i = 0 ; i < currentLevel ; ++i) { + void print( const std::string& name, BaseSyntaxNode *node) { + for (size_t i = 0 ; i < parents.size() ; ++i) { std::cout << " "; } - if (2 <= printLevel) { + if (2 <= printLevel) { std::cout << name << '@'; } std::cout << node->location << std::endl; - } + } - void atNode(char const * name, BaseSyntaxNode *node) { - if (-1 == node->location.linenumber) { - if (nullptr != parent) { - node->location.linenumber = parent->linenumber; - node->location.filename = parent->filename; - } else if (nullptr != lastNode) { - node->location.linenumber = lastNode->linenumber; - node->location.filename = lastNode->filename; - } else { - std::cerr << "Top level node has no CodeLocation " << - name << std::endl; + void atNode( BaseSyntaxNode *node ) { + std::string name = std::type_index(typeid(*node)).name(); + if ( node->location.isUnset() ) { + if ( !parents.empty() ) { + node->location = *parents.top(); + } + else if (nullptr != lastNode) { + node->location = *lastNode; + } + else { + std::cerr << "Top level node has no CodeLocation " << name << std::endl; exit(EXIT_FAILURE); } } + if (0 < printLevel) { - print(name, node); + print( name, node ); } lastNode = &node->location; } -#define VISIT_FUNCTION(SyntaxNodeType) \ - virtual void visit(SyntaxNodeType *node) { \ - atNode(#SyntaxNodeType, node); \ - ++currentLevel; \ - CodeLocation * myParent = parent; \ - parent = &node->location; \ - Visitor::visit(node); \ - parent = myParent; \ - --currentLevel; \ + void previsit(BaseSyntaxNode * node) { + atNode(node); + parents.push( &node->location ); } - VISIT_FUNCTION(ObjectDecl) - VISIT_FUNCTION(FunctionDecl) - VISIT_FUNCTION(StructDecl) - VISIT_FUNCTION(UnionDecl) - VISIT_FUNCTION(EnumDecl) - VISIT_FUNCTION(TraitDecl) - VISIT_FUNCTION(TypeDecl) - VISIT_FUNCTION(TypedefDecl) - VISIT_FUNCTION(AsmDecl) - - VISIT_FUNCTION(CompoundStmt) - VISIT_FUNCTION(ExprStmt) - VISIT_FUNCTION(AsmStmt) - VISIT_FUNCTION(IfStmt) - VISIT_FUNCTION(WhileStmt) - VISIT_FUNCTION(ForStmt) - VISIT_FUNCTION(SwitchStmt) - VISIT_FUNCTION(CaseStmt) - VISIT_FUNCTION(BranchStmt) - VISIT_FUNCTION(ReturnStmt) - VISIT_FUNCTION(TryStmt) - VISIT_FUNCTION(CatchStmt) - VISIT_FUNCTION(FinallyStmt) - VISIT_FUNCTION(NullStmt) - VISIT_FUNCTION(DeclStmt) - VISIT_FUNCTION(ImplicitCtorDtorStmt) - - VISIT_FUNCTION(ApplicationExpr) - VISIT_FUNCTION(UntypedExpr) - VISIT_FUNCTION(NameExpr) - VISIT_FUNCTION(CastExpr) - VISIT_FUNCTION(AddressExpr) - VISIT_FUNCTION(LabelAddressExpr) - VISIT_FUNCTION(UntypedMemberExpr) - VISIT_FUNCTION(MemberExpr) - VISIT_FUNCTION(VariableExpr) - VISIT_FUNCTION(ConstantExpr) - VISIT_FUNCTION(SizeofExpr) - VISIT_FUNCTION(AlignofExpr) - VISIT_FUNCTION(UntypedOffsetofExpr) - VISIT_FUNCTION(OffsetofExpr) - VISIT_FUNCTION(OffsetPackExpr) - VISIT_FUNCTION(AttrExpr) - VISIT_FUNCTION(LogicalExpr) - VISIT_FUNCTION(ConditionalExpr) - VISIT_FUNCTION(CommaExpr) - VISIT_FUNCTION(TypeExpr) - VISIT_FUNCTION(AsmExpr) - VISIT_FUNCTION(ImplicitCopyCtorExpr) - VISIT_FUNCTION(ConstructorExpr) - VISIT_FUNCTION(CompoundLiteralExpr) - VISIT_FUNCTION(UntypedValofExpr) - VISIT_FUNCTION(RangeExpr) - VISIT_FUNCTION(UntypedTupleExpr) - VISIT_FUNCTION(TupleExpr) - VISIT_FUNCTION(TupleIndexExpr) - VISIT_FUNCTION(MemberTupleExpr) - VISIT_FUNCTION(TupleAssignExpr) - VISIT_FUNCTION(StmtExpr) - VISIT_FUNCTION(UniqueExpr) - - VISIT_FUNCTION(VoidType) - VISIT_FUNCTION(BasicType) - VISIT_FUNCTION(PointerType) - VISIT_FUNCTION(ArrayType) - VISIT_FUNCTION(FunctionType) - VISIT_FUNCTION(StructInstType) - VISIT_FUNCTION(UnionInstType) - VISIT_FUNCTION(EnumInstType) - VISIT_FUNCTION(TraitInstType) - VISIT_FUNCTION(TypeInstType) - VISIT_FUNCTION(TupleType) - VISIT_FUNCTION(TypeofType) - VISIT_FUNCTION(AttrType) - VISIT_FUNCTION(VarArgsType) - VISIT_FUNCTION(ZeroType) - VISIT_FUNCTION(OneType) - - VISIT_FUNCTION(SingleInit) - VISIT_FUNCTION(ListInit) - VISIT_FUNCTION(ConstructorInit) - - //VISIT_FUNCTION(Subrange) - - //VISIT_FUNCTION(Constant) + void postvisit(BaseSyntaxNode * node) { + parents.pop(); + } }; // LocationPrinter - void fillLocations( std::list< Declaration * > & translationUnit, - unsigned int printLevel) { - LocationPrinter printer(printLevel); + void fillLocations( std::list< Declaration * > & translationUnit, size_t printLevel) { + PassVisitor printer(printLevel); acceptAll( translationUnit, printer ); } Index: src/CodeTools/TrackLoc.h =================================================================== --- src/CodeTools/TrackLoc.h (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/CodeTools/TrackLoc.h (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -24,6 +24,5 @@ // printLevel: how much printing while filling in the node locations. // 0 - No Printing, 1 - Print Location, 2 - Print Node Type and Location - void fillLocations( std::list< Declaration * > &translationUnit, - unsigned int printLevel = 0 ); + void fillLocations( std::list< Declaration * > &translationUnit, size_t printLevel = 0 ); } // namespace CodeTools Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ src/Common/PassVisitor.h (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,237 @@ +#pragma once + +#include + +#include "SynTree/Mutator.h" +#include "SynTree/Visitor.h" + +#include "SynTree/Initializer.h" +#include "SynTree/Statement.h" +#include "SynTree/Type.h" +#include "SynTree/Declaration.h" +#include "SynTree/Expression.h" +#include "SynTree/Constant.h" + +#include "PassVisitor.proto.h" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +// Templated visitor type +// To use declare a PassVisitor< YOUR VISITOR TYPE > +// The visitor type should specify the previsit/postvisit for types that are desired. +//------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +template< typename pass_type > +class PassVisitor final : public Visitor, public Mutator { +public: + PassVisitor() = default; + + template< typename... Args > + PassVisitor(Args &&... args) + : pass( std::forward( args )... ) + {} + + virtual ~PassVisitor() = default; +private: + pass_type pass; + +public: + + virtual void visit( ObjectDecl *objectDecl ) override final; + virtual void visit( FunctionDecl *functionDecl ) override final; + virtual void visit( StructDecl *aggregateDecl ) override final; + virtual void visit( UnionDecl *aggregateDecl ) override final; + virtual void visit( EnumDecl *aggregateDecl ) override final; + virtual void visit( TraitDecl *aggregateDecl ) override final; + virtual void visit( TypeDecl *typeDecl ) override final; + virtual void visit( TypedefDecl *typeDecl ) override final; + virtual void visit( AsmDecl *asmDecl ) override final; + + virtual void visit( CompoundStmt *compoundStmt ) override final; + virtual void visit( ExprStmt *exprStmt ) override final; + virtual void visit( AsmStmt *asmStmt ) override final; + virtual void visit( IfStmt *ifStmt ) override final; + virtual void visit( WhileStmt *whileStmt ) override final; + virtual void visit( ForStmt *forStmt ) override final; + virtual void visit( SwitchStmt *switchStmt ) override final; + virtual void visit( CaseStmt *caseStmt ) override final; + virtual void visit( BranchStmt *branchStmt ) override final; + virtual void visit( ReturnStmt *returnStmt ) override final; + virtual void visit( TryStmt *tryStmt ) override final; + virtual void visit( CatchStmt *catchStmt ) override final; + virtual void visit( FinallyStmt *finallyStmt ) override final; + virtual void visit( NullStmt *nullStmt ) override final; + virtual void visit( DeclStmt *declStmt ) override final; + virtual void visit( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final; + + virtual void visit( ApplicationExpr *applicationExpr ) override final; + virtual void visit( UntypedExpr *untypedExpr ) override final; + virtual void visit( NameExpr *nameExpr ) override final; + virtual void visit( CastExpr *castExpr ) override final; + virtual void visit( AddressExpr *addressExpr ) override final; + virtual void visit( LabelAddressExpr *labAddressExpr ) override final; + virtual void visit( UntypedMemberExpr *memberExpr ) override final; + virtual void visit( MemberExpr *memberExpr ) override final; + virtual void visit( VariableExpr *variableExpr ) override final; + virtual void visit( ConstantExpr *constantExpr ) override final; + virtual void visit( SizeofExpr *sizeofExpr ) override final; + virtual void visit( AlignofExpr *alignofExpr ) override final; + virtual void visit( UntypedOffsetofExpr *offsetofExpr ) override final; + virtual void visit( OffsetofExpr *offsetofExpr ) override final; + virtual void visit( OffsetPackExpr *offsetPackExpr ) override final; + virtual void visit( AttrExpr *attrExpr ) override final; + virtual void visit( LogicalExpr *logicalExpr ) override final; + virtual void visit( ConditionalExpr *conditionalExpr ) override final; + virtual void visit( CommaExpr *commaExpr ) override final; + virtual void visit( TypeExpr *typeExpr ) override final; + virtual void visit( AsmExpr *asmExpr ) override final; + virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr ) override final; + virtual void visit( ConstructorExpr * ctorExpr ) override final; + virtual void visit( CompoundLiteralExpr *compLitExpr ) override final; + virtual void visit( UntypedValofExpr *valofExpr ) override final; + virtual void visit( RangeExpr *rangeExpr ) override final; + virtual void visit( UntypedTupleExpr *tupleExpr ) override final; + virtual void visit( TupleExpr *tupleExpr ) override final; + virtual void visit( TupleIndexExpr *tupleExpr ) override final; + virtual void visit( MemberTupleExpr *tupleExpr ) override final; + virtual void visit( TupleAssignExpr *assignExpr ) override final; + virtual void visit( StmtExpr * stmtExpr ) override final; + virtual void visit( UniqueExpr * uniqueExpr ) override final; + + virtual void visit( VoidType *basicType ) override final; + virtual void visit( BasicType *basicType ) override final; + virtual void visit( PointerType *pointerType ) override final; + virtual void visit( ArrayType *arrayType ) override final; + virtual void visit( FunctionType *functionType ) override final; + virtual void visit( StructInstType *aggregateUseType ) override final; + virtual void visit( UnionInstType *aggregateUseType ) override final; + virtual void visit( EnumInstType *aggregateUseType ) override final; + virtual void visit( TraitInstType *aggregateUseType ) override final; + virtual void visit( TypeInstType *aggregateUseType ) override final; + virtual void visit( TupleType *tupleType ) override final; + virtual void visit( TypeofType *typeofType ) override final; + virtual void visit( AttrType *attrType ) override final; + virtual void visit( VarArgsType *varArgsType ) override final; + virtual void visit( ZeroType *zeroType ) override final; + virtual void visit( OneType *oneType ) override final; + + virtual void visit( SingleInit *singleInit ) override final; + virtual void visit( ListInit *listInit ) override final; + virtual void visit( ConstructorInit *ctorInit ) override final; + + virtual void visit( Subrange *subrange ) override final; + + virtual void visit( Constant *constant ) override final; + + virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override final; + virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override final; + virtual Declaration* mutate( StructDecl *aggregateDecl ) override final; + virtual Declaration* mutate( UnionDecl *aggregateDecl ) override final; + virtual Declaration* mutate( EnumDecl *aggregateDecl ) override final; + virtual Declaration* mutate( TraitDecl *aggregateDecl ) override final; + virtual TypeDecl* mutate( TypeDecl *typeDecl ) override final; + virtual Declaration* mutate( TypedefDecl *typeDecl ) override final; + virtual AsmDecl* mutate( AsmDecl *asmDecl ) override final; + + virtual CompoundStmt* mutate( CompoundStmt *compoundStmt ) override final; + virtual Statement* mutate( ExprStmt *exprStmt ) override final; + virtual Statement* mutate( AsmStmt *asmStmt ) override final; + virtual Statement* mutate( IfStmt *ifStmt ) override final; + virtual Statement* mutate( WhileStmt *whileStmt ) override final; + virtual Statement* mutate( ForStmt *forStmt ) override final; + virtual Statement* mutate( SwitchStmt *switchStmt ) override final; + virtual Statement* mutate( CaseStmt *caseStmt ) override final; + virtual Statement* mutate( BranchStmt *branchStmt ) override final; + virtual Statement* mutate( ReturnStmt *returnStmt ) override final; + virtual Statement* mutate( TryStmt *returnStmt ) override final; + virtual Statement* mutate( CatchStmt *catchStmt ) override final; + virtual Statement* mutate( FinallyStmt *catchStmt ) override final; + virtual NullStmt* mutate( NullStmt *nullStmt ) override final; + virtual Statement* mutate( DeclStmt *declStmt ) override final; + virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final; + + virtual Expression* mutate( ApplicationExpr *applicationExpr ) override final; + virtual Expression* mutate( UntypedExpr *untypedExpr ) override final; + virtual Expression* mutate( NameExpr *nameExpr ) override final; + virtual Expression* mutate( AddressExpr *castExpr ) override final; + virtual Expression* mutate( LabelAddressExpr *labAddressExpr ) override final; + virtual Expression* mutate( CastExpr *castExpr ) override final; + virtual Expression* mutate( UntypedMemberExpr *memberExpr ) override final; + virtual Expression* mutate( MemberExpr *memberExpr ) override final; + virtual Expression* mutate( VariableExpr *variableExpr ) override final; + virtual Expression* mutate( ConstantExpr *constantExpr ) override final; + virtual Expression* mutate( SizeofExpr *sizeofExpr ) override final; + virtual Expression* mutate( AlignofExpr *alignofExpr ) override final; + virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr ) override final; + virtual Expression* mutate( OffsetofExpr *offsetofExpr ) override final; + virtual Expression* mutate( OffsetPackExpr *offsetPackExpr ) override final; + virtual Expression* mutate( AttrExpr *attrExpr ) override final; + virtual Expression* mutate( LogicalExpr *logicalExpr ) override final; + virtual Expression* mutate( ConditionalExpr *conditionalExpr ) override final; + virtual Expression* mutate( CommaExpr *commaExpr ) override final; + virtual Expression* mutate( TypeExpr *typeExpr ) override final; + virtual Expression* mutate( AsmExpr *asmExpr ) override final; + virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) override final; + virtual Expression* mutate( ConstructorExpr *ctorExpr ) override final; + virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ) override final; + virtual Expression* mutate( UntypedValofExpr *valofExpr ) override final; + virtual Expression* mutate( RangeExpr *rangeExpr ) override final; + virtual Expression* mutate( UntypedTupleExpr *tupleExpr ) override final; + virtual Expression* mutate( TupleExpr *tupleExpr ) override final; + virtual Expression* mutate( TupleIndexExpr *tupleExpr ) override final; + virtual Expression* mutate( MemberTupleExpr *tupleExpr ) override final; + virtual Expression* mutate( TupleAssignExpr *assignExpr ) override final; + virtual Expression* mutate( StmtExpr * stmtExpr ) override final; + virtual Expression* mutate( UniqueExpr * uniqueExpr ) override final; + + virtual Type* mutate( VoidType *basicType ) override final; + virtual Type* mutate( BasicType *basicType ) override final; + virtual Type* mutate( PointerType *pointerType ) override final; + virtual Type* mutate( ArrayType *arrayType ) override final; + virtual Type* mutate( FunctionType *functionType ) override final; + virtual Type* mutate( StructInstType *aggregateUseType ) override final; + virtual Type* mutate( UnionInstType *aggregateUseType ) override final; + virtual Type* mutate( EnumInstType *aggregateUseType ) override final; + virtual Type* mutate( TraitInstType *aggregateUseType ) override final; + virtual Type* mutate( TypeInstType *aggregateUseType ) override final; + virtual Type* mutate( TupleType *tupleType ) override final; + virtual Type* mutate( TypeofType *typeofType ) override final; + virtual Type* mutate( AttrType *attrType ) override final; + virtual Type* mutate( VarArgsType *varArgsType ) override final; + virtual Type* mutate( ZeroType *zeroType ) override final; + virtual Type* mutate( OneType *oneType ) override final; + + virtual Initializer* mutate( SingleInit *singleInit ) override final; + virtual Initializer* mutate( ListInit *listInit ) override final; + virtual Initializer* mutate( ConstructorInit *ctorInit ) override final; + + virtual Subrange *mutate( Subrange *subrange ) override final; + + virtual Constant *mutate( Constant *constant ) override final; + +private: + template void call_previsit ( node_type * node ) { previsit_impl ( pass, node, 0 ); } + template void call_postvisit( node_type * node ) { postvisit_impl( pass, node, 0 ); } + + template void call_premutate ( node_type * node ) { premutate_impl( pass, node, 0 ); } + template return_type call_postmutate ( node_type * node ) { return postmutate_impl( pass, node, 0 ); } + + void call_beginScope() { begin_scope_impl( pass, 0 ); } + void call_endScope () { end_scope_impl ( pass, 0 ); } + + void set_env( TypeSubstitution * env ) { set_env_impl( pass, env, 0); } + + void visitStatementList( std::list< Statement* > &statements ); + void mutateStatementList( std::list< Statement* > &statements ); + + Statement * visitStatement( Statement * stmt ); + Statement * mutateStatement( Statement * stmt ); + + void visitExpression( Expression * expr ); + Expression * mutateExpression( Expression * expr ); + + + TypeSubstitution ** get_env_ptr () { return env_impl ( pass, 0); } + std::list< Statement* > * get_beforeStmts() { return stmtsToAddBefore_impl( pass, 0); } + std::list< Statement* > * get_afterStmts () { return stmtsToAddAfter_impl ( pass, 0); } +}; + +#include "PassVisitor.impl.h" Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ src/Common/PassVisitor.impl.h (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,1006 @@ +#pragma once + +#define MUTATE_START( node ) \ + call_premutate( node ); \ + + +#define MUTATE_END( type, node ) \ + return call_postmutate< type * >( node ); \ + + +#define VISIT_BODY( node ) \ + call_previsit( node ); \ + Visitor::visit( node ); \ + call_postvisit( node ); \ + + +#define MUTATE_BODY( type, node ) \ + MUTATE_START( node ); \ + Mutator::mutate( node ); \ + MUTATE_END( type, node ); \ + + + +template +static inline bool empty( T * ptr ) { + return !ptr || ptr->empty(); +} + +typedef std::list< Statement * > StmtList_t; + +template< typename pass_type > +void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) { + SemanticError errors; + + StmtList_t* beforeStmts = get_beforeStmts(); + StmtList_t* afterStmts = get_afterStmts(); + + for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) { + if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); } + try { + *i = (*i)->accept( *this ); + } catch ( SemanticError &e ) { + errors.append( e ); + } + if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); } + } + + if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); } + if ( !errors.isEmpty() ) { throw errors; } +} + +template< typename pass_type > +void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) { + SemanticError errors; + + StmtList_t* beforeStmts = get_beforeStmts(); + StmtList_t* afterStmts = get_afterStmts(); + + for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) { + if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); } + try { + *i = (*i)->acceptMutator( *this ); + } catch ( SemanticError &e ) { + errors.append( e ); + } + if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); } + } + + if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); } + if ( !errors.isEmpty() ) { throw errors; } +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) { + // don't want statements from outer CompoundStmts to be added to this CompoundStmt + ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); + ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() ); + ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); + + Statement *newStmt = maybeVisit( stmt, *this ); + + StmtList_t* beforeStmts = get_beforeStmts(); + StmtList_t* afterStmts = get_afterStmts(); + + if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; } + + CompoundStmt *compound = new CompoundStmt( noLabels ); + if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); } + compound->get_kids().push_back( newStmt ); + if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); } + return compound; +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) { + // don't want statements from outer CompoundStmts to be added to this CompoundStmt + ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); + ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() ); + ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); + + Statement *newStmt = maybeMutate( stmt, *this ); + + StmtList_t* beforeStmts = get_beforeStmts(); + StmtList_t* afterStmts = get_afterStmts(); + + if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; } + + CompoundStmt *compound = new CompoundStmt( noLabels ); + if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); } + compound->get_kids().push_back( newStmt ); + if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); } + return compound; +} + + + +template< typename pass_type > +void PassVisitor< pass_type >::visitExpression( Expression * expr ) { + if( !expr ) return; + + auto env_ptr = get_env_ptr(); + if ( env_ptr && expr->get_env() ) { + *env_ptr = expr->get_env(); + } + // xxx - should env be cloned (or moved) onto the result of the mutate? + expr->accept( *this ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) { + if( !expr ) return nullptr; + + auto env_ptr = get_env_ptr(); + if ( env_ptr && expr->get_env() ) { + *env_ptr = expr->get_env(); + } + // xxx - should env be cloned (or moved) onto the result of the mutate? + return expr->acceptMutator( *this ); +} + + +//------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ObjectDecl * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( FunctionDecl * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( StructDecl * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( UnionDecl * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( EnumDecl * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TraitDecl * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TypeDecl * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TypedefDecl * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( AsmDecl * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( CompoundStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) { + MUTATE_START( node ); + call_beginScope(); + + mutateStatementList( node->get_kids() ); + + call_endScope(); + MUTATE_END( CompoundStmt, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ExprStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) { + MUTATE_START( node ); + + node->set_expr( mutateExpression( node->get_expr() ) ); + + MUTATE_END( Statement, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( AsmStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( IfStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) { + MUTATE_START( node ); + + node->set_condition( mutateExpression( node->get_condition() ) ); + node->set_thenPart ( mutateStatement ( node->get_thenPart() ) ); + node->set_elsePart ( mutateStatement ( node->get_elsePart() ) ); + + MUTATE_END( Statement, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( WhileStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) { + MUTATE_START( node ); + + node->set_condition( mutateExpression( node->get_condition() ) ); + node->set_body( mutateStatement( node->get_body() ) ); + + MUTATE_END( Statement, node ); +} + + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ForStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) { + MUTATE_START( node ); + + mutateAll( node->get_initialization(), *this ); + node->set_condition( mutateExpression( node->get_condition() ) ); + node->set_increment( mutateExpression( node->get_increment() ) ); + node->set_body( mutateStatement( node->get_body() ) ); + + MUTATE_END( Statement, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( SwitchStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) { + MUTATE_START( node ); + + node->set_condition( mutateExpression( node->get_condition() ) ); + mutateStatementList( node->get_statements() ); + + MUTATE_END( Statement, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( CaseStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) { + MUTATE_START( node ); + + node->set_condition( mutateExpression( node->get_condition() ) ); + mutateStatementList( node->get_statements() ); + + MUTATE_END( Statement, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( BranchStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ReturnStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) { + MUTATE_START( node ); + + node->set_expr( mutateExpression( node->get_expr() ) ); + + MUTATE_END( Statement, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TryStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( TryStmt * node ) { + MUTATE_START( node ); + + node->set_block( maybeMutate( node->get_block(), *this ) ); + mutateAll( node->get_catchers(), *this ); + + MUTATE_END( Statement, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( CatchStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) { + MUTATE_START( node ); + + node->set_body( mutateStatement( node->get_body() ) ); + node->set_decl( maybeMutate( node->get_decl(), *this ) ); + + MUTATE_END( Statement, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( FinallyStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( NullStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( DeclStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ApplicationExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( UntypedExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) { + MUTATE_START( node ); + + for ( auto& expr : node->get_args() ) { + expr = mutateExpression( expr ); + } + + MUTATE_END( Expression, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( NameExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( CastExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( AddressExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( MemberExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( VariableExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ConstantExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( SizeofExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( AlignofExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( OffsetofExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( AttrExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( LogicalExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ConditionalExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( CommaExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TypeExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( AsmExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ConstructorExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( RangeExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TupleExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( MemberTupleExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( StmtExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) { + MUTATE_START( node ); + + // don't want statements from outer CompoundStmts to be added to this StmtExpr + ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); + ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() ); + ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); + + Mutator::mutate( node ); + + MUTATE_END( Expression, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( UniqueExpr * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( VoidType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( BasicType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( PointerType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ArrayType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( FunctionType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( StructInstType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( UnionInstType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( EnumInstType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TraitInstType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TypeInstType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TupleType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( TypeofType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( AttrType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( VarArgsType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ZeroType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( OneType * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( SingleInit * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) { + MUTATE_START( node ); + + node->set_value( mutateExpression( node->get_value() ) ); + + MUTATE_END( Initializer, node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ListInit * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( ConstructorInit * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( Subrange * node ) { + VISIT_BODY( node ); +} + +template< typename pass_type > +void PassVisitor< pass_type >::visit( Constant * node ) { + VISIT_BODY( node ); +} + +//--------------------------------------------------------------------------------------------------------------- + +template< typename pass_type > +DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) { + MUTATE_BODY( DeclarationWithType, node ); +} + +template< typename pass_type > +DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) { + MUTATE_BODY( DeclarationWithType, node ); +} + +template< typename pass_type > +Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) { + MUTATE_BODY( Declaration, node ); +} + +template< typename pass_type > +Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) { + MUTATE_BODY( Declaration, node ); +} + +template< typename pass_type > +Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) { + MUTATE_BODY( Declaration, node ); +} + +template< typename pass_type > +Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) { + MUTATE_BODY( Declaration, node ); +} + +template< typename pass_type > +TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) { + MUTATE_BODY( TypeDecl, node ); +} + +template< typename pass_type > +Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) { + MUTATE_BODY( Declaration, node ); +} + +template< typename pass_type > +AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) { + MUTATE_BODY( AsmDecl, node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) { + MUTATE_BODY( Statement, node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) { + MUTATE_BODY( Statement, node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) { + MUTATE_BODY( Statement, node ); +} + +template< typename pass_type > +NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) { + MUTATE_BODY( NullStmt, node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) { + MUTATE_BODY( Statement, node ); +} + +template< typename pass_type > +Statement * PassVisitor< pass_type >::mutate( ImplicitCtorDtorStmt * node ) { + MUTATE_BODY( Statement, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( MemberTupleExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) { + MUTATE_BODY( Expression, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( VoidType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( BasicType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( PointerType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( ArrayType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( FunctionType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( StructInstType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( TupleType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( TypeofType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( AttrType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( ZeroType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Type * PassVisitor< pass_type >::mutate( OneType * node ) { + MUTATE_BODY( Type, node ); +} + +template< typename pass_type > +Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) { + MUTATE_BODY( Initializer, node ); +} + +template< typename pass_type > +Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) { + MUTATE_BODY( Initializer, node ); +} + +template< typename pass_type > +Subrange * PassVisitor< pass_type >::mutate( Subrange * node ) { + MUTATE_BODY( Subrange, node ); +} + +template< typename pass_type > +Constant * PassVisitor< pass_type >::mutate( Constant * node ) { + MUTATE_BODY( Constant, node ); +} Index: src/Common/PassVisitor.proto.h =================================================================== --- src/Common/PassVisitor.proto.h (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ src/Common/PassVisitor.proto.h (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,82 @@ +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +// Deep magic (a.k.a template meta programming) to make the templated visitor work +// Basically the goal is to make 2 previsit_impl +// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of +// 'pass.previsit( node )' that compiles will be used for that node for that type +// This requires that this option only compile for passes that actually define an appropriate visit. +// SFINAE will make sure the compilation errors in this function don't halt the build. +// See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE +// 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing. +// This is needed only to eliminate the need for passes to specify any kind of handlers. +// The second implementation only works because it has a lower priority. This is due to the bogus last parameter. +// The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0 +// the first implementation takes priority in regards to overloading. +// Mutator functions work along the same principal +//------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +// Visit +template +static inline auto previsit_impl( pass_type& pass, node_type * node, __attribute__((unused)) int unused ) ->decltype( pass.previsit( node ), void() ) { + pass.previsit( node ); +} + +template +static inline void previsit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {} + + +template +static inline auto postvisit_impl( pass_type& pass, node_type * node, __attribute__((unused)) int unused ) ->decltype( pass.postvisit( node ), void() ) { + pass.postvisit( node ); +} + +template +static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {} + +// Mutate +template +static inline auto premutate_impl( pass_type& pass, node_type * node, __attribute__((unused)) int unused ) ->decltype( pass.premutate( node ), void() ) { + return pass.premutate( node ); +} + +template +static inline void premutate_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {} + + +template +static inline auto postmutate_impl( pass_type& pass, node_type * node, __attribute__((unused)) int unused ) ->decltype( pass.postmutate( node ) ) { + return pass.postmutate( node ); +} + +template +static inline return_type postmutate_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) { return node; } + +// Begin/End scope +template +static inline auto begin_scope_impl( pass_type& pass, __attribute__((unused)) int unused ) ->decltype( pass.beginScope(), void() ) { + pass.beginScope(); +} + +template +static inline void begin_scope_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) long unused ) {} + + +template +static inline auto end_scope_impl( pass_type& pass, __attribute__((unused)) int unused ) ->decltype( pass.endScope(), void() ) { + pass.endScope(); +} + +template +static inline void end_scope_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) long unused ) {} + +// Fields +#define FIELD_PTR( type, name ) \ +template \ +static inline auto name##_impl( pass_type& pass, __attribute__((unused)) int unused ) ->decltype( &pass.name ) { return &pass.name; } \ + \ +template \ +static inline type * name##_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) long unused ) { return nullptr;} \ + +FIELD_PTR( TypeSubstitution *, env ) +FIELD_PTR( std::list< Statement* >, stmtsToAddBefore ) +FIELD_PTR( std::list< Statement* >, stmtsToAddAfter ) Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/Common/utility.h (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -244,4 +244,24 @@ ValueGuard(T& inRef) : old(inRef), ref(inRef) {} ~ValueGuard() { ref = old; } +}; + +template< typename T > +struct ValueGuardPtr { + T old; + T* ref; + + ValueGuardPtr(T * inRef) : old( inRef ? *inRef : T() ), ref(inRef) {} + ~ValueGuardPtr() { if( ref ) *ref = old; } +}; + +template< typename T > +struct ValueGuardPtr< std::list< T > > { + std::list< T > old; + std::list< T >* ref; + + ValueGuardPtr( std::list< T > * inRef) : old(), ref(inRef) { + if( ref ) { swap( *ref, old ); } + } + ~ValueGuardPtr() { if( ref ) { swap( *ref, old ); } } }; @@ -334,4 +354,6 @@ {} + CodeLocation( const CodeLocation& rhs ) = default; + bool isSet () const { return -1 != linenumber; Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/InitTweak/FixInit.cc (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -20,23 +20,25 @@ #include #include + #include "InitTweak.h" #include "GenInit.h" #include "FixInit.h" #include "FixGlobalInit.h" +#include "CodeGen/GenType.h" // for warning/error messages +#include "Common/PassVisitor.h" +#include "GenPoly/DeclMutator.h" +#include "GenPoly/PolyMutator.h" #include "ResolvExpr/Resolver.h" #include "ResolvExpr/typeops.h" +#include "SymTab/Autogen.h" +#include "SymTab/Indexer.h" +#include "SynTree/AddStmtVisitor.h" +#include "SynTree/Attribute.h" #include "SynTree/Declaration.h" -#include "SynTree/Type.h" #include "SynTree/Expression.h" -#include "SynTree/Attribute.h" -#include "SynTree/Statement.h" #include "SynTree/Initializer.h" #include "SynTree/Mutator.h" -#include "SymTab/Indexer.h" -#include "SymTab/Autogen.h" -#include "GenPoly/PolyMutator.h" -#include "GenPoly/DeclMutator.h" -#include "SynTree/AddStmtVisitor.h" -#include "CodeGen/GenType.h" // for warning/error messages +#include "SynTree/Statement.h" +#include "SynTree/Type.h" #include "Tuples/Tuples.h" @@ -54,5 +56,5 @@ typedef std::unordered_map< int, int > UnqCount; - class InsertImplicitCalls final : public GenPoly::PolyMutator { + class InsertImplicitCalls { public: /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which @@ -61,11 +63,11 @@ InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {} - typedef GenPoly::PolyMutator Parent; - using Parent::mutate; - virtual Expression * mutate( ApplicationExpr * appExpr ) override; - virtual Expression * mutate( StmtExpr * stmtExpr ) override; + + Expression * postmutate( ApplicationExpr * appExpr ); + void premutate( StmtExpr * stmtExpr ); // collects environments for relevant nodes EnvMap & envMap; + TypeSubstitution * env; //Magically populated by the PassVisitor }; @@ -300,5 +302,5 @@ namespace { void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) { - InsertImplicitCalls inserter( envMap ); + PassVisitor inserter( envMap ); mutateAll( translationUnit, inserter ); } @@ -350,6 +352,5 @@ } - Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) { - appExpr = dynamic_cast< ApplicationExpr * >( Parent::mutate( appExpr ) ); + Expression * InsertImplicitCalls::postmutate( ApplicationExpr * appExpr ) { assert( appExpr ); @@ -393,8 +394,7 @@ } - Expression * InsertImplicitCalls::mutate( StmtExpr * stmtExpr ) { + void InsertImplicitCalls::premutate( StmtExpr * stmtExpr ) { assert( env ); envMap[stmtExpr] = env; - return Parent::mutate( stmtExpr ); } Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/Makefile.am (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -43,5 +43,5 @@ driver_cfa_cpp_SOURCES = ${SRC} driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap -driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 +driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/Makefile.in (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -447,5 +447,5 @@ driver_cfa_cpp_SOURCES = ${SRC} driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap -driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 +driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic all: $(BUILT_SOURCES) Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/Tuples/TupleExpansion.cc (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -18,16 +18,17 @@ #include #include "Tuples.h" +#include "Common/PassVisitor.h" +#include "Common/ScopedMap.h" #include "GenPoly/DeclMutator.h" +#include "InitTweak/GenInit.h" +#include "InitTweak/InitTweak.h" +#include "ResolvExpr/typeops.h" +#include "SymTab/Mangler.h" +#include "SynTree/Declaration.h" +#include "SynTree/Expression.h" +#include "SynTree/Initializer.h" #include "SynTree/Mutator.h" #include "SynTree/Statement.h" -#include "SynTree/Declaration.h" #include "SynTree/Type.h" -#include "SynTree/Expression.h" -#include "SynTree/Initializer.h" -#include "SymTab/Mangler.h" -#include "Common/ScopedMap.h" -#include "ResolvExpr/typeops.h" -#include "InitTweak/GenInit.h" -#include "InitTweak/InitTweak.h" namespace Tuples { @@ -82,10 +83,7 @@ }; - class TupleIndexExpander final : public Mutator { - public: - typedef Mutator Parent; - using Parent::mutate; - - virtual Expression * mutate( TupleIndexExpr * tupleExpr ) override; + class TupleIndexExpander { + public: + Expression * postmutate( TupleIndexExpr * tupleExpr ); }; @@ -116,5 +114,5 @@ replacer.mutateDeclarationList( translationUnit ); - TupleIndexExpander idxExpander; + PassVisitor idxExpander; mutateAll( translationUnit, idxExpander ); @@ -250,6 +248,6 @@ } - Expression * TupleIndexExpander::mutate( TupleIndexExpr * tupleExpr ) { - Expression * tuple = maybeMutate( tupleExpr->get_tuple(), *this ); + Expression * TupleIndexExpander::postmutate( TupleIndexExpr * tupleExpr ) { + Expression * tuple = tupleExpr->get_tuple(); assert( tuple ); tupleExpr->set_tuple( nullptr ); Index: src/benchmark/create_cfaCor.c =================================================================== --- src/benchmark/create_cfaCor.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ src/benchmark/create_cfaCor.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,18 @@ +#include +#include +#include + +coroutine MyCoroutine {}; +void main(MyCoroutine * this) {} + +int main(int argc, char* argv[]) { + size_t n = 1000000; + if( argc > 2 ) return 1; + if( argc == 2 ) { + n = atoi(argv[1]); + } + printf("%lu\n", n); + for (size_t i = 0; i < n; i++) { + MyCoroutine m; + } +} Index: src/benchmark/create_cfaThrd.c =================================================================== --- src/benchmark/create_cfaThrd.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ src/benchmark/create_cfaThrd.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,18 @@ +#include +#include +#include + +thread MyThread {}; +void main(MyThread * this) {} + +int main(int argc, char* argv[]) { + size_t n = 1000000; + if( argc > 2 ) return 1; + if( argc == 2 ) { + n = atoi(argv[1]); + } + printf("%lu\n", n); + for (size_t i = 0; i < n; i++) { + MyThread m; + } +} Index: src/benchmark/create_pthrd.c =================================================================== --- src/benchmark/create_pthrd.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ src/benchmark/create_pthrd.c (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,33 @@ +#include +#include +#include +#include + +static void *foo(void *arg) { + return arg; +} + +int main(int argc, char* argv[]) { + size_t n = 1000000; + if( argc > 2 ) return 1; + if( argc == 2 ) { + n = atoi(argv[1]); + } + printf("%lu\n", n); + + for (size_t i = 0; i < n; i++) { + pthread_attr_t attr; + if (pthread_attr_init(&attr) < 0) { + return 1; + } + if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) < 0) { + return 1; + } + pthread_t thread; + if (pthread_create(&thread, &attr, foo, NULL) < 0) { + return 1; + } + } + pthread_exit(NULL); + return 0; +} Index: src/benchmark/create_uCor.cpp =================================================================== --- src/benchmark/create_uCor.cpp (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ src/benchmark/create_uCor.cpp (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,19 @@ +#include +#include + +_Coroutine MyCor { + void main() {} +}; + +int main(int argc, char* argv[]) { + size_t n = 1000000; + if( argc > 2 ) return 1; + if( argc == 2 ) { + n = atoi(argv[1]); + } + printf("%lu\n", n); + for (size_t i = 0; i < n; i++) { + MyCor m; + } + return 0; +} Index: src/benchmark/create_uTask.cpp =================================================================== --- src/benchmark/create_uTask.cpp (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) +++ src/benchmark/create_uTask.cpp (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -0,0 +1,19 @@ +#include +#include + +_Task MyThread { + void main() {} +}; + +int main(int argc, char* argv[]) { + size_t n = 1000000; + if( argc > 2 ) return 1; + if( argc == 2 ) { + n = atoi(argv[1]); + } + printf("%lu\n", n); + for (size_t i = 0; i < n; i++) { + MyThread m; + } + return 0; +} Index: src/driver/Makefile.am =================================================================== --- src/driver/Makefile.am (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/driver/Makefile.am (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -16,5 +16,5 @@ # applies to both programs -AM_CXXFLAGS = -Wall -O2 +AM_CXXFLAGS = -Wall -O2 -g -std=c++14 if BUILD_NO_LIB else Index: src/driver/Makefile.in =================================================================== --- src/driver/Makefile.in (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/driver/Makefile.in (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -208,5 +208,5 @@ # applies to both programs -AM_CXXFLAGS = -Wall -O2 $(am__append_1) $(am__append_2) \ +AM_CXXFLAGS = -Wall -O2 -g -std=c++14 $(am__append_1) $(am__append_2) \ $(am__append_3) cfa_SOURCES = cfa.cc Index: src/libcfa/Makefile.am =================================================================== --- src/libcfa/Makefile.am (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/libcfa/Makefile.am (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -54,5 +54,5 @@ # not all platforms support concurrency, add option do disable it if BUILD_CONCURRENCY -libsrc += concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/invoke.c +libsrc += concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/signal.c endif Index: src/libcfa/Makefile.in =================================================================== --- src/libcfa/Makefile.in (revision b78275bd9abfd95986bd0bac2a0f1713c872ae87) +++ src/libcfa/Makefile.in (revision 28c9ff33e44e030e446621d6d989e778e9e40ddf) @@ -46,5 +46,5 @@ # not all platforms support concurrency, add option do disable it -@BUILD_CONCURRENCY_TRUE@am__append_4 = concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/invoke.c +@BUILD_CONCURRENCY_TRUE@am__append_4 = concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c concurrency/invoke.c concurrency/signal.c subdir = src/libcfa DIST_COMMON = $(am__nobase_cfa_include_HEADERS_DIST) \ @@ -103,5 +103,6 @@ concurrency/coroutine.c concurrency/thread.c \ concurrency/kernel.c concurrency/monitor.c \ - concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/invoke.c + concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \ + concurrency/invoke.c concurrency/signal.c am__dirstamp = $(am__leading_dot)dirstamp @BUILD_CONCURRENCY_TRUE@am__objects_1 = concurrency/libcfa_d_a-coroutine.$(OBJEXT) \ @@ -119,5 +120,7 @@ containers/libcfa_d_a-vector.$(OBJEXT) $(am__objects_1) @BUILD_CONCURRENCY_TRUE@am__objects_3 = concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT) \ -@BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_d_a-invoke.$(OBJEXT) +@BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_d_a-alarm.$(OBJEXT) \ +@BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_d_a-invoke.$(OBJEXT) \ +@BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_d_a-signal.$(OBJEXT) am__objects_4 = libcfa_d_a-libcfa-prelude.$(OBJEXT) \ libcfa_d_a-interpose.$(OBJEXT) \ @@ -134,5 +137,6 @@ concurrency/coroutine.c concurrency/thread.c \ concurrency/kernel.c concurrency/monitor.c \ - concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/invoke.c + concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \ + concurrency/invoke.c concurrency/signal.c @BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \ @BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-thread.$(OBJEXT) \ @@ -148,5 +152,7 @@ containers/libcfa_a-vector.$(OBJEXT) $(am__objects_5) @BUILD_CONCURRENCY_TRUE@am__objects_7 = concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT) \ -@BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-invoke.$(OBJEXT) +@BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-alarm.$(OBJEXT) \ +@BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-invoke.$(OBJEXT) \ +@BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-signal.$(OBJEXT) am__objects_8 = libcfa_a-libcfa-prelude.$(OBJEXT) \ libcfa_a-interpose.$(OBJEXT) \ @@ -435,5 +441,9 @@ concurrency/$(am__dirstamp) \ concurrency/$(DEPDIR)/$(am__dirstamp) +concurrency/libcfa_d_a-alarm.$(OBJEXT): concurrency/$(am__dirstamp) \ + concurrency/$(DEPDIR)/$(am__dirstamp) concurrency/libcfa_d_a-invoke.$(OBJEXT): concurrency/$(am__dirstamp) \ + concurrency/$(DEPDIR)/$(am__dirstamp) +concurrency/libcfa_d_a-signal.$(OBJEXT): concurrency/$(am__dirstamp) \ concurrency/$(DEPDIR)/$(am__dirstamp) libcfa-d.a: $(libcfa_d_a_OBJECTS) $(libcfa_d_a_DEPENDENCIES) $(EXTRA_libcfa_d_a_DEPENDENCIES) @@ -459,5 +469,9 @@ concurrency/libcfa_a-monitor.$(OBJEXT): concurrency/$(am__dirstamp) \ concurrency/$(DEPDIR)/$(am__dirstamp) +concurrency/libcfa_a-alarm.$(OBJEXT): concurrency/$(am__dirstamp) \ + concurrency/$(DEPDIR)/$(am__dirstamp) concurrency/libcfa_a-invoke.$(OBJEXT): concurrency/$(am__dirstamp) \ + concurrency/$(DEPDIR)/$(am__dirstamp) +concurrency/libcfa_a-signal.$(OBJEXT): concurrency/$(am__dirstamp) \ concurrency/$(DEPDIR)/$(am__dirstamp) libcfa.a: $(libcfa_a_OBJECTS) $(libcfa_a_DEPENDENCIES) $(EXTRA_libcfa_a_DEPENDENCIES) @@ -469,13 +483,17 @@ -rm -f *.$(OBJEXT) -rm -f concurrency/CtxSwitch-@MACHINE_TYPE@.$(OBJEXT) + -rm -f concurrency/libcfa_a-alarm.$(OBJEXT) -rm -f concurrency/libcfa_a-coroutine.$(OBJEXT) -rm -f concurrency/libcfa_a-invoke.$(OBJEXT) -rm -f concurrency/libcfa_a-kernel.$(OBJEXT) -rm -f concurrency/libcfa_a-monitor.$(OBJEXT) + -rm -f concurrency/libcfa_a-signal.$(OBJEXT) -rm -f concurrency/libcfa_a-thread.$(OBJEXT) + -rm -f concurrency/libcfa_d_a-alarm.$(OBJEXT) -rm -f concurrency/libcfa_d_a-coroutine.$(OBJEXT) -rm -f concurrency/libcfa_d_a-invoke.$(OBJEXT) -rm -f concurrency/libcfa_d_a-kernel.$(OBJEXT) -rm -f concurrency/libcfa_d_a-monitor.$(OBJEXT) + -rm -f concurrency/libcfa_d_a-signal.$(OBJEXT) -rm -f concurrency/libcfa_d_a-thread.$(OBJEXT) -rm -f containers/libcfa_a-maybe.$(OBJEXT) @@ -514,13 +532,17 @@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@MACHINE_TYPE@.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-alarm.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-coroutine.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-invoke.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-kernel.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-monitor.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-signal.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-thread.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-alarm.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-coroutine.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-invoke.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-kernel.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-monitor.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-signal.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_d_a-thread.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_a-maybe.Po@am__quote@ @@ -826,4 +848,18 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi` +concurrency/libcfa_d_a-alarm.o: concurrency/alarm.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-alarm.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo -c -o concurrency/libcfa_d_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo concurrency/$(DEPDIR)/libcfa_d_a-alarm.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='concurrency/alarm.c' object='concurrency/libcfa_d_a-alarm.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c + +concurrency/libcfa_d_a-alarm.obj: concurrency/alarm.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-alarm.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo -c -o concurrency/libcfa_d_a-alarm.obj `if test -f 'concurrency/alarm.c'; then $(CYGPATH_W) 'concurrency/alarm.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/alarm.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo concurrency/$(DEPDIR)/libcfa_d_a-alarm.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='concurrency/alarm.c' object='concurrency/libcfa_d_a-alarm.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-alarm.obj `if test -f 'concurrency/alarm.c'; then $(CYGPATH_W) 'concurrency/alarm.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/alarm.c'; fi` + concurrency/libcfa_d_a-invoke.obj: concurrency/invoke.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-invoke.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-invoke.Tpo -c -o concurrency/libcfa_d_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi` @@ -833,4 +869,18 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi` +concurrency/libcfa_d_a-signal.o: concurrency/signal.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-signal.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo -c -o concurrency/libcfa_d_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_d_a-signal.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_d_a-signal.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c + +concurrency/libcfa_d_a-signal.obj: concurrency/signal.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-signal.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo -c -o concurrency/libcfa_d_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_d_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_d_a-signal.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_d_a-signal.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi` + libcfa_a-libcfa-prelude.obj: libcfa-prelude.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-libcfa-prelude.obj -MD -MP -MF $(DEPDIR)/libcfa_a-libcfa-prelude.Tpo -c -o libcfa_a-libcfa-prelude.obj `if test -f 'libcfa-prelude.c'; then $(CYGPATH_W) 'libcfa-prelude.c'; else $(CYGPATH_W) '$(srcdir)/libcfa-prelude.c'; fi` @@ -1092,4 +1142,18 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi` +concurrency/libcfa_a-alarm.o: concurrency/alarm.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-alarm.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-alarm.Tpo -c -o concurrency/libcfa_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-alarm.Tpo concurrency/$(DEPDIR)/libcfa_a-alarm.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='concurrency/alarm.c' object='concurrency/libcfa_a-alarm.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c + +concurrency/libcfa_a-alarm.obj: concurrency/alarm.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-alarm.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-alarm.Tpo -c -o concurrency/libcfa_a-alarm.obj `if test -f 'concurrency/alarm.c'; then $(CYGPATH_W) 'concurrency/alarm.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/alarm.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-alarm.Tpo concurrency/$(DEPDIR)/libcfa_a-alarm.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='concurrency/alarm.c' object='concurrency/libcfa_a-alarm.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-alarm.obj `if test -f 'concurrency/alarm.c'; then $(CYGPATH_W) 'concurrency/alarm.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/alarm.c'; fi` + concurrency/libcfa_a-invoke.obj: concurrency/invoke.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-invoke.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-invoke.Tpo -c -o concurrency/libcfa_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi` @@ -1098,4 +1162,18 @@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi` + +concurrency/libcfa_a-signal.o: concurrency/signal.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-signal.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-signal.Tpo -c -o concurrency/libcfa_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_a-signal.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_a-signal.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-signal.o `test -f 'concurrency/signal.c' || echo '$(srcdir)/'`concurrency/signal.c + +concurrency/libcfa_a-signal.obj: concurrency/signal.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_a-signal.obj -MD -MP -MF concurrency/$(DEPDIR)/libcfa_a-signal.Tpo -c -o concurrency/libcfa_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) concurrency/$(DEPDIR)/libcfa_a-signal.Tpo concurrency/$(DEPDIR)/libcfa_a-signal.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='concurrency/signal.c' object='concurrency/libcfa_a-signal.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-signal.obj `if test -f 'concurrency/signal.c'; then $(CYGPATH_W) 'concurrency/signal.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/signal.c'; fi` install-nobase_cfa_includeHEADERS: $(nobase_cfa_include_HEADERS) @$(NORMAL_INSTALL)