Changeset 0fe4e62 for src

src/Common/Debug.h

-              rf5c3b6c
+              r0fe4e62
 #include "SynTree/Declaration.h"
+/// debug codegen a translation unit
+static inline void debugCodeGen( const std::list< Declaration * > & translationUnit, const std::string & label ) {
+        std::list< Declaration * > decls;
+#define DEBUG
+        filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), []( Declaration * decl ) {
+                return ! LinkageSpec::isBuiltin( decl->get_linkage() );
+        });
+namespace Debug {
+        /// debug codegen a translation unit
+        static inline void codeGen( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label ) {
+        #ifdef DEBUG
+                std::list< Declaration * > decls;
+        std::cerr << "======" << label << "======" << std::endl;
+        CodeGen::generate( decls, std::cerr, false, true );
+} // dump
+                filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), []( Declaration * decl ) {
+                        return ! LinkageSpec::isBuiltin( decl->get_linkage() );
+                });
+                std::cerr << "======" << label << "======" << std::endl;
+                CodeGen::generate( decls, std::cerr, false, true );
+        #endif
+        } // dump
+        static inline void treeDump( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label ) {
+        #ifdef DEBUG
+                std::list< Declaration * > decls;
+                filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), []( Declaration * decl ) {
+                        return ! LinkageSpec::isBuiltin( decl->get_linkage() );
+                });
+                std::cerr << "======" << label << "======" << std::endl;
+                printAll( decls, std::cerr );
+        #endif
+        } // dump
+}
 // Local Variables: //

src/Concurrency/Keywords.cc

rf5c3b6c	r0fe4e62
553	553	),
554	554	new ListInit(
555		map_range < std::list<Initializer> > ( args, [~~this~~](DeclarationWithType var ){
	555	map_range < std::list<Initializer> > ( args, [](DeclarationWithType var ){
556	556	Type * type = var->get_type()->clone();
557	557	type->set_mutex( false );

src/InitTweak/GenInit.cc

rf5c3b6c	r0fe4e62
214	214	}
215	215	// a type is managed if it appears in the map of known managed types, or if it contains any polymorphism (is a type variable or generic type containing a type variable)
216		return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end() \|\| GenPoly::isPolyType( type );
	216	return managedTypes.find( SymTab::Mangler::mangleConcrete( type ) ) != managedTypes.end() \|\| GenPoly::isPolyType( type );
217	217	}
218	218
…	…
232	232	Type * type = InitTweak::getPointerBase( params.front()->get_type() );
233	233	assert( type );
234		managedTypes.insert( SymTab::Mangler::mangle( type ) );
	234	managedTypes.insert( SymTab::Mangler::mangleConcrete( type ) );
235	235	}
236	236	}
…	…
242	242	if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
243	243	if ( isManaged( field ) ) {
	244	// generic parameters should not play a role in determining whether a generic type is constructed - construct all generic types, so that
	245	// polymorphic constructors make generic types managed types
244	246	StructInstType inst( Type::Qualifiers(), aggregateDecl );
245		managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
	247	managedTypes.insert( SymTab::Mangler::mangleConcrete( &inst ) );
246	248	break;
247	249	}

src/InitTweak/InitTweak.cc

-              rf5c3b6c
+              r0fe4e62
         class InitExpander::ExpanderImpl {
         public:
+                virtual ~ExpanderImpl() = default;
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0;
                 virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices ) = 0;
 …
         public:
                 InitImpl( Initializer * init ) : init( init ) {}
+                virtual ~InitImpl() = default;
                 virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
 …
         public:
                 ExprImpl( Expression * expr ) : arg( expr ) {}
+                ~ExprImpl() { delete arg; }
+                virtual ~ExprImpl() { delete arg; }
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) {

src/ResolvExpr/AlternativeFinder.cc

-              rf5c3b6c
+              r0fe4e62
 #include <memory>                  // for allocator_traits<>::value_type
 #include <utility>                 // for pair
+#include <vector>                  // for vector
 #include "Alternative.h"           // for AltList, Alternative
 …
                 tmpCost.incPoly( -tmpCost.get_polyCost() );
                 if ( tmpCost != Cost::zero ) {
-                // if ( convCost != Cost::zero ) {
                         Type *newType = formalType->clone();
                         env.apply( newType );
 …
 ///     needAssertions.insert( needAssertions.end(), (*tyvar)->get_assertions().begin(), (*tyvar)->get_assertions().end() );
+                }
+        }
-        /// instantiate a single argument by matching actuals from [actualIt, actualEnd) against formalType,
-        /// producing expression(s) in out and their total cost in cost.
-        template< typename AltIterator, typename OutputIterator >
-        bool instantiateArgument( Type * formalType, Initializer * defaultValue, AltIterator & actualIt, AltIterator actualEnd, OpenVarSet & openVars, TypeEnvironment & resultEnv, AssertionSet & resultNeed, AssertionSet & resultHave, const SymTab::Indexer & indexer, Cost & cost, OutputIterator out ) {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
-                        // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
-                        std::list< Expression * > exprs;
-                        for ( Type * type : *tupleType ) {
-                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( exprs ) ) ) {
-                                        deleteAll( exprs );
-                                        return false;
+                                }
+                        }
-                        *out++ = new TupleExpr( exprs );
-                } else if ( TypeInstType * ttype = Tuples::isTtype( formalType ) ) {
-                        // xxx - mixing default arguments with variadic??
-                        std::list< Expression * > exprs;
-                        for ( ; actualIt != actualEnd; ++actualIt ) {
-                                exprs.push_back( actualIt->expr->clone() );
-                                cost += actualIt->cost;
+                        }
-                        Expression * arg = nullptr;
-                        if ( exprs.size() == 1 && Tuples::isTtype( exprs.front()->get_result() ) ) {
-                                // the case where a ttype value is passed directly is special, e.g. for argument forwarding purposes
-                                // xxx - what if passing multiple arguments, last of which is ttype?
-                                // xxx - what would happen if unify was changed so that unifying tuple types flattened both before unifying lists? then pass in TupleType(ttype) below.
-                                arg = exprs.front();
-                        } else {
-                                arg = new TupleExpr( exprs );
+                        }
-                        assert( arg && arg->get_result() );
-                        if ( ! unify( ttype, arg->get_result(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                return false;
+                        }
-                        *out++ = arg;
-                } else if ( actualIt != actualEnd ) {
-                        // both actualType and formalType are atomic (non-tuple) types - if they unify
-                        // then accept actual as an argument, otherwise return false (fail to instantiate argument)
-                        Expression * actual = actualIt->expr;
-                        Type * actualType = actual->get_result();
-                        PRINT(
-                                std::cerr << "formal type is ";
-                                formalType->print( std::cerr );
-                                std::cerr << std::endl << "actual type is ";
-                                actualType->print( std::cerr );
-                                std::cerr << std::endl;
+                        )
-                        if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                // std::cerr << "unify failed" << std::endl;
-                                return false;
+                        }
-                        // move the expression from the alternative to the output iterator
-                        *out++ = actual;
-                        actualIt->expr = nullptr;
-                        cost += actualIt->cost;
-                        ++actualIt;
-                } else {
-                        // End of actuals - Handle default values
-                        if ( SingleInit *si = dynamic_cast<SingleInit *>( defaultValue )) {
-                                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( si->get_value() ) ) {
-                                        // so far, only constant expressions are accepted as default values
-                                        if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( castExpr->get_arg() ) ) {
-                                                if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) ) {
-                                                        if ( unify( formalType, cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                                                *out++ = cnstexpr->clone();
-                                                                return true;
-                                                        } // if
-                                                } // if
-                                        } // if
+                                }
-                        } // if
-                        return false;
-                } // if
-                return true;
+        }
-        bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out ) {
-                simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
-                // make sure we don't widen any existing bindings
-                for ( TypeEnvironment::iterator i = resultEnv.begin(); i != resultEnv.end(); ++i ) {
-                        i->allowWidening = false;
+                }
-                resultEnv.extractOpenVars( openVars );
-                // flatten actuals so that each actual has an atomic (non-tuple) type
-                AltList exploded;
-                Tuples::explode( actuals, indexer, back_inserter( exploded ) );
-                AltList::iterator actualExpr = exploded.begin();
-                AltList::iterator actualEnd = exploded.end();
-                for ( DeclarationWithType * formal : formals ) {
-                        // match flattened actuals with formal parameters - actuals will be grouped to match
-                        // with formals as appropriate
-                        Cost cost = Cost::zero;
-                        std::list< Expression * > newExprs;
-                        ObjectDecl * obj = strict_dynamic_cast< ObjectDecl * >( formal );
-                        if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) {
-                                deleteAll( newExprs );
-                                return false;
+                        }
-                        // success - produce argument as a new alternative
-                        assert( newExprs.size() == 1 );
-                        out.push_back( Alternative( newExprs.front(), resultEnv, cost ) );
+                }
-                if ( actualExpr != actualEnd ) {
-                        // there are still actuals remaining, but we've run out of formal parameters to match against
-                        // this is okay only if the function is variadic
-                        if ( ! isVarArgs ) {
-                                return false;
+                        }
-                        out.splice( out.end(), exploded, actualExpr, actualEnd );
+                }
-                return true;
+        }
 …
+        }
+        template< typename OutputIterator >
+        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out ) {
+                OpenVarSet openVars;
+                AssertionSet resultNeed, resultHave;
+                TypeEnvironment resultEnv( func.env );
+                makeUnifiableVars( funcType, openVars, resultNeed );
+                resultEnv.add( funcType->get_forall() ); // add all type variables as open variables now so that those not used in the parameter list are still considered open
+                AltList instantiatedActuals; // filled by instantiate function
+        /// Gets a default value from an initializer, nullptr if not present
+        ConstantExpr* getDefaultValue( Initializer* init ) {
+                if ( SingleInit* si = dynamic_cast<SingleInit*>( init ) ) {
+                        if ( CastExpr* ce = dynamic_cast<CastExpr*>( si->get_value() ) ) {
+                                return dynamic_cast<ConstantExpr*>( ce->get_arg() );
+                        }
+                }
+                return nullptr;
+        }
+        /// State to iteratively build a match of parameter expressions to arguments
+        struct ArgPack {
+                AltList actuals;                 ///< Arguments included in this pack
+                TypeEnvironment env;             ///< Environment for this pack
+                AssertionSet need;               ///< Assertions outstanding for this pack
+                AssertionSet have;               ///< Assertions found for this pack
+                OpenVarSet openVars;             ///< Open variables for this pack
+                unsigned nextArg;                ///< Index of next argument in arguments list
+                std::vector<Alternative> expls;  ///< Exploded actuals left over from last match
+                unsigned nextExpl;               ///< Index of next exploded alternative to use
+                std::vector<unsigned> tupleEls;  /// Number of elements in current tuple element(s)
+                ArgPack(const TypeEnvironment& env, const AssertionSet& need, const AssertionSet& have,
+                                const OpenVarSet& openVars)
+                        : actuals(), env(env), need(need), have(have), openVars(openVars), nextArg(0),
+                          expls(), nextExpl(0), tupleEls() {}
+                /// Starts a new tuple expression
+                void beginTuple() {
+                        if ( ! tupleEls.empty() ) ++tupleEls.back();
+                        tupleEls.push_back(0);
+                }
+                /// Ends a tuple expression, consolidating the appropriate actuals
+                void endTuple() {
+                        // set up new Tuple alternative
+                        std::list<Expression*> exprs;
+                        Cost cost = Cost::zero;
+                        // transfer elements into alternative
+                        for (unsigned i = 0; i < tupleEls.back(); ++i) {
+                                exprs.push_front( actuals.back().expr );
+                                actuals.back().expr = nullptr;
+                                cost += actuals.back().cost;
+                                actuals.pop_back();
+                        }
+                        tupleEls.pop_back();
+                        // build new alternative
+                        actuals.emplace_back( new TupleExpr( exprs ), this->env, cost );
+                }
+                /// Clones and adds an actual, returns this
+                ArgPack& withArg( Expression* expr, Cost cost = Cost::zero ) {
+                        actuals.emplace_back( expr->clone(), this->env, cost );
+                        if ( ! tupleEls.empty() ) ++tupleEls.back();
+                        return *this;
+                }
+        };
+        /// Instantiates an argument to match a formal, returns false if no results left
+        bool instantiateArgument( Type* formalType, Initializer* initializer,
+                        const std::vector< AlternativeFinder >& args,
+                        std::vector<ArgPack>& results, std::vector<ArgPack>& nextResults,
+                        const SymTab::Indexer& indexer ) {
+                if ( TupleType* tupleType = dynamic_cast<TupleType*>( formalType ) ) {
+                        // formalType is a TupleType - group actuals into a TupleExpr
+                        for ( ArgPack& result : results ) { result.beginTuple(); }
+                        for ( Type* type : *tupleType ) {
+                                // xxx - dropping initializer changes behaviour from previous, but seems correct
+                                if ( ! instantiateArgument( type, nullptr, args, results, nextResults, indexer ) )
+                                        return false;
+                        }
+                        for ( ArgPack& result : results ) { result.endTuple(); }
+                        return true;
+                } else if ( TypeInstType* ttype = Tuples::isTtype( formalType ) ) {
+                        // formalType is a ttype, consumes all remaining arguments
+                        // xxx - mixing default arguments with variadic??
+                        std::vector<ArgPack> finalResults{};  /// list of completed tuples
+                        // start tuples
+                        for ( ArgPack& result : results ) {
+                                result.beginTuple();
+                                // use rest of exploded tuple if present
+                                while ( result.nextExpl < result.expls.size() ) {
+                                        const Alternative& actual = result.expls[result.nextExpl];
+                                        result.env.addActual( actual.env, result.openVars );
+                                        result.withArg( actual.expr );
+                                        ++result.nextExpl;
+                                }
+                        }
+                        // iterate until all results completed
+                        while ( ! results.empty() ) {
+                                // add another argument to results
+                                for ( ArgPack& result : results ) {
+                                        // finish result when out of arguments
+                                        if ( result.nextArg >= args.size() ) {
+                                                Type* argType = result.actuals.back().expr->get_result();
+                                                if ( result.tupleEls.back() == 1 && Tuples::isTtype( argType ) ) {
+                                                        // the case where a ttype value is passed directly is special, e.g. for
+                                                        // argument forwarding purposes
+                                                        // xxx - what if passing multiple arguments, last of which is ttype?
+                                                        // xxx - what would happen if unify was changed so that unifying tuple
+                                                        // types flattened both before unifying lists? then pass in TupleType
+                                                        // (ttype) below.
+                                                        result.tupleEls.pop_back();
+                                                } else {
+                                                        // collapse leftover arguments into tuple
+                                                        result.endTuple();
+                                                        argType = result.actuals.back().expr->get_result();
+                                                }
+                                                // check unification for ttype before adding to final
+                                                if ( unify( ttype, argType, result.env, result.need, result.have,
+                                                                result.openVars, indexer ) ) {
+                                                        finalResults.push_back( std::move(result) );
+                                                }
+                                                continue;
+                                        }
+                                        // add each possible next argument
+                                        for ( const Alternative& actual : args[result.nextArg] ) {
+                                                ArgPack aResult = result;  // copy to clone everything
+                                                // add details of actual to result
+                                                aResult.env.addActual( actual.env, aResult.openVars );
+                                                Cost cost = actual.cost;
+                                                // explode argument
+                                                std::vector<Alternative> exploded;
+                                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
+                                                // add exploded argument to tuple
+                                                for ( Alternative& aActual : exploded ) {
+                                                        aResult.withArg( aActual.expr, cost );
+                                                        cost = Cost::zero;
+                                                }
+                                                ++aResult.nextArg;
+                                                nextResults.push_back( std::move(aResult) );
+                                        }
+                                }
+                                // reset for next round
+                                results.swap( nextResults );
+                                nextResults.clear();
+                        }
+                        results.swap( finalResults );
+                        return ! results.empty();
+                }
+                // iterate each current subresult
+                for ( unsigned iResult = 0; iResult < results.size(); ++iResult ) {
+                        ArgPack& result = results[iResult];
+                        if ( result.nextExpl < result.expls.size() ) {
+                                // use remainder of exploded tuple if present
+                                const Alternative& actual = result.expls[result.nextExpl];
+                                result.env.addActual( actual.env, result.openVars );
+                                Type* actualType = actual.expr->get_result();
+                                PRINT(
+                                        std::cerr << "formal type is ";
+                                        formalType->print( std::cerr );
+                                        std::cerr << std::endl << "actual type is ";
+                                        actualType->print( std::cerr );
+                                        std::cerr << std::endl;
+                                )
+                                if ( unify( formalType, actualType, result.env, result.need, result.have,
+                                                result.openVars, indexer ) ) {
+                                        ++result.nextExpl;
+                                        nextResults.push_back( std::move(result.withArg( actual.expr )) );
+                                }
+                                continue;
+                        } else if ( result.nextArg >= args.size() ) {
+                                // use default initializers if out of arguments
+                                if ( ConstantExpr* cnstExpr = getDefaultValue( initializer ) ) {
+                                        if ( Constant* cnst = dynamic_cast<Constant*>( cnstExpr->get_constant() ) ) {
+                                                if ( unify( formalType, cnst->get_type(), result.env, result.need,
+                                                                result.have, result.openVars, indexer ) ) {
+                                                        nextResults.push_back( std::move(result.withArg( cnstExpr )) );
+                                                }
+                                        }
+                                }
+                                continue;
+                        }
+                        // Check each possible next argument
+                        for ( const Alternative& actual : args[result.nextArg] ) {
+                                ArgPack aResult = result;  // copy to clone everything
+                                // add details of actual to result
+                                aResult.env.addActual( actual.env, aResult.openVars );
+                                // explode argument
+                                std::vector<Alternative> exploded;
+                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
+                                if ( exploded.empty() ) {
+                                        // skip empty tuple arguments
+                                        ++aResult.nextArg;
+                                        results.push_back( std::move(aResult) );
+                                        continue;
+                                }
+                                // consider only first exploded actual
+                                const Alternative& aActual = exploded.front();
+                                Type* actualType = aActual.expr->get_result()->clone();
+                                PRINT(
+                                        std::cerr << "formal type is ";
+                                        formalType->print( std::cerr );
+                                        std::cerr << std::endl << "actual type is ";
+                                        actualType->print( std::cerr );
+                                        std::cerr << std::endl;
+                                )
+                                // attempt to unify types
+                                if ( unify( formalType, actualType, aResult.env, aResult.need, aResult.have, aResult.openVars, indexer ) ) {
+                                        // add argument
+                                        aResult.withArg( aActual.expr, actual.cost );
+                                        ++aResult.nextArg;
+                                        if ( exploded.size() > 1 ) {
+                                                // other parts of tuple left over
+                                                aResult.expls = std::move( exploded );
+                                                aResult.nextExpl = 1;
+                                        }
+                                        nextResults.push_back( std::move(aResult) );
+                                }
+                        }
+                }
+                // reset for next parameter
+                results.swap( nextResults );
+                nextResults.clear();
+                return ! results.empty();
+        }
+        template<typename OutputIterator>
+        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func,
+                        FunctionType *funcType, const std::vector< AlternativeFinder > &args,
+                        OutputIterator out ) {
+                OpenVarSet funcOpenVars;
+                AssertionSet funcNeed, funcHave;
+                TypeEnvironment funcEnv( func.env );
+                makeUnifiableVars( funcType, funcOpenVars, funcNeed );
+                // add all type variables as open variables now so that those not used in the parameter
+                // list are still considered open.
+                funcEnv.add( funcType->get_forall() );
                 if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) {
                         // attempt to narrow based on expected target type
                         Type * returnType = funcType->get_returnVals().front()->get_type();
+                        if ( ! unify( returnType, targetType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                // unification failed, don't pursue this alternative
+                        if ( ! unify( returnType, targetType, funcEnv, funcNeed, funcHave, funcOpenVars,
+                                        indexer ) ) {
+                                // unification failed, don't pursue this function alternative
                                 return;
+                        }
+                }
+                if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave, instantiatedActuals ) ) {
+                // iteratively build matches, one parameter at a time
+                std::vector<ArgPack> results{ ArgPack{ funcEnv, funcNeed, funcHave, funcOpenVars } };
+                std::vector<ArgPack> nextResults{};
+                for ( DeclarationWithType* formal : funcType->get_parameters() ) {
+                        ObjectDecl* obj = strict_dynamic_cast< ObjectDecl* >( formal );
+                        if ( ! instantiateArgument(
+                                        obj->get_type(), obj->get_init(), args, results, nextResults, indexer ) )
+                                return;
+                }
+                // filter out results that don't use all the arguments, and aren't variadic
+                std::vector<ArgPack> finalResults{};
+                if ( funcType->get_isVarArgs() ) {
+                        for ( ArgPack& result : results ) {
+                                // use rest of exploded tuple if present
+                                while ( result.nextExpl < result.expls.size() ) {
+                                        const Alternative& actual = result.expls[result.nextExpl];
+                                        result.env.addActual( actual.env, result.openVars );
+                                        result.withArg( actual.expr );
+                                        ++result.nextExpl;
+                                }
+                        }
+                        while ( ! results.empty() ) {
+                                // build combinations for all remaining arguments
+                                for ( ArgPack& result : results ) {
+                                        // keep if used all arguments
+                                        if ( result.nextArg >= args.size() ) {
+                                                finalResults.push_back( std::move(result) );
+                                                continue;
+                                        }
+                                        // add each possible next argument
+                                        for ( const Alternative& actual : args[result.nextArg] ) {
+                                                ArgPack aResult = result; // copy to clone everything
+                                                // add details of actual to result
+                                                aResult.env.addActual( actual.env, aResult.openVars );
+                                                Cost cost = actual.cost;
+                                                // explode argument
+                                                std::vector<Alternative> exploded;
+                                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
+                                                // add exploded argument to arg list
+                                                for ( Alternative& aActual : exploded ) {
+                                                        aResult.withArg( aActual.expr, cost );
+                                                        cost = Cost::zero;
+                                                }
+                                                ++aResult.nextArg;
+                                                nextResults.push_back( std::move(aResult) );
+                                        }
+                                }
+                                // reset for next round
+                                results.swap( nextResults );
+                                nextResults.clear();
+                        }
+                } else {
+                        // filter out results that don't use all the arguments
+                        for ( ArgPack& result : results ) {
+                                if ( result.nextExpl >= result.expls.size() && result.nextArg >= args.size() ) {
+                                        finalResults.push_back( std::move(result) );
+                                }
+                        }
+                }
+                // validate matching combos, add to final result list
+                for ( ArgPack& result : finalResults ) {
                         ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
                         Alternative newAlt( appExpr, resultEnv, sumCost( instantiatedActuals ) );
                         makeExprList( instantiatedActuals, appExpr->get_args() );
+                        Alternative newAlt( appExpr, result.env, sumCost( result.actuals ) );
+                        makeExprList( result.actuals, appExpr->get_args() );
                         PRINT(
                                 std::cerr << "instantiate function success: " << appExpr << std::endl;
                                 std::cerr << "need assertions:" << std::endl;
                                 printAssertionSet( resultNeed, std::cerr, 8 );
+                                printAssertionSet( result.need, std::cerr, 8 );
+                        )
                         inferParameters( resultNeed, resultHave, newAlt, openVars, out );
+                        inferParameters( result.need, result.have, newAlt, result.openVars, out );
+                }
+        }
 …
                 if ( funcFinder.alternatives.empty() ) return;
