Changeset 692be4e

Timestamp:

Jan 29, 2019, 1:49:06 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

72514aa

Parents:

528ccc8 (diff), 8f99233 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'jenkins-sandbox' of plg.uwaterloo.ca:software/cfa/cfa-cc into jenkins-sandbox

Files:

• Jenkinsfile (modified) (7 diffs)
• benchmark/jenkins.sh (added)
• doc/theses/aaron_moss_PhD/phd/background.tex (modified) (1 diff)
• doc/theses/aaron_moss_PhD/phd/resolution-heuristics.tex (modified) (1 diff)
• driver/cfa.cc (modified) (4 diffs)
• src/ResolvExpr/AlternativeFinder.cc (modified) (3 diffs)
• src/ResolvExpr/ResolveAssertions.cc (modified) (13 diffs)
• src/SymTab/Mangler.cc (modified) (6 diffs)
• src/SymTab/Mangler.h (modified) (2 diffs)
• src/main.cc (modified) (2 diffs)
• tests/abort.cfa (added)
• tests/pybin/print-core.gdb (added)
• tests/pybin/tools.py (modified) (4 diffs)
• tests/test.py (modified) (5 diffs)
• tools/PrettyGitLogs.sh (modified) (1 diff)

Jenkinsfile

@@ -7 +7 @@
 node('master') {
         // Globals
-        BuildDir  = null
-        SrcDir    = null
+        BuildDir  = pwd tmp: true
+        SrcDir    = pwd tmp: false
         Settings  = null
         StageName = ''
@@ -46 +46 @@
                                 publish()
                         }
+
+                        // Update the build directories when exiting the node
+                        BuildDir  = pwd tmp: true
+                        SrcDir    = pwd tmp: false
 
                         notify_server(45)
@@ -149 +153 @@
                 dir (BuildDir) {
                         //Append bench results
-                        sh "make --no-print-directory -C benchmark jenkins githash=${Settings.GitNewRef} arch=${Settings.Architecture} | tee ${SrcDir}/bench.json"
+                        sh "${SrcDir}/jenkins.sh ${GitNewRef} ${Architecture} ${BuildDir}/bench.json"
                 }
         }
@@ -175 +179 @@
 
                 //Then publish the results
-                sh 'curl --silent --show-error -H \'Content-Type: application/json\' --data @bench.json https://cforall.uwaterloo.ca:8082/jenkins/publish > /dev/null || true'
+                sh 'curl --silent --show-error -H \'Content-Type: application/json\' --data @${BuildDir}/bench.json https://cforall.uwaterloo.ca:8082/jenkins/publish > /dev/null || true'
         }
 }
@@ -185 +189 @@
         if (!Settings || !Settings.GitOldRef || !Settings.GitNewRef) return "\nERROR retrieveing git information!\n"
 
-        sh "${SrcDir}/tools/PrettyGitLogs.sh ${BuildDir} ${Settings.GitOldRef} ${Settings.GitNewRef}"
+        sh "${SrcDir}/tools/PrettyGitLogs.sh ${SrcDir} ${BuildDir} ${Settings.GitOldRef} ${Settings.GitNewRef}"
 
         def gitUpdate = readFile("${BuildDir}/GIT_UPDATE")
@@ -377 +381 @@
                 ]])
 
+        // It's unfortunate but it looks like we need to checkout the entire repo just to get the pretty git printer
+        checkout scm
+
         final settings = new BuildSettings(params, env.BRANCH_NAME)
 
