Changeset 5c4a473


Ignore:
Timestamp:
Aug 15, 2019, 10:31:53 AM (2 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
6daaee3
Parents:
d65f92c (diff), 3c7f01b (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 'master' into distcc

Files:
21 edited

Legend:

Unmodified
Added
Removed
  • Jenkins/FullBuild

    rd65f92c r5c4a473  
    132132
    133133<img src="https://cforall.uwaterloo.ca/jenkins/job/Cforall/job/master/plot/Compilation/getPlot?index=0" >
     134<img src="https://cforall.uwaterloo.ca/jenkins/job/Cforall/job/master/plot/Compilation/getPlot?index=1" >
    134135
    135136<p>- Logs ----------------------------------------------------------------</p>
  • Jenkinsfile

    rd65f92c r5c4a473  
    197197                if( Settings.Publish && !Settings.RunBenchmark ) { echo 'No results to publish!!!' }
    198198
    199                 def groupCompile = new PlotGroup('Compilation', 'seconds', true)
    200                 def groupConcurrency = new PlotGroup('Concurrency', 'nanoseconds', false)
     199                def groupCompile = new PlotGroup('Compilation', 'duration (s) - lower is better', true)
     200                def groupConcurrency = new PlotGroup('Concurrency', 'duration (n) - lower is better', false)
    201201
    202202                //Then publish the results
    203                 do_plot(Settings.RunBenchmark && Settings.Publish, 'compile'       , groupCompile    , 'Compilation')
    204                 do_plot(Settings.RunBenchmark && Settings.Publish, 'compile.diff'  , groupCompile    , 'Compilation Speed-Up')
    205                 do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch'     , groupConcurrency, 'Context Switching')
    206                 do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch.diff', groupConcurrency, 'Context Switching Speed-Up')
    207                 do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex'         , groupConcurrency, 'Mutual Exclusion')
    208                 do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex.diff'    , groupConcurrency, 'Mutual Exclusion Speed-Up')
    209                 do_plot(Settings.RunBenchmark && Settings.Publish, 'signal'        , groupConcurrency, 'Internal and External Scheduling')
    210                 do_plot(Settings.RunBenchmark && Settings.Publish, 'signal.diff'   , groupConcurrency, 'Internal and External Scheduling Speed-Up')
     203                do_plot(Settings.RunBenchmark && Settings.Publish, 'compile'       , groupCompile    , false, 'Compilation')
     204                do_plot(Settings.RunBenchmark && Settings.Publish, 'compile.diff'  , groupCompile    , true , 'Compilation (relative)')
     205                do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch'     , groupConcurrency, false, 'Context Switching')
     206                do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch.diff', groupConcurrency, true , 'Context Switching (relative)')
     207                do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex'         , groupConcurrency, false, 'Mutual Exclusion')
     208                do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex.diff'    , groupConcurrency, true , 'Mutual Exclusion (relative)')
     209                do_plot(Settings.RunBenchmark && Settings.Publish, 'signal'        , groupConcurrency, false, 'Internal and External Scheduling')
     210                do_plot(Settings.RunBenchmark && Settings.Publish, 'signal.diff'   , groupConcurrency, true , 'Internal and External Scheduling (relative)')
    211211        }
    212212}
     
    466466}
    467467
    468 def do_plot(boolean new_data, String file, PlotGroup group, String title) {
     468def do_plot(boolean new_data, String file, PlotGroup group, boolean relative, String title) {
    469469
    470470        if(new_data) {
     
    489489                        exclZero: false,
    490490                        keepRecords: false,
    491                         logarithmic: group.log,
     491                        logarithmic: !relative && group.log,
    492492                        numBuilds: '120',
    493493                        useDescr: true,
  • libcfa/src/Makefile.am

    rd65f92c r5c4a473  
    2626VPATH += :../prelude
    2727
     28gdbwaittarget=""
     29
    2830# AM_CFLAGS for all cfa source
    2931# AM_CFAFLAGS for only cfa source
    3032# use -no-include-stdhdr to prevent rebuild cycles
    3133# The built sources must not depend on the installed headers
    32 AM_CFAFLAGS = -quiet -cfalib @PRELUDEFLAG@ -I$(srcdir)/stdhdr @CONFIG_CFAFLAGS@
     34AM_CFAFLAGS = -quiet -cfalib @PRELUDEFLAG@ -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
    3335AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
    3436AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
  • libcfa/src/Makefile.in

    rd65f92c r5c4a473  
    438438am__v_UPP_1 =
    439439lib_LTLIBRARIES = libcfa.la libcfathread.la
     440gdbwaittarget = ""
    440441
    441442# AM_CFLAGS for all cfa source
     
    443444# use -no-include-stdhdr to prevent rebuild cycles
    444445# The built sources must not depend on the installed headers
    445 AM_CFAFLAGS = -quiet -cfalib @PRELUDEFLAG@ -I$(srcdir)/stdhdr @CONFIG_CFAFLAGS@
     446AM_CFAFLAGS = -quiet -cfalib @PRELUDEFLAG@ -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
    446447AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
    447448AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
  • src/ResolvExpr/AlternativeFinder.cc

    rd65f92c r5c4a473  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sat May 16 23:52:08 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 25 22:37:46 2019
    13 // Update Count     : 37
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thu Aug  8 16:35:00 2019
     13// Update Count     : 38
    1414//
    1515
     
    377377        }
    378378
    379         Cost computeConversionCost( Type * actualType, Type * formalType, const SymTab::Indexer &indexer, const TypeEnvironment & env ) {
     379        Cost computeConversionCost( Type * actualType, Type * formalType, bool actualIsLvalue,
     380                        const SymTab::Indexer &indexer, const TypeEnvironment & env ) {
    380381                PRINT(
    381382                        std::cerr << std::endl << "converting ";
     
    387388                        std::cerr << std::endl;
    388389                )
    389                 Cost convCost = conversionCost( actualType, formalType, indexer, env );
     390                Cost convCost = conversionCost( actualType, formalType, actualIsLvalue, indexer, env );
    390391                PRINT(
    391392                        std::cerr << std::endl << "cost is " << convCost << std::endl;
     
    402403
    403404        Cost computeExpressionConversionCost( Expression *& actualExpr, Type * formalType, const SymTab::Indexer &indexer, const TypeEnvironment & env ) {
    404                 Cost convCost = computeConversionCost( actualExpr->result, formalType, indexer, env );
     405                Cost convCost = computeConversionCost(
     406                        actualExpr->result, formalType, actualExpr->get_lvalue(), indexer, env );
    405407
    406408                // if there is a non-zero conversion cost, ignoring poly cost, then the expression requires conversion.
     
    11861188                assert( toType );
    11871189                toType = resolveTypeof( toType, indexer );
     1190                assert(!dynamic_cast<TypeofType *>(toType));
    11881191                SymTab::validateType( toType, &indexer );
    11891192                adjustExprType( toType, env, indexer );
     
    12121215                        unify( castExpr->result, alt.expr->result, alt.env, needAssertions,
    12131216                                haveAssertions, openVars, indexer );
    1214                         Cost thisCost = castCost( alt.expr->result, castExpr->result, indexer,
    1215                                 alt.env );
     1217                        Cost thisCost = castCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(),
     1218                                indexer, alt.env );
    12161219                        PRINT(
    12171220                                std::cerr << "working on cast with result: " << castExpr->result << std::endl;
     
    16401643                                // xxx - do some inspecting on this line... why isn't result bound to initAlt.type?
    16411644
    1642                                 Cost thisCost = castCost( alt.expr->result, toType, indexer, newEnv );
     1645                                Cost thisCost = castCost( alt.expr->result, toType, alt.expr->get_lvalue(),
     1646                                        indexer, newEnv );
    16431647                                if ( thisCost != Cost::infinity ) {
    16441648                                        // count one safe conversion for each value that is thrown away
  • src/ResolvExpr/CastCost.cc

    rd65f92c r5c4a473  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 06:57:43 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  2 15:34:36 2016
    13 // Update Count     : 7
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thu Aug  8 16:12:00 2019
     13// Update Count     : 8
    1414//
    1515
     
    3737        struct CastCost_old : public ConversionCost {
    3838          public:
    39                 CastCost_old( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
     39                CastCost_old( const Type * dest, bool srcIsLvalue,
     40                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
    4041
    4142                using ConversionCost::previsit;
     
    4546        };
    4647
    47         Cost castCost( const Type * src, const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
     48        Cost castCost( const Type * src, const Type * dest, bool srcIsLvalue,
     49                        const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    4850                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
    4951                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
    5052                                if ( eqvClass->type ) {
    51                                         return castCost( src, eqvClass->type, indexer, env );
     53                                        return castCost( src, eqvClass->type, srcIsLvalue, indexer, env );
    5254                                } else {
    5355                                        return Cost::infinity;
     
    5759                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( namedType );
    5860                                if ( type->base ) {
    59                                         return castCost( src, type->base, indexer, env ) + Cost::safe;
     61                                        return castCost( src, type->base, srcIsLvalue, indexer, env ) + Cost::safe;
    6062                                } // if
    6163                        } // if
     
    7880                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
    7981                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    80                         return convertToReferenceCost( src, refType, indexer, env, [](const Type * t1, const Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
     82                        return convertToReferenceCost( src, refType, srcIsLvalue, indexer, env, [](const Type * t1, const Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
    8183                                return ptrsCastable( t1, t2, env, indexer );
    8284                        });
    8385                } else {
    8486                        PassVisitor<CastCost_old> converter(
    85                                 dest, indexer, env,
    86                                 (Cost (*)( const Type *, const Type *, const SymTab::Indexer &, const TypeEnvironment & ))
     87                                dest, srcIsLvalue, indexer, env,
     88                                (Cost (*)( const Type *, const Type *, bool, const SymTab::Indexer &, const TypeEnvironment & ))
    8789                                        castCost );
    8890                        src->accept( converter );
     
    9698        }
    9799
    98         CastCost_old::CastCost_old( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
    99                 : ConversionCost( dest, indexer, env, costFunc ) {
     100        CastCost_old::CastCost_old( const Type * dest, bool srcIsLvalue,
     101                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
     102                : ConversionCost( dest, srcIsLvalue, indexer, env, costFunc ) {
    100103        }
    101104
     
    106109                        cost = Cost::unsafe;
    107110                } else {
    108                         cost = conversionCost( basicType, dest, indexer, env );
     111                        cost = conversionCost( basicType, dest, srcIsLvalue, indexer, env );
    109112                } // if
    110113        }
  • src/ResolvExpr/ConversionCost.cc

    rd65f92c r5c4a473  
    1010// Created On       : Sun May 17 07:06:19 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jun 24 13:33:00 2019
    13 // Update Count     : 26
     12// Last Modified On : Mon Aug 12 10:21:00 2019
     13// Update Count     : 27
    1414//
    1515
     
    4646#endif
    4747
    48         Cost conversionCost( const Type * src, const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
     48        Cost conversionCost( const Type * src, const Type * dest, bool srcIsLvalue,
     49                        const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    4950                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
    5051                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
    5152                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
    5253                                if ( eqvClass->type ) {
    53                                         return conversionCost( src, eqvClass->type, indexer, env );
     54                                        return conversionCost( src, eqvClass->type, srcIsLvalue, indexer, env );
    5455                                } else {
    5556                                        return Cost::infinity;
     
    6162                                assert( type );
    6263                                if ( type->base ) {
    63                                         return conversionCost( src, type->base, indexer, env ) + Cost::safe;
     64                                        return conversionCost( src, type->base, srcIsLvalue, indexer, env )
     65                                                + Cost::safe;
    6466                                } // if
    6567                        } // if
     
    8183                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
    8284                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    83                         return convertToReferenceCost( src, refType, indexer, env, [](const Type * const t1, const Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
     85                        return convertToReferenceCost( src, refType, srcIsLvalue, indexer, env, [](const Type * const t1, const Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
    8486                                return ptrsAssignable( t1, t2, env );
    8587                        });
    8688                } else {
    8789                        PassVisitor<ConversionCost> converter(
    88                                 dest, indexer, env,
    89                                 (Cost (*)(const Type *, const Type *, const SymTab::Indexer&, const TypeEnvironment&))
     90                                dest, srcIsLvalue, indexer, env,
     91                                (Cost (*)(const Type *, const Type *, bool, const SymTab::Indexer&, const TypeEnvironment&))
    9092                                        conversionCost );
    9193                        src->accept( converter );
     
    98100        }
    99101
    100         static Cost convertToReferenceCost( const Type * src, const Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
     102        static Cost convertToReferenceCost( const Type * src, const Type * dest, bool srcIsLvalue,
     103                        int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
    101104                PRINT( std::cerr << "convert to reference cost... diff " << diff << " " << src << " / " << dest << std::endl; )
    102105                if ( diff > 0 ) {
    103106                        // TODO: document this
    104                         Cost cost = convertToReferenceCost( strict_dynamic_cast< const ReferenceType * >( src )->base, dest, diff-1, indexer, env, func );
     107                        Cost cost = convertToReferenceCost(
     108                                strict_dynamic_cast< const ReferenceType * >( src )->base, dest, srcIsLvalue,
     109                                diff-1, indexer, env, func );
    105110                        cost.incReference();
    106111                        return cost;
    107112                } else if ( diff < -1 ) {
    108113                        // TODO: document this
    109                         Cost cost = convertToReferenceCost( src, strict_dynamic_cast< const ReferenceType * >( dest )->base, diff+1, indexer, env, func );
     114                        Cost cost = convertToReferenceCost(
     115                                src, strict_dynamic_cast< const ReferenceType * >( dest )->base, srcIsLvalue,
     116                                diff+1, indexer, env, func );
    110117                        cost.incReference();
    111118                        return cost;
     
    138145                                PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
    139146                                PassVisitor<ConversionCost> converter(
    140                                         dest, indexer, env,
    141                                         (Cost (*)(const Type *, const Type *, const SymTab::Indexer&, const TypeEnvironment&))
     147                                        dest, srcIsLvalue, indexer, env,
     148                                        (Cost (*)(const Type *, const Type *, bool, const SymTab::Indexer&, const TypeEnvironment&))
    142149                                                conversionCost );
    143150                                src->accept( converter );
     
    150157                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
    151158                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
    152                                 if ( src->get_lvalue() ) {
     159                                assert( src->get_lvalue() == srcIsLvalue );
     160                                if ( srcIsLvalue ) {
    153161                                        PRINT(
    154162                                                std::cerr << "lvalue to reference conversion" << std::endl;
     
    178186        }
    179187
    180         Cost convertToReferenceCost( const Type * src, const ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
     188        Cost convertToReferenceCost( const Type * src, const ReferenceType * dest, bool srcIsLvalue,
     189                        const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
    181190                int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth();
    182                 Cost cost = convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env, func );
     191                Cost cost = convertToReferenceCost( src, dest, srcIsLvalue, sdepth-ddepth, indexer, env, func );
    183192                PRINT( std::cerr << "convertToReferenceCost result: " << cost << std::endl; )
    184193                return cost;
    185194        }
    186195
    187         ConversionCost::ConversionCost( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
    188                 : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
     196        ConversionCost::ConversionCost( const Type * dest, bool srcIsLvalue, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
     197                : dest( dest ), srcIsLvalue( srcIsLvalue ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
    189198        }
    190199
     
    371380                // recursively compute conversion cost from T1 to T2.
    372381                // cv can be safely dropped because of 'implicit dereference' behavior.
    373                 cost = costFunc( refType->base, dest, indexer, env );
     382                cost = costFunc( refType->base, dest, srcIsLvalue, indexer, env );
    374383                if ( refType->base->tq == dest->tq ) {
    375384                        cost.incReference();  // prefer exact qualifiers
     
    403412                static Type::Qualifiers q;
    404413                static BasicType integer( q, BasicType::SignedInt );
    405                 cost = costFunc( &integer, dest, indexer, env );  // safe if dest >= int
     414                cost = costFunc( &integer, dest, srcIsLvalue, indexer, env );  // safe if dest >= int
    406415                if ( cost < Cost::unsafe ) {
    407416                        cost.incSafe();
     
    413422        void ConversionCost::postvisit( const TypeInstType * inst ) {
    414423                if ( const EqvClass * eqvClass = env.lookup( inst->name ) ) {
    415                         cost = costFunc( eqvClass->type, dest, indexer, env );
     424                        cost = costFunc( eqvClass->type, dest, srcIsLvalue, indexer, env );
    416425                } else if ( const TypeInstType * destAsInst = dynamic_cast< const TypeInstType * >( dest ) ) {
    417426                        if ( inst->name == destAsInst->name ) {
     
    423432                        assert( type );
    424433                        if ( type->base ) {
    425                                 cost = costFunc( type->base, dest, indexer, env ) + Cost::safe;
     434                                cost = costFunc( type->base, dest, srcIsLvalue, indexer, env ) + Cost::safe;
    426435                        } // if
    427436                } // if
     
    434443                        std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
    435444                        while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
    436                                 Cost newCost = costFunc( * srcIt++, * destIt++, indexer, env );
     445                                Cost newCost = costFunc( * srcIt++, * destIt++, srcIsLvalue, indexer, env );
    437446                                if ( newCost == Cost::infinity ) {
    438447                                        return;
  • src/ResolvExpr/ConversionCost.h

    rd65f92c r5c4a473  
    1010// Created On       : Sun May 17 09:37:28 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jun 24 10:00:00 2019
    13 // Update Count     : 5
     12// Last Modified On : Thu Aug  8 16:13:00 2019
     13// Update Count     : 6
    1414//
    1515
     
    3333        class TypeEnvironment;
    3434
    35         typedef std::function<Cost(const Type *, const Type *, const SymTab::Indexer &, const TypeEnvironment &)> CostFunction;
     35        typedef std::function<Cost(const Type *, const Type *, bool,
     36                const SymTab::Indexer &, const TypeEnvironment &)> CostFunction;
     37
    3638        struct ConversionCost : public WithShortCircuiting {
    3739          public:
    38                 ConversionCost( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction );
     40                ConversionCost( const Type * dest, bool srcIsLvalue,
     41                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction );
    3942
    4043                Cost get_cost() const { return cost; }
     
    5962          protected:
    6063                const Type * dest;
     64                bool srcIsLvalue;
    6165                const SymTab::Indexer &indexer;
    6266                Cost cost;
     
    6670
    6771        typedef std::function<int(const Type *, const Type *, const SymTab::Indexer &, const TypeEnvironment &)> PtrsFunction;
    68         Cost convertToReferenceCost( const Type * src, const ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func );
     72        Cost convertToReferenceCost( const Type * src, const ReferenceType * dest, bool srcIsLvalue,
     73                const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func );
    6974
    7075// Some function pointer types, differ in return type.
  • src/ResolvExpr/ResolveAssertions.cc

    rd65f92c r5c4a473  
    99// Author           : Aaron B. Moss
    1010// Created On       : Fri Oct 05 13:46:00 2018
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 10 16:10:37 2019
    13 // Update Count     : 2
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thu Aug  8 16:47:00 2019
     13// Update Count     : 3
    1414//
    1515
     
    156156                        for ( const auto& assn : x.assns ) {
    157157                                // compute conversion cost from satisfying decl to assertion
     158                                assert( !assn.match.adjType->get_lvalue() );
    158159                                k += computeConversionCost(
    159                                         assn.match.adjType, assn.decl->get_type(), indexer, x.env );
     160                                        assn.match.adjType, assn.decl->get_type(), false, indexer, x.env );
    160161
    161162                                // mark vars+specialization cost on function-type assertions
  • src/ResolvExpr/typeops.h

    rd65f92c r5c4a473  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 07:28:22 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  8 09:30:34 2019
    13 // Update Count     : 4
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thu Aug  8 16:36:00 2019
     13// Update Count     : 5
    1414//
    1515
     
    8080
    8181        // in CastCost.cc
    82         Cost castCost( const Type * src, const Type * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env );
     82        Cost castCost( const Type * src, const Type * dest, bool srcIsLvalue,
     83                const SymTab::Indexer & indexer, const TypeEnvironment & env );
    8384        Cost castCost(
    8485                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
     
    8687
    8788        // in ConversionCost.cc
    88         Cost conversionCost( const Type * src, const Type * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env );
     89        Cost conversionCost( const Type * src, const Type * dest, bool srcIsLvalue,
     90                const SymTab::Indexer & indexer, const TypeEnvironment & env );
    8991        Cost conversionCost(
    9092                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
     
    9294
    9395        // in AlternativeFinder.cc
    94         Cost computeConversionCost( Type * actualType, Type * formalType,
     96        Cost computeConversionCost( Type * actualType, Type * formalType, bool actualIsLvalue,
    9597                const SymTab::Indexer & indexer, const TypeEnvironment & env );
    9698
  • src/SynTree/ApplicationExpr.cc

    rd65f92c r5c4a473  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Tue Apr 26 12:41:06 2016
    13 // Update Count     : 4
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Mon Aug 12 14:28:00 2019
     13// Update Count     : 5
    1414//
    1515
     
    7676}
    7777
     78bool ApplicationExpr::get_lvalue() const {
     79        return result->get_lvalue();
     80}
     81
    7882void ApplicationExpr::print( std::ostream &os, Indenter indent ) const {
    7983        os << "Application of" << std::endl << indent+1;
  • src/SynTree/CommaExpr.cc

    rd65f92c r5c4a473  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Mon May 02 15:19:44 2016
    13 // Update Count     : 1
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Mon Arg 12 16:11:00 2016
     13// Update Count     : 2
    1414//
    1515
     
    3939}
    4040
     41bool CommaExpr::get_lvalue() const {
     42        // xxx - as above, shouldn't be an lvalue but that information is used anyways.
     43        return result->get_lvalue();
     44}
     45
    4146void CommaExpr::print( std::ostream &os, Indenter indent ) const {
    4247        os << "Comma Expression:" << std::endl;
  • src/SynTree/Expression.cc

    rd65f92c r5c4a473  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Aug  7 17:03:00 2019
    13 // Update Count     : 62
     12// Last Modified On : Tue Aug 13 11:31:00 2019
     13// Update Count     : 63
    1414//
    1515
     
    6464
    6565bool Expression::get_lvalue() const {
    66         return result->get_lvalue();
     66        assert( !result->get_lvalue() );
     67        return false;
    6768}
    6869
     
    138139}
    139140
     141bool VariableExpr::get_lvalue() const {
     142        return result->get_lvalue();
     143}
     144
    140145VariableExpr * VariableExpr::functionPointer( FunctionDecl * func ) {
    141146        VariableExpr * funcExpr = new VariableExpr( func );
     
    269274CastExpr::~CastExpr() {
    270275        delete arg;
     276}
     277
     278bool CastExpr::get_lvalue() const {
     279        return result->get_lvalue();
    271280}
    272281
     
    380389        // don't delete the member declaration, since it points somewhere else in the tree
    381390        delete aggregate;
     391}
     392
     393bool MemberExpr::get_lvalue() const {
     394        assert( result->get_lvalue() );
     395        return true;
    382396}
    383397
     
    432446}
    433447
     448bool UntypedExpr::get_lvalue() const {
     449        return result->get_lvalue();
     450}
    434451
    435452void UntypedExpr::print( std::ostream & os, Indenter indent ) const {
     
    490507        delete arg2;
    491508        delete arg3;
     509}
     510
     511bool ConditionalExpr::get_lvalue() const {
     512        return result->get_lvalue();
    492513}
    493514
     
    548569}
    549570
     571bool ConstructorExpr::get_lvalue() const {
     572        return result->get_lvalue();
     573}
     574
    550575void ConstructorExpr::print( std::ostream & os, Indenter indent ) const {
    551576        os <<  "Constructor Expression: " << std::endl << indent+1;
     
    565590CompoundLiteralExpr::~CompoundLiteralExpr() {
    566591        delete initializer;
     592}
     593
     594bool CompoundLiteralExpr::get_lvalue() const {
     595        assert( result->get_lvalue() );
     596        return true;
    567597}
    568598
  • src/SynTree/Expression.h

    rd65f92c r5c4a473  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Aug  7 16:56:00 2019
    13 // Update Count     : 51
     12// Last Modified On : Wed Aug 14 14:24:00 2019
     13// Update Count     : 53
    1414//
    1515
     
    7171        const Type * get_result() const { return result; }
    7272        void set_result( Type * newValue ) { result = newValue; }
    73         bool get_lvalue() const;
     73        virtual bool get_lvalue() const;
    7474
    7575        TypeSubstitution * get_env() const { return env; }
     
    9999        virtual ~ApplicationExpr();
    100100
     101        bool get_lvalue() const final;
     102
    101103        Expression * get_function() const { return function; }
    102104        void set_function( Expression * newValue ) { function = newValue; }
     
    121123        UntypedExpr( const UntypedExpr & other );
    122124        virtual ~UntypedExpr();
     125
     126        bool get_lvalue() const final;
    123127
    124128        Expression * get_function() const { return function; }
     
    209213        virtual ~CastExpr();
    210214
     215        bool get_lvalue() const final;
     216
    211217        Expression * get_arg() const { return arg; }
    212218        void set_arg( Expression * newValue ) { arg = newValue; }
     
    292298        virtual ~MemberExpr();
    293299
     300        bool get_lvalue() const final;
     301
    294302        DeclarationWithType * get_member() const { return member; }
    295303        void set_member( DeclarationWithType * newValue ) { member = newValue; }
     
    314322        VariableExpr( const VariableExpr & other );
    315323        virtual ~VariableExpr();
     324
     325        bool get_lvalue() const final;
    316326
    317327        DeclarationWithType * get_var() const { return var; }
     
    501511        virtual ~ConditionalExpr();
    502512
     513        bool get_lvalue() const final;
     514
    503515        Expression * get_arg1() const { return arg1; }
    504516        void set_arg1( Expression * newValue ) { arg1 = newValue; }
     
    525537        virtual ~CommaExpr();
    526538
     539        bool get_lvalue() const final;
     540
    527541        Expression * get_arg1() const { return arg1; }
    528542        void set_arg1( Expression * newValue ) { arg1 = newValue; }
     
    611625        ~ConstructorExpr();
    612626
     627        bool get_lvalue() const final;
     628
    613629        Expression * get_callExpr() const { return callExpr; }
    614630        void set_callExpr( Expression * newValue ) { callExpr = newValue; }
     
    629645        CompoundLiteralExpr( const CompoundLiteralExpr & other );
    630646        virtual ~CompoundLiteralExpr();
     647
     648        bool get_lvalue() const final;
    631649
    632650        Initializer * get_initializer() const { return initializer; }
     
    687705        virtual ~TupleExpr();
    688706
     707        bool get_lvalue() const final;
     708
    689709        std::list<Expression*>& get_exprs() { return exprs; }
    690710
     
    705725        TupleIndexExpr( const TupleIndexExpr & other );
    706726        virtual ~TupleIndexExpr();
     727
     728        bool get_lvalue() const final;
    707729
    708730        Expression * get_tuple() const { return tuple; }
  • src/SynTree/TupleExpr.cc

    rd65f92c r5c4a473  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 17 09:42:29 2017
    13 // Update Count     : 3
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Wed Aug 14 14:34:00 2019
     13// Update Count     : 5
    1414//
    1515
     
    5757}
    5858
     59bool TupleExpr::get_lvalue() const {
     60        return result->get_lvalue();
     61}
     62
    5963void TupleExpr::print( std::ostream &os, Indenter indent ) const {
    6064        os << "Tuple:" << std::endl;
     
    7680TupleIndexExpr::~TupleIndexExpr() {
    7781        delete tuple;
     82}
     83
     84bool TupleIndexExpr::get_lvalue() const {
     85        assert( result->get_lvalue() );
     86        return true;
    7887}
    7988
  • src/main.cc

    rd65f92c r5c4a473  
    1717#include <execinfo.h>                       // for backtrace, backtrace_symbols
    1818#include <getopt.h>                         // for no_argument, optind, geto...
    19 #include <signal.h>                         // for signal, SIGABRT, SIGSEGV
    2019#include <cassert>                          // for assertf
    2120#include <cstdio>                           // for fopen, FILE, fclose, stdin
    2221#include <cstdlib>                          // for exit, free, abort, EXIT_F...
     22#include <csignal>                         // for signal, SIGABRT, SIGSEGV
    2323#include <cstring>                          // for index
    2424#include <fstream>                          // for ofstream
     
    9696DeclarationNode * parseTree = nullptr;                                  // program parse tree
    9797
     98static bool waiting_for_gdb = false; // flag to set cfa-cpp to wait for gdb on start
     99
    98100static std::string PreludeDirector = "";
    99101
     
    167169} // sigAbortHandler
    168170
    169 
    170171int main( int argc, char * argv[] ) {
    171172        FILE * input;                                                                           // use FILE rather than istream because yyin is FILE
     
    185186        parse_cmdline( argc, argv, filename );                          // process command-line arguments
    186187        CodeGen::FixMain::setReplaceMain( !nomainp );
     188
     189        if(waiting_for_gdb) {
     190                std::cerr << "Waiting for gdb" << std::endl;
     191                std::cerr << "run :" << std::endl;
     192                std::cerr << "  gdb attach " << getpid() << std::endl;
     193                raise(SIGSTOP);
     194        }
    187195
    188196        try {
     
    198206                } else {                                                                                // no input file name
    199207                        input = stdin;
     208                        std::cerr << "Input from stdin" << std::endl;
    200209                        // if running cfa-cpp directly, might forget to pass -F option. Since this takes from stdin, pass
    201210                        // a fake name along
     
    438447
    439448
    440 static const char optstring[] = ":hlLmNnpP:S:twW:D:F:";
     449static const char optstring[] = ":hlLmNnpP:S:tgwW:D:F:";
    441450
    442451enum { PreludeDir = 128 };
     
    453462        { "statistics", required_argument, nullptr, 'S' },
    454463        { "tree", no_argument, nullptr, 't' },
     464        { "gdb", no_argument, nullptr, 'g' },
    455465        { "", no_argument, nullptr, 0 },                                        // -w
    456466        { "", no_argument, nullptr, 0 },                                        // -W
     
    471481        "<directory> prelude directory for debug/nodebug",      // no flag
    472482        "<option-list> enable profiling information:\n          counters,heap,time,all,none", // -S
    473         "build in tree",                                                                        // -t
     483        "building cfa standard lib",                                                                    // -t
     484        "wait for gdb to attach",                                                                       // -g
    474485        "",                                                                                                     // -w
    475486        "",                                                                                                     // -W
     
    582593                        Stats::parse_params( optarg );
    583594                        break;
    584                   case 't':                                                                             // build in tree
     595                  case 't':                                                                             // building cfa stdlib
    585596                        treep = true;
     597                        break;
     598                  case 'g':                                                                             // wait for gdb
     599                        waiting_for_gdb = true;
    586600                        break;
    587601                  case 'w':                                                                             // suppress all warnings, hidden
  • tests/Makefile.am

    rd65f92c r5c4a473  
    2222debug=yes
    2323installed=no
     24archiveerrors=
    2425
    2526INSTALL_FLAGS=-in-tree
     
    5859#----------------------------------------------------------------------------------------------------------------
    5960all-local :
    60         @+${TEST_PY} --debug=${debug} --install=${installed} ${concurrent} ${timeouts} ${quick_test}
     61        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
    6162
    6263all-tests :
    63         @+${TEST_PY} --debug=${debug} --install=${installed} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
     64        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
    6465
    6566clean-local :
  • tests/Makefile.in

    rd65f92c r5c4a473  
    378378debug = yes
    379379installed = no
     380archiveerrors =
    380381INSTALL_FLAGS = -in-tree
    381382DEBUG_FLAGS = -debug -O0
     
    777778#----------------------------------------------------------------------------------------------------------------
    778779all-local :
    779         @+${TEST_PY} --debug=${debug} --install=${installed} ${concurrent} ${timeouts} ${quick_test}
     780        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
    780781
    781782all-tests :
    782         @+${TEST_PY} --debug=${debug} --install=${installed} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
     783        @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
    783784
    784785clean-local :
  • tests/pybin/settings.py

    rd65f92c r5c4a473  
    44from . import tools
    55
     6global original_path
     7
    68try :
     9        original_path = os.getcwd()
    710        testpath = os.path.dirname(os.path.abspath(os.path.join(os.getcwd(), sys.argv[0])))
    811        sys.path.append(testpath)
     
    118121        global timeout
    119122        global output_width
     123<<<<<<< HEAD
    120124        global distcc
     125=======
     126        global archive
     127>>>>>>> master
    121128
    122129        dry_run      = options.dry_run
     
    128135        timeout      = Timeouts(options.timeout, options.global_timeout)
    129136        output_width = 24
     137<<<<<<< HEAD
    130138        distcc       = "DISTCC_CFA_PATH=~/.cfadistcc/%s/cfa" % tools.config_hash()
     139=======
     140        archive      = os.path.abspath(os.path.join(original_path, options.archive_errors)) if options.archive_errors else None
     141>>>>>>> master
    131142
    132143        if distribute and not os.environ.get('DISTCC_LOG'):
  • tests/pybin/tools.py

    rd65f92c r5c4a473  
    22import argparse
    33import contextlib
     4import datetime
    45import fileinput
    56import multiprocessing
     
    289290        return out.strip()
    290291
     292# get pretty string for time of day
     293def pretty_now():
     294        ts = time.time()
     295        print(ts, file=sys.stderr)
     296        return datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d_%H:%M:%S')
     297
    291298# check if arguments is yes or no
    292299def yes_no(string):
     
    320327        return sh('gdb', '-n', path, core, '-batch', '-x', cmd, output_file=subprocess.PIPE)
    321328
     329def core_archive(dst, name, exe):
     330        # Get the files to copy
     331        core = os.path.join(os.getcwd(), "core" )
     332
     333        # Uncomment if we want timestamps on coredumps
     334        # dst  = os.path.join(dst, "%s_%s" % (name, pretty_now()))
     335
     336        # make a directory for this test
     337        mkdir(os.path.join(dst, "dir"))
     338
     339        # moves the files
     340        mv( core, os.path.join(dst, "core" ) )
     341        mv( exe , os.path.join(dst, name   ) )
     342
     343        # return explanatory test
     344        return "Archiving %s (executable and core) to %s" % (os.path.relpath(exe, settings.BUILDDIR), os.path.relpath(dst, settings.original_path))
     345
    322346class Timed:
    323347    def __enter__(self):
  • tests/test.py

    rd65f92c r5c4a473  
    9191        parser.add_argument('--all', help='Run all test available', action='store_true')
    9292        parser.add_argument('--regenerate-expected', help='Regenerate the .expect by running the specified tets, can be used with --all option', action='store_true')
     93        parser.add_argument('--archive-errors', help='If called with a valid path, on test crashes the test script will copy the core dump and the executable to the specified path.', type=str, default='')
    9394        parser.add_argument('-j', '--jobs', help='Number of tests to run simultaneously', type=int)
    9495        parser.add_argument('--list-comp', help='List all valide arguments', action='store_true')
     
    179180                        error = error + info if error else info
    180181
     182                        if settings.archive:
     183                                error = error + '\n' + core_archive(settings.archive, test.target(), exe_file)
     184
    181185
    182186
     
    295299        # users may want to simply list the tests
    296300        if options.list_comp :
    297                 print("-h --help --debug --dry-run --list --arch --all --regenerate-expected --install --timeout --global-timeout -j --jobs ", end='')
     301                print("-h --help --debug --dry-run --list --arch --all --regenerate-expected --archive-errors --install --timeout --global-timeout -j --jobs ", end='')
    298302                print(" ".join(map(lambda t: "%s" % (t.target()), tests)))
    299303
Note: See TracChangeset for help on using the changeset viewer.