+                std::list< AlternativeFinder > argAlternatives;
+                findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), back_inserter( argAlternatives ) );
+                std::list< AltList > possibilities;
+                combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
+                std::vector< AlternativeFinder > argAlternatives;
+                findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(),
+                        back_inserter( argAlternatives ) );
                 // take care of possible tuple assignments
                 // if not tuple assignment, assignment is taken care of as a normal function call
                 Tuples::handleTupleAssignment( *this, untypedExpr, possibilities );
+                Tuples::handleTupleAssignment( *this, untypedExpr, argAlternatives );
                 // find function operators
 …
                                                 Alternative newFunc( *func );
                                                 referenceToRvalueConversion( newFunc.expr );
+                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                        // XXX
+                                                        //Designators::check_alternative( function, *actualAlt );
+                                                        makeFunctionAlternatives( newFunc, function, *actualAlt, std::back_inserter( candidates ) );
+                                                }
+                                                makeFunctionAlternatives( newFunc, function, argAlternatives,
+                                                        std::back_inserter( candidates ) );
+                                        }
                                 } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->get_result()->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
 …
                                                         Alternative newFunc( *func );
                                                         referenceToRvalueConversion( newFunc.expr );
+                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                makeFunctionAlternatives( newFunc, function, *actualAlt, std::back_inserter( candidates ) );
+                                                        } // for
+                                                        makeFunctionAlternatives( newFunc, function, argAlternatives,
+                                                                std::back_inserter( candidates ) );
                                                 } // if
                                         } // if
+                                }
+                                // try each function operator ?() with the current function alternative and each of the argument combinations
+                                for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
+                                        // check if the type is pointer to function
+                                        if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) {
+                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                        } catch ( SemanticError &e ) {
+                                errors.append( e );
+                        }
+                } // for
+                // try each function operator ?() with each function alternative
+                if ( ! funcOpFinder.alternatives.empty() ) {
+                        // add function alternatives to front of argument list
+                        argAlternatives.insert( argAlternatives.begin(), std::move(funcFinder) );
+                        for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin();
+                                        funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
+                                try {
+                                        // check if type is a pointer to function
+                                        if ( PointerType* pointer = dynamic_cast<PointerType*>(
+                                                        funcOp->expr->get_result()->stripReferences() ) ) {
+                                                if ( FunctionType* function =
+                                                                dynamic_cast<FunctionType*>( pointer->get_base() ) ) {
                                                         Alternative newFunc( *funcOp );
                                                         referenceToRvalueConversion( newFunc.expr );
+                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                AltList currentAlt;
+                                                                currentAlt.push_back( *func );
+                                                                currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
+                                                                makeFunctionAlternatives( newFunc, function, currentAlt, std::back_inserter( candidates ) );
+                                                        } // for
+                                                } // if
+                                        } // if
+                                } // for
+                        } catch ( SemanticError &e ) {
+                                errors.append( e );
+                        }
+                } // for
+                                                        makeFunctionAlternatives( newFunc, function, argAlternatives,
+                                                                std::back_inserter( candidates ) );
+                                                }
+                                        }
+                                } catch ( SemanticError &e ) {
+                                        errors.append( e );
+                                }
+                        }
+                }
                 // Implement SFINAE; resolution errors are only errors if there aren't any non-erroneous resolutions
 …
                 candidates.splice( candidates.end(), alternatives );
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( alternatives ) );
+                // use a new list so that alternatives are not examined by addAnonConversions twice.
+                AltList winners;
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( winners ) );
                 // function may return struct or union value, in which case we need to add alternatives for implicit
                 // conversions to each of the anonymous members, must happen after findMinCost since anon conversions
                 // are never the cheapest expression
                 for ( const Alternative & alt : alternatives ) {
+                for ( const Alternative & alt : winners ) {
                         addAnonConversions( alt );
+                }
+                alternatives.splice( alternatives.begin(), winners );
                 if ( alternatives.empty() && targetType && ! targetType->isVoid() ) {

src/ResolvExpr/AlternativeFinder.h

-              rf5c3b6c
+              r0fe4e62
           public:
                 AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
+                AlternativeFinder( const AlternativeFinder& o )
+                        : indexer(o.indexer), alternatives(o.alternatives), env(o.env),
+                          targetType(o.targetType) {}
+                AlternativeFinder( AlternativeFinder&& o )
+                        : indexer(o.indexer), alternatives(std::move(o.alternatives)), env(o.env),
+                          targetType(o.targetType) {}
+                AlternativeFinder& operator= ( const AlternativeFinder& o ) {
+                        if (&o == this) return *this;
+                        // horrific nasty hack to rebind references...
+                        alternatives.~AltList();
+                        new(this) AlternativeFinder(o);
+                        return *this;
+                }
+                AlternativeFinder& operator= ( AlternativeFinder&& o ) {
+                        if (&o == this) return *this;
+                        // horrific nasty hack to rebind references...
+                        alternatives.~AltList();
+                        new(this) AlternativeFinder(std::move(o));
+                        return *this;
+                }
                 void find( Expression *expr, bool adjust = false, bool prune = true, bool failFast = true );
                 /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types
 …
                 /// Adds alternatives for offsetof expressions, given the base type and name of the member
                 template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
+                bool instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out );
+                template< typename OutputIterator >
+                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out );
+                template<typename OutputIterator>
+                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const std::vector< AlternativeFinder >& args, OutputIterator out );
                 template< typename OutputIterator >
                 void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );

src/ResolvExpr/CurrentObject.cc

rf5c3b6c	r0fe4e62
260	260
261	261	AggregateIterator( const std::string & kind, const std::string & name, Type * inst, const MemberList & members ) : kind( kind ), name( name ), inst( inst ), members( members ), curMember( members.begin() ), sub( makeGenericSubstitution( inst ) ) {
	262	PRINT( std::cerr << "Creating " << kind << "(" << name << ")"; )
262	263	init();
263	264	}

src/ResolvExpr/RenameVars.cc

-              rf5c3b6c
+              r0fe4e62
         RenameVars global_renamer;
         RenameVars::RenameVars() : level( 0 ) {
+        RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
                 mapStack.push_front( std::map< std::string, std::string >() );
+        }
 …
         void RenameVars::reset() {
                 level = 0;
+                resetCount++;
+        }
 …
                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 std::ostringstream output;
                                 output << "_" << level << "_" << (*i)->get_name();
+                                output << "_" << resetCount << "_" << level << "_" << (*i)->get_name();
                                 std::string newname( output.str() );
                                 mapStack.front()[ (*i)->get_name() ] = newname;

src/ResolvExpr/RenameVars.h

rf5c3b6c	r0fe4e62
48	48	void typeBefore( Type *type );
49	49	void typeAfter( Type *type );
50		int level;
	50	int level, resetCount;
51	51	std::list< std::map< std::string, std::string > > mapStack;
52	52	};

src/ResolvExpr/TypeEnvironment.cc

-              rf5c3b6c
+              r0fe4e62
+        }
+        void TypeEnvironment::addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars ) {
+                for ( const EqvClass& c : actualEnv ) {
+                        EqvClass c2 = c;
+                        c2.allowWidening = false;
+                        for ( const std::string& var : c2.vars ) {
+                                openVars[ var ] = c2.data;
+                        }
+                        env.push_back( std::move(c2) );
+                }
+        }
 } // namespace ResolvExpr

src/ResolvExpr/TypeEnvironment.h

-              rf5c3b6c
+              r0fe4e62
                 TypeEnvironment *clone() const { return new TypeEnvironment( *this ); }
+                /// Iteratively adds the environment of a new actual (with allowWidening = false),
+                /// and extracts open variables.
+                void addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars );
                 typedef std::list< EqvClass >::iterator iterator;
                 iterator begin() { return env.begin(); }

src/SymTab/Mangler.cc

-              rf5c3b6c
+              r0fe4e62
 namespace SymTab {
         std::string Mangler::mangleType( Type * ty ) {
                 Mangler mangler( false, true );
+                Mangler mangler( false, true, true );
                 maybeAccept( ty, mangler );
                 return mangler.get_mangleName();
+        }
+        Mangler::Mangler( bool mangleOverridable, bool typeMode )
+                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
+        std::string Mangler::mangleConcrete( Type* ty ) {
+                Mangler mangler( false, false, false );
+                maybeAccept( ty, mangler );
+                return mangler.get_mangleName();
+        }
+        Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
+                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
         Mangler::Mangler( const Mangler &rhs ) : mangleName() {
 …
                 mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
+        }
+        void Mangler::mangleGenericRef( ReferenceToType * refType, std::string prefix ) {
+                printQualifiers( refType );
+                std::ostringstream oldName( mangleName.str() );
+                mangleName.clear();
+                mangleName << prefix << refType->get_name();
+                std::list< Expression* >& params = refType->get_parameters();
+                if ( ! params.empty() ) {
+                        mangleName << "_";
+                        for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
+                                maybeAccept( paramType->get_type(), *this );
+                if ( mangleGenericParams ) {
+                        std::list< Expression* >& params = refType->get_parameters();
+                        if ( ! params.empty() ) {
+                                mangleName << "_";
+                                for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
+                                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
+                                        maybeAccept( paramType->get_type(), *this );
+                                }
+                                mangleName << "_";
+                        }
-                        mangleName << "_";
+                }
-                oldName << mangleName.str().length() << mangleName.str();
-                mangleName.str( oldName.str() );
+        }
         void Mangler::visit( StructInstType * aggregateUseType ) {
+                if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
+                else mangleRef( aggregateUseType, "s" );
+                mangleRef( aggregateUseType, "s" );
+        }
         void Mangler::visit( UnionInstType * aggregateUseType ) {
+                if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
+                else mangleRef( aggregateUseType, "u" );
+                mangleRef( aggregateUseType, "u" );
+        }
 …
                                 varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
                                         Mangler sub_mangler( mangleOverridable, typeMode );
+                                        Mangler sub_mangler( mangleOverridable, typeMode, mangleGenericParams );
                                         sub_mangler.nextVarNum = nextVarNum;
                                         sub_mangler.isTopLevel = false;

src/SymTab/Mangler.h

-              rf5c3b6c
+              r0fe4e62
                 /// Mangle syntax tree object; primary interface to clients
                 template< typename SynTreeClass >
             static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false );