@@ -404 +411 @@
         catch (Exception caughtError) {
                 err = caughtError //rethrow error later
-                sh 'cat *.log'
+                sh 'cat build/*.log'
         }
         finally {

doc/theses/aaron_moss_PhD/phd/background.tex

@@ -213 +213 @@
 The ability of types to begin or cease to satisfy traits when declarations go into or out of scope makes caching of trait satisfaction judgements difficult, and the ability of traits to take multiple type parameters can lead to a combinatorial explosion of work in any attempt to pre-compute trait satisfaction relationships. 
 
-\subsection{Implicit Conversions}
+\subsection{Implicit Conversions} \label{implicit-conv-sec}
 
 In addition to the multiple interpretations of an expression produced by name overloading and polymorphic functions, for backward compatibility \CFA{} must support all of the implicit conversions present in C, producing further candidate interpretations for expressions. 

doc/theses/aaron_moss_PhD/phd/resolution-heuristics.tex

@@ -2 +2 @@
 \label{resolution-chap}
 
-Talk about the resolution heuristics. This is the bulk of the thesis.
+The main task of the \CFACC{} type-checker is \emph{expression resolution}, determining which declarations the identifiers in each expression correspond to. 
+Resolution is a straightforward task in C, as each declaration has a unique identifier, but in \CFA{} the name overloading features discussed in Section~\ref{overloading-sec} generate multiple candidate declarations for each identifier.
+I refer to a given matching between identifiers and declarations in an expression as an \emph{interpretation}; an interpretation also includes information about polymorphic type bindings and implicit casts to support the \CFA{} features discussed in Sections~\ref{poly-func-sec} and~\ref{implicit-conv-sec}, each of which increase the proportion of feasible candidate interpretations. 
+To choose between feasible interpretations, \CFA{} defines a \emph{conversion cost} to rank interpretations; the expression resolution problem is thus to find the unique minimal-cost interpretation for an expression, reporting an error if no such interpretation exists.
+
+\section{Conversion Cost}
+
+
 
 % Discuss changes to cost model, as promised in Ch. 2
+
+% Mention relevance of work to C++20 concepts

driver/cfa.cc

@@ -10 +10 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep 14 23:02:59 2018
-// Update Count     : 277
+// Last Modified On : Tue Jan 15 20:56:03 2019
+// Update Count     : 280
 //
 
@@ -384 +384 @@
         nargs += 1;
 
+        for ( int i = 0; i < nlibs; i += 1 ) {                          // copy non-user libraries after all user libraries
+                args[nargs] = libs[i];
+                nargs += 1;
+        } // for
+
         if ( link ) {
                 args[nargs] = "-Xlinker";
@@ -414 +419 @@
                 nargs += 1;
                 args[nargs] = "-lrt";
+                nargs += 1;
+                args[nargs] = "-lm";
                 nargs += 1;
         } // if
@@ -498 +505 @@
                 args[nargs] = ( *new string( string("-B") + Bprefix ) ).c_str();
                 nargs += 1;
-                args[nargs] = "-lm";
-                nargs += 1;
         } else {
                 cerr << argv[0] << " error, compiler \"" << compiler_name << "\" unsupported." << endl;
                 exit( EXIT_FAILURE );
         } // if
-
-        for ( int i = 0; i < nlibs; i += 1 ) {                          // copy non-user libraries after all user libraries
-                args[nargs] = libs[i];
-                nargs += 1;
-        } // for
 
         args[nargs] = NULL;                                                                     // terminate with NULL

src/ResolvExpr/AlternativeFinder.cc

@@ -474 +474 @@
                 }
 
-                // mark specialization cost of return types
-                for ( DeclarationWithType* returnVal : function->returnVals ) {
-                        convCost.decSpec( specCost( returnVal->get_type() ) );
-                }
+                // specialization cost of return types can't be accounted for directly, it disables 
+                // otherwise-identical calls, like this example based on auto-newline in the I/O lib:
+                //
+                //   forall(otype OS) {
+                //     void ?|?(OS&, int);  // with newline
+                //     OS&  ?|?(OS&, int);  // no newline, always chosen due to more specialization
+                //   }
 
                 // mark type variable and specialization cost of forall clause
@@ -483 +486 @@
                 for ( TypeDecl* td : function->forall ) {
                         convCost.decSpec( td->assertions.size() );
-                }
-
-                // xxx -- replace with new costs in resolver
-                for ( InferredParams::const_iterator assert = appExpr->inferParams.begin(); assert != appExpr->inferParams.end(); ++assert ) {
-                        convCost += computeConversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
                 }
 
@@ -1229 +1227 @@
                                 Alternative newAlt{ 
                                         restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), 
-                                        alt.env, openVars, needAssertions, alt.cost + thisCost, thisCost };
+                                        alt.env, openVars, needAssertions, alt.cost, alt.cost + thisCost };
                                 inferParameters( newAlt, back_inserter( candidates ) );
                         } // if

