Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/CodeGen/CodeGenerator.cc (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -119,10 +119,11 @@ string CodeGenerator::mangleName( DeclarationWithType * decl ) { - if ( pretty ) return decl->get_name(); - if ( decl->get_mangleName() != "" ) { + // GCC builtins should always be printed unmangled + if ( pretty || decl->linkage.is_gcc_builtin ) return decl->name; + if ( decl->mangleName != "" ) { // need to incorporate scope level in order to differentiate names for destructors return decl->get_scopedMangleName(); } else { - return decl->get_name(); + return decl->name; } // if } Index: src/Common/Heap.cc =================================================================== --- src/Common/Heap.cc (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/Common/Heap.cc (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -30,10 +30,12 @@ #else struct StatBlock { - const char * name = nullptr; - size_t mallocs = 0; - size_t frees = 0; + const char * name = nullptr; ///< Name of this pass + size_t mallocs = 0; ///< Allocations in this pass + size_t frees = 0; ///< Frees in this pass + size_t n_allocs = 0; ///< Current number of live allocations + size_t peak_allocs = 0; ///< Peak number of live allocations this pass }; - StatBlock passes[100] = {{ "Pre-Parse", 0, 0 }}; + StatBlock passes[100] = {{ "Pre-Parse", 0, 0, 0, 0 }}; const size_t passes_size = sizeof(passes) / sizeof(passes[0]); size_t passes_cnt = 1; @@ -43,4 +45,7 @@ passes[passes_cnt].mallocs = 0; passes[passes_cnt].frees = 0; + passes[passes_cnt].n_allocs + = passes[passes_cnt].peak_allocs + = passes[passes_cnt-1].n_allocs; passes_cnt++; @@ -55,10 +60,11 @@ } - void print(const StatBlock& stat, size_t nc, size_t total_mallocs, size_t total_frees) { + void print(const StatBlock& stat, size_t nc, size_t total_mallocs, size_t total_frees, size_t overall_peak) { std::cerr << std::setw(nc) << stat.name; std::cerr << " | "; - print(stat.mallocs, total_mallocs); - print(stat.frees , total_frees ); + print(stat.mallocs, total_mallocs); + print(stat.frees, total_frees ); + print(stat.peak_allocs, overall_peak ); std::cerr << "\n"; } @@ -75,10 +81,12 @@ size_t total_mallocs = 0; size_t total_frees = 0; + size_t overall_peak = 0; for(size_t i = 0; i < passes_cnt; i++) { nc = std::max(nc, std::strlen(passes[i].name)); total_mallocs += passes[i].mallocs; total_frees += passes[i].frees; - } - size_t nct = nc + 44; + overall_peak = std::max(overall_peak, passes[i].peak_allocs); + } + size_t nct = nc + 65; const char * const title = "Heap Usage Statistic"; @@ -88,12 +96,13 @@ print('-', nct); std::cerr << std::setw(nc) << "Pass"; - std::cerr << " | Malloc Count | Free Count |" << std::endl; + std::cerr << " | Malloc Count | Free Count | Peak Allocs |" << std::endl; print('-', nct); for(size_t i = 0; i < passes_cnt; i++) { - print(passes[i], nc, total_mallocs, total_frees); + print(passes[i], nc, total_mallocs, total_frees, overall_peak); } print('-', nct); - print({"Sum", total_mallocs, total_frees}, nc, total_mallocs, total_frees); + print({"Sum", total_mallocs, total_frees, 0, overall_peak}, + nc, total_mallocs, total_frees, overall_peak); } @@ -158,5 +167,10 @@ void * malloc( size_t size ) { static auto __malloc = reinterpret_cast(interpose_symbol( "malloc", nullptr )); - if( passes_cnt > 0 ) passes[passes_cnt - 1].mallocs++; + if( passes_cnt > 0 ) { + passes[passes_cnt - 1].mallocs++; + passes[passes_cnt - 1].n_allocs++; + passes[passes_cnt - 1].peak_allocs + = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs); + } return __malloc( size ); } @@ -164,5 +178,8 @@ void free( void * ptr ) { static auto __free = reinterpret_cast(interpose_symbol( "free", nullptr )); - if( passes_cnt > 0 ) passes[passes_cnt - 1].frees++; + if( passes_cnt > 0 ) { + passes[passes_cnt - 1].frees++; + passes[passes_cnt - 1].n_allocs--; + } return __free( ptr ); } @@ -170,5 +187,10 @@ void * calloc( size_t nelem, size_t size ) { static auto __calloc = reinterpret_cast(interpose_symbol( "calloc", nullptr )); - if( passes_cnt > 0 ) passes[passes_cnt - 1].mallocs++; + if( passes_cnt > 0 ) { + passes[passes_cnt - 1].mallocs++; + passes[passes_cnt - 1].n_allocs++; + passes[passes_cnt - 1].peak_allocs + = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs); + } return __calloc( nelem, size ); } Index: src/Concurrency/Keywords.cc =================================================================== --- src/Concurrency/Keywords.cc (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/Concurrency/Keywords.cc (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -191,5 +191,5 @@ void postvisit( StructDecl * decl ); - std::list findMutexArgs( FunctionDecl* ); + std::list findMutexArgs( FunctionDecl*, bool & first ); void validate( DeclarationWithType * ); void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list &); @@ -441,8 +441,9 @@ void MutexKeyword::postvisit(FunctionDecl* decl) { - std::list mutexArgs = findMutexArgs( decl ); + bool first = false; + std::list mutexArgs = findMutexArgs( decl, first ); if( mutexArgs.empty() ) return; - if( CodeGen::isConstructor(decl->name) ) SemanticError( decl, "constructors cannot have mutex parameters" ); + if( CodeGen::isConstructor(decl->name) && first ) SemanticError( decl, "constructors cannot have mutex parameters" ); bool isDtor = CodeGen::isDestructor( decl->name ); @@ -484,11 +485,15 @@ } - std::list MutexKeyword::findMutexArgs( FunctionDecl* decl ) { + std::list MutexKeyword::findMutexArgs( FunctionDecl* decl, bool & first ) { std::list mutexArgs; + bool once = true; for( auto arg : decl->get_functionType()->get_parameters()) { //Find mutex arguments Type* ty = arg->get_type(); if( ! ty->get_mutex() ) continue; + + if(once) {first = true;} + once = false; //Append it to the list Index: src/Parser/LinkageSpec.h =================================================================== --- src/Parser/LinkageSpec.h (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/Parser/LinkageSpec.h (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -27,6 +27,7 @@ Overrideable = 1 << 2, Builtin = 1 << 3, + GccBuiltin = 1 << 4, - NoOfSpecs = 1 << 4, + NoOfSpecs = 1 << 5, }; @@ -38,4 +39,5 @@ bool is_overridable : 1; bool is_builtin : 1; + bool is_gcc_builtin : 1; }; constexpr Spec( unsigned int val ) : val( val ) {} @@ -61,4 +63,5 @@ inline bool isOverridable( Spec spec ) { return spec.is_overridable; } inline bool isBuiltin( Spec spec ) { return spec.is_builtin; } + inline bool isGccBuiltin( Spec spec ) { return spec.is_gcc_builtin; } // Pre-defined flag combinations: @@ -72,5 +75,5 @@ constexpr Spec const AutoGen = { Mangle | Generate | Overrideable }; // gcc internal - constexpr Spec const Compiler = { Builtin }; + constexpr Spec const Compiler = { Mangle | Builtin | GccBuiltin }; // mangled builtins constexpr Spec const BuiltinCFA = { Mangle | Generate | Builtin }; Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/Parser/TypeData.cc (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -575,5 +575,5 @@ case DeclarationNode::Int128: - ret = td->signedness == 1 ? BasicType::UnsignedInt128 : BasicType::SignedInt128; + ret = td->signedness == DeclarationNode::Unsigned ? BasicType::UnsignedInt128 : BasicType::SignedInt128; if ( td->length != DeclarationNode::NoLength ) { genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); @@ -599,5 +599,5 @@ genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if - if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) { + if ( td->basictype != DeclarationNode::Double && td->length == DeclarationNode::Long ) { genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype ); } // if @@ -605,4 +605,13 @@ const_cast(td)->basictype = DeclarationNode::LongDouble; } // if + + if ( td->basictype == DeclarationNode::Float80 || td->basictype == DeclarationNode::Float128 ) { + if ( td->complextype != DeclarationNode::NoComplexType ) { + genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype ); + } + if ( td->basictype == DeclarationNode::Float80 ) ret = BasicType::Float80; + else ret = BasicType::Float128; + break; + } ret = floattype[ td->complextype ][ td->basictype - DeclarationNode::Float ]; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/Parser/parser.yy (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 22 08:41:57 2018 -// Update Count : 3353 +// Last Modified On : Mon May 28 17:01:36 2018 +// Update Count : 3383 // @@ -326,5 +326,5 @@ %type cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr -%type cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list_opt +%type cfa_parameter_declaration cfa_parameter_list cfa_parameter_ellipsis_list_opt %type cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier @@ -852,10 +852,10 @@ // '[' ']' // { $$ = new ExpressionNode( build_tuple() ); } -// '[' push assignment_expression pop ']' +// | '[' push assignment_expression pop ']' // { $$ = new ExpressionNode( build_tuple( $3 ) ); } - '[' ',' tuple_expression_list ']' - { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); } - | '[' assignment_expression ',' tuple_expression_list ']' - { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$2->set_last( $4 ) ) ); } + '[' push ',' tuple_expression_list pop ']' + { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $4 ) ) ); } + | '[' push assignment_expression ',' tuple_expression_list pop ']' + { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $5 ) ) ); } ; @@ -883,5 +883,5 @@ labeled_statement | compound_statement - | expression_statement { $$ = $1; } + | expression_statement | selection_statement | iteration_statement @@ -1200,13 +1200,9 @@ type_specifier_nobody | type_specifier_nobody declarator - { - $$ = $2->addType( $1 ); - } + { $$ = $2->addType( $1 ); } | type_specifier_nobody variable_abstract_declarator { $$ = $2->addType( $1 ); } | cfa_abstract_declarator_tuple no_attr_identifier // CFA - { - $$ = $1->addName( $2 ); - } + { $$ = $1->addName( $2 ); } | cfa_abstract_declarator_tuple // CFA ; @@ -1286,5 +1282,5 @@ declaration_list_opt: // used at beginning of switch statement - pop + pop // empty { $$ = nullptr; } | declaration_list @@ -1321,6 +1317,6 @@ local_label_list: // GCC, local label - no_attr_identifier_or_type_name {} - | local_label_list ',' no_attr_identifier_or_type_name {} + no_attr_identifier_or_type_name + | local_label_list ',' no_attr_identifier_or_type_name ; @@ -1385,24 +1381,24 @@ | declaration_qualifier_list type_qualifier_list cfa_function_specifier { $$ = $3->addQualifiers( $1 )->addQualifiers( $2 ); } - | cfa_function_declaration ',' identifier_or_type_name '(' cfa_parameter_type_list_opt ')' + | cfa_function_declaration ',' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' { // Append the return type at the start (left-hand-side) to each identifier in the list. DeclarationNode * ret = new DeclarationNode; ret->type = maybeClone( $1->type->base ); - $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $5, nullptr ) ); + $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $6, nullptr ) ); } ; cfa_function_specifier: // CFA -// '[' ']' identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')' // S/R conflict +// '[' ']' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' // S/R conflict // { // $$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, 0, true ); // } -// '[' ']' identifier '(' push cfa_parameter_type_list_opt pop ')' +// '[' ']' identifier '(' push cfa_parameter_ellipsis_list_opt pop ')' // { // typedefTable.setNextIdentifier( *$5 ); // $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true ); // } -// | '[' ']' TYPEDEFname '(' push cfa_parameter_type_list_opt pop ')' +// | '[' ']' TYPEDEFname '(' push cfa_parameter_ellipsis_list_opt pop ')' // { // typedefTable.setNextIdentifier( *$5 ); @@ -1412,23 +1408,22 @@ // identifier_or_type_name must be broken apart because of the sequence: // - // '[' ']' identifier_or_type_name '(' cfa_parameter_type_list_opt ')' + // '[' ']' identifier_or_type_name '(' cfa_parameter_ellipsis_list_opt ')' // '[' ']' type_specifier // // type_specifier can resolve to just TYPEDEFname (e.g., typedef int T; int f( T );). Therefore this must be // flattened to allow lookahead to the '(' without having to reduce identifier_or_type_name. - cfa_abstract_tuple identifier_or_type_name '(' cfa_parameter_type_list_opt ')' + cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator). - { $$ = DeclarationNode::newFunction( $2, $1, $4, 0 ); } - | cfa_function_return identifier_or_type_name '(' cfa_parameter_type_list_opt ')' - { $$ = DeclarationNode::newFunction( $2, $1, $4, 0 ); } + { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); } + | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' + { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); } ; cfa_function_return: // CFA - '[' cfa_parameter_list ']' - { $$ = DeclarationNode::newTuple( $2 ); } - | '[' cfa_parameter_list ',' cfa_abstract_parameter_list ']' - // To obtain LR(1 ), the last cfa_abstract_parameter_list is added into this flattened rule to lookahead to the - // ']'. - { $$ = DeclarationNode::newTuple( $2->appendList( $4 ) ); } + '[' push cfa_parameter_list pop ']' + { $$ = DeclarationNode::newTuple( $3 ); } + | '[' push cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ']' + // To obtain LR(1 ), the last cfa_abstract_parameter_list is added into this flattened rule to lookahead to the ']'. + { $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); } ; @@ -1604,13 +1599,6 @@ forall: - FORALL '(' - { - typedefTable.enterScope(); - } - type_parameter_list ')' // CFA - { - typedefTable.leaveScope(); - $$ = DeclarationNode::newForall( $4 ); - } + FORALL '(' push type_parameter_list pop ')' // CFA + { $$ = DeclarationNode::newForall( $4 ); } ; @@ -1980,5 +1968,5 @@ ; -cfa_parameter_type_list_opt: // CFA, abstract + real +cfa_parameter_ellipsis_list_opt: // CFA, abstract + real // empty { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } @@ -1987,9 +1975,9 @@ | cfa_abstract_parameter_list | cfa_parameter_list - | cfa_parameter_list ',' cfa_abstract_parameter_list - { $$ = $1->appendList( $3 ); } - | cfa_abstract_parameter_list ',' ELLIPSIS + | cfa_parameter_list pop ',' push cfa_abstract_parameter_list + { $$ = $1->appendList( $5 ); } + | cfa_abstract_parameter_list pop ',' push ELLIPSIS { $$ = $1->addVarArgs(); } - | cfa_parameter_list ',' ELLIPSIS + | cfa_parameter_list pop ',' push ELLIPSIS { $$ = $1->addVarArgs(); } ; @@ -1999,16 +1987,16 @@ // factored out from cfa_parameter_list, flattening the rules to get lookahead to the ']'. cfa_parameter_declaration - | cfa_abstract_parameter_list ',' cfa_parameter_declaration - { $$ = $1->appendList( $3 ); } - | cfa_parameter_list ',' cfa_parameter_declaration - { $$ = $1->appendList( $3 ); } - | cfa_parameter_list ',' cfa_abstract_parameter_list ',' cfa_parameter_declaration - { $$ = $1->appendList( $3 )->appendList( $5 ); } + | cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration + { $$ = $1->appendList( $5 ); } + | cfa_parameter_list pop ',' push cfa_parameter_declaration + { $$ = $1->appendList( $5 ); } + | cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration + { $$ = $1->appendList( $5 )->appendList( $9 ); } ; cfa_abstract_parameter_list: // CFA, new & old style abstract cfa_abstract_parameter_declaration - | cfa_abstract_parameter_list ',' cfa_abstract_parameter_declaration - { $$ = $1->appendList( $3 ); } + | cfa_abstract_parameter_list pop ',' push cfa_abstract_parameter_declaration + { $$ = $1->appendList( $5 ); } ; @@ -2159,13 +2147,13 @@ '.' no_attr_identifier // C99, field name { $$ = new ExpressionNode( build_varref( $2 ) ); } - | '[' assignment_expression ']' // C99, single array element + | '[' push assignment_expression pop ']' // C99, single array element // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple. - { $$ = $2; } - | '[' subrange ']' // CFA, multiple array elements - { $$ = $2; } - | '[' constant_expression ELLIPSIS constant_expression ']' // GCC, multiple array elements - { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $2 ), maybeMoveBuild< Expression >( $4 ) ) ); } - | '.' '[' field_list ']' // CFA, tuple field selector { $$ = $3; } + | '[' push subrange pop ']' // CFA, multiple array elements + { $$ = $3; } + | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements + { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $3 ), maybeMoveBuild< Expression >( $5 ) ) ); } + | '.' '[' push field_list pop ']' // CFA, tuple field selector + { $$ = $4; } ; @@ -2238,7 +2226,7 @@ '|' no_attr_identifier_or_type_name '(' type_list ')' { $$ = DeclarationNode::newTraitUse( $2, $4 ); } - | '|' '{' push trait_declaration_list '}' + | '|' '{' push trait_declaration_list pop '}' { $$ = $4; } - | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_list ')' + | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list pop '}' '(' type_list ')' { SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; } ; @@ -2286,7 +2274,5 @@ TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' '}' { $$ = DeclarationNode::newTrait( $2, $5, 0 ); } - | TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' - { typedefTable.enterScope(); } - trait_declaration_list '}' + | TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' push trait_declaration_list pop '}' { $$ = DeclarationNode::newTrait( $2, $5, $10 ); } ; @@ -2294,18 +2280,16 @@ trait_declaration_list: // CFA trait_declaration - | trait_declaration_list push trait_declaration - { $$ = $1->appendList( $3 ); } + | trait_declaration_list pop push trait_declaration + { $$ = $1->appendList( $4 ); } ; trait_declaration: // CFA - cfa_trait_declaring_list pop ';' - | trait_declaring_list pop ';' + cfa_trait_declaring_list ';' + | trait_declaring_list ';' ; cfa_trait_declaring_list: // CFA cfa_variable_specifier - { $$ = $1; } | cfa_function_specifier - { $$ = $1; } | cfa_trait_declaring_list pop ',' push identifier_or_type_name { $$ = $1->appendList( $1->cloneType( $5 ) ); } @@ -2366,7 +2350,5 @@ } | type_qualifier_list - { - if ( $1->type->forall ) xxx = forall = true; // remember generic type - } + { if ( $1->type->forall ) xxx = forall = true; } // remember generic type push '{' external_definition_list '}' // CFA, namespace { @@ -2381,7 +2363,5 @@ } | declaration_qualifier_list - { - if ( $1->type->forall ) xxx = forall = true; // remember generic type - } + { if ( $1->type->forall ) xxx = forall = true; } // remember generic type push '{' external_definition_list '}' // CFA, namespace { @@ -2423,13 +2403,7 @@ // declaration must still have a type_specifier. OBSOLESCENT (see 1) | function_declarator compound_statement - { - typedefTable.leaveScope(); - $$ = $1->addFunctionBody( $2 ); - } + { $$ = $1->addFunctionBody( $2 ); } | KR_function_declarator KR_declaration_list_opt compound_statement - { - typedefTable.leaveScope(); - $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 ); - } + { $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 ); } ; @@ -2444,5 +2418,4 @@ cfa_function_declaration with_clause_opt compound_statement // CFA { - typedefTable.leaveScope(); // Add the function body to the last identifier in the function definition list, i.e., foo3: // [const double] foo1(), foo2( int ), foo3( double ) { return 3.0; } @@ -2453,5 +2426,4 @@ { rebindForall( $1, $2 ); - typedefTable.leaveScope(); $$ = $2->addFunctionBody( $4, $3 )->addType( $1 ); } @@ -2459,25 +2431,15 @@ { rebindForall( $1, $2 ); - typedefTable.leaveScope(); $$ = $2->addFunctionBody( $4, $3 )->addType( $1 ); } // handles default int return type, OBSOLESCENT (see 1) | type_qualifier_list function_declarator with_clause_opt compound_statement - { - typedefTable.leaveScope(); - $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); - } + { $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); } // handles default int return type, OBSOLESCENT (see 1) | declaration_qualifier_list function_declarator with_clause_opt compound_statement - { - typedefTable.leaveScope(); - $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); - } + { $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); } // handles default int return type, OBSOLESCENT (see 1) | declaration_qualifier_list type_qualifier_list function_declarator with_clause_opt compound_statement - { - typedefTable.leaveScope(); - $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 ); - } + { $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 ); } // Old-style K&R function definition, OBSOLESCENT (see 4) @@ -2485,25 +2447,15 @@ { rebindForall( $1, $2 ); - typedefTable.leaveScope(); $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addType( $1 ); } // handles default int return type, OBSOLESCENT (see 1) | type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement - { - typedefTable.leaveScope(); - $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); - } + { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); } // handles default int return type, OBSOLESCENT (see 1) | declaration_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement - { - typedefTable.leaveScope(); - $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); - } + { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); } // handles default int return type, OBSOLESCENT (see 1) | declaration_qualifier_list type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement - { - typedefTable.leaveScope(); - $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 ); - } + { $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 ); } ; @@ -2702,6 +2654,6 @@ paren_identifier '(' identifier_list ')' // function_declarator handles empty parameter { $$ = $1->addIdList( $3 ); } - | '(' KR_function_ptr ')' '(' parameter_type_list_opt ')' - { $$ = $2->addParamList( $5 ); } + | '(' KR_function_ptr ')' '(' push parameter_type_list_opt pop ')' + { $$ = $2->addParamList( $6 ); } | '(' KR_function_no_ptr ')' // redundant parenthesis { $$ = $2; } @@ -2821,8 +2773,8 @@ identifier_parameter_function: - paren_identifier '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $1->addParamList( $3 ); } - | '(' identifier_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $5 ); } + paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $1->addParamList( $4 ); } + | '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } | '(' identifier_parameter_function ')' // redundant parenthesis { $$ = $2; } @@ -2874,8 +2826,8 @@ type_parameter_function: - typedef '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $1->addParamList( $3 ); } - | '(' type_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $5 ); } + typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $1->addParamList( $4 ); } + | '(' type_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } ; @@ -2924,8 +2876,8 @@ abstract_function: - '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); } - | '(' abstract_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $5 ); } + '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); } + | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } | '(' abstract_function ')' // redundant parenthesis { $$ = $2; } @@ -2942,11 +2894,11 @@ multi_array_dimension: - '[' assignment_expression ']' - { $$ = DeclarationNode::newArray( $2, 0, false ); } - | '[' '*' ']' // C99 + '[' push assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $3, 0, false ); } + | '[' push '*' pop ']' // C99 { $$ = DeclarationNode::newVarArray( 0 ); } - | multi_array_dimension '[' assignment_expression ']' - { $$ = $1->addArray( DeclarationNode::newArray( $3, 0, false ) ); } - | multi_array_dimension '[' '*' ']' // C99 + | multi_array_dimension '[' push assignment_expression pop ']' + { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); } + | multi_array_dimension '[' push '*' pop ']' // C99 { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); } ; @@ -3015,8 +2967,8 @@ abstract_parameter_function: - '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); } - | '(' abstract_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $5 ); } + '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); } + | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } | '(' abstract_parameter_function ')' // redundant parenthesis { $$ = $2; } @@ -3039,16 +2991,16 @@ '[' ']' { $$ = DeclarationNode::newArray( 0, 0, false ); } - // multi_array_dimension handles the '[' '*' ']' case - | '[' type_qualifier_list '*' ']' // remaining C99 - { $$ = DeclarationNode::newVarArray( $2 ); } - | '[' type_qualifier_list ']' - { $$ = DeclarationNode::newArray( 0, $2, false ); } - // multi_array_dimension handles the '[' assignment_expression ']' case - | '[' type_qualifier_list assignment_expression ']' - { $$ = DeclarationNode::newArray( $3, $2, false ); } - | '[' STATIC type_qualifier_list_opt assignment_expression ']' - { $$ = DeclarationNode::newArray( $4, $3, true ); } - | '[' type_qualifier_list STATIC assignment_expression ']' - { $$ = DeclarationNode::newArray( $4, $2, true ); } + // multi_array_dimension handles the '[' '*' ']' case + | '[' push type_qualifier_list '*' pop ']' // remaining C99 + { $$ = DeclarationNode::newVarArray( $3 ); } + | '[' push type_qualifier_list pop ']' + { $$ = DeclarationNode::newArray( 0, $3, false ); } + // multi_array_dimension handles the '[' assignment_expression ']' case + | '[' push type_qualifier_list assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $4, $3, false ); } + | '[' push STATIC type_qualifier_list_opt assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $5, $4, true ); } + | '[' push type_qualifier_list STATIC assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $5, $3, true ); } ; @@ -3094,6 +3046,6 @@ variable_abstract_function: - '(' variable_abstract_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3) - { $$ = $2->addParamList( $5 ); } + '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3) + { $$ = $2->addParamList( $6 ); } | '(' variable_abstract_function ')' // redundant parenthesis { $$ = $2; } @@ -3158,15 +3110,15 @@ cfa_array_parameter_1st_dimension: - '[' type_qualifier_list '*' ']' // remaining C99 - { $$ = DeclarationNode::newVarArray( $2 ); } - | '[' type_qualifier_list assignment_expression ']' - { $$ = DeclarationNode::newArray( $3, $2, false ); } - | '[' declaration_qualifier_list assignment_expression ']' + '[' push type_qualifier_list '*' pop ']' // remaining C99 + { $$ = DeclarationNode::newVarArray( $3 ); } + | '[' push type_qualifier_list assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $4, $3, false ); } + | '[' push declaration_qualifier_list assignment_expression pop ']' // declaration_qualifier_list must be used because of shift/reduce conflict with // assignment_expression, so a semantic check is necessary to preclude them as a type_qualifier cannot // appear in this context. - { $$ = DeclarationNode::newArray( $3, $2, true ); } - | '[' declaration_qualifier_list type_qualifier_list assignment_expression ']' - { $$ = DeclarationNode::newArray( $4, $3->addQualifiers( $3 ), true ); } + { $$ = DeclarationNode::newArray( $4, $3, true ); } + | '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']' + { $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); } ; @@ -3180,5 +3132,5 @@ // // cfa_abstract_tuple identifier_or_type_name -// '[' cfa_parameter_list ']' identifier_or_type_name '(' cfa_parameter_type_list_opt ')' +// '[' cfa_parameter_list ']' identifier_or_type_name '(' cfa_parameter_ellipsis_list_opt ')' // // since a function return type can be syntactically identical to a tuple type: @@ -3237,15 +3189,19 @@ cfa_abstract_tuple: // CFA - '[' cfa_abstract_parameter_list ']' - { $$ = DeclarationNode::newTuple( $2 ); } + '[' push cfa_abstract_parameter_list pop ']' + { $$ = DeclarationNode::newTuple( $3 ); } + | '[' push type_specifier_nobody ELLIPSIS ']' + { SemanticError( yylloc, "Tuple array currently unimplemented." ); $$ = nullptr; } + | '[' push type_specifier_nobody ELLIPSIS constant_expression ']' + { SemanticError( yylloc, "Tuple array currently unimplemented." ); $$ = nullptr; } ; cfa_abstract_function: // CFA -// '[' ']' '(' cfa_parameter_type_list_opt ')' +// '[' ']' '(' cfa_parameter_ellipsis_list_opt ')' // { $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, nullptr ); } - cfa_abstract_tuple '(' cfa_parameter_type_list_opt ')' - { $$ = DeclarationNode::newFunction( nullptr, $1, $3, nullptr ); } - | cfa_function_return '(' cfa_parameter_type_list_opt ')' - { $$ = DeclarationNode::newFunction( nullptr, $1, $3, nullptr ); } + cfa_abstract_tuple '(' push cfa_parameter_ellipsis_list_opt pop ')' + { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); } + | cfa_function_return '(' push cfa_parameter_ellipsis_list_opt pop ')' + { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); } ; Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/ResolvExpr/CommonType.cc (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -176,31 +176,37 @@ } - static const BasicType::Kind combinedType[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = + static const BasicType::Kind combinedType[][ BasicType::NUMBER_OF_BASIC_TYPES ] = { -/* Bool Char SignedChar UnsignedChar ShortSignedInt ShortUnsignedInt SignedInt UnsignedInt LongSignedInt LongUnsignedInt LongLongSignedInt LongLongUnsignedInt Float Double LongDouble FloatComplex DoubleComplex LongDoubleComplex FloatImaginary DoubleImaginary LongDoubleImaginary SignedInt128 UnsignedInt128 */ - /* Bool */ { BasicType::Bool, BasicType::Char, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* Char */ { BasicType::Char, BasicType::Char, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* SignedChar */ { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* UnsignedChar */ { BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* ShortSignedInt */ { BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* ShortUnsignedInt */ { BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* SignedInt */ { BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* UnsignedInt */ { BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* LongSignedInt */ { BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* LongUnsignedInt */ { BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* LongLongSignedInt */ { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* LongLongUnsignedInt */ { BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* Float */ { BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Float, BasicType::Float, }, - /* Double */ { BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::LongDouble, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Double, BasicType::Double, }, - /* LongDouble */ { BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDouble, BasicType::LongDouble, }, - /* FloatComplex */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::FloatComplex, }, - /* DoubleComplex */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, }, - /* LongDoubleComplex */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, }, - /* FloatImaginary */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::FloatImaginary, BasicType::FloatImaginary, }, - /* DoubleImaginary */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::DoubleImaginary, BasicType::DoubleImaginary, }, - /* LongDoubleImaginary */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary }, - /* SignedInt128 */ { BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, }, - /* UnsignedInt128 */ { BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::UnsignedInt128, BasicType::UnsignedInt128, }, +/* Bool Char SignedChar UnsignedChar ShortSignedInt ShortUnsignedInt SignedInt UnsignedInt LongSignedInt LongUnsignedInt LongLongSignedInt LongLongUnsignedInt Float Double LongDouble FloatComplex DoubleComplex LongDoubleComplex FloatImaginary DoubleImaginary LongDoubleImaginary SignedInt128 UnsignedInt128 Float80 Float128 */ + /* Bool */ { BasicType::Bool, BasicType::Char, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* Char */ { BasicType::Char, BasicType::Char, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* SignedChar */ { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::SignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* UnsignedChar */ { BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::UnsignedChar, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* ShortSignedInt */ { BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortSignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* ShortUnsignedInt */ { BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::ShortUnsignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* SignedInt */ { BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::SignedInt, BasicType::UnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* UnsignedInt */ { BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* LongSignedInt */ { BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongSignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* LongUnsignedInt */ { BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* LongLongSignedInt */ { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongSignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* LongLongUnsignedInt */ { BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 }, + /* Float */ { BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Float, BasicType::Float, BasicType::Float80, BasicType::Float128 }, + /* Double */ { BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::Double, BasicType::LongDouble, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::Double, BasicType::Double, BasicType::Float80, BasicType::Float128 }, + /* LongDouble */ { BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDouble, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDouble, BasicType::LongDouble, BasicType::BasicType::LongDouble, BasicType::Float128 }, + /* FloatComplex */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, }, + /* DoubleComplex */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex }, + /* LongDoubleComplex */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, }, + /* FloatImaginary */ { BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::FloatImaginary, BasicType::FloatImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, }, + /* DoubleImaginary */ { BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::DoubleImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::DoubleImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, }, + /* LongDoubleImaginary */ { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, }, + /* SignedInt128 */ { BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::SignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::SignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128, }, + /* UnsignedInt128 */ { BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::UnsignedInt128, BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128, }, + /* Float80 */ { BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::LongDouble, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::Float80, BasicType::Float80, BasicType::Float80, BasicType::Float128 }, + /* Float128 */ { BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::Float128, BasicType::Float128, BasicType::Float128, BasicType::Float128 }, }; + static_assert( + sizeof(combinedType)/sizeof(combinedType[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES, + "Each basic type kind should have a corresponding row in the combined type matrix" + ); CommonType::CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/ResolvExpr/ConversionCost.cc (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -230,32 +230,40 @@ */ - static const int costMatrix[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = { - /* Src \ Dest: Bool Char SChar UChar Short UShort Int UInt Long ULong LLong ULLong Float Double LDbl FCplex DCplex LDCplex FImag DImag LDImag I128, U128 */ - /* Bool */ { 0, 1, 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 12, 13, 14, 12, 13, 14, -1, -1, -1, 10, 11, }, - /* Char */ { -1, 0, -1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 11, 12, 13, 11, 12, 13, -1, -1, -1, 9, 10, }, - /* SChar */ { -1, -1, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 11, 12, 13, 11, 12, 13, -1, -1, -1, 9, 10, }, - /* UChar */ { -1, -1, -1, 0, 1, 2, 3, 4, 4, 5, 6, 7, 10, 11, 12, 10, 11, 12, -1, -1, -1, 8, 9, }, - /* Short */ { -1, -1, -1, -1, 0, 1, 2, 3, 3, 4, 5, 6, 9, 10, 11, 9, 10, 11, -1, -1, -1, 7, 8, }, - /* UShort */{ -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 4, 5, 8, 9, 10, 8, 9, 10, -1, -1, -1, 6, 7, }, - /* Int */ { -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 4, 7, 8, 9, 7, 8, 9, -1, -1, -1, 5, 6, }, - /* UInt */ { -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, 2, 3, 6, 7, 8, 6, 7, 8, -1, -1, -1, 4, 5, }, - /* Long */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 6, 7, 8, 6, 7, 8, -1, -1, -1, 4, 5, }, - /* ULong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 5, 6, 7, 5, 6, 7, -1, -1, -1, 3, 4, }, - /* LLong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 4, 5, 6, 4, 5, 6, -1, -1, -1, 2, 3, }, - /* ULLong */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 3, 4, 5, 3, 4, 5, -1, -1, -1, 1, 2, }, - - /* Float */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 1, 2, 3, -1, -1, -1, -1, -1, }, - /* Double */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, 1, 2, -1, -1, -1, -1, -1, }, - /* LDbl */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, -1, -1, -1, -1, }, - /* FCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, -1, -1, -1, -1, }, - /* DCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, -1, -1, -1, -1, }, - /* LDCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, }, - /* FImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 1, 2, -1, -1, }, - /* DImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, -1, 0, 1, -1, -1, }, - /* LDImag */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 0, -1, -1, }, - - /* I128 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 3, 4, 3, 4, 5, -1, -1, -1, 0, 1, }, - /* U128 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 2, 3, 4, -1, -1, -1, -1, 0, }, + static const int costMatrix[][ BasicType::NUMBER_OF_BASIC_TYPES ] = { + /* Src \ Dest: Bool Char SChar UChar Short UShort Int UInt Long ULong LLong ULLong Float Double LDbl FCplex DCplex LDCplex FImag DImag LDImag I128, U128, F80, F128 */ + /* Bool */ { 0, 1, 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 12, 13, 14, 12, 13, 14, -1, -1, -1, 10, 11, 14, 15}, + /* Char */ { -1, 0, -1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 11, 12, 13, 11, 12, 13, -1, -1, -1, 9, 10, 13, 14}, + /* SChar */ { -1, -1, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 11, 12, 13, 11, 12, 13, -1, -1, -1, 9, 10, 13, 14}, + /* UChar */ { -1, -1, -1, 0, 1, 2, 3, 4, 4, 5, 6, 7, 10, 11, 12, 10, 11, 12, -1, -1, -1, 8, 9, 12, 13}, + /* Short */ { -1, -1, -1, -1, 0, 1, 2, 3, 3, 4, 5, 6, 9, 10, 11, 9, 10, 11, -1, -1, -1, 7, 8, 11, 12}, + /* UShort */{ -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 4, 5, 8, 9, 10, 8, 9, 10, -1, -1, -1, 6, 7, 10, 11}, + /* Int */ { -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 4, 7, 8, 9, 7, 8, 9, -1, -1, -1, 5, 6, 9, 10}, + /* UInt */ { -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, 2, 3, 6, 7, 8, 6, 7, 8, -1, -1, -1, 4, 5, 8, 9}, + /* Long */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 6, 7, 8, 6, 7, 8, -1, -1, -1, 4, 5, 8, 9}, + /* ULong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 5, 6, 7, 5, 6, 7, -1, -1, -1, 3, 4, 7, 8}, + /* LLong */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 4, 5, 6, 4, 5, 6, -1, -1, -1, 2, 3, 6, 7}, + /* ULLong */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 3, 4, 5, 3, 4, 5, -1, -1, -1, 1, 2, 5, 6}, + + /* Float */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 1, 2, 3, -1, -1, -1, -1, -1, 2, 3}, + /* Double */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, 1, 2, -1, -1, -1, -1, -1, 1, 2}, + /* LDbl */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, 1, -1, -1, -1, -1, -1, -1, 1}, + /* FCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, -1, -1, -1, -1, -1, -1}, + /* DCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, -1, -1, -1, -1, -1, -1}, + /* LDCplex */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1}, + /* FImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 1, 2, -1, -1, -1, -1}, + /* DImag */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, -1, 0, 1, -1, -1, -1, -1}, + /* LDImag */{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 0, -1, -1, -1, -1}, + + /* I128 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 3, 4, 3, 4, 5, -1, -1, -1, 0, 1, 4, 4}, + /* U128 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 2, 3, 4, -1, -1, -1, -1, 0, 3, 3}, + + /* F80 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, -1, -1, -1, -1, 0, 1}, + /* F128 */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, 0}, }; + static_assert( + sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES, + "Each basic type kind should have a corresponding row in the cost matrix" + ); + void ConversionCost::postvisit( VoidType * ) { Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/SymTab/Mangler.cc (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -171,7 +171,14 @@ "w", // SignedInt128 "Uw", // UnsignedInt128 + "a", // Float80 + "A", // Float128 }; + static_assert( + sizeof(btLetter)/sizeof(btLetter[0]) == BasicType::NUMBER_OF_BASIC_TYPES, + "Each basic type kind should have a corresponding mangler letter" + ); printQualifiers( basicType ); + assert( basicType->get_kind() < sizeof(btLetter)/sizeof(btLetter[0]) ); mangleName << btLetter[ basicType->get_kind() ]; } Index: src/SynTree/BasicType.cc =================================================================== --- src/SynTree/BasicType.cc (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/SynTree/BasicType.cc (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -55,4 +55,6 @@ case DoubleImaginary: case LongDoubleImaginary: + case Float80: + case Float128: return false; case NUMBER_OF_BASIC_TYPES: Index: src/SynTree/Type.cc =================================================================== --- src/SynTree/Type.cc (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/SynTree/Type.cc (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -24,5 +24,5 @@ using namespace std; -const char *BasicType::typeNames[BasicType::NUMBER_OF_BASIC_TYPES] = { +const char *BasicType::typeNames[] = { "_Bool", "char", @@ -48,5 +48,11 @@ "__int128", "unsigned __int128", + "__float80", + "__float128" }; +static_assert( + sizeof(BasicType::typeNames)/sizeof(BasicType::typeNames[0]) == BasicType::NUMBER_OF_BASIC_TYPES, + "Each basic type name should have a corresponding kind enum value" +); Type::Type( const Qualifiers &tq, const std::list< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {} Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/SynTree/Type.h (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -231,4 +231,6 @@ SignedInt128, UnsignedInt128, + Float80, + Float128, NUMBER_OF_BASIC_TYPES } kind; Index: src/libcfa/bits/locks.h =================================================================== --- src/libcfa/bits/locks.h (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/libcfa/bits/locks.h (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -39,18 +39,14 @@ #endif -#if __SIZEOF_SIZE_T__ == 8 - #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_8( &(lock), 1 ) == 0 - #define __lock_release( lock ) __sync_lock_release_8( &(lock) ); -#elif __SIZEOF_SIZE_T__ == 4 - #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_4( &(lock), 1 ) == 0 - #define __lock_release( lock ) __sync_lock_release_4( &(lock) ); -#else - #error unsupported architecture -#endif - struct __spinlock_t { - __ALIGN__ volatile size_t lock; + // Wrap in struct to prevent false sharing with debug info + struct { + // Align lock on 128-bit boundary + __ALIGN__ volatile _Bool lock; + }; #ifdef __CFA_DEBUG__ + // previous function to acquire the lock const char * prev_name; + // previous thread to acquire the lock void* prev_thrd; #endif @@ -78,5 +74,5 @@ // Lock the spinlock, return false if already acquired static inline _Bool try_lock ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { - _Bool result = __lock_test_and_test_and_set( this.lock ); + _Bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0); if( result ) { disable_interrupts(); @@ -94,5 +90,5 @@ for ( unsigned int i = 1;; i += 1 ) { - if ( __lock_test_and_test_and_set( this.lock ) ) break; + if ( (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0) ) break; #ifndef NOEXPBACK // exponential spin @@ -112,20 +108,7 @@ } - // // Lock the spinlock, yield if already acquired - // static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { - // for ( unsigned int i = 1;; i += 1 ) { - // if ( __lock_test_and_test_and_set( this.lock ) ) break; - // yield( i ); - // } - // disable_interrupts(); - // __cfaabi_dbg_debug_do( - // this.prev_name = caller; - // this.prev_thrd = this_thread; - // ) - // } - static inline void unlock( __spinlock_t & this ) { enable_interrupts_noPoll(); - __lock_release( this.lock ); + __atomic_clear( &this.lock, __ATOMIC_RELEASE ); } #endif Index: src/libcfa/concurrency/alarm.c =================================================================== --- src/libcfa/concurrency/alarm.c (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/libcfa/concurrency/alarm.c (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -10,6 +10,6 @@ // Created On : Fri Jun 2 11:31:25 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Apr 9 13:36:18 2018 -// Update Count : 61 +// Last Modified On : Fri May 25 06:25:47 2018 +// Update Count : 67 // @@ -37,5 +37,5 @@ void __kernel_set_timer( Duration alarm ) { - verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%luns)", alarm.tv); + verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm.tv); setitimer( ITIMER_REAL, &(itimerval){ alarm }, NULL ); } Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/libcfa/concurrency/preemption.c (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -161,5 +161,16 @@ void disable_interrupts() { with( kernelTLS.preemption_state ) { - enabled = false; + #if GCC_VERSION > 50000 + static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free"); + #endif + + // Set enabled flag to false + // should be atomic to avoid preemption in the middle of the operation. + // use memory order RELAXED since there is no inter-thread on this variable requirements + __atomic_store_n(&enabled, false, __ATOMIC_RELAXED); + + // Signal the compiler that a fence is needed but only for signal handlers + __atomic_signal_fence(__ATOMIC_ACQUIRE); + __attribute__((unused)) unsigned short new_val = disable_count + 1; disable_count = new_val; @@ -171,6 +182,6 @@ // If counter reaches 0, execute any pending CtxSwitch void enable_interrupts( __cfaabi_dbg_ctx_param ) { - processor * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic add - thread_desc * thrd = kernelTLS.this_thread; // Cache the thread now since interrupts can start happening after the atomic add + processor * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store + thread_desc * thrd = kernelTLS.this_thread; // Cache the thread now since interrupts can start happening after the atomic store with( kernelTLS.preemption_state ){ @@ -181,5 +192,15 @@ // Check if we need to prempt the thread because an interrupt was missed if( prev == 1 ) { - enabled = true; + #if GCC_VERSION > 50000 + static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free"); + #endif + + // Set enabled flag to true + // should be atomic to avoid preemption in the middle of the operation. + // use memory order RELAXED since there is no inter-thread on this variable requirements + __atomic_store_n(&enabled, true, __ATOMIC_RELAXED); + + // Signal the compiler that a fence is needed but only for signal handlers + __atomic_signal_fence(__ATOMIC_RELEASE); if( proc->pending_preemption ) { proc->pending_preemption = false; @@ -200,5 +221,14 @@ verifyf( prev != 0u, "Incremented from %u\n", prev ); // If this triggers someone is enabled already enabled interrupts if( prev == 1 ) { - kernelTLS.preemption_state.enabled = true; + #if GCC_VERSION > 50000 + static_assert(__atomic_always_lock_free(sizeof(kernelTLS.preemption_state.enabled), &kernelTLS.preemption_state.enabled), "Must be lock-free"); + #endif + // Set enabled flag to true + // should be atomic to avoid preemption in the middle of the operation. + // use memory order RELAXED since there is no inter-thread on this variable requirements + __atomic_store_n(&kernelTLS.preemption_state.enabled, true, __ATOMIC_RELAXED); + + // Signal the compiler that a fence is needed but only for signal handlers + __atomic_signal_fence(__ATOMIC_RELEASE); } } @@ -352,5 +382,7 @@ // Clear sighandler mask before context switching. + #if GCC_VERSION > 50000 static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" ); + #endif if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), NULL ) == -1 ) { abort( "internal error, sigprocmask" ); Index: src/prelude/Makefile.am =================================================================== --- src/prelude/Makefile.am (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/prelude/Makefile.am (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -37,8 +37,8 @@ # create forward declarations for gcc builtins gcc-builtins.cf : gcc-builtins.c prototypes.sed - ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@ + ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E -P $< | sed -r -f prototypes.sed > $@ -gcc-builtins.c : builtins.def prototypes.awk - ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ +gcc-builtins.c : builtins.def prototypes.awk sync-builtins.cf + ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E prototypes.c | awk -f prototypes.awk > $@ builtins.def : Index: src/prelude/Makefile.in =================================================================== --- src/prelude/Makefile.in (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/prelude/Makefile.in (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -506,8 +506,8 @@ # create forward declarations for gcc builtins gcc-builtins.cf : gcc-builtins.c prototypes.sed - ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@ - -gcc-builtins.c : builtins.def prototypes.awk - ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ + ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E -P $< | sed -r -f prototypes.sed > $@ + +gcc-builtins.c : builtins.def prototypes.awk sync-builtins.cf + ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E prototypes.c | awk -f prototypes.awk > $@ builtins.def : Index: src/prelude/builtins.def =================================================================== --- src/prelude/builtins.def (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/prelude/builtins.def (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -190,5 +190,5 @@ /* Builtin used by implementation of Cilk Plus. Most of these are decomposed - by the compiler but a few are implemented in libcilkrts. */ + by the compiler but a few are implemented in libcilkrts. */ #undef DEF_CILK_BUILTIN_STUB #define DEF_CILK_BUILTIN_STUB(ENUM, NAME) \ @@ -204,5 +204,5 @@ /* Builtin used by the implementation of libsanitizer. These - functions are mapped to the actual implementation of the + functions are mapped to the actual implementation of the libtsan library. */ #undef DEF_SANITIZER_BUILTIN @@ -217,5 +217,5 @@ #define DEF_CILKPLUS_BUILTIN(ENUM, NAME, TYPE, ATTRS) \ DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_FN_INT_VAR, BT_LAST, \ - false, false, false, ATTRS, false, flag_cilkplus) + false, false, false, ATTRS, false, flag_cilkplus) /* Builtin used by the implementation of Pointer Bounds Checker. */ @@ -927,8 +927,8 @@ DEF_GCC_BUILTIN (BUILT_IN_LINE, "LINE", BT_FN_INT, ATTR_NOTHROW_LEAF_LIST) +#if 0 //Ifdefed out because we hard-coded the proper overloadings of the atomic built-ins /* Synchronization Primitives. */ #include "sync-builtins.def" -#if 0 /* Offloading and Multi Processing builtins. */ #include "omp-builtins.def" Index: src/prelude/prototypes.awk =================================================================== --- src/prelude/prototypes.awk (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/prelude/prototypes.awk (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -5,5 +5,5 @@ # file "LICENCE" distributed with Cforall. # -# prototypes.awk -- +# prototypes.awk -- # # Author : Peter A. Buhr @@ -12,5 +12,5 @@ # Last Modified On : Tue Jul 5 14:32:52 2016 # Update Count : 32 -# +# # http://llvm.org/svn/llvm-project/cfe/trunk/include/clang/Basic/Builtins.def @@ -83,5 +83,5 @@ } # BEGIN -/BT_FN/ { +/BT_FN/ { for (i = 1; i <= NF; i++) { if( match($i, "BT_FN") != 0 ) { @@ -116,5 +116,5 @@ # generate function return type as macro - for ( t = 0; t < N; t += 1 ) { # find longest match + for ( t = 0; t < N; t += 1 ) { # find longest match type = types[t]; if ( index( prototype, type ) == 1 ) { # found match @@ -150,4 +150,5 @@ # extras printf( "\n#include \"builtins.def\"\n\n" ); + printf( "\n#include \"sync-builtins.cf\"\n\n" ); printf( "extern const char *__PRETTY_FUNCTION__;\n" ); } # END Index: src/prelude/prototypes.sed =================================================================== --- src/prelude/prototypes.sed (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/prelude/prototypes.sed (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -2,5 +2,21 @@ /targetm/s/.*// #Remove targetm declarations /__Unsupported/s/.*// #Remove Unsupported types declarations -s/void (const char \*)0();// #Remove void (const char \*)0(); +s/void \(const char \*\)0\(\);// #Remove void (const char \*)0(); s/\"//g #Remove extraenous quotes in declarations -/__builtin_/s/_ /_/g #Remove extraenous spaces in declarations +/__builtin_/s/_ /_/g #Remove extraenous spaces in declarations + +#Fix gcc overloading +# various sed rules for the gcc sync builtins which are overloaded +# kept here because they generate an acceptable approximate of the correct prototypes + +#/__sync_/s/_[0-9][0-9]*\(.*\)/\(\);/g #hack since it will accept any parameters +#/__atomic_/s/_[0-9][0-9]*\(.*\)/\(\);/g #hack since it will accept any parameters + +#/_16/s/void \*/__int128 \*/g +#/_8/s/void \*/long long int \*/g +#/_4/s/void \*/int \*/g +#/_2/s/void \*/short \*/g +#/_1/s/void \*/char \*/g + +#s/([a-zA-Z0-9_ ]+)\s+__sync([a-z_]+)_([0-9]+)\((.*)\);/\1 __sync\2\(\4\,...); \1 __sync\2_\3\(\4\,...);/ +#s/([a-zA-Z0-9_ ]+)\s+__atomic([a-z_]+)_([0-9]+)\((.*)\);/\1 __atomic\2\(\4\); \1 __atomic\2_\3\(\4\);/ Index: src/prelude/sync-builtins.cf =================================================================== --- src/prelude/sync-builtins.cf (revision 054514d366b6a7a6863d673a9c760baa03661f21) +++ src/prelude/sync-builtins.cf (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -0,0 +1,468 @@ +char __sync_fetch_and_add(volatile char *, char,...); +char __sync_fetch_and_add_1(volatile char *, char,...); +short __sync_fetch_and_add(volatile short *, short,...); +short __sync_fetch_and_add_2(volatile short *, short,...); +int __sync_fetch_and_add(volatile int *, int,...); +int __sync_fetch_and_add_4(volatile int *, int,...); +long long int __sync_fetch_and_add(volatile long long int *, long long int,...); +long long int __sync_fetch_and_add_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_fetch_and_add(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_add_16(volatile __int128 *, __int128,...); +#endif + +char __sync_fetch_and_sub(volatile char *, char,...); +char __sync_fetch_and_sub_1(volatile char *, char,...); +short __sync_fetch_and_sub(volatile short *, short,...); +short __sync_fetch_and_sub_2(volatile short *, short,...); +int __sync_fetch_and_sub(volatile int *, int,...); +int __sync_fetch_and_sub_4(volatile int *, int,...); +long long int __sync_fetch_and_sub(volatile long long int *, long long int,...); +long long int __sync_fetch_and_sub_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_fetch_and_sub(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_sub_16(volatile __int128 *, __int128,...); +#endif + +char __sync_fetch_and_or(volatile char *, char,...); +char __sync_fetch_and_or_1(volatile char *, char,...); +short __sync_fetch_and_or(volatile short *, short,...); +short __sync_fetch_and_or_2(volatile short *, short,...); +int __sync_fetch_and_or(volatile int *, int,...); +int __sync_fetch_and_or_4(volatile int *, int,...); +long long int __sync_fetch_and_or(volatile long long int *, long long int,...); +long long int __sync_fetch_and_or_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_fetch_and_or(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_or_16(volatile __int128 *, __int128,...); +#endif + +char __sync_fetch_and_and(volatile char *, char,...); +char __sync_fetch_and_and_1(volatile char *, char,...); +short __sync_fetch_and_and(volatile short *, short,...); +short __sync_fetch_and_and_2(volatile short *, short,...); +int __sync_fetch_and_and(volatile int *, int,...); +int __sync_fetch_and_and_4(volatile int *, int,...); +long long int __sync_fetch_and_and(volatile long long int *, long long int,...); +long long int __sync_fetch_and_and_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_fetch_and_and(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_and_16(volatile __int128 *, __int128,...); +#endif + +char __sync_fetch_and_xor(volatile char *, char,...); +char __sync_fetch_and_xor_1(volatile char *, char,...); +short __sync_fetch_and_xor(volatile short *, short,...); +short __sync_fetch_and_xor_2(volatile short *, short,...); +int __sync_fetch_and_xor(volatile int *, int,...); +int __sync_fetch_and_xor_4(volatile int *, int,...); +long long int __sync_fetch_and_xor(volatile long long int *, long long int,...); +long long int __sync_fetch_and_xor_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_fetch_and_xor(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_xor_16(volatile __int128 *, __int128,...); +#endif + +char __sync_fetch_and_nand(volatile char *, char,...); +char __sync_fetch_and_nand_1(volatile char *, char,...); +short __sync_fetch_and_nand(volatile short *, short,...); +short __sync_fetch_and_nand_2(volatile short *, short,...); +int __sync_fetch_and_nand(volatile int *, int,...); +int __sync_fetch_and_nand_4(volatile int *, int,...); +long long int __sync_fetch_and_nand(volatile long long int *, long long int,...); +long long int __sync_fetch_and_nand_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_fetch_and_nand(volatile __int128 *, __int128,...); +__int128 __sync_fetch_and_nand_16(volatile __int128 *, __int128,...); +#endif + +char __sync_add_and_fetch(volatile char *, char,...); +char __sync_add_and_fetch_1(volatile char *, char,...); +short __sync_add_and_fetch(volatile short *, short,...); +short __sync_add_and_fetch_2(volatile short *, short,...); +int __sync_add_and_fetch(volatile int *, int,...); +int __sync_add_and_fetch_4(volatile int *, int,...); +long long int __sync_add_and_fetch(volatile long long int *, long long int,...); +long long int __sync_add_and_fetch_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_add_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_add_and_fetch_16(volatile __int128 *, __int128,...); +#endif + +char __sync_sub_and_fetch(volatile char *, char,...); +char __sync_sub_and_fetch_1(volatile char *, char,...); +short __sync_sub_and_fetch(volatile short *, short,...); +short __sync_sub_and_fetch_2(volatile short *, short,...); +int __sync_sub_and_fetch(volatile int *, int,...); +int __sync_sub_and_fetch_4(volatile int *, int,...); +long long int __sync_sub_and_fetch(volatile long long int *, long long int,...); +long long int __sync_sub_and_fetch_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_sub_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_sub_and_fetch_16(volatile __int128 *, __int128,...); +#endif + +char __sync_or_and_fetch(volatile char *, char,...); +char __sync_or_and_fetch_1(volatile char *, char,...); +short __sync_or_and_fetch(volatile short *, short,...); +short __sync_or_and_fetch_2(volatile short *, short,...); +int __sync_or_and_fetch(volatile int *, int,...); +int __sync_or_and_fetch_4(volatile int *, int,...); +long long int __sync_or_and_fetch(volatile long long int *, long long int,...); +long long int __sync_or_and_fetch_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_or_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_or_and_fetch_16(volatile __int128 *, __int128,...); +#endif + +char __sync_and_and_fetch(volatile char *, char,...); +char __sync_and_and_fetch_1(volatile char *, char,...); +short __sync_and_and_fetch(volatile short *, short,...); +short __sync_and_and_fetch_2(volatile short *, short,...); +int __sync_and_and_fetch(volatile int *, int,...); +int __sync_and_and_fetch_4(volatile int *, int,...); +long long int __sync_and_and_fetch(volatile long long int *, long long int,...); +long long int __sync_and_and_fetch_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_and_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_and_and_fetch_16(volatile __int128 *, __int128,...); +#endif + +char __sync_xor_and_fetch(volatile char *, char,...); +char __sync_xor_and_fetch_1(volatile char *, char,...); +short __sync_xor_and_fetch(volatile short *, short,...); +short __sync_xor_and_fetch_2(volatile short *, short,...); +int __sync_xor_and_fetch(volatile int *, int,...); +int __sync_xor_and_fetch_4(volatile int *, int,...); +long long int __sync_xor_and_fetch(volatile long long int *, long long int,...); +long long int __sync_xor_and_fetch_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_xor_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_xor_and_fetch_16(volatile __int128 *, __int128,...); +#endif + +char __sync_nand_and_fetch(volatile char *, char,...); +char __sync_nand_and_fetch_1(volatile char *, char,...); +short __sync_nand_and_fetch(volatile short *, short,...); +short __sync_nand_and_fetch_2(volatile short *, short,...); +int __sync_nand_and_fetch(volatile int *, int,...); +int __sync_nand_and_fetch_4(volatile int *, int,...); +long long int __sync_nand_and_fetch(volatile long long int *, long long int,...); +long long int __sync_nand_and_fetch_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_nand_and_fetch(volatile __int128 *, __int128,...); +__int128 __sync_nand_and_fetch_16(volatile __int128 *, __int128,...); +#endif + +_Bool __sync_bool_compare_and_swap(volatile char *, char, char,...); +_Bool __sync_bool_compare_and_swap_1(volatile char *, char, char,...); +_Bool __sync_bool_compare_and_swap(volatile short *, short, short,...); +_Bool __sync_bool_compare_and_swap_2(volatile short *, short, short,...); +_Bool __sync_bool_compare_and_swap(volatile int *, int, int,...); +_Bool __sync_bool_compare_and_swap_4(volatile int *, int, int,...); +_Bool __sync_bool_compare_and_swap(volatile long long int *, long long int, long long int,...); +_Bool __sync_bool_compare_and_swap_8(volatile long long int *, long long int, long long int,...); +#if defined(__SIZEOF_INT128__) +_Bool __sync_bool_compare_and_swap(volatile __int128 *, __int128, __int128,...); +_Bool __sync_bool_compare_and_swap_16(volatile __int128 *, __int128, __int128,...); +#endif + +char __sync_val_compare_and_swap(volatile char *, char, char,...); +char __sync_val_compare_and_swap_1(volatile char *, char, char,...); +short __sync_val_compare_and_swap(volatile short *, short, short,...); +short __sync_val_compare_and_swap_2(volatile short *, short, short,...); +int __sync_val_compare_and_swap(volatile int *, int, int,...); +int __sync_val_compare_and_swap_4(volatile int *, int, int,...); +long long int __sync_val_compare_and_swap(volatile long long int *, long long int, long long int,...); +long long int __sync_val_compare_and_swap_8(volatile long long int *, long long int, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_val_compare_and_swap(volatile __int128 *, __int128, __int128,...); +__int128 __sync_val_compare_and_swap_16(volatile __int128 *, __int128, __int128,...); +#endif + +char __sync_lock_test_and_set(volatile char *, char,...); +char __sync_lock_test_and_set_1(volatile char *, char,...); +short __sync_lock_test_and_set(volatile short *, short,...); +short __sync_lock_test_and_set_2(volatile short *, short,...); +int __sync_lock_test_and_set(volatile int *, int,...); +int __sync_lock_test_and_set_4(volatile int *, int,...); +long long int __sync_lock_test_and_set(volatile long long int *, long long int,...); +long long int __sync_lock_test_and_set_8(volatile long long int *, long long int,...); +#if defined(__SIZEOF_INT128__) +__int128 __sync_lock_test_and_set(volatile __int128 *, __int128,...); +__int128 __sync_lock_test_and_set_16(volatile __int128 *, __int128,...); +#endif + +void __sync_lock_release(volatile char *,...); +void __sync_lock_release_1(volatile char *,...); +void __sync_lock_release(volatile short *,...); +void __sync_lock_release_2(volatile short *,...); +void __sync_lock_release(volatile int *,...); +void __sync_lock_release_4(volatile int *,...); +void __sync_lock_release(volatile long long int *,...); +void __sync_lock_release_8(volatile long long int *,...); +#if defined(__SIZEOF_INT128__) +void __sync_lock_release(volatile __int128 *,...); +void __sync_lock_release_16(volatile __int128 *,...); +#endif + +void __sync_synchronize(); + + + + +_Bool __atomic_test_and_set(volatile _Bool *, int); +_Bool __atomic_test_and_set(volatile char *, int); +_Bool __atomic_test_and_set(volatile short *, int); +_Bool __atomic_test_and_set(volatile int *, int); +_Bool __atomic_test_and_set(volatile long long int *, int); +#if defined(__SIZEOF_INT128__) +_Bool __atomic_test_and_set(volatile __int128 *, int); +#endif + +void __atomic_clear(volatile _Bool *, int); +void __atomic_clear(volatile char *, int); +void __atomic_clear(volatile short *, int); +void __atomic_clear(volatile int *, int); +void __atomic_clear(volatile long long int *, int); +#if defined(__SIZEOF_INT128__) +void __atomic_clear(volatile __int128 *, int); +#endif + +char __atomic_exchange_n(volatile char *, volatile char *, int); +char __atomic_exchange_1(volatile char *, char, int); +void __atomic_exchange(volatile char *, volatile char *, volatile char *, int); +short __atomic_exchange_n(volatile short *, volatile short *, int); +short __atomic_exchange_2(volatile short *, short, int); +void __atomic_exchange(volatile short *, volatile short *, volatile short *, int); +int __atomic_exchange_n(volatile int *, volatile int *, int); +int __atomic_exchange_4(volatile int *, int, int); +void __atomic_exchange(volatile int *, volatile int *, volatile int *, int); +long long int __atomic_exchange_n(volatile long long int *, volatile long long int *, int); +long long int __atomic_exchange_8(volatile long long int *, long long int, int); +void __atomic_exchange(volatile long long int *, volatile long long int *, volatile long long int *, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_exchange_n(volatile __int128 *, volatile __int128 *, int); +__int128 __atomic_exchange_16(volatile __int128 *, __int128, int); +void __atomic_exchange(volatile __int128 *, volatile __int128 *, volatile __int128 *, int); +#endif + +char __atomic_load_n(const volatile char *, int); +char __atomic_load_1(const volatile char *, int); +void __atomic_load(const volatile char *, volatile char *, int); +short __atomic_load_n(const volatile short *, int); +short __atomic_load_2(const volatile short *, int); +void __atomic_load(const volatile short *, volatile short *, int); +int __atomic_load_n(const volatile int *, int); +int __atomic_load_4(const volatile int *, int); +void __atomic_load(const volatile int *, volatile int *, int); +long long int __atomic_load_n(const volatile long long int *, int); +long long int __atomic_load_8(const volatile long long int *, int); +void __atomic_load(const volatile long long int *, volatile long long int *, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_load_n(const volatile __int128 *, int); +__int128 __atomic_load_16(const volatile __int128 *, int); +void __atomic_load(const volatile __int128 *, volatile __int128 *, int); +#endif + +_Bool __atomic_compare_exchange_n(volatile char *, char *, char, _Bool, int, int); +_Bool __atomic_compare_exchange_1(volatile char *, char *, char, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile char *, char *, char *, _Bool, int, int); +_Bool __atomic_compare_exchange_n(volatile short *, short *, short, _Bool, int, int); +_Bool __atomic_compare_exchange_2(volatile short *, short *, short, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile short *, short *, short *, _Bool, int, int); +_Bool __atomic_compare_exchange_n(volatile int *, int *, int, _Bool, int, int); +_Bool __atomic_compare_exchange_4(volatile int *, int *, int, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile int *, int *, int *, _Bool, int, int); +_Bool __atomic_compare_exchange_n(volatile long long int *, long long int *, long long int, _Bool, int, int); +_Bool __atomic_compare_exchange_8(volatile long long int *, long long int *, long long int, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile long long int *, long long int *, long long int *, _Bool, int, int); +#if defined(__SIZEOF_INT128__) +_Bool __atomic_compare_exchange_n (volatile __int128 *, __int128 *, __int128, _Bool, int, int); +_Bool __atomic_compare_exchange_16(volatile __int128 *, __int128 *, __int128, _Bool, int, int); +_Bool __atomic_compare_exchange (volatile __int128 *, __int128 *, __int128 *, _Bool, int, int); +#endif + +void __atomic_store_n(volatile _Bool *, _Bool, int); +void __atomic_store_1(volatile _Bool *, _Bool, int); +void __atomic_store(volatile _Bool *, _Bool *, int); +void __atomic_store_n(volatile char *, char, int); +void __atomic_store_1(volatile char *, char, int); +void __atomic_store(volatile char *, char *, int); +void __atomic_store_n(volatile short *, short, int); +void __atomic_store_2(volatile short *, short, int); +void __atomic_store(volatile short *, short *, int); +void __atomic_store_n(volatile int *, int, int); +void __atomic_store_4(volatile int *, int, int); +void __atomic_store(volatile int *, int *, int); +void __atomic_store_n(volatile long long int *, long long int, int); +void __atomic_store_8(volatile long long int *, long long int, int); +void __atomic_store(volatile long long int *, long long int *, int); +#if defined(__SIZEOF_INT128__) +void __atomic_store_n(volatile __int128 *, __int128, int); +void __atomic_store_16(volatile __int128 *, __int128, int); +void __atomic_store(volatile __int128 *, __int128 *, int); +#endif + +char __atomic_add_fetch (volatile char *, char, int); +char __atomic_add_fetch_1(volatile char *, char, int); +short __atomic_add_fetch (volatile short *, short, int); +short __atomic_add_fetch_2(volatile short *, short, int); +int __atomic_add_fetch (volatile int *, int, int); +int __atomic_add_fetch_4(volatile int *, int, int); +long long int __atomic_add_fetch (volatile long long int *, long long int, int); +long long int __atomic_add_fetch_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_add_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_add_fetch_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_sub_fetch (volatile char *, char, int); +char __atomic_sub_fetch_1(volatile char *, char, int); +short __atomic_sub_fetch (volatile short *, short, int); +short __atomic_sub_fetch_2(volatile short *, short, int); +int __atomic_sub_fetch (volatile int *, int, int); +int __atomic_sub_fetch_4(volatile int *, int, int); +long long int __atomic_sub_fetch (volatile long long int *, long long int, int); +long long int __atomic_sub_fetch_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_sub_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_sub_fetch_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_and_fetch (volatile char *, char, int); +char __atomic_and_fetch_1(volatile char *, char, int); +short __atomic_and_fetch (volatile short *, short, int); +short __atomic_and_fetch_2(volatile short *, short, int); +int __atomic_and_fetch (volatile int *, int, int); +int __atomic_and_fetch_4(volatile int *, int, int); +long long int __atomic_and_fetch (volatile long long int *, long long int, int); +long long int __atomic_and_fetch_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_and_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_and_fetch_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_nand_fetch (volatile char *, char, int); +char __atomic_nand_fetch_1(volatile char *, char, int); +short __atomic_nand_fetch (volatile short *, short, int); +short __atomic_nand_fetch_2(volatile short *, short, int); +int __atomic_nand_fetch (volatile int *, int, int); +int __atomic_nand_fetch_4(volatile int *, int, int); +long long int __atomic_nand_fetch (volatile long long int *, long long int, int); +long long int __atomic_nand_fetch_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_nand_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_nand_fetch_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_xor_fetch (volatile char *, char, int); +char __atomic_xor_fetch_1(volatile char *, char, int); +short __atomic_xor_fetch (volatile short *, short, int); +short __atomic_xor_fetch_2(volatile short *, short, int); +int __atomic_xor_fetch (volatile int *, int, int); +int __atomic_xor_fetch_4(volatile int *, int, int); +long long int __atomic_xor_fetch (volatile long long int *, long long int, int); +long long int __atomic_xor_fetch_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_xor_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_xor_fetch_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_or_fetch (volatile char *, char, int); +char __atomic_or_fetch_1(volatile char *, char, int); +short __atomic_or_fetch (volatile short *, short, int); +short __atomic_or_fetch_2(volatile short *, short, int); +int __atomic_or_fetch (volatile int *, int, int); +int __atomic_or_fetch_4(volatile int *, int, int); +long long int __atomic_or_fetch (volatile long long int *, long long int, int); +long long int __atomic_or_fetch_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_or_fetch (volatile __int128 *, __int128, int); +__int128 __atomic_or_fetch_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_fetch_add (volatile char *, char, int); +char __atomic_fetch_add_1(volatile char *, char, int); +short __atomic_fetch_add (volatile short *, short, int); +short __atomic_fetch_add_2(volatile short *, short, int); +int __atomic_fetch_add (volatile int *, int, int); +int __atomic_fetch_add_4(volatile int *, int, int); +long long int __atomic_fetch_add (volatile long long int *, long long int, int); +long long int __atomic_fetch_add_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_fetch_add (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_add_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_fetch_sub (volatile char *, char, int); +char __atomic_fetch_sub_1(volatile char *, char, int); +short __atomic_fetch_sub (volatile short *, short, int); +short __atomic_fetch_sub_2(volatile short *, short, int); +int __atomic_fetch_sub (volatile int *, int, int); +int __atomic_fetch_sub_4(volatile int *, int, int); +long long int __atomic_fetch_sub (volatile long long int *, long long int, int); +long long int __atomic_fetch_sub_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_fetch_sub (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_sub_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_fetch_and (volatile char *, char, int); +char __atomic_fetch_and_1(volatile char *, char, int); +short __atomic_fetch_and (volatile short *, short, int); +short __atomic_fetch_and_2(volatile short *, short, int); +int __atomic_fetch_and (volatile int *, int, int); +int __atomic_fetch_and_4(volatile int *, int, int); +long long int __atomic_fetch_and (volatile long long int *, long long int, int); +long long int __atomic_fetch_and_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_fetch_and (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_and_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_fetch_nand (volatile char *, char, int); +char __atomic_fetch_nand_1(volatile char *, char, int); +short __atomic_fetch_nand (volatile short *, short, int); +short __atomic_fetch_nand_2(volatile short *, short, int); +int __atomic_fetch_nand (volatile int *, int, int); +int __atomic_fetch_nand_4(volatile int *, int, int); +long long int __atomic_fetch_nand (volatile long long int *, long long int, int); +long long int __atomic_fetch_nand_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_fetch_nand (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_nand_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_fetch_xor (volatile char *, char, int); +char __atomic_fetch_xor_1(volatile char *, char, int); +short __atomic_fetch_xor (volatile short *, short, int); +short __atomic_fetch_xor_2(volatile short *, short, int); +int __atomic_fetch_xor (volatile int *, int, int); +int __atomic_fetch_xor_4(volatile int *, int, int); +long long int __atomic_fetch_xor (volatile long long int *, long long int, int); +long long int __atomic_fetch_xor_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_fetch_xor (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_xor_16(volatile __int128 *, __int128, int); +#endif + +char __atomic_fetch_or (volatile char *, char, int); +char __atomic_fetch_or_1(volatile char *, char, int); +short __atomic_fetch_or (volatile short *, short, int); +short __atomic_fetch_or_2(volatile short *, short, int); +int __atomic_fetch_or (volatile int *, int, int); +int __atomic_fetch_or_4(volatile int *, int, int); +long long int __atomic_fetch_or (volatile long long int *, long long int, int); +long long int __atomic_fetch_or_8(volatile long long int *, long long int, int); +#if defined(__SIZEOF_INT128__) +__int128 __atomic_fetch_or (volatile __int128 *, __int128, int); +__int128 __atomic_fetch_or_16(volatile __int128 *, __int128, int); +#endif + +_Bool __atomic_always_lock_free(unsigned long, const volatile void *); +_Bool __atomic_is_lock_free(unsigned long, const volatile void *); + +void __atomic_thread_fence (int); +void __atomic_signal_fence (int); +void __atomic_feraiseexcept(int); Index: src/tests/.expect/io.txt =================================================================== --- src/tests/.expect/io.txt (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ (revision ) @@ -1,85 +1,0 @@ -9 6 28 0 7 1 2 -1 2 3 -123 -123 - -opening delimiters -x (1 x [2 x {3 x =4 x $5 x £6 x ¥7 x ¡8 x ¿9 x «10 - -closing delimiters -1, x 2. x 3; x 4! x 5? x 6% x 7¢ x 8» x 9) x 10] x 11} x - -opening/closing delimiters -x`1`x'2'x"3"x:4:x 5 x 6 x -7 -x -8 -x -9 -x -10 -x - -override opening/closing delimiters -x ( 1 ) x 2 , x 3 :x: 4 - -input bacis types - -output basic types -false -A 23 93 -1 2 3 4 5 6 7 8 -1.1 1.2 1.3 -1.1+2.3i 1.1-2.3i 1.1-2.3i - -tuples -1, 2, 3 4, 5, 6 - -toggle separator -1.11.21.3 -1.1+2.3i1.1-2.3i1.1-2.3i -1.1+2.3i 1.1-2.3i1.1-2.3i -1.1+2.3i 1.1-2.3i 1.1-2.3i -1.1+2.3i1.1-2.3i 1.1-2.3i -abcxyz -abcxyz - -change separator -from " " to ", $" -1.1, $1.2, $1.3 -1.1+2.3i, $1.1-2.3i, $1.1-2.3i -abc, $xyz -1, 2, 3, $4, 5, 6 - -from ", $" to " " -1.1 1.2 1.3 -1.1+2.3i 1.1-2.3i 1.1-2.3i -abc xyz -1, 2, 3 4, 5, 6 - -check sepOn/sepOff -1 2 3 -12 3 -1 2 3 -1 2 3 - -1 2 3 - -check enable/disable -123 -1 23 -1 2 3 -123 -1 2 3 -123 -1 2 3 - -1 2 3 4 5 6 " " -1, 2, 3 4, 5, 6 " " -1, 2, 3 4, 5, 6 - -3, 4, a, 7.2 -3, 4, a, 7.2 -3 4 a 7.2 -3 4 a 7.234a7.23 4 a 7.2 -3-4-a-7.2^3^4^3-4-a-7.2 Index: src/tests/.expect/io1.txt =================================================================== --- src/tests/.expect/io1.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) +++ src/tests/.expect/io1.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -0,0 +1,25 @@ +9 6 28 0 7 1 2 +1 2 3 +123 +123 + +opening delimiters +x (1 x [2 x {3 x =4 x $5 x £6 x ¥7 x ¡8 x ¿9 x «10 + +closing delimiters +1, x 2. x 3; x 4! x 5? x 6% x 7¢ x 8» x 9) x 10] x 11} x + +opening/closing delimiters +x`1`x'2'x"3"x:4:x 5 x 6 x +7 +x +8 +x +9 +x +10 +x + +override opening/closing delimiters +x ( 1 ) x 2 , x 3 :x: 4 + Index: src/tests/.expect/io2.txt =================================================================== --- src/tests/.expect/io2.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) +++ src/tests/.expect/io2.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -0,0 +1,60 @@ +input bacis types + +output basic types +false +A 23 93 +1 2 3 4 5 6 7 8 +1.1 1.2 1.3 +1.1+2.3i 1.1-2.3i 1.1-2.3i + +tuples +1, 2, 3 4, 5, 6 + +toggle separator +1.11.21.3 +1.1+2.3i1.1-2.3i1.1-2.3i +1.1+2.3i 1.1-2.3i1.1-2.3i +1.1+2.3i 1.1-2.3i 1.1-2.3i +1.1+2.3i1.1-2.3i 1.1-2.3i +abcxyz +abcxyz + +change separator +from " " to ", $" +1.1, $1.2, $1.3 +1.1+2.3i, $1.1-2.3i, $1.1-2.3i +abc, $xyz +1, 2, 3, $4, 5, 6 + +from ", $" to " " +1.1 1.2 1.3 +1.1+2.3i 1.1-2.3i 1.1-2.3i +abc xyz +1, 2, 3 4, 5, 6 + +check sepOn/sepOff +1 2 3 +12 3 +1 2 3 +1 2 3 + +1 2 3 + +check enable/disable +123 +1 23 +1 2 3 +123 +1 2 3 +123 +1 2 3 + +1 2 3 4 5 6 " " +1, 2, 3 4, 5, 6 " " +1, 2, 3 4, 5, 6 + +3, 4, a, 7.2 +3, 4, a, 7.2 +3 4 a 7.2 +3 4 a 7.234a7.23 4 a 7.2 +3-4-a-7.2^3^4^3-4-a-7.2 Index: src/tests/.expect/math1.x64.txt =================================================================== --- src/tests/.expect/math1.x64.txt (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/tests/.expect/math1.x64.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -12,11 +12,2 @@ \ 16 256 \ 912673 256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i -log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i -log2:3 3 3 -log10:2 2 2 -log1p:0.693147 0.693147180559945 0.693147180559945309 -ilogb:0 0 0 -logb:3 3 3 -sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i -cbrt:3 3 3 -hypot:1.41421 1.4142135623731 1.41421356237309505 Index: src/tests/.expect/math1.x86.txt =================================================================== --- src/tests/.expect/math1.x86.txt (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/tests/.expect/math1.x86.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -12,11 +12,2 @@ \ 16 256 \ 912673 256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i -log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i -log2:3 3 3 -log10:2 2 2 -log1p:0.693147 0.693147180559945 0.693147180559945309 -ilogb:0 0 0 -logb:3 3 3 -sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i -cbrt:3 3 3 -hypot:1.41421 1.4142135623731 1.41421356237309505 Index: src/tests/.expect/math2.x64.txt =================================================================== --- src/tests/.expect/math2.x64.txt (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/tests/.expect/math2.x64.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -1,2 +1,11 @@ +log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i +log2:3 3 3 +log10:2 2 2 +log1p:0.693147 0.693147180559945 0.693147180559945309 +ilogb:0 0 0 +logb:3 3 3 +sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i +cbrt:3 3 3 +hypot:1.41421 1.4142135623731 1.41421356237309505 sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i cos:0.540302 0.54030230586814 0.540302305868139717 0.83373-0.988898i 0.833730025131149-0.988897705762865i 0.833730025131149049-0.988897705762865096i @@ -6,13 +15,2 @@ atan:0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i atan2:0.785398 0.785398163397448 0.78539816339744831 atan:0.785398 0.785398163397448 0.78539816339744831 -sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i -cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i -tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i -acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i -asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i -atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i -erf:0.842701 0.842700792949715 0.842700792949714869 -erfc:0.157299 0.157299207050285 0.157299207050285131 -lgamma:1.79176 1.79175946922805 1.791759469228055 -lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1 -tgamma:6 6 6 Index: src/tests/.expect/math2.x86.txt =================================================================== --- src/tests/.expect/math2.x86.txt (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/tests/.expect/math2.x86.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -1,2 +1,11 @@ +log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i +log2:3 3 3 +log10:2 2 2 +log1p:0.693147 0.693147180559945 0.693147180559945309 +ilogb:0 0 0 +logb:3 3 3 +sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i +cbrt:3 3 3 +hypot:1.41421 1.4142135623731 1.41421356237309505 sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i cos:0.540302 0.54030230586814 0.540302305868139717 0.83373-0.988898i 0.833730025131149-0.988897705762865i 0.833730025131149049-0.988897705762865096i @@ -6,13 +15,2 @@ atan:0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i atan2:0.785398 0.785398163397448 0.78539816339744831 atan:0.785398 0.785398163397448 0.78539816339744831 -sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i -cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i -tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i -acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i -asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i -atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i -erf:0.842701 0.842700792949715 0.842700792949714869 -erfc:0.157299 0.157299207050285 0.157299207050285131 -lgamma:1.79176 1.79175946922805 1.791759469228055 -lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1 -tgamma:6 6 6 Index: src/tests/.expect/math3.x64.txt =================================================================== --- src/tests/.expect/math3.x64.txt (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/tests/.expect/math3.x64.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -1,23 +1,11 @@ -floor:1 1 1 -ceil:2 2 2 -trunc:3 3 3 -rint:2 2 2 -rint:2 2 2 -rint:2 2 2 -lrint:2 2 2 -llrint:2 2 2 -nearbyint:4 4 4 -round:2 2 2 -round:2 2 2 -round:2 2 2 -lround:2 2 2 -llround:2 2 2 -copysign:-1 -1 -1 -frexp:0.5 3 0.5 3 0.5 3 -ldexp:8 8 8 -modf:2 0.3 2 0.3 2 0.3 -modf:2, 0.3 2, 0.3 2, 0.3 -nextafter:2 2 2 -nexttoward:2 2 2 -scalbn:16 16 16 -scalbln:16 16 16 +sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i +cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i +tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i +acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i +asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i +atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i +erf:0.842701 0.842700792949715 0.842700792949714869 +erfc:0.157299 0.157299207050285 0.157299207050285131 +lgamma:1.79176 1.79175946922805 1.791759469228055 +lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1 +tgamma:6 6 6 Index: src/tests/.expect/math3.x86.txt =================================================================== --- src/tests/.expect/math3.x86.txt (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/tests/.expect/math3.x86.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -1,23 +1,11 @@ -floor:1 1 1 -ceil:2 2 2 -trunc:3 3 3 -rint:2 2 2 -rint:2 2 2 -rint:2 2 2 -lrint:2 2 2 -llrint:2 2 2 -nearbyint:4 4 4 -round:2 2 2 -round:2 2 2 -round:2 2 2 -lround:2 2 2 -llround:2 2 2 -copysign:-1 -1 -1 -frexp:0.5 3 0.5 3 0.5 3 -ldexp:8 8 8 -modf:2 0.3 2 0.3 2 0.3 -modf:2, 0.3 2, 0.3 2, 0.3 -nextafter:2 2 2 -nexttoward:2 2 2 -scalbn:16 16 16 -scalbln:16 16 16 +sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i +cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i +tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i +acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i +asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i +atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i +erf:0.842701 0.842700792949715 0.842700792949714869 +erfc:0.157299 0.157299207050285 0.157299207050285131 +lgamma:1.79176 1.79175946922805 1.791759469228055 +lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1 +tgamma:6 6 6 Index: src/tests/.expect/math4.x64.txt =================================================================== --- src/tests/.expect/math4.x64.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) +++ src/tests/.expect/math4.x64.txt (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -0,0 +1,23 @@ +floor:1 1 1 +ceil:2 2 2 +trunc:3 3 3 +rint:2 2 2 +rint:2 2 2 +rint:2 2 2 +lrint:2 2 2 +llrint:2 2 2 +nearbyint:4 4 4 +round:2 2 2 +round:2 2 2 +round:2 2 2 +lround:2 2 2 +llround:2 2 2 +copysign:-1 -1 -1 +frexp:0.5 3 0.5 3 0.5 3 +ldexp:8 8 8 +modf:2 0.3 2 0.3 2 0.3 +modf:2, 0.3 2, 0.3 2, 0.3 +nextafter:2 2 2 +nexttoward:2 2 2 +scalbn:16 16 16 +scalbln:16 16 16 Index: src/tests/Makefile.am =================================================================== --- src/tests/Makefile.am (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/tests/Makefile.am (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -129,2 +129,6 @@ warnings/self-assignment: warnings/self-assignment.c @CFA_BINDIR@/@CFA_NAME@ ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only + +#builtins +builtins/sync: builtins/sync.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only Index: src/tests/Makefile.in =================================================================== --- src/tests/Makefile.in (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/tests/Makefile.in (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -807,4 +807,8 @@ ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only +#builtins +builtins/sync: builtins/sync.c @CFA_BINDIR@/@CFA_NAME@ + ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only + # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. Index: src/tests/builtins/sync.c =================================================================== --- src/tests/builtins/sync.c (revision 054514d366b6a7a6863d673a9c760baa03661f21) +++ src/tests/builtins/sync.c (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -0,0 +1,468 @@ +#include +#include + +void foo() { + volatile _Bool * vpB = 0; _Bool vB = 0; + volatile char * vp1 = 0; char * rp1 = 0; char v1 = 0; + volatile short * vp2 = 0; short * rp2 = 0; short v2 = 0; + volatile int * vp4 = 0; int * rp4 = 0; int v4 = 0; + volatile long long int * vp8 = 0; long long int * rp8 = 0; long long int v8 = 0; + #if defined(__SIZEOF_INT128__) + volatile __int128 * vp16 = 0; __int128 * rp16 = 0; __int128 v16 = 0; + #endif + + { char ret; ret = __sync_fetch_and_add(vp1, v1); } + { char ret; ret = __sync_fetch_and_add_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_add(vp2, v2); } + { short ret; ret = __sync_fetch_and_add_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_add(vp4, v4); } + { int ret; ret = __sync_fetch_and_add_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_add(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_add_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_fetch_and_add(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_add_16(vp16, v16); } + #endif + + { char ret; ret = __sync_fetch_and_sub(vp1, v1); } + { char ret; ret = __sync_fetch_and_sub_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_sub(vp2, v2); } + { short ret; ret = __sync_fetch_and_sub_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_sub(vp4, v4); } + { int ret; ret = __sync_fetch_and_sub_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_sub(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_sub_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_fetch_and_sub(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_sub_16(vp16, v16); } + #endif + + { char ret; ret = __sync_fetch_and_or(vp1, v1); } + { char ret; ret = __sync_fetch_and_or_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_or(vp2, v2); } + { short ret; ret = __sync_fetch_and_or_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_or(vp4, v4); } + { int ret; ret = __sync_fetch_and_or_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_or(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_or_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_fetch_and_or(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_or_16(vp16, v16); } + #endif + + { char ret; ret = __sync_fetch_and_and(vp1, v1); } + { char ret; ret = __sync_fetch_and_and_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_and(vp2, v2); } + { short ret; ret = __sync_fetch_and_and_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_and(vp4, v4); } + { int ret; ret = __sync_fetch_and_and_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_and(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_and_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_fetch_and_and(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_and_16(vp16, v16); } + #endif + + { char ret; ret = __sync_fetch_and_xor(vp1, v1); } + { char ret; ret = __sync_fetch_and_xor_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_xor(vp2, v2); } + { short ret; ret = __sync_fetch_and_xor_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_xor(vp4, v4); } + { int ret; ret = __sync_fetch_and_xor_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_xor(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_xor_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_fetch_and_xor(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_xor_16(vp16, v16); } + #endif + + { char ret; ret = __sync_fetch_and_nand(vp1, v1); } + { char ret; ret = __sync_fetch_and_nand_1(vp1, v1); } + { short ret; ret = __sync_fetch_and_nand(vp2, v2); } + { short ret; ret = __sync_fetch_and_nand_2(vp2, v2); } + { int ret; ret = __sync_fetch_and_nand(vp4, v4); } + { int ret; ret = __sync_fetch_and_nand_4(vp4, v4); } + { long long int ret; ret = __sync_fetch_and_nand(vp8, v8); } + { long long int ret; ret = __sync_fetch_and_nand_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_fetch_and_nand(vp16, v16); } + { __int128 ret; ret = __sync_fetch_and_nand_16(vp16, v16); } + #endif + + { char ret; ret = __sync_add_and_fetch(vp1, v1); } + { char ret; ret = __sync_add_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_add_and_fetch(vp2, v2); } + { short ret; ret = __sync_add_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_add_and_fetch(vp4, v4); } + { int ret; ret = __sync_add_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_add_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_add_and_fetch_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_add_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_add_and_fetch_16(vp16, v16); } + #endif + + { char ret; ret = __sync_sub_and_fetch(vp1, v1); } + { char ret; ret = __sync_sub_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_sub_and_fetch(vp2, v2); } + { short ret; ret = __sync_sub_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_sub_and_fetch(vp4, v4); } + { int ret; ret = __sync_sub_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_sub_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_sub_and_fetch_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_sub_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_sub_and_fetch_16(vp16, v16); } + #endif + + { char ret; ret = __sync_or_and_fetch(vp1, v1); } + { char ret; ret = __sync_or_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_or_and_fetch(vp2, v2); } + { short ret; ret = __sync_or_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_or_and_fetch(vp4, v4); } + { int ret; ret = __sync_or_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_or_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_or_and_fetch_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_or_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_or_and_fetch_16(vp16, v16); } + #endif + + { char ret; ret = __sync_and_and_fetch(vp1, v1); } + { char ret; ret = __sync_and_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_and_and_fetch(vp2, v2); } + { short ret; ret = __sync_and_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_and_and_fetch(vp4, v4); } + { int ret; ret = __sync_and_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_and_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_and_and_fetch_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_and_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_and_and_fetch_16(vp16, v16); } + #endif + + { char ret; ret = __sync_xor_and_fetch(vp1, v1); } + { char ret; ret = __sync_xor_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_xor_and_fetch(vp2, v2); } + { short ret; ret = __sync_xor_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_xor_and_fetch(vp4, v4); } + { int ret; ret = __sync_xor_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_xor_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_xor_and_fetch_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_xor_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_xor_and_fetch_16(vp16, v16); } + #endif + + { char ret; ret = __sync_nand_and_fetch(vp1, v1); } + { char ret; ret = __sync_nand_and_fetch_1(vp1, v1); } + { short ret; ret = __sync_nand_and_fetch(vp2, v2); } + { short ret; ret = __sync_nand_and_fetch_2(vp2, v2); } + { int ret; ret = __sync_nand_and_fetch(vp4, v4); } + { int ret; ret = __sync_nand_and_fetch_4(vp4, v4); } + { long long int ret; ret = __sync_nand_and_fetch(vp8, v8); } + { long long int ret; ret = __sync_nand_and_fetch_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_nand_and_fetch(vp16, v16); } + { __int128 ret; ret = __sync_nand_and_fetch_16(vp16, v16); } + #endif + + { _Bool ret; ret = __sync_bool_compare_and_swap(vp1, v1, v1); } + { _Bool ret; ret = __sync_bool_compare_and_swap_1(vp1, v1, v1); } + { _Bool ret; ret = __sync_bool_compare_and_swap(vp2, v2, v2); } + { _Bool ret; ret = __sync_bool_compare_and_swap_2(vp2, v2, v2); } + { _Bool ret; ret = __sync_bool_compare_and_swap(vp4, v4, v4); } + { _Bool ret; ret = __sync_bool_compare_and_swap_4(vp4, v4, v4); } + { _Bool ret; ret = __sync_bool_compare_and_swap(vp8, v8, v8); } + { _Bool ret; ret = __sync_bool_compare_and_swap_8(vp8, v8, v8); } + #if defined(__SIZEOF_INT128__) + { _Bool ret; ret = __sync_bool_compare_and_swap(vp16, v16, v16); } + { _Bool ret; ret = __sync_bool_compare_and_swap_16(vp16, v16,v16); } + #endif + + { char ret; ret = __sync_val_compare_and_swap(vp1, v1, v1); } + { char ret; ret = __sync_val_compare_and_swap_1(vp1, v1, v1); } + { short ret; ret = __sync_val_compare_and_swap(vp2, v2, v2); } + { short ret; ret = __sync_val_compare_and_swap_2(vp2, v2, v2); } + { int ret; ret = __sync_val_compare_and_swap(vp4, v4, v4); } + { int ret; ret = __sync_val_compare_and_swap_4(vp4, v4, v4); } + { long long int ret; ret = __sync_val_compare_and_swap(vp8, v8, v8); } + { long long int ret; ret = __sync_val_compare_and_swap_8(vp8, v8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_val_compare_and_swap(vp16, v16, v16); } + { __int128 ret; ret = __sync_val_compare_and_swap_16(vp16, v16,v16); } + #endif + + { char ret; ret = __sync_lock_test_and_set(vp1, v1); } + { char ret; ret = __sync_lock_test_and_set_1(vp1, v1); } + { short ret; ret = __sync_lock_test_and_set(vp2, v2); } + { short ret; ret = __sync_lock_test_and_set_2(vp2, v2); } + { int ret; ret = __sync_lock_test_and_set(vp4, v4); } + { int ret; ret = __sync_lock_test_and_set_4(vp4, v4); } + { long long int ret; ret = __sync_lock_test_and_set(vp8, v8); } + { long long int ret; ret = __sync_lock_test_and_set_8(vp8, v8); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __sync_lock_test_and_set(vp16, v16); } + { __int128 ret; ret = __sync_lock_test_and_set_16(vp16, v16); } + #endif + + { __sync_lock_release(vp1); } + { __sync_lock_release_1(vp1); } + { __sync_lock_release(vp2); } + { __sync_lock_release_2(vp2); } + { __sync_lock_release(vp4); } + { __sync_lock_release_4(vp4); } + { __sync_lock_release(vp8); } + { __sync_lock_release_8(vp8); } + #if defined(__SIZEOF_INT128__) + { __sync_lock_release(vp16); } + { __sync_lock_release_16(vp16); } + #endif + + { __sync_synchronize(); } + + + + + { _Bool ret; ret = __atomic_test_and_set(vpB, vB); } + { _Bool ret; ret = __atomic_test_and_set(vp1, v1); } + { __atomic_clear(vpB, vB); } + { __atomic_clear(vp1, v1); } + + { char ret; ret = __atomic_exchange_n(vp1, &v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_exchange_1(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; __atomic_exchange(vp1, &v1, &ret, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_exchange_n(vp2, &v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_exchange_2(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; __atomic_exchange(vp2, &v2, &ret, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_exchange_n(vp4, &v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_exchange_4(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; __atomic_exchange(vp4, &v4, &ret, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_exchange_n(vp8, &v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_exchange_8(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; __atomic_exchange(vp8, &v8, &ret, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_exchange_n(vp16, &v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_exchange_16(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; __atomic_exchange(vp16, &v16, &ret, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_load_n(vp1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_load_1(vp1, __ATOMIC_SEQ_CST); } + { char ret; __atomic_load(vp1, &ret, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_load_n(vp2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_load_2(vp2, __ATOMIC_SEQ_CST); } + { short ret; __atomic_load(vp2, &ret, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_load_n(vp4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_load_4(vp4, __ATOMIC_SEQ_CST); } + { int ret; __atomic_load(vp4, &ret, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_load_n(vp8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_load_8(vp8, __ATOMIC_SEQ_CST); } + { long long int ret; __atomic_load(vp8, &ret, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_load_n(vp16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_load_16(vp16, __ATOMIC_SEQ_CST); } + { __int128 ret; __atomic_load(vp16, &ret, __ATOMIC_SEQ_CST); } + #endif + + { _Bool ret; ret = __atomic_compare_exchange_n(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_1(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange(vp1, rp1, &v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_n(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_2(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange(vp2, rp2, &v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_n(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_4(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange(vp4, rp4, &v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_n(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_8(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange(vp8, rp8, &v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { _Bool ret; ret = __atomic_compare_exchange_n(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange_16(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + { _Bool ret; ret = __atomic_compare_exchange(vp16, rp16, &v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); } + #endif + + { __atomic_store_n(vp1, v1, __ATOMIC_SEQ_CST); } + { __atomic_store_1(vp1, v1, __ATOMIC_SEQ_CST); } + { __atomic_store(vp1, &v1, __ATOMIC_SEQ_CST); } + { __atomic_store_n(vp2, v2, __ATOMIC_SEQ_CST); } + { __atomic_store_2(vp2, v2, __ATOMIC_SEQ_CST); } + { __atomic_store(vp2, &v2, __ATOMIC_SEQ_CST); } + { __atomic_store_n(vp4, v4, __ATOMIC_SEQ_CST); } + { __atomic_store_4(vp4, v4, __ATOMIC_SEQ_CST); } + { __atomic_store(vp4, &v4, __ATOMIC_SEQ_CST); } + { __atomic_store_n(vp8, v8, __ATOMIC_SEQ_CST); } + { __atomic_store_8(vp8, v8, __ATOMIC_SEQ_CST); } + { __atomic_store(vp8, &v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __atomic_store_n(vp16, v16, __ATOMIC_SEQ_CST); } + { __atomic_store_16(vp16, v16, __ATOMIC_SEQ_CST); } + { __atomic_store(vp16, &v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_add_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_add_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_add_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_add_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_add_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_add_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_add_fetch(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_add_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_add_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_add_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_sub_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_sub_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_sub_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_sub_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_sub_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_sub_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_sub_fetch(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_sub_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_sub_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_sub_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_and_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_and_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_and_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_and_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_and_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_and_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_and_fetch(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_and_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_and_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_and_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_nand_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_nand_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_nand_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_nand_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_nand_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_nand_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_nand_fetch(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_nand_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_nand_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_nand_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_xor_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_xor_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_xor_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_xor_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_xor_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_xor_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_xor_fetch(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_xor_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_xor_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_xor_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_or_fetch(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_or_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_or_fetch(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_or_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_or_fetch(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_or_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_or_fetch(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_or_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_or_fetch(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_or_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_fetch_add(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_add_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_add(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_add_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_add(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_add_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_add(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_add_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_fetch_add(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_add_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_fetch_sub(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_sub_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_sub(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_sub_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_sub(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_sub_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_sub(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_sub_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_fetch_sub(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_sub_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_fetch_and(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_and_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_and(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_and_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_and(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_and_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_and(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_and_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_fetch_and(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_and_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_fetch_nand(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_nand_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_nand(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_nand_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_nand(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_nand_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_nand(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_nand_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_fetch_nand(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_nand_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_fetch_xor(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_xor_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_xor(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_xor_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_xor(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_xor_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_xor(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_xor_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_fetch_xor(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_xor_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { char ret; ret = __atomic_fetch_or(vp1, v1, __ATOMIC_SEQ_CST); } + { char ret; ret = __atomic_fetch_or_1(vp1, v1, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_or(vp2, v2, __ATOMIC_SEQ_CST); } + { short ret; ret = __atomic_fetch_or_2(vp2, v2, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_or(vp4, v4, __ATOMIC_SEQ_CST); } + { int ret; ret = __atomic_fetch_or_4(vp4, v4, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_or(vp8, v8, __ATOMIC_SEQ_CST); } + { long long int ret; ret = __atomic_fetch_or_8(vp8, v8, __ATOMIC_SEQ_CST); } + #if defined(__SIZEOF_INT128__) + { __int128 ret; ret = __atomic_fetch_or(vp16, v16, __ATOMIC_SEQ_CST); } + { __int128 ret; ret = __atomic_fetch_or_16(vp16, v16, __ATOMIC_SEQ_CST); } + #endif + + { _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vp4); } + { _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vp4); } + { __atomic_thread_fence(__ATOMIC_SEQ_CST); } + { __atomic_signal_fence(__ATOMIC_SEQ_CST); } +} + +int main() { + return 0; +} Index: src/tests/concurrent/coroutineYield.c =================================================================== --- src/tests/concurrent/coroutineYield.c (revision 96812c08a8de9308f7cd2aa6c43b95d71bf1bba1) +++ src/tests/concurrent/coroutineYield.c (revision 054514d366b6a7a6863d673a9c760baa03661f21) @@ -3,4 +3,13 @@ #include #include +#include