+            static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
                 /// Mangle a type name; secondary interface
                 static std::string mangleType( Type* ty );
+                /// Mangle ignoring generic type parameters
+                static std::string mangleConcrete( Type* ty );
                 virtual void visit( ObjectDecl *declaration );
 …
                 bool mangleOverridable;         ///< Specially mangle overridable built-in methods
                 bool typeMode;                  ///< Produce a unique mangled name for a type
+                bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
                 Mangler( bool mangleOverridable, bool typeMode );
+                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
                 Mangler( const Mangler & );
                 void mangleDecl( DeclarationWithType *declaration );
                 void mangleRef( ReferenceToType *refType, std::string prefix );
-                void mangleGenericRef( ReferenceToType *refType, std::string prefix );
                 void printQualifiers( Type *type );
 …
         template< typename SynTreeClass >
         std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode ) {
                 Mangler mangler( mangleOverridable, typeMode );
+        std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
+                Mangler mangler( mangleOverridable, typeMode, mangleGenericParams );
                 maybeAccept( decl, mangler );
                 return mangler.get_mangleName();

src/SymTab/Validate.cc

-              rf5c3b6c
+              r0fe4e62
                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                 ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
+                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
                 acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
-                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist
                 VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                 ReturnChecker::checkFunctionReturns( translationUnit );

src/Tuples/TupleAssignment.cc

-              rf5c3b6c
+              r0fe4e62
 #include <memory>                          // for unique_ptr, allocator_trai...
 #include <string>                          // for string
+#include <vector>
 #include "CodeGen/OperatorTable.h"
 …
 #include "ResolvExpr/Resolver.h"           // for resolveCtorInit
 #include "ResolvExpr/TypeEnvironment.h"    // for TypeEnvironment
+#include "ResolvExpr/typeops.h"            // for combos
 #include "SynTree/Declaration.h"           // for ObjectDecl
 #include "SynTree/Expression.h"            // for Expression, CastExpr, Name...
 …
                 // dispatcher for Tuple (multiple and mass) assignment operations
                 TupleAssignSpotter( ResolvExpr::AlternativeFinder & );
                 void spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities );
+                void spot( UntypedExpr * expr, std::vector<ResolvExpr::AlternativeFinder> &args );
           private:
 …
                 struct Matcher {
                   public:
+                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
+                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, const
+                                ResolvExpr::AltList& rhs );
                         virtual ~Matcher() {}
                         virtual void match( std::list< Expression * > &out ) = 0;
 …
                 struct MassAssignMatcher : public Matcher {
                   public:
+                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
+                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
+                                const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
                 };
 …
                 struct MultipleAssignMatcher : public Matcher {
                   public:
+                        MultipleAssignMatcher( TupleAssignSpotter &spot, const ResolvExpr::AltList & alts );
+                        MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
+                                const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
                 };
 …
+        }
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr,
+                                std::vector<ResolvExpr::AlternativeFinder> &args ) {
                 TupleAssignSpotter spotter( currentFinder );
                 spotter.spot( expr, possibilities );
+                spotter.spot( expr, args );
+        }
 …
                 : currentFinder(f) {}
+        void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
+        void TupleAssignSpotter::spot( UntypedExpr * expr,
+                        std::vector<ResolvExpr::AlternativeFinder> &args ) {
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
                         if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) {
+                               fname = op->get_name();
+                                PRINT( std::cerr << "TupleAssignment: " << fname << std::endl; )
+                                for ( std::list<ResolvExpr::AltList>::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
+                                        if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal
+                                        if ( ali->size() <= 1 && CodeGen::isAssignment( op->get_name() ) ) {
+                                                // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it
+                                                continue;
+                                fname = op->get_name();
+                                // AlternativeFinder will naturally handle this case case, if it's legal
+                                if ( args.size() == 0 ) return;
+                                // if an assignment only takes 1 argument, that's odd, but maybe someone wrote
+                                // the function, in which case AlternativeFinder will handle it normally
+                                if ( args.size() == 1 && CodeGen::isAssignment( fname ) ) return;
+                                // look over all possible left-hand-sides
+                                for ( ResolvExpr::Alternative& lhsAlt : args[0] ) {
+                                        // skip non-tuple LHS
+                                        if ( ! refToTuple(lhsAlt.expr) ) continue;
+                                        // explode is aware of casts - ensure every LHS expression is sent into explode
+                                        // with a reference cast
+                                        // xxx - this seems to change the alternatives before the normal
+                                        //  AlternativeFinder flow; maybe this is desired?
+                                        if ( ! dynamic_cast<CastExpr*>( lhsAlt.expr ) ) {
+                                                lhsAlt.expr = new CastExpr( lhsAlt.expr,
+                                                                new ReferenceType( Type::Qualifiers(),
+                                                                        lhsAlt.expr->get_result()->clone() ) );
+                                        }
+                                        assert( ! ali->empty() );
+                                        // grab args 2-N and group into a TupleExpr
+                                        const ResolvExpr::Alternative & alt1 = ali->front();
+                                        auto begin = std::next(ali->begin(), 1), end = ali->end();
+                                        PRINT( std::cerr << "alt1 is " << alt1.expr << std::endl; )
+                                        if ( refToTuple(alt1.expr) ) {
+                                                PRINT( std::cerr << "and is reference to tuple" << std::endl; )
+                                                if ( isMultAssign( begin, end ) ) {
+                                                        PRINT( std::cerr << "possible multiple assignment" << std::endl; )
+                                                        matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
+                                                } else {
+                                                        // mass assignment
+                                                        PRINT( std::cerr << "possible mass assignment" << std::endl; )
+                                                        matcher.reset( new MassAssignMatcher( *this,  *ali ) );
+                                        // explode the LHS so that each field of a tuple-valued-expr is assigned
+                                        ResolvExpr::AltList lhs;
+                                        explode( lhsAlt, currentFinder.get_indexer(), back_inserter(lhs), true );
+                                        for ( ResolvExpr::Alternative& alt : lhs ) {
+                                                // each LHS value must be a reference - some come in with a cast expression,
+                                                // if not just cast to reference here
+                                                if ( ! dynamic_cast<ReferenceType*>( alt.expr->get_result() ) ) {
+                                                        alt.expr = new CastExpr( alt.expr,
+                                                                new ReferenceType( Type::Qualifiers(),
+                                                                        alt.expr->get_result()->clone() ) );
+                                                }
+                                        }
+                                        if ( args.size() == 1 ) {
+                                                // mass default-initialization/destruction
+                                                ResolvExpr::AltList rhs{};
+                                                matcher.reset( new MassAssignMatcher( *this, lhs, rhs ) );
                                                 match();
+                                        } else if ( args.size() > 2 ) {
+                                                // expand all possible RHS possibilities
+                                                // TODO build iterative version of this instead of using combos
+                                                std::vector< ResolvExpr::AltList > rhsAlts;
+                                                combos( std::next(args.begin(), 1), args.end(),
+                                                        std::back_inserter( rhsAlts ) );
+                                                for ( const ResolvExpr::AltList& rhsAlt : rhsAlts ) {
+                                                        // multiple assignment
+                                                        ResolvExpr::AltList rhs;
+                                                        explode( rhsAlt, currentFinder.get_indexer(),
+                                                                std::back_inserter(rhs), true );
+                                                        matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
+                                                        match();
+                                                }
+                                        } else {
+                                                for ( const ResolvExpr::Alternative& rhsAlt : args[1] ) {
+                                                        ResolvExpr::AltList rhs;
+                                                        if ( isTuple(rhsAlt.expr) ) {
+                                                                // multiple assignment
+                                                                explode( rhsAlt, currentFinder.get_indexer(),
+                                                                        std::back_inserter(rhs), true );
+                                                                matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
+                                                        } else {
+                                                                // mass assignment
+                                                                rhs.push_back( rhsAlt );
+                                                                matcher.reset( new MassAssignMatcher( *this, lhs, rhs ) );
+                                                        }
+                                                        match();
+                                                }
+                                        }
+                                }
 …
                 ResolvExpr::AltList current;
                 // now resolve new assignments
+                for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+                for ( std::list< Expression * >::iterator i = new_assigns.begin();
+                                i != new_assigns.end(); ++i ) {
                         PRINT(
                                 std::cerr << "== resolving tuple assign ==" << std::endl;
 …
+                        )
+                        ResolvExpr::AlternativeFinder finder( currentFinder.get_indexer(), currentFinder.get_environ() );
+                        ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(),
+                                currentFinder.get_environ() };
                         try {
                                 finder.findWithAdjustment(*i);
 …
                 // combine assignment environments into combined expression environment
                 simpleCombineEnvironments( current.begin(), current.end(), matcher->compositeEnv );
+                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv, ResolvExpr::sumCost( current  ) + matcher->baseCost ) );
+        }
+        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList &alts ) : spotter(spotter), baseCost( ResolvExpr::sumCost( alts ) ) {
+                assert( ! alts.empty() );
+                // combine argument environments into combined expression environment
+                simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
+                ResolvExpr::Alternative lhsAlt = alts.front();
+                // explode is aware of casts - ensure every LHS expression is sent into explode with a reference cast
+                if ( ! dynamic_cast< CastExpr * >( lhsAlt.expr ) ) {
+                        lhsAlt.expr = new CastExpr( lhsAlt.expr, new ReferenceType( Type::Qualifiers(), lhsAlt.expr->get_result()->clone() ) );
+                }
+                // explode the lhs so that each field of the tuple-valued-expr is assigned.
+                explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs), true );
+                for ( ResolvExpr::Alternative & alt : lhs ) {
+                        // every LHS value must be a reference - some come in with a cast expression, if it doesn't just cast to reference here.
+                        if ( ! dynamic_cast< ReferenceType * >( alt.expr->get_result() ) ) {
+                                alt.expr = new CastExpr( alt.expr, new ReferenceType( Type::Qualifiers(), alt.expr->get_result()->clone() ) );
+                        }
+                }
+        }
+        TupleAssignSpotter::MassAssignMatcher::MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
+                assert( alts.size() == 1 || alts.size() == 2 );
+                if ( alts.size() == 2 ) {
+                        rhs.push_back( alts.back() );
+                }
+        }
+        TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
+                // explode the rhs so that each field of the tuple-valued-expr is assigned.
+                explode( std::next(alts.begin(), 1), alts.end(), spotter.currentFinder.get_indexer(), back_inserter(rhs), true );
+                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(
+                        new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv,
+                        ResolvExpr::sumCost( current ) + matcher->baseCost ) );
+        }
+        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter,
+                const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs )
+        : lhs(lhs), rhs(rhs), spotter(spotter),
+          baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ) {
+                simpleCombineEnvironments( lhs.begin(), lhs.end(), compositeEnv );
+                simpleCombineEnvironments( rhs.begin(), rhs.end(), compositeEnv );
+        }

src/Tuples/Tuples.h

-              rf5c3b6c
+              r0fe4e62
 #include <string>
+#include <vector>
 #include "SynTree/Expression.h"
 …
 namespace Tuples {
         // TupleAssignment.cc
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign, const std::list<ResolvExpr::AltList> & possibilities );
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign,
+                std::vector< ResolvExpr::AlternativeFinder >& args );
         // TupleExpansion.cc
         /// expands z.[a, b.[x, y], c] into [z.a, z.b.x, z.b.y, z.c], inserting UniqueExprs as appropriate

src/benchmark/Makefile.am

-              rf5c3b6c
+              r0fe4e62
 STATS    = ${TOOLSDIR}stat.py
 repeats  = 30
+TIME_FORMAT = "%E"
+PRINT_FORMAT = '%20s\t'
 .NOTPARALLEL:
 …
 noinst_PROGRAMS =
