Changeset a01faa98


Ignore:
Timestamp:
May 26, 2023, 11:55:33 AM (2 years ago)
Author:
caparsons <caparson@…>
Branches:
ast-experimental, master
Children:
6c121eed
Parents:
b09ca2b (diff), 53f6a11 (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
9 added
2 deleted
23 edited
198 moved

Legend:

Unmodified
Added
Removed

  • libcfa/src/Makefile.am

    rb09ca2b ra01faa98  
    1111## Created On       : Sun May 31 08:54:01 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Fri Jul 16 16:00:40 2021
    14 ## Update Count     : 255
     13## Last Modified On : Thu May 25 15:20:04 2023
     14## Update Count     : 259
    1515###############################################################################
    1616
    … …  
    5959        bits/queue.hfa \
    6060        bits/sequence.hfa \
     61        concurrency/atomic.hfa \
    6162        concurrency/iofwd.hfa \
    6263        concurrency/barrier.hfa \
    … …  
    115116        concurrency/kernel/fwd.hfa \
    116117        concurrency/mutex_stmt.hfa \
    117     concurrency/channel.hfa \
    118     concurrency/actor.hfa
     118        concurrency/channel.hfa \
     119        concurrency/actor.hfa
    119120
    120121inst_thread_headers_src = \
    … …  
    127128        concurrency/monitor.hfa \
    128129        concurrency/mutex.hfa \
    129     concurrency/select.hfa \
     130        concurrency/select.hfa \
    130131        concurrency/thread.hfa
    131132

  • src/AST/Pass.impl.hpp

    rb09ca2b ra01faa98  
    2020#include <unordered_map>
    2121
     22#include "AST/Copy.hpp"
    2223#include "AST/TranslationUnit.hpp"
    2324#include "AST/TypeSubstitution.hpp"

  • src/AST/Print.cpp

    rb09ca2b ra01faa98  
    1616#include "Print.hpp"
    1717
     18#include "Attribute.hpp"
    1819#include "Decl.hpp"
    1920#include "Expr.hpp"
     21#include "Init.hpp"
    2022#include "Stmt.hpp"
    2123#include "Type.hpp"
    2224#include "TypeSubstitution.hpp"
    2325#include "CompilationState.h"
    24 
    25 #include "Common/utility.h" // for group_iterate
     26#include "Common/Iterate.hpp"
    2627
    2728using namespace std;

  • src/AST/SymbolTable.cpp

    rb09ca2b ra01faa98  
    1818#include <cassert>
    1919
     20#include "Copy.hpp"
    2021#include "Decl.hpp"
    2122#include "Expr.hpp"

  • src/AST/TypeSubstitution.cpp

    rb09ca2b ra01faa98  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jun  3 13:26:00 2017
    13 // Update Count     : 5
    14 //
     12// Last Modified On : Thr May 25 11:24:00 2023
     13// Update Count     : 6
     14//
     15
     16#include "TypeSubstitution.hpp"
    1517
    1618#include "Type.hpp"   // for TypeInstType, Type, StructInstType, UnionInstType
    17 #include "TypeSubstitution.hpp"
     19#include "Pass.hpp"   // for Pass, PureVisitor, WithGuards, WithVisitorRef
    1820
    1921namespace ast {
    20 
    21 
    22 // size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
    2322
    2423TypeSubstitution::TypeSubstitution() {
    … …  
    119118}
    120119
     120// definitition must happen after PassVisitor is included so that WithGuards can be used
     121struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter>, public PureVisitor {
     122        //static size_t traceId;
     123
     124        Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
     125
     126        const Type * postvisit( const TypeInstType * aggregateUseType );
     127
     128        /// Records type variable bindings from forall-statements
     129        void previsit( const FunctionType * type );
     130        /// Records type variable bindings from forall-statements and instantiations of generic types
     131        // void handleAggregateType( const BaseInstType * type );
     132
     133        // void previsit( const StructInstType * aggregateUseType );
     134        // void previsit( const UnionInstType * aggregateUseType );
     135
     136        const TypeSubstitution & sub;
     137        int subCount = 0;
     138        bool freeOnly;
     139        typedef std::unordered_set< TypeEnvKey > BoundVarsType;
     140        BoundVarsType boundVars;
     141};
     142
     143// size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
     144
    121145void TypeSubstitution::normalize() {
    122146        Pass<Substituter> sub( *this, true );
    … …  
    128152                }
    129153        } while ( sub.core.subCount );
     154}
     155
     156TypeSubstitution::ApplyResult<Node> TypeSubstitution::applyBase(
     157                const Node * input, bool isFree ) const {
     158        assert( input );
     159        Pass<Substituter> sub( *this, isFree );
     160        const Node * output = input->accept( sub );
     161        return { output, sub.core.subCount };
    130162}
    131163

  • src/AST/TypeSubstitution.hpp

    rb09ca2b ra01faa98  
    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 : Tue Apr 30 22:52:47 2019
    13 // Update Count     : 9
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thr May 25 12:31:00 2023
     13// Update Count     : 10
    1414//
    1515
    … …  
    4646        TypeSubstitution &operator=( const TypeSubstitution &other );
    4747
    48         template< typename SynTreeClass >
     48        template< typename node_t >
    4949        struct ApplyResult {
    50                 ast::ptr<SynTreeClass> node;
     50                ast::ptr<node_t> node;
    5151                int count;
    5252        };
    5353
    54         template< typename SynTreeClass > ApplyResult<SynTreeClass> apply( const SynTreeClass * input ) const;
    55         template< typename SynTreeClass > ApplyResult<SynTreeClass> applyFree( const SynTreeClass * input ) const;
     54        template< typename node_t >
     55        ApplyResult<node_t> apply( const node_t * input ) const {
     56                ApplyResult<Node> ret = applyBase( input, false );
     57                return { ret.node.strict_as<node_t>(), ret.count };
     58        }
    5659
    5760        template< typename node_t, enum Node::ref_type ref_t >
    5861        int apply( ptr_base< node_t, ref_t > & input ) const {
    59                 const node_t * p = input.get();
    60                 auto ret = apply(p);
    61                 input = ret.node;
     62                ApplyResult<Node> ret = applyBase( input.get(), false );
     63                input = ret.node.strict_as<node_t>();
    6264                return ret.count;
     65        }
     66
     67        template< typename node_t >
     68        ApplyResult<node_t> applyFree( const node_t * input ) const {
     69                ApplyResult<Node> ret = applyBase( input, true );
     70                return { ret.node.strict_as<node_t>(), ret.count };
    6371        }
    6472
    6573        template< typename node_t, enum Node::ref_type ref_t >
    6674        int applyFree( ptr_base< node_t, ref_t > & input ) const {
    67                 const node_t * p = input.get();
    68                 auto ret = applyFree(p);
    69                 input = ret.node;
     75                ApplyResult<Node> ret = applyBase( input.get(), true );
     76                input = ret.node.strict_as<node_t>();
    7077                return ret.count;
    7178        }
    … …  
    97104        // Mutator that performs the substitution
    98105        struct Substituter;
     106        ApplyResult<Node> applyBase( const Node * input, bool isFree ) const;
    99107
    100108        // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
    … …  
    158166} // namespace ast
    159167
    160 // include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and
    161 // PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals.
    162 #include "Pass.hpp"
    163 #include "Copy.hpp"
    164 
    165 namespace ast {
    166 
    167 // definitition must happen after PassVisitor is included so that WithGuards can be used
    168 struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter>, public PureVisitor {
    169                 static size_t traceId;
    170 
    171                 Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
    172 
    173                 const Type * postvisit( const TypeInstType * aggregateUseType );
    174 
    175                 /// Records type variable bindings from forall-statements
    176                 void previsit( const FunctionType * type );
    177                 /// Records type variable bindings from forall-statements and instantiations of generic types
    178                 // void handleAggregateType( const BaseInstType * type );
    179 
    180                 // void previsit( const StructInstType * aggregateUseType );
    181                 // void previsit( const UnionInstType * aggregateUseType );
    182 
    183                 const TypeSubstitution & sub;
    184                 int subCount = 0;
    185                 bool freeOnly;
    186                 typedef std::unordered_set< TypeEnvKey > BoundVarsType;
    187                 BoundVarsType boundVars;
    188 
    189 };
    190 
    191 template< typename SynTreeClass >
    192 TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::apply( const SynTreeClass * input ) const {
    193         assert( input );
    194         Pass<Substituter> sub( *this, false );
    195         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
    196         return { input, sub.core.subCount };
    197 }
    198 
    199 template< typename SynTreeClass >
    200 TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::applyFree( const SynTreeClass * input ) const {
    201         assert( input );
    202         Pass<Substituter> sub( *this, true );
    203         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
    204         return { input, sub.core.subCount };
    205 }
    206 
    207 } // namespace ast
    208 
    209168// Local Variables: //
    210169// tab-width: 4 //

  • src/Concurrency/Waituntil.cpp

    rb09ca2b ra01faa98  
    1414//
    1515
     16#include "Waituntil.hpp"
     17
    1618#include <string>
    1719
    18 #include "Waituntil.hpp"
     20#include "AST/Copy.hpp"
    1921#include "AST/Expr.hpp"
    2022#include "AST/Pass.hpp"

  • src/ControlStruct/ExceptDeclNew.cpp

    rb09ca2b ra01faa98  
    1818#include <sstream>
    1919
     20#include "AST/Copy.hpp"
    2021#include "AST/Decl.hpp"
    2122#include "AST/Pass.hpp"

  • src/GenPoly/SpecializeNew.cpp

    rb09ca2b ra01faa98  
    1616#include "Specialize.h"
    1717
     18#include "AST/Copy.hpp"                  // for deepCopy
    1819#include "AST/Inspect.hpp"               // for isIntrinsicCallExpr
    1920#include "AST/Pass.hpp"                  // for Pass

  • src/MakeLibCfaNew.cpp

    rb09ca2b ra01faa98  
    1616#include "MakeLibCfa.h"
    1717
     18#include "AST/Copy.hpp"
    1819#include "AST/Fwd.hpp"
    1920#include "AST/Pass.hpp"

  • src/ResolvExpr/CommonType.cc

    rb09ca2b ra01faa98  
    2121
    2222#include "AST/Decl.hpp"
     23#include "AST/Pass.hpp"
    2324#include "AST/Type.hpp"
    2425#include "Common/PassVisitor.h"

  • src/ResolvExpr/PolyCost.cc

    rb09ca2b ra01faa98  
    1515
    1616#include "AST/SymbolTable.hpp"
     17#include "AST/Pass.hpp"
    1718#include "AST/Type.hpp"
    1819#include "AST/TypeEnvironment.hpp"

  • src/Tuples/Explode.cc

    rb09ca2b ra01faa98  
    1717#include <list>                  // for list
    1818
     19#include "AST/Pass.hpp"          // for Pass
    1920#include "SynTree/Mutator.h"     // for Mutator
    2021#include "Common/PassVisitor.h"  // for PassVisitor

  • src/Validate/Autogen.cpp

    rb09ca2b ra01faa98  
    2525
    2626#include "AST/Attribute.hpp"
     27#include "AST/Copy.hpp"
    2728#include "AST/Create.hpp"
    2829#include "AST/Decl.hpp"

  • src/Validate/FixQualifiedTypes.cpp

    rb09ca2b ra01faa98  
    1616#include "Validate/FixQualifiedTypes.hpp"
    1717
     18#include "AST/Copy.hpp"
    1819#include "AST/LinkageSpec.hpp"             // for Linkage
    1920#include "AST/Pass.hpp"

  • src/Validate/GenericParameter.cpp

    rb09ca2b ra01faa98  
    1616#include "GenericParameter.hpp"
    1717
     18#include "AST/Copy.hpp"
    1819#include "AST/Decl.hpp"
    1920#include "AST/Expr.hpp"

  • src/Validate/ReplaceTypedef.cpp

    rb09ca2b ra01faa98  
    1616#include "ReplaceTypedef.hpp"
    1717
     18#include "AST/Copy.hpp"
    1819#include "AST/Pass.hpp"
    1920#include "Common/ScopedMap.h"

  • src/Virtual/ExpandCasts.cc

    rb09ca2b ra01faa98  
    2020#include <string>                  // for string, allocator, operator==, ope...
    2121
     22#include "AST/Copy.hpp"
    2223#include "AST/Decl.hpp"
    2324#include "AST/Expr.hpp"

  • src/main.cc

    rb09ca2b ra01faa98  
    3232
    3333#include "AST/Convert.hpp"
     34#include "AST/Pass.hpp"                     // for pass_visitor_stats
     35#include "AST/TranslationUnit.hpp"          // for TranslationUnit
    3436#include "AST/Util.hpp"                     // for checkInvariants
    3537#include "CompilationState.h"

  • tests/.expect/array.txt

    rb09ca2b ra01faa98  
    1 array.cfa:52:25: warning: Compiled
     1array.cfa:105:25: warning: Preprocessor started

  • tests/Makefile.am

    rb09ca2b ra01faa98  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Tue May 16 09:27:48 2023
    14 ## Update Count     : 178
     13## Last Modified On : Fri May 26 08:23:09 2023
     14## Update Count     : 179
    1515###############################################################################
    1616
    … …  
    7979        avltree/avl-private.h \
    8080        avltree/avl.h \
    81         concurrent/clib_tls.c \
    82         concurrent/clib.c \
    8381        configs/.in/parseconfig-all.txt \
    8482        configs/.in/parseconfig-errors.txt \
    … …  
    8987        io/.in/many_read.data \
    9088        meta/fork+exec.hfa \
    91         concurrent/unified_locking/mutex_test.hfa \
    92         concurrent/channels/parallel_harness.hfa
     89        concurrency/clib_tls.c \
     90        concurrency/clib.c \
     91        concurrency/unified_locking/mutex_test.hfa \
     92        concurrentcy/channels/parallel_harness.hfa
    9393
    9494dist-hook:
    … …  
    204204
    205205SYNTAX_ONLY_CODE = expression typedefRedef variableDeclarator switch numericConstants identFuncDeclarator \
    206         init1 limits nested-types cast labelledExit array quasiKeyword include/stdincludes include/includes builtins/sync warnings/self-assignment concurrent/waitfor/parse
     206        init1 limits nested-types cast labelledExit array quasiKeyword include/stdincludes include/includes builtins/sync warnings/self-assignment concurrency/waitfor/parse
    207207${SYNTAX_ONLY_CODE} : % : %.cfa ${CFACCBIN}
    208208        ${CFACOMPILE_SYNTAX}
    … …  
    211211# expected failures
    212212# use custom target since they require a custom define *and* have a name that doesn't match the file
     213
     214array-ERR1 : array.cfa ${CFACCBIN}
     215        ${CFACOMPILE_SYNTAX} -DERR1
     216        -cp ${test} ${abspath ${@}}
     217
     218array-ERR2 : array.cfa ${CFACCBIN}
     219        ${CFACOMPILE_SYNTAX} -DERR2
     220        -cp ${test} ${abspath ${@}}
     221
     222array-ERR3 : array.cfa ${CFACCBIN}
     223        ${CFACOMPILE_SYNTAX} -DERR3
     224        -cp ${test} ${abspath ${@}}
     225
    213226alloc-ERROR : alloc.cfa ${CFACCBIN}
    214227        ${CFACOMPILE_SYNTAX} -DERR1

  • tests/PRNG.cfa

    rb09ca2b ra01faa98  
    1 //                               -*- Mode: C -*-
    2 //
     1//
    32// Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
    4 //
    5 // PRNG.c --
    6 //
     3//
     4// PRNG.c -- high-perforamnce pseudo-random numbers
     5//
     6// The contents of this file are covered under the licence agreement in the
     7// file "LICENCE" distributed with Cforall.
     8//
    79// Author           : Peter A. Buhr
    810// Created On       : Wed Dec 29 09:38:12 2021
    911// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Sun Apr 23 22:02:09 2023
    11 // Update Count     : 420
     12// Last Modified On : Thu May 25 15:39:52 2023
     13// Update Count     : 422
    1214//
    1315

  • tests/array.cfa

    rb09ca2b ra01faa98  
    1515//
    1616
    17 int a1[0];
    18 //int a2[*];
    19 //double a4[3.0];
     17// Tests syntax.  Comments explain semantics.  Test does not show semantics.
     18// Mostly illustrates facts about C (with which CFA is being tested to agree).
     19// Is a test oracle under `gcc -x c`.
    2020
    21 int m1[0][3];
    22 //int m2[*][*];
    23 int m4[3][3];
     21#ifdef ERR1
     22#define E1(...) __VA_ARGS__
     23#else
     24#define E1(...)
     25#endif
    2426
    25 typedef int T;
     27#ifdef ERR2
     28#define E2(...) __VA_ARGS__
     29#else
     30#define E2(...)
     31#endif
    2632
    27 int fred() {
    28 //      int a1[];
    29 //      int a2[*];
    30         int a4[3];
    31         int T[3];
    32 }
     33#ifdef ERR3
     34#define E3(...) __VA_ARGS__
     35#else
     36#define E3(...)
     37#endif
    3338
    34 int mary( int T[3],
    35                   int p1[const 3],
    36                   int p2[static 3],
    37                   int p3[static const 3]
    38         ) {
    39 }
     39    int a1[0];
     40E1( int a2[*];       )
     41                                                        #ifndef __cforall
     42E1( double a4[3.0];  )                                  // BUG 275: CFA accepts but should reject
     43                                                        #endif
    4044
    41 int (*tom())[3] {
    42 }
     45    int m1[0][3];
     46E1( int m2[*][*];    )
     47    int m4[3][3];
    4348
    44 int (*(jane)())( int T[3],
    45                                  int p1[const 3],
    46                                  int p2[static 3],
    47                                  int p3[static const 3]
    48         ) {
    49 }
     49    typedef int T;
     50
     51    int fred(int n) {
     52E1(     int a1[];    )
     53E1(     int a2[*];   )
     54        int a4[3];
     55        int T[3];
     56        int a5[n];
     57    }
     58
     59    int mary( int T[3],                                 // same as: int *T
     60              int p1[const 3],                          // same as: int const *p1
     61              int p2[static 3],                         // same as T, but length >=3 checked
     62              int p3[static const 3]                    // both above: 3 is static, p3 is const
     63        ) {
     64    }
     65
     66    // function taking (), returning pointer to array of ints
     67    int (*tom())[3] {
     68    }
     69
     70    // function taking (), returning pointer to function of same type as mary
     71    int (*(jane)())( int T[3],
     72                     int p1[const 3],
     73                     int p2[static 3],
     74                     int p3[static const 3]
     75        ) {
     76    }
     77
     78    // functions returning same exotic pointers, in CFA's non-onion syntax
     79    #ifdef __cforall
     80    [ * [3] int ] toms_twin(...) {
     81    }
     82    [ * [int]( [3] int T,
     83            [const 3] int p1,
     84            [static 3] int p2,
     85            [static const 3] int p3
     86            )
     87    ] janes_twin(...) {
     88    }
     89    #endif
     90
     91
     92//  int fm1( int, int, int[][*] );                      // TODO: investigate gcc-11 warning
     93//  int fm1( int r, int c, int m[][c] ) {}
     94    int fm2( int r, int c, int (*m)[c] ) {}             // same as fm1
     95E2( int fm3( int r, int c, int m[][static c] ) {}  )    // that's not static
     96E3( int fm4( int r, int c, int m[][] );            )    // m's immediate element type is incomplete
     97    int fm5( int, int, int[*][*] );                     // same as fm1 decl
     98                                                        #ifndef __cforall
     99    int fm5( int r, int c, int m[r][c] ) {}             // BUG 276: CFA chokes but should accept
     100                                                        // C: same as fm1 defn
     101                                                        #endif
     102
    50103
    51104int main() {
    52     #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
     105    #pragma GCC warning "Preprocessor started"          // force non-empty .expect file, NO TABS!!!
    53106}
    54107

  • tests/concurrency/.expect/ctor-check.txt

    rb09ca2b ra01faa98  
    1 concurrent/ctor-check.cfa:11:1 error: constructors cannot have mutex parameters
     1concurrency/ctor-check.cfa:11:1 error: constructors cannot have mutex parameters
    22?{}: function
    33... with parameters
Note: See TracChangeset for help on using the changeset viewer.