src/ResolvExpr/ResolveAssertions.cc

@@ -20 +20 @@
 #include <list>                     // for list
 #include <memory>                   // for unique_ptr
+#include <string>
 #include <unordered_map>            // for unordered_map, unordered_multimap
 #include <utility>                  // for move
@@ -55 +56 @@
         using CandidateList = std::vector<AssnCandidate>;
 
+        /// Unique identifier for a yet-to-be-resolved assertion
+        struct AssnId {
+                DeclarationWithType* decl;  ///< Declaration of assertion
+                AssertionSetValue info;     ///< Information about assertion
+
+                AssnId(DeclarationWithType* decl, const AssertionSetValue& info) : decl(decl), info(info) {}
+        };
+
+        /// Cached assertion items
+        struct AssnCacheItem {
+                CandidateList matches;         ///< Possible matches for this assertion
+                std::vector<AssnId> deferIds;  ///< Deferred assertions which resolve to this item
+
+                AssnCacheItem( CandidateList&& m ) : matches(std::move(m)), deferIds() {}
+        };
+
+        /// Cache of resolved assertions
+        using AssnCache = std::unordered_map<std::string, AssnCacheItem>;
+
         /// Reference to single deferred item
         struct DeferRef {
-                const DeclarationWithType* decl;
-                const AssertionSetValue& info;
+                const AssnCacheItem& item;
                 const AssnCandidate& match;
         };
@@ -65 +84 @@
         /// Acts like indexed list of DeferRef
         struct DeferItem {
-                DeclarationWithType* decl;
-                AssertionSetValue info;
-                CandidateList matches;
-
-                DeferItem( DeclarationWithType* decl, const AssertionSetValue& info, 
-                        CandidateList&& matches )
-                : decl(decl), info(info), matches(std::move(matches)) {}
-
-                bool empty() const { return matches.empty(); }
-
-                CandidateList::size_type size() const { return matches.size(); }
-
-                DeferRef operator[] ( unsigned i ) const { return { decl, info, matches[i] }; }
+                const AssnCache* cache;     ///< Cache storing assertion item
+                std::string key;            ///< Key into cache
+                
+                DeferItem( const AssnCache& cache, const std::string& key ) : cache(&cache), key(key) {}
+
+                bool empty() const { return cache->at(key).matches.empty(); }
+
+                CandidateList::size_type size() const { return cache->at(key).matches.size(); }
+
+                DeferRef operator[] ( unsigned i ) const {
+                        const AssnCacheItem& item = cache->at(key);
+                        return { item, item.matches[i] };
+                }
+
+                // sortable by key
+                // TODO look into optimizing combination process with other sort orders (e.g. by number 
+                // of matches in candidate)
+                bool operator< ( const DeferItem& o ) const { return key < o.key; }
+                bool operator== ( const DeferItem& o ) const { return key == o.key; }
         };
 
@@ -152 +177 @@
                                 for ( const auto& assn : x.assns ) {
                                         k += computeConversionCost( 
-                                                assn.match.adjType, assn.decl->get_type(), indexer, x.env );
+                                                assn.match.adjType, assn.item.deferIds[0].decl->get_type(), indexer, 
+                                                x.env );
                                 }
                                 it = cache.emplace_hint( it, &x, k );
@@ -208 +234 @@
                                 candidate->get_uniqueId(), match.adjType->clone(), decl->get_type()->clone(), 
                                 varExpr };
-
-                // // follow the current assertion's ID chain to find the correct set of inferred parameters 
-                // // to add the candidate o (i.e. the set of inferred parameters belonging to the entity 
-                // // which requested the assertion parameter)
-                // InferredParams* inferParams = &alt.expr->inferParams;
-                // for ( UniqueId id : info.idChain ) {
-                //      inferParams = (*inferParams)[ id ].inferParams.get();
-                // }
-
-                // (*inferParams)[ decl->get_uniqueId() ] = ParamEntry{
-                //              candidate->get_uniqueId(), match.adjType, decl->get_type()->clone(), varExpr };
         }
 
         /// Adds a captured assertion to the symbol table
         void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
-                for ( AssertionSet::iterator i = assertSet.begin(); i != assertSet.end(); ++i ) {
-                        if ( i->second.isUsed ) {
-                                indexer.addId( i->first );
+                for ( auto&  i : assertSet ) {
+                        if ( i.second.isUsed ) {
+                                indexer.addId( i.first );
                         }
                 }
@@ -234 +249 @@
 
         /// Resolve a single assertion, in context
-        bool resolveAssertion( AssertionItem& assn, ResnState& resn ) {
+        bool resolveAssertion( AssertionItem& assn, ResnState& resn, AssnCache& cache ) {
                 // skip unused assertions
                 if ( ! assn.info.isUsed ) return true;
 
-                // lookup candidates for this assertion
-                std::list< SymTab::Indexer::IdData > candidates;
-                resn.indexer.lookupId( assn.decl->name, candidates );
-
-                // find the candidates that unify with the desired type
-                CandidateList matches;
-                for ( const auto& cdata : candidates ) {
-                        DeclarationWithType* candidate = cdata.id;
-
-                        // build independent unification context for candidate
-                        AssertionSet have, newNeed;
-                        TypeEnvironment newEnv{ resn.alt.env };
-                        OpenVarSet newOpenVars{ resn.alt.openVars };
-                        Type* adjType = candidate->get_type()->clone();
-                        adjustExprType( adjType, newEnv, resn.indexer );
-                        renameTyVars( adjType );
-
-                        // keep unifying candidates
-                        if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars, 
-                                        resn.indexer ) ) {
-                                // set up binding slot for recursive assertions
-                                UniqueId crntResnSlot = 0;
-                                if ( ! newNeed.empty() ) {
-                                        crntResnSlot = ++globalResnSlot;
-                                        for ( auto& a : newNeed ) {
-                                                a.second.resnSlot = crntResnSlot;
+                // check cache for this assertion
+                std::string assnKey = SymTab::Mangler::mangleAssnKey( assn.decl, resn.alt.env );
+                auto it = cache.find( assnKey );
+
+                // attempt to resolve assertion if this is the first time seen
+                if ( it == cache.end() ) {
+                        // lookup candidates for this assertion
+                        std::list< SymTab::Indexer::IdData > candidates;
+                        resn.indexer.lookupId( assn.decl->name, candidates );
+
+                        // find the candidates that unify with the desired type
+                        CandidateList matches;
+                        for ( const auto& cdata : candidates ) {
+                                DeclarationWithType* candidate = cdata.id;
+
+                                // build independent unification context for candidate
+                                AssertionSet have, newNeed;
+                                TypeEnvironment newEnv{ resn.alt.env };
+                                OpenVarSet newOpenVars{ resn.alt.openVars };
+                                Type* adjType = candidate->get_type()->clone();
+                                adjustExprType( adjType, newEnv, resn.indexer );
+                                renameTyVars( adjType );
+
+                                // keep unifying candidates
+                                if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars, 
+                                                resn.indexer ) ) {
+                                        // set up binding slot for recursive assertions
+                                        UniqueId crntResnSlot = 0;
+                                        if ( ! newNeed.empty() ) {
+                                                crntResnSlot = ++globalResnSlot;
+                                                for ( auto& a : newNeed ) {
+                                                        a.second.resnSlot = crntResnSlot;
+                                                }
                                         }
-                                }
-                                // // set up idChain on new assertions
-                                // for ( auto& a : newNeed ) {
-                                //      a.second.idChain = assn.info.idChain;
-                                //      a.second.idChain.push_back( assn.decl->get_uniqueId() );
-                                // }
-
-                                matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have), 
-                                        std::move(newNeed), std::move(newOpenVars), crntResnSlot );
-                        } else {
-                                delete adjType;
+
+                                        matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have), 
+                                                std::move(newNeed), std::move(newOpenVars), crntResnSlot );
+                                } else {
+                                        delete adjType;
+                                }
                         }
-                }
+
+                        it = cache.emplace_hint( it, assnKey, AssnCacheItem{ std::move(matches) } );
+                }
+
+                CandidateList& matches = it->second.matches;
 
                 // break if no suitable assertion