+bench$(EXEEXT) :
+        @for ccflags in "-debug" "-nodebug"; do \
+                echo ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -lrt bench.c;\
+                ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -lrt bench.c;\
+                ./a.out ; \
+        done ; \
+        rm -f ./a.out ;
+csv-data$(EXEEXT):
+        @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=50000000 csv-data.c
+        @./a.out
+        @rm -f ./a.out
+## =========================================================================================================
+ctxswitch$(EXEEXT): \
+        ctxswitch-pthread.run           \
+        ctxswitch-cfa_coroutine.run     \
+        ctxswitch-cfa_thread.run        \
+        ctxswitch-upp_coroutine.run     \
+        ctxswitch-upp_thread.run
+ctxswitch-cfa_coroutine$(EXEEXT):
+        ${CC}        ctxswitch/cfa_cor.c   -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-cfa_thread$(EXEEXT):
+        ${CC}        ctxswitch/cfa_thrd.c  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_coroutine$(EXEEXT):
+        u++          ctxswitch/upp_cor.cc  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_thread$(EXEEXT):
+        u++          ctxswitch/upp_thrd.cc -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-pthread$(EXEEXT):
+        @BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+creation$(EXEEXT) :\
+        creation-pthread.run            \
+        creation-cfa_coroutine.run      \
+        creation-cfa_thread.run         \
+        creation-upp_coroutine.run      \
+        creation-upp_thread.run
+creation-cfa_coroutine$(EXEEXT):
+        ${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-cfa_thread$(EXEEXT):
+        ${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_coroutine$(EXEEXT):
+        u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_thread$(EXEEXT):
+        u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-pthread$(EXEEXT):
+        @BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+mutex$(EXEEXT) :\
+        mutex-function.run      \
+        mutex-pthread_lock.run  \
+        mutex-upp.run           \
+        mutex-cfa1.run          \
+        mutex-cfa2.run          \
+        mutex-cfa4.run
+mutex-function$(EXEEXT):
+        @BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-pthread_lock$(EXEEXT):
+        @BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-upp$(EXEEXT):
+        u++          mutex/upp.cc        -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa1$(EXEEXT):
+        ${CC}        mutex/cfa1.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa2$(EXEEXT):
+        ${CC}        mutex/cfa2.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa4$(EXEEXT):
+        ${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+signal$(EXEEXT) :\
+        signal-upp.run          \
+        signal-cfa1.run         \
+        signal-cfa2.run         \
+        signal-cfa4.run
+signal-upp$(EXEEXT):
+        u++          schedint/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa1$(EXEEXT):
+        ${CC}        schedint/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa2$(EXEEXT):
+        ${CC}        schedint/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa4$(EXEEXT):
+        ${CC}        schedint/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+waitfor$(EXEEXT) :\
+        waitfor-upp.run         \
+        waitfor-cfa1.run                \
+        waitfor-cfa2.run                \
+        waitfor-cfa4.run
+waitfor-upp$(EXEEXT):
+        u++          schedext/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa1$(EXEEXT):
+        ${CC}        schedext/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa2$(EXEEXT):
+        ${CC}        schedext/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa4$(EXEEXT):
+        ${CC}        schedext/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 %.run : %$(EXEEXT) ${REPEAT}
 …
         @rm -f a.out .result.log
+%.runquiet :
+        @+make $(basename $@)
+        @./a.out
+        @rm -f a.out
+%.make :
+        @printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
+        @+/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
 ${REPEAT} :
         @+make -C ${TOOLSDIR} repeat
+## =========================================================================================================
+jenkins$(EXEEXT):
+        @echo "{"
+        @echo -e '\t"githash": "'${githash}'",'
+        @echo -e '\t"arch": "'   ${arch}   '",'
+        @echo -e '\t"compile": {'
+        @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
+        @echo -e '\t\t"dummy" : {}'
+        @echo -e '\t},'
+        @echo -e '\t"ctxswitch": {'
+        @echo -en '\t\t"coroutine":'
+        @+make ctxswitch-cfa_coroutine.runquiet
+        @echo -en '\t\t,"thread":'
+        @+make ctxswitch-cfa_thread.runquiet
+        @echo -e '\t},'
+        @echo -e '\t"mutex": ['
+        @echo -en '\t\t'
+        @+make mutex-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make mutex-cfa2.runquiet
+        @echo -e '\t],'
+        @echo -e '\t"scheduling": ['
+        @echo -en '\t\t'
+        @+make signal-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make signal-cfa2.runquiet
+        @echo -en '\t\t,'
+        @+make waitfor-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make waitfor-cfa2.runquiet
+        @echo -e '\n\t],'
+        @echo -e '\t"epoch": ' $(shell date +%s)
+        @echo "}"
+## =========================================================================================================
+ctxswitch$(EXEEXT): \
+        ctxswitch-pthread.run           \
+        ctxswitch-cfa_coroutine.run     \
+        ctxswitch-cfa_thread.run        \
+        ctxswitch-upp_coroutine.run     \
+        ctxswitch-upp_thread.run
+ctxswitch-cfa_coroutine$(EXEEXT):
+        @${CC}        ctxswitch/cfa_cor.c   -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-cfa_thread$(EXEEXT):
+        @${CC}        ctxswitch/cfa_thrd.c  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_coroutine$(EXEEXT):
+        @u++          ctxswitch/upp_cor.cc  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_thread$(EXEEXT):
+        @u++          ctxswitch/upp_thrd.cc -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-pthread$(EXEEXT):
+        @@BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+mutex$(EXEEXT) :\
+        mutex-function.run      \
+        mutex-pthread_lock.run  \
+        mutex-upp.run           \
+        mutex-cfa1.run          \
+        mutex-cfa2.run          \
+        mutex-cfa4.run
+mutex-function$(EXEEXT):
+        @@BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-pthread_lock$(EXEEXT):
+        @@BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-upp$(EXEEXT):
+        @u++          mutex/upp.cc        -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa1$(EXEEXT):
+        @${CC}        mutex/cfa1.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa2$(EXEEXT):
+        @${CC}        mutex/cfa2.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa4$(EXEEXT):
+        @${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+signal$(EXEEXT) :\
+        signal-upp.run          \
+        signal-cfa1.run         \
+        signal-cfa2.run         \
+        signal-cfa4.run
+signal-upp$(EXEEXT):
+        @u++          schedint/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa1$(EXEEXT):
+        @${CC}        schedint/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa2$(EXEEXT):
+        @${CC}        schedint/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa4$(EXEEXT):
+        @${CC}        schedint/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+waitfor$(EXEEXT) :\
+        waitfor-upp.run         \
+        waitfor-cfa1.run                \
+        waitfor-cfa2.run                \
+        waitfor-cfa4.run
+waitfor-upp$(EXEEXT):
+        @u++          schedext/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa1$(EXEEXT):
+        @${CC}        schedext/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa2$(EXEEXT):
+        @${CC}        schedext/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa4$(EXEEXT):
+        @${CC}        schedext/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+creation$(EXEEXT) :\
+        creation-pthread.run                    \
+        creation-cfa_coroutine.run              \
+        creation-cfa_coroutine_eager.run        \
+        creation-cfa_thread.run                 \
+        creation-upp_coroutine.run              \
+        creation-upp_thread.run
+creation-cfa_coroutine$(EXEEXT):
+        @${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-cfa_coroutine_eager$(EXEEXT):
+        @${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} -DEAGER
+creation-cfa_thread$(EXEEXT):
+        @${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_coroutine$(EXEEXT):
+        @u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_thread$(EXEEXT):
+        @u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-pthread$(EXEEXT):
+        @@BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+compile$(EXEEXT) :\
+        compile-array.make      \
+        compile-attributes.make \
+        compile-empty.make      \
+        compile-expression.make \
+        compile-io.make         \
+        compile-monitor.make    \
+        compile-operators.make  \
+        compile-typeof.make
+compile-array$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c
+compile-attributes$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c
+compile-empty$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c
+compile-expression$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c
+compile-io$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c
+compile-monitor$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/monitor.c
+compile-operators$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c
+compile-thread$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/thread.c
+compile-typeof$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c

src/benchmark/Makefile.in

-              rf5c3b6c
+              r0fe4e62
   esac
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
 am__DIST_COMMON = $(srcdir)/Makefile.in
+am__DIST_COMMON = $(srcdir)/Makefile.in compile
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 …
 STATS = ${TOOLSDIR}stat.py
 repeats = 30
+TIME_FORMAT = "%E"
+PRINT_FORMAT = '%20s\t'
 all: all-am
 …
 .NOTPARALLEL:
+bench$(EXEEXT) :
+        @for ccflags in "-debug" "-nodebug"; do \
+                echo ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -lrt bench.c;\
+                ${CC} ${AM_CFLAGS} ${CFLAGS} $${ccflags} -lrt bench.c;\
+                ./a.out ; \
+        done ; \
+        rm -f ./a.out ;
+csv-data$(EXEEXT):
+        @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=50000000 csv-data.c
+        @./a.out
+        @rm -f ./a.out
+ctxswitch$(EXEEXT): \
+        ctxswitch-pthread.run           \
+        ctxswitch-cfa_coroutine.run     \
+        ctxswitch-cfa_thread.run        \
+        ctxswitch-upp_coroutine.run     \
+        ctxswitch-upp_thread.run
+ctxswitch-cfa_coroutine$(EXEEXT):
+        ${CC}        ctxswitch/cfa_cor.c   -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-cfa_thread$(EXEEXT):
+        ${CC}        ctxswitch/cfa_thrd.c  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_coroutine$(EXEEXT):
+        u++          ctxswitch/upp_cor.cc  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_thread$(EXEEXT):
+        u++          ctxswitch/upp_thrd.cc -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-pthread$(EXEEXT):
+        @BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation$(EXEEXT) :\
+        creation-pthread.run            \
+        creation-cfa_coroutine.run      \
+        creation-cfa_thread.run         \
+        creation-upp_coroutine.run      \
+        creation-upp_thread.run
+creation-cfa_coroutine$(EXEEXT):
+        ${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-cfa_thread$(EXEEXT):
+        ${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_coroutine$(EXEEXT):
+        u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_thread$(EXEEXT):
+        u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-pthread$(EXEEXT):
+        @BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex$(EXEEXT) :\
+        mutex-function.run      \
+        mutex-pthread_lock.run  \
+        mutex-upp.run           \
+        mutex-cfa1.run          \
+        mutex-cfa2.run          \
+        mutex-cfa4.run
+mutex-function$(EXEEXT):
+        @BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-pthread_lock$(EXEEXT):
+        @BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-upp$(EXEEXT):
+        u++          mutex/upp.cc        -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa1$(EXEEXT):
+        ${CC}        mutex/cfa1.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa2$(EXEEXT):
+        ${CC}        mutex/cfa2.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa4$(EXEEXT):
+        ${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal$(EXEEXT) :\
+        signal-upp.run          \
+        signal-cfa1.run         \
+        signal-cfa2.run         \
+        signal-cfa4.run
+signal-upp$(EXEEXT):
+        u++          schedint/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa1$(EXEEXT):
+        ${CC}        schedint/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa2$(EXEEXT):
+        ${CC}        schedint/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa4$(EXEEXT):
+        ${CC}        schedint/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor$(EXEEXT) :\
+        waitfor-upp.run         \
+        waitfor-cfa1.run                \
+        waitfor-cfa2.run                \
+        waitfor-cfa4.run
+waitfor-upp$(EXEEXT):
+        u++          schedext/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa1$(EXEEXT):
+        ${CC}        schedext/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa2$(EXEEXT):
+        ${CC}        schedext/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa4$(EXEEXT):
+        ${CC}        schedext/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 %.run : %$(EXEEXT) ${REPEAT}
 …
         @rm -f a.out .result.log
+%.runquiet :
+        @+make $(basename $@)
+        @./a.out
+        @rm -f a.out
+%.make :
+        @printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
+        @+/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
 ${REPEAT} :
         @+make -C ${TOOLSDIR} repeat
+jenkins$(EXEEXT):
+        @echo "{"
+        @echo -e '\t"githash": "'${githash}'",'
+        @echo -e '\t"arch": "'   ${arch}   '",'
+        @echo -e '\t"compile": {'
+        @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
+        @echo -e '\t\t"dummy" : {}'
+        @echo -e '\t},'
+        @echo -e '\t"ctxswitch": {'
+        @echo -en '\t\t"coroutine":'
+        @+make ctxswitch-cfa_coroutine.runquiet
+        @echo -en '\t\t,"thread":'
+        @+make ctxswitch-cfa_thread.runquiet
+        @echo -e '\t},'
+        @echo -e '\t"mutex": ['
+        @echo -en '\t\t'
+        @+make mutex-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make mutex-cfa2.runquiet
+        @echo -e '\t],'
+        @echo -e '\t"scheduling": ['
+        @echo -en '\t\t'
+        @+make signal-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make signal-cfa2.runquiet
+        @echo -en '\t\t,'
+        @+make waitfor-cfa1.runquiet
+        @echo -en '\t\t,'
+        @+make waitfor-cfa2.runquiet
+        @echo -e '\n\t],'
+        @echo -e '\t"epoch": ' $(shell date +%s)
+        @echo "}"
+ctxswitch$(EXEEXT): \
+        ctxswitch-pthread.run           \
+        ctxswitch-cfa_coroutine.run     \
+        ctxswitch-cfa_thread.run        \
+        ctxswitch-upp_coroutine.run     \
+        ctxswitch-upp_thread.run
+ctxswitch-cfa_coroutine$(EXEEXT):
+        @${CC}        ctxswitch/cfa_cor.c   -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-cfa_thread$(EXEEXT):
+        @${CC}        ctxswitch/cfa_thrd.c  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_coroutine$(EXEEXT):
+        @u++          ctxswitch/upp_cor.cc  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_thread$(EXEEXT):
+        @u++          ctxswitch/upp_thrd.cc -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-pthread$(EXEEXT):
+        @@BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex$(EXEEXT) :\
+        mutex-function.run      \
+        mutex-pthread_lock.run  \
+        mutex-upp.run           \
+        mutex-cfa1.run          \
+        mutex-cfa2.run          \
+        mutex-cfa4.run
+mutex-function$(EXEEXT):
+        @@BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-pthread_lock$(EXEEXT):
+        @@BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-upp$(EXEEXT):
+        @u++          mutex/upp.cc        -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa1$(EXEEXT):
+        @${CC}        mutex/cfa1.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa2$(EXEEXT):
+        @${CC}        mutex/cfa2.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa4$(EXEEXT):
+        @${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal$(EXEEXT) :\
+        signal-upp.run          \
+        signal-cfa1.run         \
+        signal-cfa2.run         \
+        signal-cfa4.run
+signal-upp$(EXEEXT):
+        @u++          schedint/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa1$(EXEEXT):
+        @${CC}        schedint/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa2$(EXEEXT):
+        @${CC}        schedint/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa4$(EXEEXT):
+        @${CC}        schedint/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor$(EXEEXT) :\
+        waitfor-upp.run         \
+        waitfor-cfa1.run                \
+        waitfor-cfa2.run                \
+        waitfor-cfa4.run
+waitfor-upp$(EXEEXT):
+        @u++          schedext/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa1$(EXEEXT):
+        @${CC}        schedext/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa2$(EXEEXT):
+        @${CC}        schedext/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa4$(EXEEXT):
+        @${CC}        schedext/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation$(EXEEXT) :\
+        creation-pthread.run                    \
+        creation-cfa_coroutine.run              \
+        creation-cfa_coroutine_eager.run        \
+        creation-cfa_thread.run                 \
+        creation-upp_coroutine.run              \
+        creation-upp_thread.run
+creation-cfa_coroutine$(EXEEXT):
+        @${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-cfa_coroutine_eager$(EXEEXT):
+        @${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} -DEAGER
+creation-cfa_thread$(EXEEXT):
+        @${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_coroutine$(EXEEXT):
+        @u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_thread$(EXEEXT):
+        @u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-pthread$(EXEEXT):
+        @@BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+compile$(EXEEXT) :\
+        compile-array.make      \
+        compile-attributes.make \
+        compile-empty.make      \
+        compile-expression.make \
+        compile-io.make         \
+        compile-monitor.make    \
+        compile-operators.make  \
+        compile-typeof.make
+compile-array$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c
+compile-attributes$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c
+compile-empty$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c
+compile-expression$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c
+compile-io$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c
+compile-monitor$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/monitor.c
+compile-operators$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c
+compile-thread$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/thread.c
+compile-typeof$(EXEEXT):
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

src/benchmark/creation/cfa_cor.c

-              rf5c3b6c
+              r0fe4e62
 coroutine MyCoroutine {};
+void ?{} (MyCoroutine & this) { prime(this); }
+void ?{} (MyCoroutine & this) {
+#ifdef EAGER
+        prime(this);
+#endif
+}
 void main(MyCoroutine & this) {}

src/benchmark/csv-data.c

-              rf5c3b6c
+              r0fe4e62
 // coroutine context switch
 long long int measure_coroutine() {
         const unsigned int NoOfTimes = N;
+        const unsigned int NoOfTimes = 50000000;
         long long int StartTime, EndTime;
 …
 // thread context switch
 long long int measure_thread() {
         const unsigned int NoOfTimes = N;
+        const unsigned int NoOfTimes = 50000000;
         long long int StartTime, EndTime;
 …
 long long int measure_1_monitor_entry() {
         const unsigned int NoOfTimes = N;
+        const unsigned int NoOfTimes = 5000000;
         long long int StartTime, EndTime;
         mon_t mon;
 …
 long long int measure_2_monitor_entry() {
         const unsigned int NoOfTimes = N;
+        const unsigned int NoOfTimes = 5000000;
         long long int StartTime, EndTime;
         mon_t mon1, mon2;
 …
 //-----------------------------------------------------------------------------
 // single internal sched entry
+const unsigned int NoOfTimes = 500000;
 mon_t mon1;
 …
 void side1A( mon_t & mutex a, long long int * out ) {
+        long long int StartTime, EndTime;
+        StartTime = Time();
+        for( int i = 0;; i++ ) {
+                signal(&cond1a);
+        const unsigned int NoOfTimes = 500000;
+        long long int StartTime, EndTime;
+        StartTime = Time();
+        for( int i = 0;; i++ ) {
+                signal(cond1a);
+                if( i > NoOfTimes ) break;
+                wait(cond1b);
+        }
+        EndTime = Time();
+        *out = ( EndTime - StartTime ) / NoOfTimes;
+}
+void side1B( mon_t & mutex a ) {
+        for( int i = 0;; i++ ) {
+                signal(cond1b);
                 if( i > N ) break;
+                wait(&cond1b);
+        }
+        EndTime = Time();
+        *out = ( EndTime - StartTime ) / N;
+}
+void side1B( mon_t & mutex a ) {
+        for( int i = 0;; i++ ) {
+                signal(&cond1b);
+                if( i > N ) break;
+                wait(&cond1a);
+                wait(cond1a);
+        }
+}
 …
 //-----------------------------------------------------------------------------
 // multi internal sched entry
+// multi internal sched
 mon_t mon2;
 …
 void side2A( mon_t & mutex a, mon_t & mutex b, long long int * out ) {
+        long long int StartTime, EndTime;
+        StartTime = Time();
+        for( int i = 0;; i++ ) {
+                signal(&cond2a);
+        const unsigned int NoOfTimes = 500000;
+        long long int StartTime, EndTime;
+        StartTime = Time();
+        for( int i = 0;; i++ ) {
+                signal(cond2a);
+                if( i > NoOfTimes ) break;
+                wait(cond2b);
+        }
+        EndTime = Time();
+        *out = ( EndTime - StartTime ) / NoOfTimes;
+}
+void side2B( mon_t & mutex a, mon_t & mutex b ) {
+        for( int i = 0;; i++ ) {
+                signal(cond2b);
                 if( i > N ) break;
+                wait(&cond2b);
+        }
+        EndTime = Time();
+        *out = ( EndTime - StartTime ) / N;
+}
+void side2B( mon_t & mutex a, mon_t & mutex b ) {
+        for( int i = 0;; i++ ) {
+                signal(&cond2b);
+                if( i > N ) break;
+                wait(&cond2a);
+                wait(cond2a);
+        }
+}
 …
 //-----------------------------------------------------------------------------
+// single external sched
+volatile int go = 0;
+void __attribute__((noinline)) call( mon_t & mutex m1 ) {}
+long long int  __attribute__((noinline)) wait( mon_t & mutex m1 ) {
+        go = 1;
+        const unsigned int NoOfTimes = 5000000;
+        long long int StartTime, EndTime;
+        StartTime = Time();
+        for (size_t i = 0; i < NoOfTimes; i++) {
+                waitfor(call, m1);
+        }
+        EndTime = Time();
+        go = 0;
+        return ( EndTime - StartTime ) / NoOfTimes;
+}
+thread thrd3 {};
+void ^?{}( thrd3 & mutex this ) {}
+void main( thrd3 & this ) {
+        while(go == 0) { yield(); }
+        while(go == 1) { call(mon1); }
+}
+long long int measure_1_sched_ext() {
+        go = 0;
+        thrd3 t;
+        return wait(mon1);
+}
+//-----------------------------------------------------------------------------
+// multi external sched
+void __attribute__((noinline)) call( mon_t & mutex m1, mon_t & mutex m2 ) {}
+long long int  __attribute__((noinline)) wait( mon_t & mutex m1, mon_t & mutex m2 ) {
+        go = 1;
+        const unsigned int NoOfTimes = 5000000;
+        long long int StartTime, EndTime;
+        StartTime = Time();
+        for (size_t i = 0; i < NoOfTimes; i++) {
+                waitfor(call, m1, m2);
+        }
+        EndTime = Time();
+        go = 0;
+        return ( EndTime - StartTime ) / NoOfTimes;
+}
+thread thrd4 {};
+void ^?{}( thrd4 & mutex this ) {}
+void main( thrd4 & this ) {
+        while(go == 0) { yield(); }
+        while(go == 1) { call(mon1, mon2); }
+}
+long long int measure_2_sched_ext() {
+        go = 0;
+        thrd3 t;
+        return wait(mon1, mon2);
+}
+//-----------------------------------------------------------------------------
 // main loop
 int main()
+{
+        sout | time(NULL) | ',';
+        sout | measure_coroutine() | ',';
+        sout | measure_thread() | ',';
+        sout | measure_1_monitor_entry() | ',';
+        sout | measure_2_monitor_entry() | ',';
+        sout | measure_1_sched_int() | ',';
+        sout | measure_2_sched_int() | endl;
+}
+        sout | "\tepoch:" | time(NULL) | ',' | endl;
+        sout | "\tctxswitch: {" | endl;
+        sout | "\t\tcoroutine: "| measure_coroutine() | ',' | endl;
+        sout | "\t\tthread:" | measure_thread() | ',' | endl;
+        sout | "\t}," | endl;
+        sout | "\tmutex: ["     | measure_1_monitor_entry()     | ',' | measure_2_monitor_entry()       | "]," | endl;
+        sout | "\tscheduling: ["| measure_1_sched_int()         | ',' | measure_2_sched_int()   | ','  |
+                                          measure_1_sched_ext()         | ',' | measure_2_sched_ext()   | "]," | endl;
+}

src/benchmark/schedint/cfa1.c

-              rf5c3b6c
+              r0fe4e62
 void __attribute__((noinline)) call( M & mutex a1 ) {
         signal(&c);
+        signal(c);
+}
 …
         BENCH(
                 for (size_t i = 0; i < n; i++) {
                         wait(&c);
+                        wait(c);
                 },
                 result

src/benchmark/schedint/cfa2.c

-              rf5c3b6c
+              r0fe4e62
 void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {
         signal(&c);
+        signal(c);
+}
 …
         BENCH(
                 for (size_t i = 0; i < n; i++) {
                         wait(&c);
+                        wait(c);
                 },
                 result

src/benchmark/schedint/cfa4.c

-              rf5c3b6c
+              r0fe4e62
 void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
         signal(&c);
+        signal(c);
+}
 …
         BENCH(
                 for (size_t i = 0; i < n; i++) {
                         wait(&c);
+                        wait(c);
                 },
                 result

src/libcfa/Makefile.am

-              rf5c3b6c
+              r0fe4e62
 cfa_includedir = $(CFA_INCDIR)
+nobase_cfa_include_HEADERS = ${headers} ${stdhdr} math gmp concurrency/invoke.h
+nobase_cfa_include_HEADERS =    \
+        ${headers}                      \
+        ${stdhdr}                       \
+        math                            \
+        gmp                             \
+        bits/defs.h             \
+        bits/locks.h            \
+        concurrency/invoke.h    \
+        libhdr.h                        \
+        libhdr/libalign.h       \
+        libhdr/libdebug.h       \
+        libhdr/libtools.h
 CLEANFILES = libcfa-prelude.c

src/libcfa/Makefile.in

-              rf5c3b6c
+              r0fe4e62
         containers/result containers/vector concurrency/coroutine \
         concurrency/thread concurrency/kernel concurrency/monitor \
+        ${shell echo stdhdr/*} math gmp concurrency/invoke.h
+        ${shell echo stdhdr/*} math gmp bits/defs.h bits/locks.h \
+        concurrency/invoke.h libhdr.h libhdr/libalign.h \
+        libhdr/libdebug.h libhdr/libtools.h
 HEADERS = $(nobase_cfa_include_HEADERS)
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
 …
 stdhdr = ${shell echo stdhdr/*}
 cfa_includedir = $(CFA_INCDIR)
+nobase_cfa_include_HEADERS = ${headers} ${stdhdr} math gmp concurrency/invoke.h
+nobase_cfa_include_HEADERS = \
+        ${headers}                      \
+        ${stdhdr}                       \
+        math                            \
+        gmp                             \
+        bits/defs.h             \
+        bits/locks.h            \
+        concurrency/invoke.h    \
+        libhdr.h                        \
+        libhdr/libalign.h       \
+        libhdr/libdebug.h       \
+        libhdr/libtools.h
 CLEANFILES = libcfa-prelude.c
 all: all-am

src/libcfa/concurrency/alarm.c

-              rf5c3b6c
+              r0fe4e62
         disable_interrupts();
         lock( &event_kernel->lock DEBUG_CTX2 );
+        lock( event_kernel->lock DEBUG_CTX2 );
+        {
                 verify( validate( alarms ) );
 …
+                }
+        }
         unlock( &event_kernel->lock );
+        unlock( event_kernel->lock );
         this->set = true;
         enable_interrupts( DEBUG_CTX );
 …
 void unregister_self( alarm_node_t * this ) {
         disable_interrupts();
         lock( &event_kernel->lock DEBUG_CTX2 );
+        lock( event_kernel->lock DEBUG_CTX2 );
+        {
                 verify( validate( &event_kernel->alarms ) );
                 remove( &event_kernel->alarms, this );
+        }
         unlock( &event_kernel->lock );
+        unlock( event_kernel->lock );
         enable_interrupts( DEBUG_CTX );
         this->set = false;

src/libcfa/concurrency/coroutine.c

rf5c3b6c	r0fe4e62
156	156	this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ); // minimum alignment
157	157	} // if
158		assertf( this->size >= MinStackSize, "Stack size %d provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
	158	assertf( this->size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
159	159
160	160	this->base = (char *)this->limit + this->size;

src/libcfa/concurrency/invoke.h

-              rf5c3b6c
+              r0fe4e62
 //
 #include <stdbool.h>
 #include <stdint.h>
+#include "bits/defs.h"
+#include "bits/locks.h"
 #ifdef __CFORALL__
 …
 #define _INVOKE_H_
+      #define unlikely(x)    __builtin_expect(!!(x), 0)
+      #define thread_local _Thread_local
+      typedef void (*fptr_t)();
+      struct spinlock {
+            volatile int lock;
+            #ifdef __CFA_DEBUG__
+                  const char * prev_name;
+                  void* prev_thrd;
+            #endif
+      };
+      struct __thread_queue_t {
+            struct thread_desc * head;
+            struct thread_desc ** tail;
+      };
+      struct __condition_stack_t {
+            struct __condition_criterion_t * top;
+      };
+      #ifdef __CFORALL__
+      extern "Cforall" {
+            void ?{}( struct __thread_queue_t & );
+            void append( struct __thread_queue_t *, struct thread_desc * );
+            struct thread_desc * pop_head( struct __thread_queue_t * );
+            struct thread_desc * remove( struct __thread_queue_t *, struct thread_desc ** );
+            void ?{}( struct __condition_stack_t & );
+            void push( struct __condition_stack_t *, struct __condition_criterion_t * );
+            struct __condition_criterion_t * pop( struct __condition_stack_t * );
+            void ?{}(spinlock & this);
+            void ^?{}(spinlock & this);
+      }
+      #endif
+      struct coStack_t {
+            unsigned int size;                        // size of stack
+            void *storage;                            // pointer to stack
+            void *limit;                              // stack grows towards stack limit
+            void *base;                               // base of stack
+            void *context;                            // address of cfa_context_t
+            void *top;                                // address of top of storage
+            bool userStack;                           // whether or not the user allocated the stack
+      };
+      enum coroutine_state { Halted, Start, Inactive, Active, Primed };
+      struct coroutine_desc {
+            struct coStack_t stack;                   // stack information of the coroutine
+            const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
+            int errno_;                               // copy of global UNIX variable errno
+            enum coroutine_state state;               // current execution status for coroutine
+            struct coroutine_desc * starter;          // first coroutine to resume this one
+            struct coroutine_desc * last;             // last coroutine to resume this one
+      };
+      struct __waitfor_mask_t {
+            short * accepted;                         // the index of the accepted function, -1 if none
+            struct __acceptable_t * clauses;          // list of acceptable functions, null if any
+            short size;                               // number of acceptable functions
+      };
+      struct monitor_desc {
+            struct spinlock lock;                     // spinlock to protect internal data
+            struct thread_desc * owner;               // current owner of the monitor
+            struct __thread_queue_t entry_queue;      // queue of threads that are blocked waiting for the monitor
+            struct __condition_stack_t signal_stack;  // stack of conditions to run next once we exit the monitor
+            unsigned int recursion;                   // monitor routines can be called recursively, we need to keep track of that
+            struct __waitfor_mask_t mask;             // mask used to know if some thread is waiting for something while holding the monitor
+            struct __condition_node_t * dtor_node;    // node used to signal the dtor in a waitfor dtor
+      };
+      struct __monitor_group_t {
+            struct monitor_desc ** list;              // currently held monitors
+            short                  size;              // number of currently held monitors
+            fptr_t                 func;              // last function that acquired monitors
+      };
+      struct thread_desc {
+            // Core threading fields
+            struct coroutine_desc  self_cor;          // coroutine body used to store context
+            struct monitor_desc    self_mon;          // monitor body used for mutual exclusion
+            struct monitor_desc *  self_mon_p;        // pointer to monitor with sufficient lifetime for current monitors
+            struct __monitor_group_t monitors;        // monitors currently held by this thread
+            // Link lists fields
+            struct thread_desc * next;                // instrusive link field for threads
+        typedef void (*fptr_t)();
+        typedef int_fast16_t __lock_size_t;
+        struct __thread_queue_t {
+                struct thread_desc * head;
+                struct thread_desc ** tail;
+        };
+        struct __condition_stack_t {
+                struct __condition_criterion_t * top;
+        };
+        #ifdef __CFORALL__
+        extern "Cforall" {
+                void ?{}( struct __thread_queue_t & );
+                void append( struct __thread_queue_t &, struct thread_desc * );
+                struct thread_desc * pop_head( struct __thread_queue_t & );
+                struct thread_desc * remove( struct __thread_queue_t &, struct thread_desc ** );
+                void ?{}( struct __condition_stack_t & );
+                void push( struct __condition_stack_t &, struct __condition_criterion_t * );
+                struct __condition_criterion_t * pop( struct __condition_stack_t & );
+        }
+        #endif
+        struct coStack_t {
+                // size of stack
+                size_t size;
+                // pointer to stack
+                void *storage;
+                // stack grows towards stack limit
+                void *limit;
+                // base of stack
+                void *base;
+                // address of cfa_context_t
+                void *context;
+                // address of top of storage
+                void *top;
+                // whether or not the user allocated the stack
+                bool userStack;
+        };
+        enum coroutine_state { Halted, Start, Inactive, Active, Primed };
+        struct coroutine_desc {
+                // stack information of the coroutine
+                struct coStack_t stack;
+                // textual name for coroutine/task, initialized by uC++ generated code
+                const char *name;
+                // copy of global UNIX variable errno
+                int errno_;
+                // current execution status for coroutine
+                enum coroutine_state state;
+                // first coroutine to resume this one
+                struct coroutine_desc * starter;
+                // last coroutine to resume this one
+                struct coroutine_desc * last;
+        };
+        struct __waitfor_mask_t {
+                // the index of the accepted function, -1 if none
+                short * accepted;
+                // list of acceptable functions, null if any
+                struct __acceptable_t * clauses;
+                // number of acceptable functions
+                __lock_size_t size;
+        };
+        struct monitor_desc {
+                // spinlock to protect internal data
+                struct __spinlock_t lock;
+                // current owner of the monitor
+                struct thread_desc * owner;
+                // queue of threads that are blocked waiting for the monitor
+                struct __thread_queue_t entry_queue;
+                // stack of conditions to run next once we exit the monitor
+                struct __condition_stack_t signal_stack;
+                // monitor routines can be called recursively, we need to keep track of that
+                unsigned int recursion;
+                // mask used to know if some thread is waiting for something while holding the monitor
+                struct __waitfor_mask_t mask;
+                // node used to signal the dtor in a waitfor dtor
+                struct __condition_node_t * dtor_node;
+        };
+        struct __monitor_group_t {
+                // currently held monitors
+                struct monitor_desc ** list;
+                // number of currently held monitors
+                __lock_size_t size;
+                // last function that acquired monitors
+                fptr_t func;
+        };
+        struct thread_desc {
+                // Core threading fields
+                // coroutine body used to store context
+                struct coroutine_desc  self_cor;
+                // monitor body used for mutual exclusion
+                struct monitor_desc    self_mon;
+                // pointer to monitor with sufficient lifetime for current monitors
+                struct monitor_desc *  self_mon_p;
+                // monitors currently held by this thread
+                struct __monitor_group_t monitors;
+                // Link lists fields
+                // instrusive link field for threads
+                struct thread_desc * next;
      };
      #ifdef __CFORALL__
      extern "Cforall" {
             static inline monitor_desc * ?[?]( const __monitor_group_t & this, ptrdiff_t index ) {
                   return this.list[index];
+            }
             static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
                   if( (lhs.list != 0) != (rhs.list != 0) ) return false;
                   if( lhs.size != rhs.size ) return false;
                   if( lhs.func != rhs.func ) return false;
                   // Check that all the monitors match
                   for( int i = 0; i < lhs.size; i++ ) {
                         // If not a match, check next function
                         if( lhs[i] != rhs[i] ) return false;
+                  }
                   return true;
+            }
+      }
       #endif
+                static inline monitor_desc * ?[?]( const __monitor_group_t & this, ptrdiff_t index ) {
+                        return this.list[index];
+                }
+                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
+                        if( (lhs.list != 0) != (rhs.list != 0) ) return false;
+                        if( lhs.size != rhs.size ) return false;
+                        if( lhs.func != rhs.func ) return false;
+                        // Check that all the monitors match
+                        for( int i = 0; i < lhs.size; i++ ) {
+                                // If not a match, check next function
+                                if( lhs[i] != rhs[i] ) return false;
+                        }
+                        return true;
+                }
+        }
+        #endif
 #endif //_INVOKE_H_
 …
 #define _INVOKE_PRIVATE_H_
       struct machine_context_t {
             void *SP;
             void *FP;
             void *PC;
       };
       // assembler routines that performs the context switch
       extern void CtxInvokeStub( void );
       void CtxSwitch( void * from, void * to ) asm ("CtxSwitch");
       #if   defined( __x86_64__ )
       #define CtxGet( ctx ) __asm__ ( \
                   "movq %%rsp,%0\n"   \
                   "movq %%rbp,%1\n"   \
             : "=rm" (ctx.SP), "=rm" (ctx.FP) )
       #elif defined( __i386__ )
       #define CtxGet( ctx ) __asm__ ( \
                   "movl %%esp,%0\n"   \
                   "movl %%ebp,%1\n"   \
             : "=rm" (ctx.SP), "=rm" (ctx.FP) )
       #endif
+        struct machine_context_t {
+                void *SP;
+                void *FP;
+                void *PC;
+        };
+        // assembler routines that performs the context switch
+        extern void CtxInvokeStub( void );
+        void CtxSwitch( void * from, void * to ) asm ("CtxSwitch");
+        #if   defined( __x86_64__ )
+        #define CtxGet( ctx ) __asm__ ( \
+                        "movq %%rsp,%0\n"   \
+                        "movq %%rbp,%1\n"   \
+                : "=rm" (ctx.SP), "=rm" (ctx.FP) )
+        #elif defined( __i386__ )
+        #define CtxGet( ctx ) __asm__ ( \
+                        "movl %%esp,%0\n"   \
+                        "movl %%ebp,%1\n"   \
+                : "=rm" (ctx.SP), "=rm" (ctx.FP) )
+        #endif
 #endif //_INVOKE_PRIVATE_H_

src/libcfa/concurrency/kernel

-              rf5c3b6c
+              r0fe4e62
 //-----------------------------------------------------------------------------
 // Locks
+void lock      ( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, spin if already acquired
+void lock_yield( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, yield repeatedly if already acquired
+bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, return false if already acquired
+void unlock    ( spinlock * );                        // Unlock the spinlock
+// // Lock the spinlock, spin if already acquired
+// void lock      ( spinlock * DEBUG_CTX_PARAM2 );
+// // Lock the spinlock, yield repeatedly if already acquired
+// void lock_yield( spinlock * DEBUG_CTX_PARAM2 );
+// // Lock the spinlock, return false if already acquired
+// bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );
+// // Unlock the spinlock
+// void unlock    ( spinlock * );
 struct semaphore {
         spinlock lock;
+        __spinlock_t lock;
         int count;
         __thread_queue_t waiting;
 …
 void  ?{}(semaphore & this, int count = 1);
 void ^?{}(semaphore & this);
 void P(semaphore * this);
 void V(semaphore * this);
+void   P (semaphore & this);
+void   V (semaphore & this);
 …
 // Cluster
 struct cluster {
+        spinlock ready_queue_lock;                      // Ready queue locks
+        __thread_queue_t ready_queue;                   // Ready queue for threads
+        unsigned long long int preemption;              // Preemption rate on this cluster
+        // Ready queue locks
+        __spinlock_t ready_queue_lock;
+        // Ready queue for threads
+        __thread_queue_t ready_queue;
+        // Preemption rate on this cluster
+        unsigned long long int preemption;
 };
 void ?{}(cluster & this);
+void ?{} (cluster & this);
 void ^?{}(cluster & this);
 …
         FinishOpCode action_code;
         thread_desc * thrd;
         spinlock * lock;
         spinlock ** locks;
+        __spinlock_t * lock;
+        __spinlock_t ** locks;
         unsigned short lock_count;
         thread_desc ** thrds;
 …
 struct processor {
         // Main state
+        struct processorCtx_t * runner;                 // Coroutine ctx who does keeps the state of the processor
+        cluster * cltr;                                 // Cluster from which to get threads
+        pthread_t kernel_thread;                        // Handle to pthreads
+        // Coroutine ctx who does keeps the state of the processor
+        struct processorCtx_t * runner;
+        // Cluster from which to get threads
+        cluster * cltr;
+        // Handle to pthreads
+        pthread_t kernel_thread;
         // Termination
+        volatile bool do_terminate;                     // Set to true to notify the processor should terminate
+        semaphore terminated;                           // Termination synchronisation
+        // Set to true to notify the processor should terminate
+        volatile bool do_terminate;
+        // Termination synchronisation
+        semaphore terminated;
         // RunThread data
+        struct FinishAction finish;                     // Action to do after a thread is ran
+        // Action to do after a thread is ran
+        struct FinishAction finish;
         // Preemption data
+        struct alarm_node_t * preemption_alarm;         // Node which is added in the discrete event simulaiton
+        bool pending_preemption;                        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
+        // Node which is added in the discrete event simulaiton
+        struct alarm_node_t * preemption_alarm;
+        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
+        bool pending_preemption;
 #ifdef __CFA_DEBUG__
+        char * last_enable;                             // Last function to enable preemption on this processor
+        // Last function to enable preemption on this processor
+        char * last_enable;
 #endif
 };
 void ?{}(processor & this);
 void ?{}(processor & this, cluster * cltr);
+void  ?{}(processor & this);
+void  ?{}(processor & this, cluster * cltr);
 void ^?{}(processor & this);

src/libcfa/concurrency/kernel.c

-              rf5c3b6c
+              r0fe4e62
                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
                 this.do_terminate = true;
                 P( &this.terminated );
+                P( this.terminated );
                 pthread_join( this.kernel_thread, NULL );
+        }
 …
+        }
         V( &this->terminated );
+        V( this->terminated );
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
 …
 void finishRunning(processor * this) {
         if( this->finish.action_code == Release ) {
                 unlock( this->finish.lock );
+                unlock( *this->finish.lock );
+        }
         else if( this->finish.action_code == Schedule ) {
 …
+        }
         else if( this->finish.action_code == Release_Schedule ) {
                 unlock( this->finish.lock );
+                unlock( *this->finish.lock );
                 ScheduleThread( this->finish.thrd );
+        }
         else if( this->finish.action_code == Release_Multi ) {
                 for(int i = 0; i < this->finish.lock_count; i++) {
                         unlock( this->finish.locks[i] );
+                        unlock( *this->finish.locks[i] );
+                }
+        }
         else if( this->finish.action_code == Release_Multi_Schedule ) {
                 for(int i = 0; i < this->finish.lock_count; i++) {
                         unlock( this->finish.locks[i] );
+                        unlock( *this->finish.locks[i] );
+                }
                 for(int i = 0; i < this->finish.thrd_count; i++) {
 …
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
         lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
         append( &this_processor->cltr->ready_queue, thrd );
         unlock( &this_processor->cltr->ready_queue_lock );
+        lock(   this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
+        append( this_processor->cltr->ready_queue, thrd );
+        unlock( this_processor->cltr->ready_queue_lock );
         verify( disable_preempt_count > 0 );
 …
 thread_desc * nextThread(cluster * this) {
         verify( disable_preempt_count > 0 );
         lock( &this->ready_queue_lock DEBUG_CTX2 );
         thread_desc * head = pop_head( &this->ready_queue );
         unlock( &this->ready_queue_lock );
+        lock( this->ready_queue_lock DEBUG_CTX2 );
+        thread_desc * head = pop_head( this->ready_queue );
+        unlock( this->ready_queue_lock );
         verify( disable_preempt_count > 0 );
         return head;
 …
+}
 void BlockInternal( spinlock * lock ) {
+void BlockInternal( __spinlock_t * lock ) {
         disable_interrupts();
         this_processor->finish.action_code = Release;
 …
+}
 void BlockInternal( spinlock * lock, thread_desc * thrd ) {
+void BlockInternal( __spinlock_t * lock, thread_desc * thrd ) {
         assert(thrd);
         disable_interrupts();
 …
+}
 void BlockInternal(spinlock ** locks, unsigned short count) {
+void BlockInternal(__spinlock_t * locks [], unsigned short count) {
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi;
 …
+}
 void BlockInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) {
+void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi_Schedule;
 …
+}
 void LeaveThread(spinlock * lock, thread_desc * thrd) {
+void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
         verify( disable_preempt_count > 0 );
         this_processor->finish.action_code = thrd ? Release_Schedule : Release;
 …
+}
 static spinlock kernel_abort_lock;
 static spinlock kernel_debug_lock;
+static __spinlock_t kernel_abort_lock;
+static __spinlock_t kernel_debug_lock;
 static bool kernel_abort_called = false;
 …
         // abort cannot be recursively entered by the same or different processors because all signal handlers return when
         // the globalAbort flag is true.
         lock( &kernel_abort_lock DEBUG_CTX2 );
+        lock( kernel_abort_lock DEBUG_CTX2 );
         // first task to abort ?
         if ( !kernel_abort_called ) {                   // not first task to abort ?
                 kernel_abort_called = true;
                 unlock( &kernel_abort_lock );
+                unlock( kernel_abort_lock );
+        }
         else {
                 unlock( &kernel_abort_lock );
+                unlock( kernel_abort_lock );
                 sigset_t mask;
 …
 extern "C" {
         void __lib_debug_acquire() {
                 lock( &kernel_debug_lock DEBUG_CTX2 );
+                lock( kernel_debug_lock DEBUG_CTX2 );
+        }
         void __lib_debug_release() {
                 unlock( &kernel_debug_lock );
+                unlock( kernel_debug_lock );
+        }
+}
 …
 //-----------------------------------------------------------------------------
 // Locks
-void ?{}( spinlock & this ) {
-        this.lock = 0;
+}
-void ^?{}( spinlock & this ) {
+}
-bool try_lock( spinlock * this DEBUG_CTX_PARAM2 ) {
-        return this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
+}
-void lock( spinlock * this DEBUG_CTX_PARAM2 ) {
-        for ( unsigned int i = 1;; i += 1 ) {
-                if ( this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0 ) { break; }
+        }
-        LIB_DEBUG_DO(
-                this->prev_name = caller;
-                this->prev_thrd = this_thread;
+        )
+}
-void lock_yield( spinlock * this DEBUG_CTX_PARAM2 ) {
-        for ( unsigned int i = 1;; i += 1 ) {
-                if ( this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0 ) { break; }
-                yield();
+        }
-        LIB_DEBUG_DO(
-                this->prev_name = caller;
-                this->prev_thrd = this_thread;
+        )
+}
-void unlock( spinlock * this ) {
-        __sync_lock_release_4( &this->lock );
+}
 void  ?{}( semaphore & this, int count = 1 ) {
         (this.lock){};
 …
 void ^?{}(semaphore & this) {}
 void P(semaphore * this) {
         lock( &this->lock DEBUG_CTX2 );
         this->count -= 1;
         if ( this->count < 0 ) {
+void P(semaphore & this) {
+        lock( this.lock DEBUG_CTX2 );
+        this.count -= 1;
+        if ( this.count < 0 ) {
                 // queue current task
                 append( &this->waiting, (thread_desc *)this_thread );
+                append( this.waiting, (thread_desc *)this_thread );
                 // atomically release spin lock and block
                 BlockInternal( &this->lock );
+                BlockInternal( &this.lock );
+        }
         else {
             unlock( &this->lock );
+        }
+}
 void V(semaphore * this) {
+            unlock( this.lock );
+        }
+}
+void V(semaphore & this) {
         thread_desc * thrd = NULL;
         lock( &this->lock DEBUG_CTX2 );
         this->count += 1;
         if ( this->count <= 0 ) {
+        lock( this.lock DEBUG_CTX2 );
+        this.count += 1;
+        if ( this.count <= 0 ) {
                 // remove task at head of waiting list
                 thrd = pop_head( &this->waiting );
+        }
         unlock( &this->lock );
+                thrd = pop_head( this.waiting );
+        }
+        unlock( this.lock );
         // make new owner
 …
+}
 void append( __thread_queue_t * this, thread_desc * t ) {
         verify(this->tail != NULL);
         *this->tail = t;
         this->tail = &t->next;
+}
 thread_desc * pop_head( __thread_queue_t * this ) {
         thread_desc * head = this->head;
+void append( __thread_queue_t & this, thread_desc * t ) {
+        verify(this.tail != NULL);
+        *this.tail = t;
+        this.tail = &t->next;
+}
+thread_desc * pop_head( __thread_queue_t & this ) {
+        thread_desc * head = this.head;
         if( head ) {
                 this->head = head->next;
+                this.head = head->next;
                 if( !head->next ) {
                         this->tail = &this->head;
+                        this.tail = &this.head;
+                }
                 head->next = NULL;
 …
+}
 thread_desc * remove( __thread_queue_t * this, thread_desc ** it ) {
+thread_desc * remove( __thread_queue_t & this, thread_desc ** it ) {
         thread_desc * thrd = *it;
         verify( thrd );
 …
         (*it) = thrd->next;
         if( this->tail == &thrd->next ) {
                 this->tail = it;
+        if( this.tail == &thrd->next ) {
+                this.tail = it;
+        }
         thrd->next = NULL;
         verify( (this->head == NULL) == (&this->head == this->tail) );
         verify( *this->tail == NULL );
+        verify( (this.head == NULL) == (&this.head == this.tail) );
+        verify( *this.tail == NULL );
         return thrd;
+}
 …
+}
 void push( __condition_stack_t * this, __condition_criterion_t * t ) {
+void push( __condition_stack_t & this, __condition_criterion_t * t ) {
         verify( !t->next );
         t->next = this->top;
         this->top = t;
+}
 __condition_criterion_t * pop( __condition_stack_t * this ) {
         __condition_criterion_t * top = this->top;
+        t->next = this.top;
+        this.top = t;
+}
+__condition_criterion_t * pop( __condition_stack_t & this ) {
+        __condition_criterion_t * top = this.top;
         if( top ) {
                 this->top = top->next;
+                this.top = top->next;
                 top->next = NULL;
+        }

src/libcfa/concurrency/kernel_private.h

-              rf5c3b6c
+              r0fe4e62
 //Block current thread and release/wake-up the following resources
 void BlockInternal(void);
 void BlockInternal(spinlock * lock);
+void BlockInternal(__spinlock_t * lock);
 void BlockInternal(thread_desc * thrd);
 void BlockInternal(spinlock * lock, thread_desc * thrd);
 void BlockInternal(spinlock ** locks, unsigned short count);
 void BlockInternal(spinlock ** locks, unsigned short count, thread_desc ** thrds, unsigned short thrd_count);
 void LeaveThread(spinlock * lock, thread_desc * thrd);
+void BlockInternal(__spinlock_t * lock, thread_desc * thrd);
+void BlockInternal(__spinlock_t * locks [], unsigned short count);
+void BlockInternal(__spinlock_t * locks [], unsigned short count, thread_desc * thrds [], unsigned short thrd_count);
+void LeaveThread(__spinlock_t * lock, thread_desc * thrd);
 //-----------------------------------------------------------------------------
 …
 struct event_kernel_t {
         alarm_list_t alarms;
         spinlock lock;
+        __spinlock_t lock;
 };

src/libcfa/concurrency/monitor

-              rf5c3b6c
+              r0fe4e62
+}
-// static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
-//      return ((intptr_t)lhs) < ((intptr_t)rhs);
-// }
 struct monitor_guard_t {
         monitor_desc ** m;
         int count;
+        __lock_size_t   count;
         monitor_desc ** prev_mntrs;
         unsigned short  prev_count;
+        __lock_size_t   prev_count;
         fptr_t          prev_func;
 };
 void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() );
+void ?{}( monitor_guard_t & this, monitor_desc ** m, __lock_size_t count, void (*func)() );
 void ^?{}( monitor_guard_t & this );
 …
         monitor_desc * m;
         monitor_desc ** prev_mntrs;
         unsigned short  prev_count;
+        __lock_size_t   prev_count;
         fptr_t          prev_func;
 };
 …
 struct __condition_criterion_t {
+        bool ready;                                             //Whether or not the criterion is met (True if met)
+        monitor_desc * target;                          //The monitor this criterion concerns
+        struct __condition_node_t * owner;              //The parent node to which this criterion belongs
+        __condition_criterion_t * next;         //Intrusive linked list Next field
+        // Whether or not the criterion is met (True if met)
+        bool ready;
+        // The monitor this criterion concerns
+        monitor_desc * target;
+        // The parent node to which this criterion belongs
+        struct __condition_node_t * owner;
+        // Intrusive linked list Next field
+        __condition_criterion_t * next;
 };
 struct __condition_node_t {
+        thread_desc * waiting_thread;                   //Thread that needs to be woken when all criteria are met
+        __condition_criterion_t * criteria;     //Array of criteria (Criterions are contiguous in memory)
+        unsigned short count;                           //Number of criterions in the criteria
+        __condition_node_t * next;                      //Intrusive linked list Next field
+        uintptr_t user_info;                            //Custom user info accessible before signalling
+        // Thread that needs to be woken when all criteria are met
+        thread_desc * waiting_thread;
+        // Array of criteria (Criterions are contiguous in memory)
+        __condition_criterion_t * criteria;
+        // Number of criterions in the criteria
+        __lock_size_t count;
+        // Intrusive linked list Next field
+        __condition_node_t * next;
+        // Custom user info accessible before signalling
+        uintptr_t user_info;
 };
 …
 };
 void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info );
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info );
 void ?{}(__condition_criterion_t & this );
 void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
 void ?{}( __condition_blocked_queue_t & );
 void append( __condition_blocked_queue_t *, __condition_node_t * );
 __condition_node_t * pop_head( __condition_blocked_queue_t * );
+void append( __condition_blocked_queue_t &, __condition_node_t * );
+__condition_node_t * pop_head( __condition_blocked_queue_t & );
 struct condition {
+        __condition_blocked_queue_t blocked;    //Link list which contains the blocked threads as-well as the information needed to unblock them
+        monitor_desc ** monitors;                       //Array of monitor pointers (Monitors are NOT contiguous in memory)
+        unsigned short monitor_count;                   //Number of monitors in the array
+        // Link list which contains the blocked threads as-well as the information needed to unblock them
+        __condition_blocked_queue_t blocked;
+        // Array of monitor pointers (Monitors are NOT contiguous in memory)
+        monitor_desc ** monitors;
+        // Number of monitors in the array
+        __lock_size_t monitor_count;
 };
 …
+}
 void wait( condition * this, uintptr_t user_info = 0 );
 bool signal( condition * this );
 bool signal_block( condition * this );
 static inline bool is_empty( condition * this ) { return !this->blocked.head; }
 uintptr_t front( condition * this );
+              void wait        ( condition & this, uintptr_t user_info = 0 );
+              bool signal      ( condition & this );
+              bool signal_block( condition & this );
+static inline bool is_empty    ( condition & this ) { return !this.blocked.head; }
+         uintptr_t front       ( condition & this );
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/monitor.c

-              rf5c3b6c
+              r0fe4e62
 #include <stdlib>
+#include <inttypes.h>
 #include "libhdr.h"
 …
 // Forward declarations
 static inline void set_owner ( monitor_desc * this, thread_desc * owner );
 static inline void set_owner ( monitor_desc ** storage, short count, thread_desc * owner );
 static inline void set_mask  ( monitor_desc ** storage, short count, const __waitfor_mask_t & mask );
+static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner );
+static inline void set_mask  ( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
 static inline void reset_mask( monitor_desc * this );
 …
 static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
 static inline void lock_all( spinlock ** locks, unsigned short count );
 static inline void lock_all( monitor_desc ** source, spinlock ** /*out*/ locks, unsigned short count );
 static inline void unlock_all( spinlock ** locks, unsigned short count );
 static inline void unlock_all( monitor_desc ** locks, unsigned short count );
 static inline void save   ( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks );
 static inline void restore( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*in */ recursions, __waitfor_mask_t * /*in */ masks );
 static inline void init     ( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
 static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
+static inline void lock_all  ( __spinlock_t * locks [], __lock_size_t count );
+static inline void lock_all  ( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
+static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count );
+static inline void unlock_all( monitor_desc * locks [], __lock_size_t count );
+static inline void save   ( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
+static inline void restore( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
+static inline void init     ( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
 static inline thread_desc *        check_condition   ( __condition_criterion_t * );
 static inline void                 brand_condition   ( condition * );
 static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc ** monitors, int count );
+static inline void                 brand_condition   ( condition & );
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], __lock_size_t count );
 forall(dtype T | sized( T ))
+static inline short insert_unique( T ** array, short & size, T * val );
+static inline short count_max    ( const __waitfor_mask_t & mask );
+static inline short aggregate    ( monitor_desc ** storage, const __waitfor_mask_t & mask );
+static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val );
+static inline __lock_size_t count_max    ( const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
+#ifndef __CFA_LOCK_NO_YIELD
+#define DO_LOCK lock_yield
+#else
+#define DO_LOCK lock
+#endif
 //-----------------------------------------------------------------------------
 …
         __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
         __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
         init( count, monitors, &waiter, criteria );               /* Link everything together                                                            */ \
+        init( count, monitors, waiter, criteria );                /* Link everything together                                                            */ \
 #define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack                         */ \
         __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
         __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
         init_push( count, monitors, &waiter, criteria );          /* Link everything together and push it to the AS-Stack                                */ \
+        init_push( count, monitors, waiter, criteria );           /* Link everything together and push it to the AS-Stack                                */ \
 #define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
         monitor_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
         unsigned short count = cnt;                               /* Save the count to a local variable                                                  */ \
+        __lock_size_t count = cnt;                                /* Save the count to a local variable                                                  */ \
         unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
         __waitfor_mask_t masks[ count ];                          /* Save the current waitfor masks to restore them later                                */ \
         spinlock *   locks     [ count ];                         /* We need to pass-in an array of locks to BlockInternal                               */ \
+        __waitfor_mask_t masks [ count ];                         /* Save the current waitfor masks to restore them later                                */ \
+        __spinlock_t *   locks [ count ];                         /* We need to pass-in an array of locks to BlockInternal                               */ \
 #define monitor_save    save   ( monitors, count, locks, recursions, masks )
 …
         // Enter single monitor
         static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
                 // Lock the monitor spinlock, lock_yield to reduce contention
                 lock_yield( &this->lock DEBUG_CTX2 );
+                // Lock the monitor spinlock
+                DO_LOCK( this->lock DEBUG_CTX2 );
                 thread_desc * thrd = this_thread;
 …
                         // Some one else has the monitor, wait in line for it
                         append( &this->entry_queue, thrd );
+                        append( this->entry_queue, thrd );
                         BlockInternal( &this->lock );
 …
                 // Release the lock and leave
                 unlock( &this->lock );
+                unlock( this->lock );
                 return;
+        }
         static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
                 // Lock the monitor spinlock, lock_yield to reduce contention
                 lock_yield( &this->lock DEBUG_CTX2 );
+                // Lock the monitor spinlock
+                DO_LOCK( this->lock DEBUG_CTX2 );
                 thread_desc * thrd = this_thread;
 …
                         set_owner( this, thrd );
                         unlock( &this->lock );
+                        unlock( this->lock );
                         return;
+                }
 …
+                }
                 int count = 1;
+                __lock_size_t count = 1;
                 monitor_desc ** monitors = &this;
                 __monitor_group_t group = { &this, 1, func };
 …
                         // Wake the thread that is waiting for this
                         __condition_criterion_t * urgent = pop( &this->signal_stack );
+                        __condition_criterion_t * urgent = pop( this->signal_stack );
                         verify( urgent );
 …
                         // Some one else has the monitor, wait in line for it
                         append( &this->entry_queue, thrd );
+                        append( this->entry_queue, thrd );
                         BlockInternal( &this->lock );
 …
         // Leave single monitor
         void __leave_monitor_desc( monitor_desc * this ) {
                 // Lock the monitor spinlock, lock_yield to reduce contention
                 lock_yield( &this->lock DEBUG_CTX2 );
+                // Lock the monitor spinlock, DO_LOCK to reduce contention
+                DO_LOCK( this->lock DEBUG_CTX2 );
                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
 …
                 if( this->recursion != 0) {
                         LIB_DEBUG_PRINT_SAFE("Kernel :  recursion still %d\n", this->recursion);
                         unlock( &this->lock );
+                        unlock( this->lock );
                         return;
+                }
 …
                 // We can now let other threads in safely
                 unlock( &this->lock );
+                unlock( this->lock );
                 //We need to wake-up the thread
 …
                 // Lock the monitor now
                 lock_yield( &this->lock DEBUG_CTX2 );
+                DO_LOCK( this->lock DEBUG_CTX2 );
                 disable_interrupts();
 …
 // relies on the monitor array being sorted
 static inline void enter( __monitor_group_t monitors ) {
         for(int i = 0; i < monitors.size; i++) {
+        for( __lock_size_t i = 0; i < monitors.size; i++) {
                 __enter_monitor_desc( monitors.list[i], monitors );
+        }
 …
 // Leave multiple monitor
 // relies on the monitor array being sorted
 static inline void leave(monitor_desc ** monitors, int count) {
         for(int i = count - 1; i >= 0; i--) {
+static inline void leave(monitor_desc * monitors [], __lock_size_t count) {
+        for( __lock_size_t i = count - 1; i >= 0; i--) {
                 __leave_monitor_desc( monitors[i] );
+        }
 …
 // Ctor for monitor guard
 // Sorts monitors before entering
 void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, fptr_t func ) {
+void ?{}( monitor_guard_t & this, monitor_desc * m [], __lock_size_t count, fptr_t func ) {
         // Store current array
         this.m = m;
 …
         // Save previous thread context
+        this.prev_mntrs = this_thread->monitors.list;
+        this.prev_count = this_thread->monitors.size;
+        this.prev_func  = this_thread->monitors.func;
+        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
         // Update thread context (needed for conditions)
+        this_thread->monitors.list = m;
+        this_thread->monitors.size = count;
+        this_thread->monitors.func = func;
+        this_thread->monitors.[list, size, func] = [m, count, func];
         // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
 …
         // Restore thread context
+        this_thread->monitors.list = this.prev_mntrs;
+        this_thread->monitors.size = this.prev_count;
+        this_thread->monitors.func = this.prev_func;
+}
+        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
+}
 // Ctor for monitor guard
 // Sorts monitors before entering
 void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, fptr_t func ) {
+void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
         // Store current array
         this.m = *m;
         // Save previous thread context
+        this.prev_mntrs = this_thread->monitors.list;
+        this.prev_count = this_thread->monitors.size;
+        this.prev_func  = this_thread->monitors.func;
+        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
         // Update thread context (needed for conditions)
+        this_thread->monitors.list = m;
+        this_thread->monitors.size = 1;
+        this_thread->monitors.func = func;
+        this_thread->monitors.[list, size, func] = [m, 1, func];
         __enter_monitor_dtor( this.m, func );
+}
 // Dtor for monitor guard
 …
         // Restore thread context
+        this_thread->monitors.list = this.prev_mntrs;
+        this_thread->monitors.size = this.prev_count;
+        this_thread->monitors.func = this.prev_func;
+        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
+}
 //-----------------------------------------------------------------------------
 // Internal scheduling types
 void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
         this.count = count;
 …
+}
 void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner ) {
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
         this.ready  = false;
         this.target = target;
         this.owner  = owner;
+        this.owner  = &owner;
         this.next   = NULL;
+}
 …
 //-----------------------------------------------------------------------------
 // Internal scheduling
 void wait( condition * this, uintptr_t user_info = 0 ) {
+void wait( condition & this, uintptr_t user_info = 0 ) {
         brand_condition( this );
         // Check that everything is as expected
         assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
         verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
         verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
+        assertf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
+        verifyf( this.monitor_count < 32u, "Excessive monitor count (%"PRIiFAST16")", this.monitor_count );
         // Create storage for monitor context
         monitor_ctx( this->monitors, this->monitor_count );
+        monitor_ctx( this.monitors, this.monitor_count );
         // Create the node specific to this wait operation
 …
         // Append the current wait operation to the ones already queued on the condition
         // We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion
         append( &this->blocked, &waiter );
+        append( this.blocked, &waiter );
         // Lock all monitors (aggregates the locks as well)
 …
         // Find the next thread(s) to run
         short thread_count = 0;
+        __lock_size_t thread_count = 0;
         thread_desc * threads[ count ];
         __builtin_memset( threads, 0, sizeof( threads ) );
 …
         // Remove any duplicate threads
         for( int i = 0; i < count; i++) {
+        for( __lock_size_t i = 0; i < count; i++) {
                 thread_desc * new_owner = next_thread( monitors[i] );
                 insert_unique( threads, thread_count, new_owner );
 …
+}
 bool signal( condition * this ) {
+bool signal( condition & this ) {
         if( is_empty( this ) ) { return false; }
         //Check that everything is as expected
         verify( this->monitors );
         verify( this->monitor_count != 0 );
+        verify( this.monitors );
+        verify( this.monitor_count != 0 );
         //Some more checking in debug
         LIB_DEBUG_DO(
                 thread_desc * this_thrd = this_thread;
                 if ( this->monitor_count != this_thrd->monitors.size ) {
                         abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->monitors.size );
+                }
                 for(int i = 0; i < this->monitor_count; i++) {
                         if ( this->monitors[i] != this_thrd->monitors.list[i] ) {
                                 abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->monitors.list[i] );
+                if ( this.monitor_count != this_thrd->monitors.size ) {
+                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", &this, this.monitor_count, this_thrd->monitors.size );
+                }
+                for(int i = 0; i < this.monitor_count; i++) {
+                        if ( this.monitors[i] != this_thrd->monitors.list[i] ) {
+                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors.list[i] );
+                        }
+                }
         );
         unsigned short count = this->monitor_count;
+        __lock_size_t count = this.monitor_count;
         // Lock all monitors
         lock_all( this->monitors, NULL, count );
+        lock_all( this.monitors, NULL, count );
         //Pop the head of the waiting queue
         __condition_node_t * node = pop_head( &this->blocked );
+        __condition_node_t * node = pop_head( this.blocked );
         //Add the thread to the proper AS stack
 …
                 __condition_criterion_t * crit = &node->criteria[i];
                 assert( !crit->ready );
                 push( &crit->target->signal_stack, crit );
+                push( crit->target->signal_stack, crit );
+        }
         //Release
         unlock_all( this->monitors, count );
+        unlock_all( this.monitors, count );
         return true;
+}
 bool signal_block( condition * this ) {
         if( !this->blocked.head ) { return false; }
+bool signal_block( condition & this ) {
+        if( !this.blocked.head ) { return false; }
         //Check that everything is as expected
         verifyf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
         verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+        verifyf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
         // Create storage for monitor context
         monitor_ctx( this->monitors, this->monitor_count );
+        monitor_ctx( this.monitors, this.monitor_count );
         // Lock all monitors (aggregates the locks them as well)
 …
         //Find the thread to run
         thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
+        thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
         set_owner( monitors, count, signallee );
         LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", this, signallee );
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
         //Everything is ready to go to sleep
 …
 // Access the user_info of the thread waiting at the front of the queue
 uintptr_t front( condition * this ) {
+uintptr_t front( condition & this ) {
         verifyf( !is_empty(this),
                 "Attempt to access user data on an empty condition.\n"
                 "Possible cause is not checking if the condition is empty before reading stored data."
         );
         return this->blocked.head->user_info;
+        return this.blocked.head->user_info;
+}
 …
         // This statment doesn't have a contiguous list of monitors...
         // Create one!
         short max = count_max( mask );
+        __lock_size_t max = count_max( mask );
         monitor_desc * mon_storage[max];
         __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
         short actual_count = aggregate( mon_storage, mask );
         LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (short)max);
+        __lock_size_t actual_count = aggregate( mon_storage, mask );
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
         if(actual_count == 0) return;
 …
                                 __condition_criterion_t * dtor_crit = mon2dtor->dtor_node->criteria;
                                 push( &mon2dtor->signal_stack, dtor_crit );
+                                push( mon2dtor->signal_stack, dtor_crit );
                                 unlock_all( locks, count );
 …
         set_mask( monitors, count, mask );
         for(int i = 0; i < count; i++) {
+        for( __lock_size_t i = 0; i < count; i++) {
                 verify( monitors[i]->owner == this_thread );
+        }
 …
+}
 static inline void set_owner( monitor_desc ** monitors, short count, thread_desc * owner ) {
+static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
         monitors[0]->owner     = owner;
         monitors[0]->recursion = 1;
         for( int i = 1; i < count; i++ ) {
+        for( __lock_size_t i = 1; i < count; i++ ) {
                 monitors[i]->owner     = owner;
                 monitors[i]->recursion = 0;
 …
+}
 static inline void set_mask( monitor_desc ** storage, short count, const __waitfor_mask_t & mask ) {
         for(int i = 0; i < count; i++) {
+static inline void set_mask( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
+        for( __lock_size_t i = 0; i < count; i++) {
                 storage[i]->mask = mask;
+        }
 …
         //Check the signaller stack
         LIB_DEBUG_PRINT_SAFE("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
         __condition_criterion_t * urgent = pop( &this->signal_stack );
+        __condition_criterion_t * urgent = pop( this->signal_stack );
         if( urgent ) {
                 //The signaller stack is not empty,
 …
         // No signaller thread
         // Get the next thread in the entry_queue
         thread_desc * new_owner = pop_head( &this->entry_queue );
+        thread_desc * new_owner = pop_head( this->entry_queue );
         set_owner( this, new_owner );
 …
 static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
         __acceptable_t * it = this->mask.clauses; // Optim
         int count = this->mask.size;
+        __lock_size_t count = this->mask.size;
         // Check if there are any acceptable functions
 …
         // For all acceptable functions check if this is the current function.
         for( short i = 0; i < count; i++, it++ ) {
+        for( __lock_size_t i = 0; i < count; i++, it++ ) {
                 if( *it == group ) {
                         *this->mask.accepted = i;
 …
+}
 static inline void init( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
         for(int i = 0; i < count; i++) {
+static inline void init( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+        for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
+        }
         waiter->criteria = criteria;
+}
 static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
         for(int i = 0; i < count; i++) {
+        waiter.criteria = criteria;
+}
+static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+        for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
                 LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
                 push( &criteria[i].target->signal_stack, &criteria[i] );
+        }
         waiter->criteria = criteria;
+}
 static inline void lock_all( spinlock ** locks, unsigned short count ) {
         for( int i = 0; i < count; i++ ) {
                 lock_yield( locks[i] DEBUG_CTX2 );
+        }
+}
 static inline void lock_all( monitor_desc ** source, spinlock ** /*out*/ locks, unsigned short count ) {
         for( int i = 0; i < count; i++ ) {
                 spinlock * l = &source[i]->lock;
                 lock_yield( l DEBUG_CTX2 );
+                push( criteria[i].target->signal_stack, &criteria[i] );
+        }
+        waiter.criteria = criteria;
+}
+static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
+                DO_LOCK( *locks[i] DEBUG_CTX2 );
+        }
+}
+static inline void lock_all( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
+                __spinlock_t * l = &source[i]->lock;
+                DO_LOCK( *l DEBUG_CTX2 );
                 if(locks) locks[i] = l;
+        }
+}
+static inline void unlock_all( spinlock ** locks, unsigned short count ) {
+        for( int i = 0; i < count; i++ ) {
+                unlock( locks[i] );
+        }
+}
+static inline void unlock_all( monitor_desc ** locks, unsigned short count ) {
+        for( int i = 0; i < count; i++ ) {
+                unlock( &locks[i]->lock );
+        }
+}
+static inline void save( monitor_desc ** ctx, short count, __attribute((unused)) spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
+        for( int i = 0; i < count; i++ ) {
+static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count ) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
+                unlock( *locks[i] );
+        }
+}
+static inline void unlock_all( monitor_desc * locks [], __lock_size_t count ) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
+                unlock( locks[i]->lock );
+        }
+}
+static inline void save(
+        monitor_desc * ctx [],
+        __lock_size_t count,
+        __attribute((unused)) __spinlock_t * locks [],
+        unsigned int /*out*/ recursions [],
+        __waitfor_mask_t /*out*/ masks []
+) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
                 recursions[i] = ctx[i]->recursion;
                 masks[i]      = ctx[i]->mask;
 …
+}
+static inline void restore( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
+static inline void restore(
+        monitor_desc * ctx [],
+        __lock_size_t count,
+        __spinlock_t * locks [],
+        unsigned int /*out*/ recursions [],
+        __waitfor_mask_t /*out*/ masks []
+) {
         lock_all( locks, count );
         for( int i = 0; i < count; i++ ) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
                 ctx[i]->recursion = recursions[i];
                 ctx[i]->mask      = masks[i];
 …
+}
 static inline void brand_condition( condition * this ) {
+static inline void brand_condition( condition & this ) {
         thread_desc * thrd = this_thread;
         if( !this->monitors ) {
+        if( !this.monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
                 assertf( thrd->monitors.list != NULL, "No current monitor to brand condition %p", thrd->monitors.list );
                 this->monitor_count = thrd->monitors.size;
                 this->monitors = malloc( this->monitor_count * sizeof( *this->monitors ) );
                 for( int i = 0; i < this->monitor_count; i++ ) {
                         this->monitors[i] = thrd->monitors.list[i];
+                }
+        }
+}
 static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc ** monitors, int count ) {
         __thread_queue_t * entry_queue = &monitors[0]->entry_queue;
+                this.monitor_count = thrd->monitors.size;
+                this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
+                for( int i = 0; i < this.monitor_count; i++ ) {
+                        this.monitors[i] = thrd->monitors.list[i];
+                }
+        }
+}
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
+        __thread_queue_t & entry_queue = monitors[0]->entry_queue;
         // For each thread in the entry-queue
         for(    thread_desc ** thrd_it = &entry_queue->head;
+        for(    thread_desc ** thrd_it = &entry_queue.head;
                 *thrd_it;
                 thrd_it = &(*thrd_it)->next
 …
 forall(dtype T | sized( T ))
 static inline short insert_unique( T ** array, short & size, T * val ) {
+static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val ) {
         if( !val ) return size;
         for(int i = 0; i <= size; i++) {
+        for( __lock_size_t i = 0; i <= size; i++) {
                 if( array[i] == val ) return size;
+        }
 …
+}
 static inline short count_max( const __waitfor_mask_t & mask ) {
         short max = 0;
         for( int i = 0; i < mask.size; i++ ) {
+static inline __lock_size_t count_max( const __waitfor_mask_t & mask ) {
+        __lock_size_t max = 0;
+        for( __lock_size_t i = 0; i < mask.size; i++ ) {
                 max += mask.clauses[i].size;
+        }
 …
+}
 static inline short aggregate( monitor_desc ** storage, const __waitfor_mask_t & mask ) {
         short size = 0;
         for( int i = 0; i < mask.size; i++ ) {
+static inline __lock_size_t aggregate( monitor_desc * storage [], const __waitfor_mask_t & mask ) {
+        __lock_size_t size = 0;
+        for( __lock_size_t i = 0; i < mask.size; i++ ) {
                 __libcfa_small_sort( mask.clauses[i].list, mask.clauses[i].size );
                 for( int j = 0; j < mask.clauses[i].size; j++) {
+                for( __lock_size_t j = 0; j < mask.clauses[i].size; j++) {
                         insert_unique( storage, size, mask.clauses[i].list[j] );
+                }
 …
+}
 void append( __condition_blocked_queue_t * this, __condition_node_t * c ) {
         verify(this->tail != NULL);
         *this->tail = c;
         this->tail = &c->next;
+}
 __condition_node_t * pop_head( __condition_blocked_queue_t * this ) {
         __condition_node_t * head = this->head;
+void append( __condition_blocked_queue_t & this, __condition_node_t * c ) {
+        verify(this.tail != NULL);
+        *this.tail = c;
+        this.tail = &c->next;
+}
+__condition_node_t * pop_head( __condition_blocked_queue_t & this ) {
+        __condition_node_t * head = this.head;
         if( head ) {
                 this->head = head->next;
+                this.head = head->next;
                 if( !head->next ) {
                         this->tail = &this->head;
+                        this.tail = &this.head;
+                }
                 head->next = NULL;

src/libcfa/concurrency/preemption.c

-              rf5c3b6c
+              r0fe4e62
                 case SI_KERNEL:
                         // LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
                         lock( &event_kernel->lock DEBUG_CTX2 );
+                        lock( event_kernel->lock DEBUG_CTX2 );
                         tick_preemption();
                         unlock( &event_kernel->lock );
+                        unlock( event_kernel->lock );
                         break;
                 // Signal was not sent by the kernel but by an other thread

src/main.cc

rf5c3b6c	r0fe4e62
206	206	FILE * extras = fopen( libcfap \| treep ? "../prelude/extras.cf" : CFA_LIBDIR "/extras.cf", "r" );
207	207	assertf( extras, "cannot open extras.cf\n" );
208		parse( extras, LinkageSpec::C );
	208	parse( extras, LinkageSpec::BuiltinC );
209	209
210	210	if ( ! libcfap ) {

src/prelude/builtins.c

-              rf5c3b6c
+              r0fe4e62
 } // ?\?
+static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
+double ?\?( T x, signed long int y ) {
+    if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
+    else return 1.0 / x \ (unsigned long int)(-y);
+} // ?\?
+// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither
+// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify
+// X as a type that casts to double, yet it doesn't make sense to write functions with that type
+// signature where X is double.
+// static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
+// double ?\?( T x, signed long int y ) {
+//     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
+//     else return 1.0 / x \ (unsigned long int)(-y);
+// } // ?\?
 static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }

src/tests/.expect/32/KRfunctions.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){
     __attribute__ ((unused)) signed int ___retval_f0__i_1;

src/tests/.expect/32/attributes.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 signed int __la__Fi___1(){
     __attribute__ ((unused)) signed int ___retval_la__i_1;

src/tests/.expect/32/declarationSpecifier.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 volatile const signed short int __x1__CVs_1;
 static volatile const signed short int __x2__CVs_1;
 …
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 static inline signed int invoke_main(signed int argc, char **argv, char **envp);
 signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

src/tests/.expect/32/extension.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 __extension__ signed int __a__i_1;
 __extension__ signed int __b__i_1;

src/tests/.expect/32/gccExtensions.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 extern signed int __x__i_1 asm ( "xx" );
 signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
 …
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 static inline signed int invoke_main(signed int argc, char **argv, char **envp);
 signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

src/tests/.expect/32/literals.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 void __for_each__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
 void __for_each_reverse__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
 …
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi___1(); }
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 static inline signed int invoke_main(signed int argc, char **argv, char **envp);
 signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

src/tests/.expect/64/KRfunctions.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){
     __attribute__ ((unused)) signed int ___retval_f0__i_1;

src/tests/.expect/64/attributes.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 signed int __la__Fi___1(){
     __attribute__ ((unused)) signed int ___retval_la__i_1;

src/tests/.expect/64/declarationSpecifier.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 volatile const signed short int __x1__CVs_1;
 static volatile const signed short int __x2__CVs_1;
 …
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 static inline signed int invoke_main(signed int argc, char **argv, char **envp);
 signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

src/tests/.expect/64/extension.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 __extension__ signed int __a__i_1;
 __extension__ signed int __b__i_1;

src/tests/.expect/64/gccExtensions.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 extern signed int __x__i_1 asm ( "xx" );
 signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
 …
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 static inline signed int invoke_main(signed int argc, char **argv, char **envp);
 signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

src/tests/.expect/64/literals.txt

-              rf5c3b6c
+              r0fe4e62
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 void __for_each__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
 void __for_each_reverse__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
 …
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi___1(); }
-__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
-__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
-__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
-__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
-extern signed int printf(const char *__restrict __format, ...);
 static inline signed int invoke_main(signed int argc, char **argv, char **envp);
 signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

src/tests/boundedBuffer.c

-              rf5c3b6c
+              r0fe4e62
 //
+//
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // boundedBuffer.c --
 //
+//
+// boundedBuffer.c --
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Oct 30 12:45:13 2017
 …
 // Last Modified On : Mon Oct 30 23:02:46 2017
 // Update Count     : 9
 //
+//
 #include <stdlib>
 …
 void insert( Buffer & mutex buffer, int elem ) {
         if ( buffer.count == 20 ) wait( &buffer.empty );
+        if ( buffer.count == 20 ) wait( buffer.empty );
         buffer.elements[buffer.back] = elem;
         buffer.back = ( buffer.back + 1 ) % 20;
         buffer.count += 1;
         signal( &buffer.full );
+        signal( buffer.full );
+}
 int remove( Buffer & mutex buffer ) {
         if ( buffer.count == 0 ) wait( &buffer.full );
+        if ( buffer.count == 0 ) wait( buffer.full );
         int elem = buffer.elements[buffer.front];
         buffer.front = ( buffer.front + 1 ) % 20;
         buffer.count -= 1;
         signal( &buffer.empty );
+        signal( buffer.empty );
         return elem;
+}

src/tests/datingService.c

-              rf5c3b6c
+              r0fe4e62
 //                               -*- Mode: C -*-
 //
+//                               -*- Mode: C -*-
+//
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // datingService.c --
 //
+//
+// datingService.c --
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Oct 30 12:56:20 2017
 …
 // Last Modified On : Mon Oct 30 23:02:11 2017
 // Update Count     : 15
 //
+//
 #include <stdlib>                                                                               // random
 …
 #include <thread>
 #include <unistd.h>                                                                             // getpid
-bool empty( condition & c ) {
-        return c.blocked.head == NULL;
+}
 enum { NoOfPairs = 20 };
 …
 unsigned int girl( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) {
         if ( empty( ds.Boys[ccode] ) ) {
                 wait( &ds.Girls[ccode] );
+        if ( is_empty( ds.Boys[ccode] ) ) {
+                wait( ds.Girls[ccode] );
                 ds.GirlPhoneNo = PhoneNo;
         } else {
                 ds.GirlPhoneNo = PhoneNo;
                 signal_block( &ds.Boys[ccode] );
+                signal_block( ds.Boys[ccode] );
         } // if
         return ds.BoyPhoneNo;
 …
 unsigned int boy( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) {
         if ( empty( ds.Girls[ccode] ) ) {
                 wait( &ds.Boys[ccode] );
+        if ( is_empty( ds.Girls[ccode] ) ) {
+                wait( ds.Boys[ccode] );
                 ds.BoyPhoneNo = PhoneNo;
         } else {
                 ds.BoyPhoneNo = PhoneNo;
                 signal_block( &ds.Girls[ccode] );
+                signal_block( ds.Girls[ccode] );
         } // if
         return ds.GirlPhoneNo;

src/tests/sched-int-barge.c

-              rf5c3b6c
+              r0fe4e62
         if( action == c.do_wait1 || action == c.do_wait2 ) {
                 c.state = WAIT;
                 wait( &cond );
+                wait( cond );
                 if(c.state != SIGNAL) {
 …
                 c.state = SIGNAL;
                 signal( &cond );
                 signal( &cond );
+                signal( cond );
+                signal( cond );
+        }
         else {

src/tests/sched-int-block.c

-              rf5c3b6c
+              r0fe4e62
 //------------------------------------------------------------------------------
 void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) {
         wait( &cond, (uintptr_t)this_thread );
+        wait( cond, (uintptr_t)this_thread );
         yield( random( 10 ) );
 …
         [a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread;
         if( !is_empty( &cond ) ) {
+        if( !is_empty( cond ) ) {
                 thread_desc * next = front( &cond );
+                thread_desc * next = front( cond );
                 if( ! signal_block( &cond ) ) {
+                if( ! signal_block( cond ) ) {
                         sout | "ERROR expected to be able to signal" | endl;
                         abort();

src/tests/sched-int-disjoint.c

-              rf5c3b6c
+              r0fe4e62
 // Waiting logic
 bool wait( global_t & mutex m, global_data_t & mutex d ) {
         wait( &cond );
+        wait( cond );
         if( d.state != SIGNAL ) {
                 sout | "ERROR barging!" | endl;
 …
 //------------------------------------------------------------------------------
 // Signalling logic
 void signal( condition * cond, global_t & mutex a, global_data_t & mutex b ) {
+void signal( condition & cond, global_t & mutex a, global_data_t & mutex b ) {
         b.state = SIGNAL;
         signal( cond );
 …
 void logic( global_t & mutex a ) {
         signal( &cond, a, data );
+        signal( cond, a, data );
         yield( random( 10 ) );

src/tests/sched-int-wait.c

-              rf5c3b6c
+              r0fe4e62
 //----------------------------------------------------------------------------------------------------
 // Tools
 void signal( condition * cond, global_t & mutex a, global_t & mutex b ) {
+void signal( condition & cond, global_t & mutex a, global_t & mutex b ) {
         signal( cond );
+}
 void signal( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
+void signal( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
         signal( cond );
+}
 void wait( condition * cond, global_t & mutex a, global_t & mutex b ) {
+void wait( condition & cond, global_t & mutex a, global_t & mutex b ) {
         wait( cond );
+}
 void wait( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
+void wait( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
         wait( cond );
+}
 …
                 switch( action ) {
                         case 0:
                                 signal( &condABC, globalA, globalB, globalC );
+                                signal( condABC, globalA, globalB, globalC );
                                 break;
                         case 1:
                                 signal( &condAB , globalA, globalB );
+                                signal( condAB , globalA, globalB );
                                 break;
                         case 2:
                                 signal( &condBC , globalB, globalC );
+                                signal( condBC , globalB, globalC );
                                 break;
                         case 3:
                                 signal( &condAC , globalA, globalC );
+                                signal( condAC , globalA, globalC );
                                 break;
                         default:
 …
 void main( WaiterABC & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condABC, globalA, globalB, globalC );
+                wait( condABC, globalA, globalB, globalC );
+        }
 …
 void main( WaiterAB & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condAB , globalA, globalB );
+                wait( condAB , globalA, globalB );
+        }
 …
 void main( WaiterAC & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condAC , globalA, globalC );
+                wait( condAC , globalA, globalC );
+        }
 …
 void main( WaiterBC & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condBC , globalB, globalC );
+                wait( condBC , globalB, globalC );
+        }

src/tests/thread.c

-              rf5c3b6c
+              r0fe4e62
                 yield();
+        }
         V(this.lock);
+        V(*this.lock);
+}
 void main(Second& this) {
         P(this.lock);
+        P(*this.lock);
         for(int i = 0; i < 10; i++) {
                 sout | "Second : Suspend No." | i + 1 | endl;

Context Navigation

Legend:

Download in other formats: