Changeset beefc34c for src


Ignore:
Timestamp:
Jun 7, 2018, 6:12:11 PM (7 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc
Children:
6eb131c, 7b28e4a
Parents:
174845e (diff), 85b1deb (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

Location:
src
Files:
1 added
2 deleted
24 edited

Legend:

Unmodified
Added
Removed

  • src/Common/SemanticError.cc

    r174845e rbeefc34c  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 16 15:01:20 2018
    13 // Update Count     : 9
     12// Last Modified On : Thu Jun  7 08:05:26 2018
     13// Update Count     : 10
    1414//
    1515
    … …  
    9797void SemanticError( CodeLocation location, std::string error ) {
    9898        SemanticErrorThrow = true;
    99         throw SemanticErrorException(location, error);
     99        throw SemanticErrorException( location, error );
    100100}
    101101

  • src/Parser/DeclarationNode.cc

    r174845e rbeefc34c  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 22 08:39:29 2018
    13 // Update Count     : 1074
     12// Last Modified On : Thu Jun  7 12:08:55 2018
     13// Update Count     : 1079
    1414//
    1515
    … …  
    174174}
    175175
    176 DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
     176DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
    177177        DeclarationNode * newnode = new DeclarationNode;
    178178        newnode->name = name;
    … …  
    245245} // DeclarationNode::newForall
    246246
    247 DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
     247DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
    248248        DeclarationNode * newnode = new DeclarationNode;
    249249        newnode->type = new TypeData( TypeData::SymbolicInst );
    … …  
    268268} // DeclarationNode::newAggregate
    269269
    270 DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants, bool body ) {
     270DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body ) {
    271271        assert( name );
    272272        DeclarationNode * newnode = new DeclarationNode;
    … …  
    278278} // DeclarationNode::newEnum
    279279
    280 DeclarationNode * DeclarationNode::newEnumConstant( string * name, ExpressionNode * constant ) {
     280DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
    281281        DeclarationNode * newnode = new DeclarationNode;
    282282        newnode->name = name;
    … …  
    285285} // DeclarationNode::newEnumConstant
    286286
    287 DeclarationNode * DeclarationNode::newName( string * name ) {
     287DeclarationNode * DeclarationNode::newName( const string * name ) {
    288288        DeclarationNode * newnode = new DeclarationNode;
    289289        newnode->name = name;
    … …  
    291291} // DeclarationNode::newName
    292292
    293 DeclarationNode * DeclarationNode::newFromTypeGen( string * name, ExpressionNode * params ) {
     293DeclarationNode * DeclarationNode::newFromTypeGen( const string * name, ExpressionNode * params ) {
    294294        DeclarationNode * newnode = new DeclarationNode;
    295295        newnode->type = new TypeData( TypeData::SymbolicInst );
    … …  
    300300} // DeclarationNode::newFromTypeGen
    301301
    302 DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, string * name ) {
     302DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, const string * name ) {
    303303        DeclarationNode * newnode = new DeclarationNode;
    304304        newnode->type = nullptr;
    … …  
    331331} // DeclarationNode::newTraitUse
    332332
    333 DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) {
     333DeclarationNode * DeclarationNode::newTypeDecl( const string * name, DeclarationNode * typeParams ) {
    334334        DeclarationNode * newnode = new DeclarationNode;
    335335        newnode->name = name;
    … …  
    406406} // DeclarationNode::newBuiltinType
    407407
    408 DeclarationNode * DeclarationNode::newAttr( string * name, ExpressionNode * expr ) {
     408DeclarationNode * DeclarationNode::newAttr( const string * name, ExpressionNode * expr ) {
    409409        DeclarationNode * newnode = new DeclarationNode;
    410410        newnode->type = nullptr;
    … …  
    415415}
    416416
    417 DeclarationNode * DeclarationNode::newAttr( string * name, DeclarationNode * type ) {
     417DeclarationNode * DeclarationNode::newAttr( const string * name, DeclarationNode * type ) {
    418418        DeclarationNode * newnode = new DeclarationNode;
    419419        newnode->type = nullptr;
    … …  
    424424}
    425425
    426 DeclarationNode * DeclarationNode::newAttribute( string * name, ExpressionNode * expr ) {
     426DeclarationNode * DeclarationNode::newAttribute( const string * name, ExpressionNode * expr ) {
    427427        DeclarationNode * newnode = new DeclarationNode;
    428428        newnode->type = nullptr;
    … …  
    545545                                        type->aggregate.params->appendList( q->type->forall ); // augment forall qualifier
    546546                                } else {                                                                // not polymorphic
    547                                         type->aggregate.params = q->type->forall; // make polymorphic type
    548                                         // change implicit typedef from TYPEDEFname to TYPEGENname
    549                                         typedefTable.changeKind( *type->aggregate.name, TYPEGENname );
     547                                        type->aggregate.params = q->type->forall; // set forall qualifier
    550548                                } // if
    551549                        } else {                                                                        // not polymorphic

  • src/Parser/ParseNode.h

    r174845e rbeefc34c  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun  4 22:21:04 2018
    13 // Update Count     : 832
     12// Last Modified On : Wed Jun  6 16:17:18 2018
     13// Update Count     : 843
    1414//
    1515
    … …  
    7777
    7878        ParseNode * next = nullptr;
    79         std::string * name = nullptr;
     79        const std::string * name = nullptr;
    8080        CodeLocation location = yylloc;
    8181}; // ParseNode
    … …  
    171171};
    172172
    173 Expression * build_constantInteger( std::string &str );
    174 Expression * build_constantFloat( std::string &str );
    175 Expression * build_constantChar( std::string &str );
    176 Expression * build_constantStr( std::string &str );
     173Expression * build_constantInteger( std::string & str ); // these 4 routines modify the string
     174Expression * build_constantFloat( std::string & str );
     175Expression * build_constantChar( std::string & str );
     176Expression * build_constantStr( std::string & str );
    177177Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
    178178Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
    … …  
    230230        static DeclarationNode * newBuiltinType( BuiltinType );
    231231        static DeclarationNode * newForall( DeclarationNode * );
    232         static DeclarationNode * newFromTypedef( std::string * );
    233         static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
     232        static DeclarationNode * newFromTypedef( const std::string * );
     233        static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
    234234        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
    235         static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
    236         static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
    237         static DeclarationNode * newName( std::string * );
    238         static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
    239         static DeclarationNode * newTypeParam( TypeClass, std::string * );
     235        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body );
     236        static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
     237        static DeclarationNode * newName( const std::string * );
     238        static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
     239        static DeclarationNode * newTypeParam( TypeClass, const std::string * );
    240240        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
    241241        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
    242         static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
     242        static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams );
    243243        static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
    244244        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
    … …  
    247247        static DeclarationNode * newTuple( DeclarationNode * members );
    248248        static DeclarationNode * newTypeof( ExpressionNode * expr );
    249         static DeclarationNode * newAttr( std::string *, ExpressionNode * expr ); // @ attributes
    250         static DeclarationNode * newAttr( std::string *, DeclarationNode * type ); // @ attributes
    251         static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
     249        static DeclarationNode * newAttr( const std::string *, ExpressionNode * expr ); // @ attributes
     250        static DeclarationNode * newAttr( const std::string *, DeclarationNode * type ); // @ attributes
     251        static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
    252252        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
    253253        static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );

  • src/Parser/TypeData.cc

    r174845e rbeefc34c  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Apr 26 13:46:07 2018
    13 // Update Count     : 603
     12// Last Modified On : Wed Jun  6 17:40:33 2018
     13// Update Count     : 604
    1414//
    1515
    … …  
    610610
    611611                if ( td->basictype == DeclarationNode::Float80 || td->basictype == DeclarationNode::Float128 ) {
    612                         if ( td->complextype != DeclarationNode::NoComplexType ) {
    613                                 genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
    614                         }
     612                        // if ( td->complextype != DeclarationNode::NoComplexType ) {
     613                        //      genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
     614                        // }
    615615                        if ( td->basictype == DeclarationNode::Float80 ) ret = BasicType::Float80;
    616616                        else ret = BasicType::Float128;

  • src/Parser/TypedefTable.cc

    r174845e rbeefc34c  
    1010// Created On       : Sat May 16 15:20:13 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jun  1 16:54:18 2018
    13 // Update Count     : 155
     12// Last Modified On : Thu Jun  7 13:17:56 2018
     13// Update Count     : 192
    1414//
    1515
    … …  
    1717#include "TypedefTable.h"
    1818#include <cassert>                                                                              // for assert
     19#include <iostream>
    1920
    2021#if 0
    21 #include <iostream>
    2222#define debugPrint( code ) code
    2323#else
    … …  
    2727using namespace std;                                                                    // string, iostream
    2828
     29debugPrint(
     30static const char *kindName( int kind ) {
     31        switch ( kind ) {
     32          case IDENTIFIER: return "identifier";
     33          case TYPEDEFname: return "typedef";
     34          case TYPEGENname: return "typegen";
     35          default:
     36                cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;
     37                abort();
     38        } // switch
     39} // kindName
     40)
     41
    2942TypedefTable::~TypedefTable() {
    3043        if ( ! SemanticErrorThrow && kindTable.currentScope() != 0 ) {
    31                 std::cerr << "scope failure " << kindTable.currentScope() << endl;
     44                cerr << "Error: cfa-cpp internal error, scope failure " << kindTable.currentScope() << endl;
     45                abort();
    3246        } // if
    3347} // TypedefTable::~TypedefTable
    … …  
    4458} // TypedefTable::isKind
    4559
    46 void TypedefTable::changeKind( const string & identifier, int kind ) {
    47         KindTable::iterator posn = kindTable.find( identifier );
    48         if ( posn != kindTable.end() ) posn->second = kind;     // exists => update
    49 } // TypedefTable::changeKind
    50 
    5160// SKULLDUGGERY: Generate a typedef for the aggregate name so the aggregate does not have to be qualified by
    5261// "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed if the
    5362// name is explicitly used.
    54 void TypedefTable::makeTypedef( const string & name ) {
     63void TypedefTable::makeTypedef( const string & name, int kind ) {
     64//    Check for existence is necessary to handle:
     65//        struct Fred {};
     66//        void Fred();
     67//        void fred() {
     68//           struct Fred act; // do not add as type in this scope
     69//           Fred();
     70//        }
    5571        if ( ! typedefTable.exists( name ) ) {
    56                 typedefTable.addToEnclosingScope( name, TYPEDEFname, "MTD" );
     72                typedefTable.addToEnclosingScope( name, kind, "MTD" );
    5773        } // if
    5874} // TypedefTable::makeTypedef
    5975
    60 void TypedefTable::addToScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) {
     76void TypedefTable::addToScope( const string & identifier, int kind, const char * locn __attribute__((unused)) ) {
    6177        auto scope = kindTable.currentScope();
    62         debugPrint( cerr << "Adding at " << locn << " " << identifier << " as kind " << kind << " scope " << scope << endl );
     78        debugPrint( cerr << "Adding current at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << endl );
    6379        auto ret = kindTable.insertAt( scope, identifier, kind );
    6480        if ( ! ret.second ) ret.first->second = kind;           // exists => update
    6581} // TypedefTable::addToScope
    6682
    67 void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind, const char * locn __attribute__((unused)) ) {
     83void TypedefTable::addToEnclosingScope( const string & identifier, int kind, const char * locn __attribute__((unused)) ) {
    6884        assert( kindTable.currentScope() >= 1 );
    6985        auto scope = kindTable.currentScope() - 1;
    70         debugPrint( cerr << "Adding+1 at " << locn << " " << identifier << " as kind " << kind << " scope " << scope << endl );
     86        debugPrint( cerr << "Adding enclosing at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << endl );
    7187        auto ret = kindTable.insertAt( scope, identifier, kind );
    7288        if ( ! ret.second ) ret.first->second = kind;           // exists => update
    … …  
    93109                        debugPrint( cerr << endl << "[" << scope << "]" );
    94110                } // while
    95                 debugPrint( cerr << " " << (*i).first << ":" << (*i).second );
     111                debugPrint( cerr << " " << (*i).first << ":" << kindName( (*i).second ) );
    96112        } // for
    97113        while ( scope > 0 ) {

  • src/Parser/TypedefTable.h

    r174845e rbeefc34c  
    1010// Created On       : Sat May 16 15:24:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 31 23:23:47 2018
    13 // Update Count     : 83
     12// Last Modified On : Thu Jun  7 12:10:17 2018
     13// Update Count     : 85
    1414//
    1515
    … …  
    3030        bool exists( const std::string & identifier );
    3131        int isKind( const std::string & identifier ) const;
    32         void changeKind( const std::string & identifier, int kind );
    33         void makeTypedef( const std::string & name );
     32        void makeTypedef( const std::string & name, int kind = TYPEDEFname );
    3433        void addToScope( const std::string & identifier, int kind, const char * );
    3534        void addToEnclosingScope( const std::string & identifier, int kind, const char * );

  • src/Parser/lex.ll

    r174845e rbeefc34c  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu May  3 13:42:40 2018
    13  * Update Count     : 676
     12 * Last Modified On : Thu Jun  7 08:27:40 2018
     13 * Update Count     : 679
    1414 */
    1515
    … …  
    232232finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
    233233float                   { KEYWORD_RETURN(FLOAT); }
     234_Float32                { KEYWORD_RETURN(FLOAT); }                              // GCC
     235_Float32x               { KEYWORD_RETURN(FLOAT); }                              // GCC
     236_Float64                { KEYWORD_RETURN(DOUBLE); }                             // GCC
     237_Float64x               { KEYWORD_RETURN(DOUBLE); }                             // GCC
    234238__float80               { KEYWORD_RETURN(FLOAT80); }                    // GCC
    235239float80                 { KEYWORD_RETURN(FLOAT80); }                    // GCC
     240_Float128               { KEYWORD_RETURN(FLOAT128); }                   // GCC
     241_Float128x              { KEYWORD_RETURN(FLOAT128); }                   // GCC
    236242__float128              { KEYWORD_RETURN(FLOAT128); }                   // GCC
    237243float128                { KEYWORD_RETURN(FLOAT128); }                   // GCC
    … …  
    446452
    447453%%
     454
    448455// ----end of lexer----
    449456
    450457void yyerror( const char * errmsg ) {
     458        SemanticErrorThrow = true;
    451459        cout << (yyfilename ? yyfilename : "*unknown file*") << ':' << yylineno << ':' << column - yyleng + 1
    452460                 << ": " << ErrorHelpers::error_str() << errmsg << " at token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << '"' << endl;

  • src/Parser/parser.yy

    r174845e rbeefc34c  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun  4 22:22:04 2018
    13 // Update Count     : 3492
     12// Last Modified On : Thu Jun  7 10:07:12 2018
     13// Update Count     : 3527
    1414//
    1515
    … …  
    503503                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $5 ) ), $2 ) ); }
    504504        | type_name '.' no_attr_identifier                                      // CFA, nested type
    505                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     505                // { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     506                { $$ = nullptr; }
    506507        | type_name '.' '[' field_list ']'                                      // CFA, nested type / tuple field selector
    507                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     508                // { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     509                { $$ = nullptr; }
    508510        | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
    509511                {
    … …  
    13001302        ;
    13011303
    1302 KR_parameter_list_opt:                                                          // used to declare parameter types in K&R style functions
     1304KR_parameter_list_opt:                                                                  // used to declare parameter types in K&R style functions
    13031305        // empty
    13041306                { $$ = nullptr; }
    … …  
    17901792                { $$ = DeclarationNode::newFromTypedef( $1 ); }
    17911793        | '.' TYPEDEFname
    1792                 { $$ = DeclarationNode::newFromTypedef( $2 ); } // FIX ME
     1794                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    17931795        | type_name '.' TYPEDEFname
    1794                 { $$ = DeclarationNode::newFromTypedef( $3 ); } // FIX ME
     1796                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    17951797        | typegen_name
    17961798        | '.' typegen_name
    1797                 { $$ = $2; }                                                                    // FIX ME
     1799                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    17981800        | type_name '.' typegen_name
    1799                 { $$ = $3; }                                                                    // FIX ME
     1801                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    18001802        ;
    18011803
    … …  
    18221824        aggregate_key attribute_list_opt '{' field_declaration_list_opt '}'
    18231825                { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), nullptr, $4, true )->addQualifiers( $2 ); }
    1824         | aggregate_key attribute_list_opt no_attr_identifier_or_type_name
    1825                 {
    1826                         typedefTable.makeTypedef( *$3 );                        // create typedef
    1827                         if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
     1826        | aggregate_key attribute_list_opt no_attr_identifier
     1827                {
     1828                        typedefTable.makeTypedef( *$3, forall ? TYPEGENname : TYPEDEFname ); // create typedef
     1829                        //if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
    18281830                        forall = false;                                                         // reset
    18291831                }
    18301832          '{' field_declaration_list_opt '}'
    18311833                { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); }
     1834        | aggregate_key attribute_list_opt type_name
     1835                {
     1836                        typedefTable.makeTypedef( *$3->type->symbolic.name, forall ? TYPEGENname : TYPEDEFname ); // create typedef
     1837                        //if ( forall ) typedefTable.changeKind( *$3->type->symbolic.name, TYPEGENname ); // possibly update
     1838                        forall = false;                                                         // reset
     1839                }
     1840          '{' field_declaration_list_opt '}'
     1841                { $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, nullptr, $6, true )->addQualifiers( $2 ); }
    18321842        | aggregate_key attribute_list_opt '(' type_list ')' '{' field_declaration_list_opt '}' // CFA
    18331843                { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $4, $7, false )->addQualifiers( $2 ); }
    … …  
    18381848        aggregate_key attribute_list_opt no_attr_identifier
    18391849                {
    1840                         typedefTable.makeTypedef( *$3 );
    1841                         if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
     1850                        typedefTable.makeTypedef( *$3, forall ? TYPEGENname : TYPEDEFname );
     1851                        //if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
    18421852                        forall = false;                                                         // reset
    18431853                        $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
    18441854                }
    1845         | aggregate_key attribute_list_opt TYPEDEFname
    1846                 {
    1847                         typedefTable.makeTypedef( *$3 );
    1848                         $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
    1849                 }
    1850         | aggregate_key attribute_list_opt typegen_name         // CFA
     1855        | aggregate_key attribute_list_opt type_name
    18511856                {
    18521857                        // Create new generic declaration with same name as previous forward declaration, where the IDENTIFIER is
    … …  
    19431948        ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
    19441949                { $$ = DeclarationNode::newEnum( new string( DeclarationNode::anonymous.newName() ), $4, true )->addQualifiers( $2 ); }
    1945         | ENUM attribute_list_opt no_attr_identifier_or_type_name
     1950        | ENUM attribute_list_opt no_attr_identifier
    19461951                { typedefTable.makeTypedef( *$3 ); }
    19471952          '{' enumerator_list comma_opt '}'
    19481953                { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
     1954        | ENUM attribute_list_opt type_name
     1955          '{' enumerator_list comma_opt '}'
     1956                { $$ = DeclarationNode::newEnum( $3->type->symbolic.name, $5, true )->addQualifiers( $2 ); }
    19491957        | enum_type_nobody
    19501958        ;
    19511959
    19521960enum_type_nobody:                                                                               // enum - {...}
    1953         ENUM attribute_list_opt no_attr_identifier_or_type_name
     1961        ENUM attribute_list_opt no_attr_identifier
    19541962                {
    19551963                        typedefTable.makeTypedef( *$3 );
    19561964                        $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 );
     1965                }
     1966        | ENUM attribute_list_opt type_name
     1967                {
     1968                        typedefTable.makeTypedef( *$3->type->symbolic.name );
     1969                        $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 );
    19571970                }
    19581971        ;
    … …  
    32513264
    32523265%%
     3266
    32533267// ----end of grammar----
    32543268

  • src/libcfa/bits/locks.h

    r174845e rbeefc34c  
    1818#include "bits/debug.h"
    1919#include "bits/defs.h"
     20#include <assert.h>
     21
     22#ifdef __cforall
     23        extern "C" {
     24                #include <pthread.h>
     25        }
     26#endif
    2027
    2128// pause to prevent excess processor bus usage
    … …  
    112119                __atomic_clear( &this.lock, __ATOMIC_RELEASE );
    113120        }
     121
     122
     123        #ifdef __CFA_WITH_VERIFY__
     124                extern bool __cfaabi_dbg_in_kernel();
     125        #endif
     126
     127        struct __bin_sem_t {
     128                bool                    signaled;
     129                pthread_mutex_t         lock;
     130                pthread_cond_t          cond;
     131        };
     132
     133        static inline void ?{}(__bin_sem_t & this) with( this ) {
     134                signaled = false;
     135                pthread_mutex_init(&lock, NULL);
     136                pthread_cond_init (&cond, NULL);
     137        }
     138
     139        static inline void ^?{}(__bin_sem_t & this) with( this ) {
     140                pthread_mutex_destroy(&lock);
     141                pthread_cond_destroy (&cond);
     142        }
     143
     144        static inline void wait(__bin_sem_t & this) with( this ) {
     145                verify(__cfaabi_dbg_in_kernel());
     146                pthread_mutex_lock(&lock);
     147                        if(!signaled) {   // this must be a loop, not if!
     148                                pthread_cond_wait(&cond, &lock);
     149                        }
     150                        signaled = false;
     151                pthread_mutex_unlock(&lock);
     152        }
     153
     154        static inline void post(__bin_sem_t & this) with( this ) {
     155                verify(__cfaabi_dbg_in_kernel());
     156
     157                pthread_mutex_lock(&lock);
     158                        bool needs_signal = !signaled;
     159                        signaled = true;
     160                pthread_mutex_unlock(&lock);
     161
     162                if (needs_signal)
     163                        pthread_cond_signal(&cond);
     164        }
    114165#endif

  • src/libcfa/concurrency/kernel

    r174845e rbeefc34c  
    113113        pthread_t kernel_thread;
    114114
     115        // RunThread data
     116        // Action to do after a thread is ran
     117        struct FinishAction finish;
     118
     119        // Preemption data
     120        // Node which is added in the discrete event simulaiton
     121        struct alarm_node_t * preemption_alarm;
     122
     123        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
     124        bool pending_preemption;
     125
     126        // Idle lock
     127        __bin_sem_t idleLock;
     128
    115129        // Termination
    116130        // Set to true to notify the processor should terminate
    … …  
    120134        semaphore terminated;
    121135
    122         // RunThread data
    123         // Action to do after a thread is ran
    124         struct FinishAction finish;
    125 
    126         // Preemption data
    127         // Node which is added in the discrete event simulaiton
    128         struct alarm_node_t * preemption_alarm;
    129 
    130         // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
    131         bool pending_preemption;
    132 
    133         // Idle lock
    134         sem_t idleLock;
    135 
    136136        // Link lists fields
    137         struct {
     137        struct __dbg_node_proc {
    138138                struct processor * next;
    139139                struct processor * prev;
    … …  
    182182
    183183        // Link lists fields
    184         struct {
     184        struct __dbg_node_cltr {
    185185                cluster * next;
    186186                cluster * prev;

  • src/libcfa/concurrency/kernel.c

    r174845e rbeefc34c  
    1616//C Includes
    1717#include <stddef.h>
     18#include <errno.h>
     19#include <string.h>
    1820extern "C" {
    1921#include <stdio.h>
    … …  
    4951thread_desc * mainThread;
    5052
    51 struct { __dllist_t(cluster) list; __spinlock_t lock; } global_clusters;
     53extern "C" {
     54struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
     55}
    5256
    5357//-----------------------------------------------------------------------------
    … …  
    143147        runner.proc = &this;
    144148
    145         sem_init(&idleLock, 0, 0);
     149        idleLock{};
    146150
    147151        start( &this );
    … …  
    149153
    150154void ^?{}(processor & this) with( this ){
    151         if( ! do_terminate ) {
     155        if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
    152156                __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
    153                 terminate(&this);
    154                 verify(this.do_terminate);
    155                 verify( kernelTLS.this_processor != &this);
     157
     158                __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
     159                wake( &this );
     160
    156161                P( terminated );
    157162                verify( kernelTLS.this_processor != &this);
    158                 pthread_join( kernel_thread, NULL );
    159         }
    160 
    161         sem_destroy(&idleLock);
     163        }
     164
     165        pthread_join( kernel_thread, NULL );
    162166}
    163167
    … …  
    198202
    199203                thread_desc * readyThread = NULL;
    200                 for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ )
     204                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ )
    201205                {
    202206                        readyThread = nextThread( this->cltr );
    … …  
    217221                        else
    218222                        {
    219                                 spin(this, &spin_count);
     223                                // spin(this, &spin_count);
     224                                halt(this);
    220225                        }
    221226                }
    … …  
    290295}
    291296
    292 // Handles spinning logic
    293 // TODO : find some strategy to put cores to sleep after some time
    294 void spin(processor * this, unsigned int * spin_count) {
    295         // (*spin_count)++;
    296         halt(this);
    297 }
    298 
    299297// KERNEL_ONLY
    300298// Context invoker for processors
    … …  
    403401                unlock( ready_queue_lock );
    404402
    405                 if( was_empty ) {
     403                if(was_empty) {
    406404                        lock      (proc_list_lock __cfaabi_dbg_ctx2);
    407405                        if(idles) {
    408                                 wake(idles.head);
     406                                wake_fast(idles.head);
    409407                        }
    410408                        unlock    (proc_list_lock);
    411409                }
     410                else if( struct processor * idle = idles.head ) {
     411                        wake_fast(idle);
     412                }
     413
    412414        }
    413415
    … …  
    544546        __cfaabi_dbg_print_safe("Kernel : Starting\n");
    545547
    546         global_clusters.list{ __get };
    547         global_clusters.lock{};
     548        __cfa_dbg_global_clusters.list{ __get };
     549        __cfa_dbg_global_clusters.lock{};
    548550
    549551        // Initialize the main cluster
    … …  
    626628        // When its coroutine terminates, it return control to the mainThread
    627629        // which is currently here
    628         mainProcessor->do_terminate = true;
     630        __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
    629631        returnToKernel();
     632        mainThread->self_cor.state = Halted;
    630633
    631634        // THE SYSTEM IS NOW COMPLETELY STOPPED
    … …  
    643646        ^(mainThread){};
    644647
    645         ^(global_clusters.list){};
    646         ^(global_clusters.lock){};
     648        ^(__cfa_dbg_global_clusters.list){};
     649        ^(__cfa_dbg_global_clusters.lock){};
    647650
    648651        __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
    … …  
    654657
    655658void halt(processor * this) with( *this ) {
     659        // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
     660
    656661        with( *cltr ) {
    657662                lock      (proc_list_lock __cfaabi_dbg_ctx2);
    … …  
    663668        __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
    664669
    665         verify( ({int sval = 0; sem_getvalue(&this->idleLock, &sval); sval; }) < 200);
    666         int __attribute__((unused)) ret = sem_wait(&idleLock);
    667         verify(ret > 0 || errno == EINTR);
     670        wait( idleLock );
    668671
    669672        __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
    … …  
    675678                unlock    (proc_list_lock);
    676679        }
    677 }
    678 
    679 void wake(processor * this) {
    680         __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
    681         int __attribute__((unused)) ret = sem_post(&this->idleLock);
    682         verify(ret > 0 || errno == EINTR);
    683         verify( ({int sval = 0; sem_getvalue(&this->idleLock, &sval); sval; }) < 200);
    684680}
    685681
    … …  
    797793// Global Queues
    798794void doregister( cluster     & cltr ) {
    799         lock      ( global_clusters.lock __cfaabi_dbg_ctx2);
    800         push_front( global_clusters.list, cltr );
    801         unlock    ( global_clusters.lock );
     795        lock      ( __cfa_dbg_global_clusters.lock __cfaabi_dbg_ctx2);
     796        push_front( __cfa_dbg_global_clusters.list, cltr );
     797        unlock    ( __cfa_dbg_global_clusters.lock );
    802798}
    803799
    804800void unregister( cluster     & cltr ) {
    805         lock  ( global_clusters.lock __cfaabi_dbg_ctx2);
    806         remove( global_clusters.list, cltr );
    807         unlock( global_clusters.lock );
     801        lock  ( __cfa_dbg_global_clusters.lock __cfaabi_dbg_ctx2);
     802        remove( __cfa_dbg_global_clusters.list, cltr );
     803        unlock( __cfa_dbg_global_clusters.lock );
    808804}
    809805

  • src/libcfa/concurrency/kernel_private.h

    r174845e rbeefc34c  
    5858void finishRunning(processor * this);
    5959void halt(processor * this);
    60 void wake(processor * this);
    61 void terminate(processor * this);
    62 void spin(processor * this, unsigned int * spin_count);
     60
     61static inline void wake_fast(processor * this) {
     62        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
     63        post( this->idleLock );
     64}
     65
     66static inline void wake(processor * this) {
     67        disable_interrupts();
     68        wake_fast(this);
     69        enable_interrupts( __cfaabi_dbg_ctx );
     70}
    6371
    6472struct event_kernel_t {
    … …  
    6876
    6977extern event_kernel_t * event_kernel;
    70 
    71 //extern thread_local coroutine_desc * volatile this_coroutine;
    72 //extern thread_local thread_desc *    volatile this_thread;
    73 //extern thread_local processor *      volatile this_processor;
    74 
    75 // extern volatile thread_local bool preemption_in_progress;
    76 // extern volatile thread_local bool preemption_enabled;
    77 // extern volatile thread_local unsigned short disable_preempt_count;
    7878
    7979struct __cfa_kernel_preemption_state_t {

  • src/libcfa/concurrency/preemption.c

    r174845e rbeefc34c  
    1010// Created On       : Mon Jun 5 14:20:42 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Apr  9 13:52:39 2018
    13 // Update Count     : 36
     12// Last Modified On : Tue Jun  5 17:35:49 2018
     13// Update Count     : 37
    1414//
    1515
    … …  
    116116        // If there are still alarms pending, reset the timer
    117117        if( alarms->head ) {
    118                 __cfaabi_dbg_print_buffer_decl( " KERNEL: @%lu(%lu) resetting alarm to %lu.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
     118                __cfaabi_dbg_print_buffer_decl( " KERNEL: @%ju(%ju) resetting alarm to %ju.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
    119119                Duration delta = alarms->head->alarm - currtime;
    120120                Duration caped = max(delta, 50`us);
    … …  
    263263}
    264264
    265 // kill wrapper : signal a processor
    266 void terminate(processor * this) {
    267         this->do_terminate = true;
    268         wake(this);
    269         sigval_t value = { PREEMPT_TERMINATE };
    270         pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
    271 }
    272 
    273265// reserved for future use
    274266static void timeout( thread_desc * this ) {
    … …  
    369361        choose(sfp->si_value.sival_int) {
    370362                case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
    371                 case PREEMPT_TERMINATE: verify( kernelTLS.this_processor->do_terminate);
     363                case PREEMPT_TERMINATE: verify( __atomic_load_n( &kernelTLS.this_processor->do_terminate, __ATOMIC_SEQ_CST ) );
    372364                default:
    373365                        abort( "internal error, signal value is %d", sfp->si_value.sival_int );
    … …  
    488480}
    489481
     482#ifdef __CFA_WITH_VERIFY__
     483bool __cfaabi_dbg_in_kernel() {
     484        return !kernelTLS.preemption_state.enabled;
     485}
     486#endif
     487
    490488// Local Variables: //
    491489// mode: c //

  • src/libcfa/fstream

    r174845e rbeefc34c  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec  7 15:17:26 2017
    13 // Update Count     : 130
     12// Last Modified On : Tue Jun  5 10:20:25 2018
     13// Update Count     : 131
    1414//
    1515
    … …  
    5454void open( ofstream &, const char * name );
    5555void close( ofstream & );
    56 ofstream & write( ofstream &, const char * data, unsigned long int size );
     56ofstream & write( ofstream &, const char * data, size_t size );
    5757int fmt( ofstream &, const char fmt[], ... );
    5858
    … …  
    7474void open( ifstream & is, const char * name );
    7575void close( ifstream & is );
    76 ifstream & read( ifstream & is, char * data, unsigned long int size );
     76ifstream & read( ifstream & is, char * data, size_t size );
    7777ifstream & ungetc( ifstream & is, char c );
    7878int fmt( ifstream &, const char fmt[], ... );

  • src/libcfa/fstream.c

    r174845e rbeefc34c  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Dec  9 09:31:23 2017
    13 // Update Count     : 275
     12// Last Modified On : Tue Jun  5 17:02:56 2018
     13// Update Count     : 281
    1414//
    1515
    … …  
    116116} // close
    117117
    118 ofstream & write( ofstream & os, const char * data, unsigned long int size ) {
     118ofstream & write( ofstream & os, const char * data, size_t size ) {
    119119        if ( fail( os ) ) {
    120120                fprintf( stderr, "attempt write I/O on failed stream\n" );
    … …  
    198198} // close
    199199
    200 ifstream & read( ifstream & is, char * data, unsigned long int size ) {
     200ifstream & read( ifstream & is, char * data, size_t size ) {
    201201        if ( fail( is ) ) {
    202202                fprintf( stderr, "attempt read I/O on failed stream\n" );

  • src/libcfa/stdhdr/assert.h

    r174845e rbeefc34c  
    3333        #define verify(x) assert(x)
    3434        #define verifyf(x, ...) assertf(x, __VA_ARGS__)
     35        #define __CFA_WITH_VERIFY__
    3536#else
    3637        #define verify(x)

  • src/main.cc

    r174845e rbeefc34c  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 30 17:53:14 2018
    13 // Update Count     : 496
     12// Last Modified On : Wed Jun  6 15:51:47 2018
     13// Update Count     : 498
    1414//
    1515
    … …  
    157157                 << "." << endl;
    158158        backtrace( 2 );                                                                         // skip first 2 stack frames
    159         exit( EXIT_FAILURE );
     159        //_exit( EXIT_FAILURE );
     160        abort();
    160161} // sigSegvBusHandler
    161162

  • src/prelude/extras.regx

    r174845e rbeefc34c  
    11typedef.* size_t;
    22typedef.* ptrdiff_t;
     3typedef.* __int8_t;
     4typedef.* __int16_t;
     5typedef.* __int32_t;
     6typedef.* __int64_t;
     7typedef.* __uint8_t;
     8typedef.* __uint16_t;
     9typedef.* __uint32_t;
     10typedef.* __uint64_t;
    311typedef.* int8_t;
    412typedef.* int16_t;

  • src/prelude/sync-builtins.cf

    r174845e rbeefc34c  
    248248#endif
    249249
     250_Bool __atomic_load_n(const volatile _Bool *, int);
     251void __atomic_load(const volatile _Bool *, volatile _Bool *, int);
    250252char __atomic_load_n(const volatile char *, int);
    251253char __atomic_load_1(const volatile char *, int);
    … …  
    285287
    286288void __atomic_store_n(volatile _Bool *, _Bool, int);
    287 void __atomic_store_1(volatile _Bool *, _Bool, int);
    288289void __atomic_store(volatile _Bool *, _Bool *, int);
    289290void __atomic_store_n(volatile char *, char, int);

  • src/tests/Makefile.am

    r174845e rbeefc34c  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Mon Nov 27 21:34:33 2017
    14 ## Update Count     : 48
     13## Last Modified On : Wed Jun  6 16:42:20 2018
     14## Update Count     : 49
    1515###############################################################################
    1616
    … …  
    9292        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
    9393
    94 literals : literals.c @CFA_BINDIR@/@CFA_NAME@
    95         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
    96 
    9794sched-ext-parse : sched-ext-parse.c @CFA_BINDIR@/@CFA_NAME@
    9895        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}

  • src/tests/Makefile.in

    r174845e rbeefc34c  
    769769        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
    770770
    771 literals : literals.c @CFA_BINDIR@/@CFA_NAME@
    772         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
    773 
    774771sched-ext-parse : sched-ext-parse.c @CFA_BINDIR@/@CFA_NAME@
    775772        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}

  • src/tests/ifwhileCtl.c

    r174845e rbeefc34c  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ifcond.c --
     7// ifwhileCtl.c --
    88//
    99// Author           : Peter A. Buhr
    1010// Created On       : Sat Aug 26 10:13:11 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun  4 22:46:48 2018
    13 // Update Count     : 19
     12// Last Modified On : Wed Jun  6 17:15:09 2018
     13// Update Count     : 21
    1414//
    1515
    … …  
    7272// Local Variables: //
    7373// tab-width: 4 //
    74 // compile-command: "cfa ifcond.c" //
     74// compile-command: "cfa ifwhileCtl.c" //
    7575// End: //

  • src/tests/preempt_longrun/enter.c

    r174845e rbeefc34c  
    1515
    1616monitor mon_t {};
     17void foo( mon_t & mutex this ) {}
    1718
    1819mon_t mon;
    19 
    20 void foo( mon_t & mutex this ) {}
    21 
    2220thread worker_t {};
    23 
    2421void main( worker_t & this ) {
    2522        for( unsigned long i = 0; i < N; i++ ) {
    … …  
    2825}
    2926
    30 extern "C" {
    31 static worker_t * workers;
    32 }
    33 
    3427int main(int argc, char * argv[] ) {
    3528        processor p;
    3629        {
    3730                worker_t w[7];
    38                 workers = w;
    3931        }
    4032}

  • src/tests/preempt_longrun/processor.c

    r174845e rbeefc34c  
    22#include <thread>
    33#include <time>
     4
     5#include <unistd.h>
    46
    57#ifndef PREEMPTION_RATE
    … …  
    1113}
    1214
    13 static const unsigned long N = 5_000ul;
     15static const unsigned long N = 50_000ul;
    1416
    1517int main(int argc, char* argv[]) {
    1618        processor * p[15];
     19        write(STDOUT_FILENO, "Preparing\n", sizeof("Preparing\n"));
    1720        for ( int pi = 0; pi < 15; pi++ ) {
    1821                p[pi] = new();
    1922        }
     23        write(STDOUT_FILENO, "Starting\n", sizeof("Starting\n"));
    2024        for ( int i = 0; i < N; i++) {
    2125                int pi = i % 15;
    … …  
    2327                p[pi] = new();
    2428        }
     29        write(STDOUT_FILENO, "Stopping\n", sizeof("Stopping\n"));
    2530        for ( int pi = 0; pi < 15; pi++ ) {
    2631                delete( p[pi] );
    2732        }
     33        write(STDOUT_FILENO, "Done\n", sizeof("Done\n"));
    2834}
Note: See TracChangeset for help on using the changeset viewer.