@@ -284 +305 @@
                 // defer if too many suitable assertions
                 if ( matches.size() > 1 ) {
-                        resn.deferred.emplace_back( assn.decl, assn.info, std::move(matches) );
+                        it->second.deferIds.emplace_back( assn.decl, assn.info );
+                        resn.deferred.emplace_back( cache, assnKey );
                         return true;
                 }
@@ -292 +314 @@
                 addToIndexer( match.have, resn.indexer );
                 resn.newNeed.insert( match.need.begin(), match.need.end() );
-                resn.alt.env = std::move(match.env);
-                resn.alt.openVars = std::move(match.openVars);
+                resn.alt.env = match.env;
+                resn.alt.openVars = match.openVars;
 
                 bindAssertion( assn.decl, assn.info, resn.alt, match, resn.inferred );
@@ -354 +376 @@
                 ResnList resns{ ResnState{ alt, root_indexer } };
                 ResnList new_resns{};
+                AssnCache assnCache;
 
                 // resolve assertions in breadth-first-order up to a limited number of levels deep
@@ -362 +385 @@
                                 for ( auto& assn : resn.need ) {
                                         // fail early if any assertion is not resolvable
-                                        if ( ! resolveAssertion( assn, resn ) ) goto nextResn;
+                                        if ( ! resolveAssertion( assn, resn, assnCache ) ) goto nextResn;
                                 }
 
@@ -373 +396 @@
                                         }
                                 } else {
+                                        // only resolve each deferred assertion once
+                                        std::sort( resn.deferred.begin(), resn.deferred.end() );
+                                        auto last = std::unique( resn.deferred.begin(), resn.deferred.end() );
+                                        resn.deferred.erase( last, resn.deferred.end() );
                                         // resolve deferred assertions by mutual compatibility
                                         std::vector<CandidateEnvMerger::OutType> compatible = filterCombos(
@@ -380 +407 @@
                                         CandidateCost coster{ resn.indexer };
                                         std::sort( compatible.begin(), compatible.end(), coster );
-                                        // // sort by cost if pruning
-                                        // if ( pruneAssertions ) {
-                                        //      auto lmin = sort_mins( compatible.begin(), compatible.end(), 
-                                        //              CandidateCost{resn.indexer} );
-                                        //      compatible.erase( lmin, compatible.end() );
-                                        // }
 
                                         // keep map of detected options
@@ -408 +429 @@
                                                         new_resn.newNeed.insert( match.need.begin(), match.need.end() );
 
-                                                        bindAssertion( r.decl, r.info, new_resn.alt, match, new_resn.inferred );
+                                                        // for each deferred assertion with the same form
+                                                        for ( AssnId id : r.item.deferIds ) {
+                                                                bindAssertion( 
+                                                                        id.decl, id.info, new_resn.alt, match, new_resn.inferred );
+                                                        }
                                                 }
 

src/SymTab/Mangler.cc

@@ -15 +15 @@
 #include "Mangler.h"
 
-#include <algorithm>                // for copy, transform
-#include <cassert>                  // for assert, assertf
-#include <functional>               // for const_mem_fun_t, mem_fun
-#include <iterator>                 // for ostream_iterator, back_insert_ite...
-#include <list>                     // for _List_iterator, list, _List_const...
-#include <string>                   // for string, char_traits, operator<<
-
-#include "CodeGen/OperatorTable.h"  // for OperatorInfo, operatorLookup
+#include <algorithm>                     // for copy, transform
+#include <cassert>                       // for assert, assertf
+#include <functional>                    // for const_mem_fun_t, mem_fun
+#include <iterator>                      // for ostream_iterator, back_insert_ite...
+#include <list>                          // for _List_iterator, list, _List_const...
+#include <string>                        // for string, char_traits, operator<<
+
+#include "CodeGen/OperatorTable.h"       // for OperatorInfo, operatorLookup
 #include "Common/PassVisitor.h"
-#include "Common/SemanticError.h"   // for SemanticError
-#include "Common/utility.h"         // for toString
-#include "Parser/LinkageSpec.h"     // for Spec, isOverridable, AutoGen, Int...
-#include "SynTree/Declaration.h"    // for TypeDecl, DeclarationWithType
-#include "SynTree/Expression.h"     // for TypeExpr, Expression, operator<<
-#include "SynTree/Type.h"           // for Type, ReferenceToType, Type::Fora...
+#include "Common/SemanticError.h"        // for SemanticError
+#include "Common/utility.h"              // for toString
+#include "Parser/LinkageSpec.h"          // for Spec, isOverridable, AutoGen, Int...
+#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
+#include "SynTree/Declaration.h"         // for TypeDecl, DeclarationWithType
+#include "SynTree/Expression.h"          // for TypeExpr, Expression, operator<<
+#include "SynTree/Type.h"                // for Type, ReferenceToType, Type::Fora...
 
 namespace SymTab {
@@ -37 +38 @@
                         struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
+                                Mangler( const ResolvExpr::TypeEnvironment& env );
                                 Mangler( const Mangler & ) = delete;
 
@@ -65 +67 @@
                           private:
                                 std::ostringstream mangleName;  ///< Mangled name being constructed
-                                typedef std::map< std::string, std::pair< int, int > > VarMapType;
+                                typedef std::map< std::string, std::pair< std::string, int > > VarMapType;
                                 VarMapType varNums;             ///< Map of type variables to indices
                                 int nextVarNum;                 ///< Next type variable index
+                                const ResolvExpr::TypeEnvironment* env;  ///< optional environment for substitutions
                                 bool isTopLevel;                ///< Is the Mangler at the top level
                                 bool mangleOverridable;         ///< Specially mangle overridable built-in methods
@@ -75 +78 @@
                                 bool inQualifiedType = false;   ///< Add start/end delimiters around qualified type
 
+                          public:
+                                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
+                                        int nextVarNum, const ResolvExpr::TypeEnvironment* env, 
+                                        const VarMapType& varNums );
+
+                          private:
                                 void mangleDecl( DeclarationWithType *declaration );
                                 void mangleRef( ReferenceToType *refType, std::string prefix );
@@ -100 +109 @@
                 }
 
