Changes in / [f53afafb:5cefa43]


Ignore:
Files:
2 added
6 deleted
14 edited

Legend:

Unmodified
Added
Removed
  • driver/cc1.cc

    rf53afafb r5cefa43  
    1010// Created On       : Fri Aug 26 14:23:51 2005
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 17 18:04:23 2022
    13 // Update Count     : 422
     12// Last Modified On : Wed Jul 21 09:46:24 2021
     13// Update Count     : 419
    1414//
    1515
     
    6161static string __CFA_FLAGPREFIX__( "__CFA_FLAG" );               // "__CFA_FLAG__=" suffix
    6262
    63 static void checkEnv1() {                                                               // stage 1
     63static void checkEnv1( const char * args[], int & nargs ) { // stage 1
    6464        extern char ** environ;
    6565
     
    155155        cerr << "Stage1" << endl;
    156156        #endif // __DEBUG_H__
    157         checkEnv1();                                                                            // arguments passed via environment variables
     157        checkEnv1( args, nargs );                                                       // arguments passed via environment variables
    158158        #ifdef __DEBUG_H__
    159159        for ( int i = 1; i < argc; i += 1 ) {
  • libcfa/src/concurrency/kernel/startup.cfa

    rf53afafb r5cefa43  
    1818
    1919// C Includes
    20 #include <errno.h>                                      // errno
     20#include <errno.h>                                                                              // errno
    2121#include <signal.h>
    22 #include <string.h>                                     // strerror
    23 #include <unistd.h>                                     // sysconf
     22#include <string.h>                                                                             // strerror
     23#include <unistd.h>                                                                             // sysconf
    2424
    2525extern "C" {
    26         #include <limits.h>                             // PTHREAD_STACK_MIN
    27         #include <unistd.h>                             // syscall
    28         #include <sys/eventfd.h>                        // eventfd
    29         #include <sys/mman.h>                           // mprotect
    30         #include <sys/resource.h>                       // getrlimit
     26        #include <limits.h>                                                                     // PTHREAD_STACK_MIN
     27        #include <unistd.h>                                                                     // syscall
     28        #include <sys/eventfd.h>                                                        // eventfd
     29        #include <sys/mman.h>                                                           // mprotect
     30        #include <sys/resource.h>                                                       // getrlimit
    3131}
    3232
    3333// CFA Includes
    3434#include "kernel_private.hfa"
    35 #include "startup.hfa"                                  // STARTUP_PRIORITY_XXX
     35#include "startup.hfa"                                                                  // STARTUP_PRIORITY_XXX
    3636#include "limits.hfa"
    3737#include "math.hfa"
     
    736736        check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
    737737
    738         size_t stacksize = max( PTHREAD_STACK_MIN, DEFAULT_STACK_SIZE );
     738        size_t stacksize = DEFAULT_STACK_SIZE;
    739739
    740740        void * stack;
  • libcfa/src/concurrency/preemption.cfa

    rf53afafb r5cefa43  
    1010// Created On       : Mon Jun 5 14:20:42 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 17 11:18:57 2022
    13 // Update Count     : 59
     12// Last Modified On : Fri Nov  6 07:42:13 2020
     13// Update Count     : 54
    1414//
    1515
     
    243243//----------
    244244// special case for preemption since used often
    245 __attribute__((optimize("no-reorder-blocks"))) bool __preemption_enabled() {
     245bool __preemption_enabled() {
    246246        // create a assembler label before
    247247        // marked as clobber all to avoid movement
  • libcfa/src/math.trait.hfa

    rf53afafb r5cefa43  
    1616#pragma once
    1717
    18 trait Not( U ) {
    19         void ?{}( U &, zero_t );
    20         int !?( U );
     18trait Not( T ) {
     19        void ?{}( T &, zero_t );
     20        int !?( T );
    2121}; // Not
    2222
     
    2626}; // Equality
    2727
    28 trait Relational( U | Equality( U ) ) {
    29         int ?<?( U, U );
    30         int ?<=?( U, U );
    31         int ?>?( U, U );
    32         int ?>=?( U, U );
     28trait Relational( T | Equality( T ) ) {
     29        int ?<?( T, T );
     30        int ?<=?( T, T );
     31        int ?>?( T, T );
     32        int ?>=?( T, T );
    3333}; // Relational
    3434
     
    3939}; // Signed
    4040
    41 trait Additive( U | Signed( U ) ) {
    42         U ?+?( U, U );
    43         U ?-?( U, U );
    44         U ?+=?( U &, U );
    45         U ?-=?( U &, U );
     41trait Additive( T | Signed( T ) ) {
     42        T ?+?( T, T );
     43        T ?-?( T, T );
     44        T ?+=?( T &, T );
     45        T ?-=?( T &, T );
    4646}; // Additive
    4747
     
    4949        void ?{}( T &, one_t );
    5050        // T ?++( T & );
    51         // T ++?( T & );
     51        // T ++?( T &);
    5252        // T ?--( T & );
    5353        // T --?( T & );
    5454}; // Incdec
    5555
    56 trait Multiplicative( U | Incdec( U ) ) {
    57         U ?*?( U, U );
    58         U ?/?( U, U );
    59         U ?%?( U, U );
    60         U ?/=?( U &, U );
     56trait Multiplicative( T | Incdec( T ) ) {
     57        T ?*?( T, T );
     58        T ?/?( T, T );
     59        T ?%?( T, T );
     60        T ?/=?( T &, T );
    6161}; // Multiplicative
    6262
  • src/AST/Decl.cpp

    rf53afafb r5cefa43  
    3939        if ( uniqueId ) return;  // ensure only set once
    4040        uniqueId = ++lastUniqueId;
    41         // The extra readonly pointer is causing some reference counting issues.
    42         // idMap[ uniqueId ] = this;
     41        idMap[ uniqueId ] = this;
    4342}
    4443
    4544readonly<Decl> Decl::fromId( UniqueId id ) {
    46         // Right now this map is always empty, so don't use it.
    47         assert( false );
    4845        IdMapType::const_iterator i = idMap.find( id );
    4946        if ( i != idMap.end() ) return i->second;
  • src/AST/module.mk

    rf53afafb r5cefa43  
    1616
    1717SRC_AST = \
     18        AST/AssertAcyclic.cpp \
     19        AST/AssertAcyclic.hpp \
    1820        AST/Attribute.cpp \
    1921        AST/Attribute.hpp \
     
    6264        AST/TypeSubstitution.cpp \
    6365        AST/TypeSubstitution.hpp \
    64         AST/Util.cpp \
    65         AST/Util.hpp \
    6666        AST/Visitor.hpp
    6767
  • src/SymTab/Validate.cc

    rf53afafb r5cefa43  
    194194        };
    195195
    196         // These structs are the sub-sub-passes of ForallPointerDecay_old.
    197 
    198         struct TraitExpander_old final {
    199                 void previsit( FunctionType * );
    200                 void previsit( StructDecl * );
    201                 void previsit( UnionDecl * );
    202         };
    203 
    204         struct AssertionFixer_old final {
    205                 void previsit( FunctionType * );
    206                 void previsit( StructDecl * );
    207                 void previsit( UnionDecl * );
    208         };
    209 
    210         struct CheckOperatorTypes_old final {
    211                 void previsit( ObjectDecl * );
    212         };
    213 
    214         struct FixUniqueIds_old final {
    215                 void previsit( DeclarationWithType * );
    216         };
    217 
    218196        struct ReturnChecker : public WithGuards {
    219197                /// Checks that return statements return nothing if their return type is void
     
    408386
    409387        void validate_D( std::list< Declaration * > & translationUnit ) {
     388                PassVisitor<ForallPointerDecay_old> fpd;
    410389                {
    411390                        Stats::Heap::newPass("validate-D");
     
    415394                        });
    416395                        Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
    417                                 decayForallPointers( translationUnit ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
     396                                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
    418397                        });
    419398                        Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
     
    475454
    476455        void decayForallPointers( std::list< Declaration * > & translationUnit ) {
    477                 PassVisitor<TraitExpander_old> te;
    478                 acceptAll( translationUnit, te );
    479                 PassVisitor<AssertionFixer_old> af;
    480                 acceptAll( translationUnit, af );
    481                 PassVisitor<CheckOperatorTypes_old> cot;
    482                 acceptAll( translationUnit, cot );
    483                 PassVisitor<FixUniqueIds_old> fui;
    484                 acceptAll( translationUnit, fui );
    485         }
    486 
    487         void decayForallPointersA( std::list< Declaration * > & translationUnit ) {
    488                 PassVisitor<TraitExpander_old> te;
    489                 acceptAll( translationUnit, te );
    490         }
    491         void decayForallPointersB( std::list< Declaration * > & translationUnit ) {
    492                 PassVisitor<AssertionFixer_old> af;
    493                 acceptAll( translationUnit, af );
    494         }
    495         void decayForallPointersC( std::list< Declaration * > & translationUnit ) {
    496                 PassVisitor<CheckOperatorTypes_old> cot;
    497                 acceptAll( translationUnit, cot );
    498         }
    499         void decayForallPointersD( std::list< Declaration * > & translationUnit ) {
    500                 PassVisitor<FixUniqueIds_old> fui;
    501                 acceptAll( translationUnit, fui );
     456                PassVisitor<ForallPointerDecay_old> fpd;
     457                acceptAll( translationUnit, fpd );
    502458        }
    503459
     
    514470                PassVisitor<EnumAndPointerDecay_old> epc;
    515471                PassVisitor<LinkReferenceToTypes_old> lrt( indexer );
    516                 PassVisitor<TraitExpander_old> te;
    517                 PassVisitor<AssertionFixer_old> af;
    518                 PassVisitor<CheckOperatorTypes_old> cot;
    519                 PassVisitor<FixUniqueIds_old> fui;
     472                PassVisitor<ForallPointerDecay_old> fpd;
    520473                type->accept( epc );
    521474                type->accept( lrt );
    522                 type->accept( te );
    523                 type->accept( af );
    524                 type->accept( cot );
    525                 type->accept( fui );
     475                type->accept( fpd );
    526476        }
    527477
     
    1022972        }
    1023973
    1024         /// Replace all traits in assertion lists with their assertions.
    1025         void expandTraits( std::list< TypeDecl * > & forall ) {
    1026                 for ( TypeDecl * type : forall ) {
    1027                         std::list< DeclarationWithType * > asserts;
    1028                         asserts.splice( asserts.end(), type->assertions );
    1029                         // expand trait instances into their members
    1030                         for ( DeclarationWithType * assertion : asserts ) {
    1031                                 if ( TraitInstType * traitInst = dynamic_cast< TraitInstType * >( assertion->get_type() ) ) {
    1032                                         // expand trait instance into all of its members
    1033                                         expandAssertions( traitInst, back_inserter( type->assertions ) );
    1034                                         delete traitInst;
    1035                                 } else {
    1036                                         // pass other assertions through
    1037                                         type->assertions.push_back( assertion );
    1038                                 } // if
    1039                         } // for
    1040                 }
    1041         }
    1042 
    1043         /// Fix each function in the assertion list and check for invalid void type.
    1044         void fixAssertions(
    1045                         std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) {
    1046                 for ( TypeDecl * type : forall ) {
    1047                         for ( DeclarationWithType *& assertion : type->assertions ) {
    1048                                 bool isVoid = fixFunction( assertion );
    1049                                 if ( isVoid ) {
    1050                                         SemanticError( node, "invalid type void in assertion of function " );
    1051                                 } // if
    1052                         } // for
    1053                 }
    1054         }
    1055 
    1056974        void ForallPointerDecay_old::previsit( ObjectDecl * object ) {
    1057975                // ensure that operator names only apply to functions or function pointers
     
    1076994        void ForallPointerDecay_old::previsit( UnionDecl * aggrDecl ) {
    1077995                forallFixer( aggrDecl->parameters, aggrDecl );
    1078         }
    1079 
    1080         void TraitExpander_old::previsit( FunctionType * ftype ) {
    1081                 expandTraits( ftype->forall );
    1082         }
    1083 
    1084         void TraitExpander_old::previsit( StructDecl * aggrDecl ) {
    1085                 expandTraits( aggrDecl->parameters );
    1086         }
    1087 
    1088         void TraitExpander_old::previsit( UnionDecl * aggrDecl ) {
    1089                 expandTraits( aggrDecl->parameters );
    1090         }
    1091 
    1092         void AssertionFixer_old::previsit( FunctionType * ftype ) {
    1093                 fixAssertions( ftype->forall, ftype );
    1094         }
    1095 
    1096         void AssertionFixer_old::previsit( StructDecl * aggrDecl ) {
    1097                 fixAssertions( aggrDecl->parameters, aggrDecl );
    1098         }
    1099 
    1100         void AssertionFixer_old::previsit( UnionDecl * aggrDecl ) {
    1101                 fixAssertions( aggrDecl->parameters, aggrDecl );
    1102         }
    1103 
    1104         void CheckOperatorTypes_old::previsit( ObjectDecl * object ) {
    1105                 // ensure that operator names only apply to functions or function pointers
    1106                 if ( CodeGen::isOperator( object->name ) && ! dynamic_cast< FunctionType * >( object->type->stripDeclarator() ) ) {
    1107                         SemanticError( object->location, toCString( "operator ", object->name.c_str(), " is not a function or function pointer." )  );
    1108                 }
    1109         }
    1110 
    1111         void FixUniqueIds_old::previsit( DeclarationWithType * decl ) {
    1112                 decl->fixUniqueId();
    1113996        }
    1114997
  • src/SymTab/Validate.h

    rf53afafb r5cefa43  
    4343        void validate_F( std::list< Declaration * > &translationUnit );
    4444        void decayForallPointers( std::list< Declaration * > & translationUnit );
    45         void decayForallPointersA( std::list< Declaration * > & translationUnit );
    46         void decayForallPointersB( std::list< Declaration * > & translationUnit );
    47         void decayForallPointersC( std::list< Declaration * > & translationUnit );
    48         void decayForallPointersD( std::list< Declaration * > & translationUnit );
    4945
    5046        const ast::Type * validateType(
  • src/Validate/module.mk

    rf53afafb r5cefa43  
    2020        Validate/CompoundLiteral.cpp \
    2121        Validate/CompoundLiteral.hpp \
    22         Validate/ForallPointerDecay.cpp \
    23         Validate/ForallPointerDecay.hpp \
    2422        Validate/HandleAttributes.cc \
    2523        Validate/HandleAttributes.h \
  • src/main.cc

    rf53afafb r5cefa43  
    3232
    3333#include "AST/Convert.hpp"
    34 #include "AST/Print.hpp"
    3534#include "CompilationState.h"
    3635#include "../config.h"                      // for CFA_LIBDIR
     
    7776#include "Validate/Autogen.hpp"             // for autogenerateRoutines
    7877#include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
    79 #include "Validate/ForallPointerDecay.hpp"  // for decayForallPointers
    8078#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
    8179#include "Validate/InitializerLength.hpp"   // for setLengthFromInitializer
     
    333331
    334332                if( useNewAST ) {
    335                         PASS( "Implement Concurrent Keywords", Concurrency::applyKeywords( translationUnit ) );
    336                         //PASS( "Forall Pointer Decay - A", SymTab::decayForallPointersA( translationUnit ) );
    337                         //PASS( "Forall Pointer Decay - B", SymTab::decayForallPointersB( translationUnit ) );
    338                         //PASS( "Forall Pointer Decay - C", SymTab::decayForallPointersC( translationUnit ) );
    339                         //PASS( "Forall Pointer Decay - D", SymTab::decayForallPointersD( translationUnit ) );
     333                        PASS( "Apply Concurrent Keywords", Concurrency::applyKeywords( translationUnit ) );
     334                        PASS( "Forall Pointer Decay", SymTab::decayForallPointers( translationUnit ) );
    340335                        CodeTools::fillLocations( translationUnit );
    341336
     
    347342
    348343                        forceFillCodeLocations( transUnit );
    349 
    350                         // Must be after implement concurrent keywords; because uniqueIds
    351                         //   must be set on declaration before resolution.
    352                         // Must happen before autogen routines are added.
    353                         PASS( "Forall Pointer Decay", Validate::decayForallPointers( transUnit ) );
    354344
    355345                        // Must happen before autogen routines are added.
  • tests/.expect/declarationSpecifier.arm64.txt

    rf53afafb r5cefa43  
    11321132char **_X13cfa_args_argvPPc_1;
    11331133char **_X13cfa_args_envpPPc_1;
    1134 __attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
     1134signed int _X17cfa_main_returnedi_1 = ((signed int )0);
    11351135signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    11361136    __attribute__ ((unused)) signed int _X12_retval_maini_1;
     
    11491149    signed int _tmp_cp_ret6;
    11501150    signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
    1151     if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
    1152         {
    1153             ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
    1154         }
    1155 
     1151    {
     1152        ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
    11561153    }
    11571154
  • tests/.expect/gccExtensions.arm64.txt

    rf53afafb r5cefa43  
    324324char **_X13cfa_args_argvPPc_1;
    325325char **_X13cfa_args_envpPPc_1;
    326 __attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
     326signed int _X17cfa_main_returnedi_1 = ((signed int )0);
    327327signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    328328    __attribute__ ((unused)) signed int _X12_retval_maini_1;
     
    341341    signed int _tmp_cp_ret6;
    342342    signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
    343     if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
    344         {
    345             ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
    346         }
    347 
     343    {
     344        ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
    348345    }
    349346
  • tests/.expect/random.arm64.txt

    rf53afafb r5cefa43  
    11õ
    22=
    3 K
     3V
    44-911259971
    556
    6 11
     6-4
    771232105397
    880
    9 11
     918
    1010-914096085
    11111
    12 20
     1215
    13132077092859
    14141
    15 12
     1511
    16160.677254
    17170.678106775246139
  • tests/meta/dumpable.cfa

    rf53afafb r5cefa43  
    7272        }
    7373
    74         uint64_t avail = buf.f_bavail;
    75         avail *= buf.f_bsize;
    76         if(avail < 536870912_l64u) {
    77                 serr | "Available diskspace is less than ~500Mb: " | avail;
     74        if((buf.f_bsize * buf.f_bavail) < 536870912) {
     75                serr | "Available diskspace is less than ~500Mb: " | (buf.f_bsize * buf.f_bavail);
    7876        }
    7977
Note: See TracChangeset for help on using the changeset viewer.