+                std::string mangleAssnKey( DeclarationWithType* decl, 
+                                const ResolvExpr::TypeEnvironment& env ) {
+                        PassVisitor<Mangler> mangler( env );
+                        maybeAccept( decl, mangler );
+                        return mangler.pass.get_mangleName();
+                }
+
                 namespace {
                         Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
-                                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
+                                : nextVarNum( 0 ), env(nullptr), isTopLevel( true ), 
+                                mangleOverridable( mangleOverridable ), typeMode( typeMode ), 
+                                mangleGenericParams( mangleGenericParams ) {}
+                        
+                        Mangler::Mangler( const ResolvExpr::TypeEnvironment& env )
+                                : nextVarNum( 0 ), env( &env ), isTopLevel( true ), mangleOverridable( false ),
+                                typeMode( false ), mangleGenericParams( true ) {}
+                        
+                        Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
+                                int nextVarNum, const ResolvExpr::TypeEnvironment* env, 
+                                const VarMapType& varNums )
+                                : varNums( varNums ), nextVarNum( nextVarNum ), env( env ), isTopLevel( false ), 
+                                mangleOverridable( mangleOverridable ), typeMode( typeMode ), 
+                                mangleGenericParams( mangleGenericParams ) {}
 
                         void Mangler::mangleDecl( DeclarationWithType * declaration ) {
@@ -329 +358 @@
                                                         assert( false );
                                                 } // switch
-                                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
+                                                std::string varName;
+                                                // replace type with substitution name if environment is available and bound
+                                                if ( env ) {
+                                                        const ResolvExpr::EqvClass* varClass = env->lookup( (*i)->name );
+                                                        if ( varClass && varClass->type ) {
+                                                                PassVisitor<Mangler> sub_mangler(
+                                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum, 
+                                                                        env, varNums );
+                                                                varClass->type->accept( sub_mangler );
+                                                                varName = std::string{"%"} + sub_mangler.pass.get_mangleName();
+                                                        }
+                                                }
+                                                // otherwise just give type numeric name
+                                                if ( varName.empty() ) {
+                                                        varName = std::to_string( nextVarNum++ );
+                                                }
+                                                varNums[ (*i)->name ] = std::make_pair( varName, (int)(*i)->get_kind() );
                                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
-                                                        PassVisitor<Mangler> sub_mangler( mangleOverridable, typeMode, mangleGenericParams );
-                                                        sub_mangler.pass.nextVarNum = nextVarNum;
-                                                        sub_mangler.pass.isTopLevel = false;
-                                                        sub_mangler.pass.varNums = varNums;
+                                                        PassVisitor<Mangler> sub_mangler( 
+                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, env, 
+                                                                varNums );
                                                         (*assert)->accept( sub_mangler );
-                                                        assertionNames.push_back( sub_mangler.pass.mangleName.str() );
+                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
                                                         acount++;
                                                 } // for

src/SymTab/Mangler.h

@@ -31 +31 @@
 // * Currently name compression is not implemented.
 
+namespace ResolvExpr {
+        class TypeEnvironment;
+}
+
 namespace SymTab {
         namespace Mangler {
@@ -40 +44 @@
                 /// Mangle ignoring generic type parameters
                 std::string mangleConcrete( Type* ty );
+                /// Mangle for assertion key
+                std::string mangleAssnKey( DeclarationWithType* decl, 
+                        const ResolvExpr::TypeEnvironment& env );
 
                 namespace Encoding {

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun  6 15:51:47 2018
-// Update Count     : 498
+// Last Modified On : Wed Dec 26 08:11:19 2018
+// Update Count     : 499
 //
 
@@ -371 +371 @@
                         }
                 } catch(const std::exception& e) {
-                        std::cerr << "Unaught Exception \"" << e.what() << "\"\n";
+                        std::cerr << "Uncaught Exception \"" << e.what() << "\"\n";
                 }
                 return 1;

tests/pybin/tools.py

@@ -3 +3 @@
 import __main__
 import argparse
+import fileinput
 import multiprocessing
 import os
 import re
+import resource
 import signal
 import stat
 import sys
-import fileinput
+import time
 
 from pybin import settings
@@ -131 +133 @@
 
     return None
+
+def run(exe, output, input):
+        ret, _ = sh("timeout %d %s > %s 2>&1" % (settings.timeout.single, exe, output), input = input)
+        return ret
+
 ################################################################################
 #               file handling
 ################################################################################
+# move a file
+def mv(source, dest):
+        ret, _ = sh("mv %s %s" % (source, dest))
+        return ret
+
+# cat one file into the other
+def cat(source, dest):
+        ret, _ = sh("cat %s > %s" % (source, dest))
+        return ret
 
 # helper function to replace patterns in a file
@@ -230 +246 @@
                 signal.signal(signal.SIGINT, signal.SIG_IGN)
 
+
+# enable core dumps for all the test children
+resource.setrlimit(resource.RLIMIT_CORE, (resource.RLIM_INFINITY, resource.RLIM_INFINITY))
+
 ################################################################################
 #               misc
@@ -251 +271 @@
         else:
                 print(text)
+
+
+def coreInfo(path):
+        cmd   = os.path.join(settings.SRCDIR, "pybin/print-core.gdb")
+        if not os.path.isfile(cmd):
+                return 1, "ERR Printing format for core dumps not found"
+
+        dname = os.path.dirname(path)
+        core  = os.path.join(dname, "core" )
+        if not os.path.isfile(path):
+                return 1, "ERR Executable path is wrong"
+
+        if not os.path.isfile(core):
+                return 1, "ERR No core dump"
+
+        return sh("gdb -n %s %s -batch -x %s" % (path, core, cmd), print2stdout=False)
+
+class Timed:
+    def __enter__(self):
+        self.start = time.time()
+        return self
+
+    def __exit__(self, *args):
+        self.end = time.time()
+        self.duration = self.end - self.start

tests/test.py

@@ -121 +121 @@
 #               running test functions
 ################################################################################
-# fix the absolute paths in the output
-def fixoutput( fname ):
-        if not is_ascii(fname):
-                return
-
-        file_replace(fname, "%s/" % settings.SRCDIR, "")
-
+def success(val):
+        return val == 0 or settings.dry_run
+
+def isExe(file):
+        return settings.dry_run or fileIsExecutable(file)
+
+def noRule(file, target):
+        return not settings.dry_run and fileContainsOnly(file, "make: *** No rule to make target `%s'.  Stop." % target)
 
 # logic to run a single test and return the result (No handling of printing or other test framework logic)
@@ -143 +144 @@
 
         # build, skipping to next test on error
-        before = time.time()
-        make_ret, _ = make( test.target(),
-                redirects  = "2> %s 1> /dev/null" % out_file,
-                error_file = err_file
-        )
-        after = time.time()
-
-        comp_dur = after - before
-
+        with Timed() as comp_dur:
+                make_ret, _ = make( test.target(),      redirects  = ("2> %s 1> /dev/null" % out_file), error_file = err_file )
+
+        # if the make command succeds continue otherwise skip to diff
         run_dur = None
-
-        # if the make command succeds continue otherwise skip to diff
-        if make_ret == 0 or settings.dry_run:
-                before = time.time()
-                if settings.dry_run or fileIsExecutable(exe_file) :
-                        # run test
-                        retcode, _ = sh("timeout %d %s > %s 2>&1" % (settings.timeout.single, exe_file, out_file), input = in_file)
-                else :
-                        # simply cat the result into the output
-                        retcode, _ = sh("cat %s > %s" % (exe_file, out_file))
-
-                after = time.time()
-                run_dur = after - before
+        if success(make_ret):
+                with Timed() as run_dur:
+                        if isExe(exe_file):
+                                # run test
+                                retcode = run(exe_file, out_file, in_file)
+                        else :
+                                # simply cat the result into the output
+                                retcode = cat(exe_file, out_file)
         else:
-                retcode, _ = sh("mv %s %s" % (err_file, out_file))
-
-
-        if retcode == 0:
-                # fixoutput(out_file)
+                retcode = mv(err_file, out_file)
+
+        if success(retcode):
                 if settings.generating :
                         # if we are ounly generating the output we still need to check that the test actually exists
-                        if not settings.dry_run and fileContainsOnly(out_file, "make: *** No rule to make target `%s'.  Stop." % test.target()) :
-                                retcode = 1;
+                        if noRule(out_file, test.target()) :
+                                retcode = 1
                                 error = "\t\tNo make target for test %s!" % test.target()
-                                sh("rm %s" % out_file, False)
+                                rm(out_file)
                         else:
                                 error = None
@@ -188 +177 @@
                         error = myfile.read()
 
+                ret, info = coreInfo(exe_file)
+                error = error + info
+
+
 
         # clean the executable
-        sh("rm -f %s > /dev/null 2>&1" % test.target())
-
-        return retcode, error, [comp_dur, run_dur]
+        rm(exe_file)
+
+        return retcode, error, [comp_dur.duration, run_dur.duration if run_dur else None]
 
 # run a single test and handle the errors, outputs, printing, exception handling, etc.
@@ -199 +192 @@
         with SignalHandling():
                 # print formated name
-                name_txt = "%20s  " % t.name
+                name_txt = "%24s  " % t.name
 
                 retcode, error, duration = run_single_test(t)
@@ -263 +256 @@
         allTests = listTests( options.include, options.exclude )
 
+
         # if user wants all tests than no other treatement of the test list is required
         if options.all or options.list or options.list_comp or options.include :

tools/PrettyGitLogs.sh

@@ -3 +3 @@
 set -e
 
-GIT_UPDATE="$1/GIT_UPDATE"
-GIT_LOG="$1/GIT_LOG"
-GIT_DIFF="$1/GIT_DIFF"
+GIT="git --git-dir=$1/.git"
+
+GIT_UPDATE="$2/GIT_UPDATE"
+GIT_LOG="$2/GIT_LOG"
+GIT_DIFF="$2/GIT_DIFF"
 
 rm -f ${GIT_UPDATE}  ${GIT_LOG}  ${GIT_DIFF}
 
-GitOldRef=$2
-GitNewRef=$3
+GitOldRef=$3
+GitNewRef=$4