Changeset b3c7963


Ignore:
Timestamp:
Sep 12, 2017, 5:55:31 PM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
4639b0d
Parents:
a506df4 (diff), a46478a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Location:
src
Files:
6 added
1 deleted
32 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    ra506df4 rb3c7963  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Aug 18 15:34:00 2017
    13 // Update Count     : 488
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun Sep  3 20:42:52 2017
     13// Update Count     : 490
    1414//
    1515#include "CodeGenerator.h"
     
    5959
    6060        void CodeGenerator::asmName( DeclarationWithType * decl ) {
    61                 if ( ConstantExpr * asmName = decl->get_asmName() ) {
     61                if ( ConstantExpr * asmName = dynamic_cast<ConstantExpr *>(decl->get_asmName()) ) {
    6262                        output << " asm ( " << asmName->get_constant()->get_value() << " )";
    6363                } // if
  • src/CodeGen/Generate.cc

    ra506df4 rb3c7963  
    3333                /// Removes misc. nodes that should not exist in CodeGen
    3434                struct TreeCleaner {
    35                         void visit( CompoundStmt * stmt );
     35                        void previsit( CompoundStmt * stmt );
    3636
    3737                        static bool shouldClean( Declaration * );
     
    7272
    7373        namespace {
    74                 void TreeCleaner::visit( CompoundStmt * cstmt ) {
     74                void TreeCleaner::previsit( CompoundStmt * cstmt ) {
    7575                        filter( cstmt->kids, [](Statement * stmt) {
    7676                                if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
  • src/Parser/ExpressionNode.cc

    ra506df4 rb3c7963  
    77// ExpressionNode.cc --
    88//
    9 // Author           : Rodolfo G. Esteves
     9// Author           : Peter A. Buhr
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep  1 15:07:09 2017
    13 // Update Count     : 618
     12// Last Modified On : Tue Sep 12 10:00:29 2017
     13// Update Count     : 672
    1414//
    1515
     
    4949// type.
    5050
    51 extern const Type::Qualifiers noQualifiers;             // no qualifiers on constants
    52 
     51extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
     52
     53static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
     54static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
     55static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
    5356static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
    54 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
    5557static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
    5658static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
     
    6668} // sepNumeric
    6769
    68 Expression * build_constantInteger( std::string & str ) {
    69         static const BasicType::Kind kind[2][3] = {
    70                 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
    71                 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
     70Expression * build_constantInteger( string & str ) {
     71        static const BasicType::Kind kind[2][5] = {
     72                // short (h) must be before char (hh)
     73                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
     74                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
    7275        };
    7376
     
    7679
    7780        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
    78         int size;                                                                                       // 0 => int, 1 => long, 2 => long long
     81        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => size_t
    7982        unsigned long long int v;                                                       // converted integral value
    8083        size_t last = str.length() - 1;                                         // last character of constant
    8184        Expression * ret;
    8285
    83         // ROB: what do we do with units on 0 and 1?
    8486        // special constants
    8587        if ( str == "0" ) {
     
    107109
    108110        if ( v <= INT_MAX ) {                                                           // signed int
    109                 size = 0;
     111                size = 2;
    110112        } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
    111                 size = 0;
     113                size = 2;
    112114                Unsigned = true;                                                                // unsigned
    113115        } else if ( v <= LONG_MAX ) {                                           // signed long int
    114                 size = 1;
     116                size = 3;
    115117        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
    116                 size = 1;
     118                size = 3;
    117119                Unsigned = true;                                                                // unsigned long int
    118120        } else if ( v <= LLONG_MAX ) {                                          // signed long long int
    119                 size = 2;
     121                size = 4;
    120122        } else {                                                                                        // unsigned long long int
    121                 size = 2;
     123                size = 4;
    122124                Unsigned = true;                                                                // unsigned long long int
    123125        } // if
     126
     127        // At least one digit in integer constant, so safe to backup while looking for suffix.
    124128
    125129        if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
    126130                Unsigned = true;
    127                 if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'l' ?
    128                         size = 1;
    129                         if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?
    130                                 size = 2;
     131                if ( checkL( str[last - 1] ) ) {                                // suffix 'l' ?
     132                        size = 3;
     133                        if ( checkL( str[last - 2] ) ) {                        // suffix "ll" ?
     134                                size = 4;
    131135                        } // if
     136                } else if ( checkH( str[last - 1] ) ) {                 // suffix 'h' ?
     137                        size = 0;
     138                        if ( checkH( str[last - 2] ) ) {                        // suffix "hh" ?
     139                                size = 1;
     140                        } // if
     141                        str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
    132142                } // if
    133143        } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
    134                 size = 1;
    135                 if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'll' ?
    136                         size = 2;
    137                         if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?
     144                size = 3;
     145                if ( checkL( str[last - 1] ) ) {                                // suffix 'll' ?
     146                        size = 4;
     147                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
    138148                                Unsigned = true;
    139149                        } // if
    140                 } else {
    141                         if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?
     150                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
     151                        Unsigned = true;
     152                } // if
     153        } else if ( checkH( str[ last ] ) ) {                           // suffix 'h' ?
     154                size = 0;
     155                if ( checkH( str[last - 1] ) ) {                                // suffix "hh" ?
     156                        size = 1;
     157                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
    142158                                Unsigned = true;
    143159                        } // if
    144                 } // if
     160                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
     161                        Unsigned = true;
     162                } // if
     163                str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
     164        } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
     165                size = 5;
     166                str.erase( last, 1 );                                                   // remove 'z'
    145167        } // if
    146168
    147169        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
     170        if ( Unsigned && size < 2 ) {                                           // less than int ?
     171                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which eliminates warnings for large values.
     172                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
     173        } else if ( size == 5 ) {                                                       // explicit cast to size_t
     174                ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), "size_t", false ) );
     175        } // if
    148176  CLEANUP:
    149177        if ( units.length() != 0 ) {
    150                 ret = new UntypedExpr( new NameExpr( units, ret ) );
     178                ret = new UntypedExpr( new NameExpr( units ), { ret } );
    151179        } // if
    152180
     
    155183} // build_constantInteger
    156184
    157 Expression * build_constantFloat( std::string & str ) {
     185Expression * build_constantFloat( string & str ) {
    158186        static const BasicType::Kind kind[2][3] = {
    159187                { BasicType::Float, BasicType::Double, BasicType::LongDouble },
     
    190218        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
    191219        if ( units.length() != 0 ) {
    192                 ret = new UntypedExpr( new NameExpr( units, ret ) );
     220                ret = new UntypedExpr( new NameExpr( units ), { ret } );
    193221        } // if
    194222
     
    205233} // sepString
    206234
    207 Expression * build_constantChar( std::string & str ) {
     235Expression * build_constantChar( string & str ) {
    208236        string units;                                                                           // units
    209237        sepString( str, units, '\'' );                                          // separate constant from units
     
    211239        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
    212240        if ( units.length() != 0 ) {
    213                 ret = new UntypedExpr( new NameExpr( units, ret ) );
     241                ret = new UntypedExpr( new NameExpr( units ), { ret } );
    214242        } // if
    215243
     
    218246} // build_constantChar
    219247
    220 ConstantExpr * build_constantStr( std::string & str ) {
     248Expression * build_constantStr( string & str ) {
    221249        string units;                                                                           // units
    222250        sepString( str, units, '"' );                                           // separate constant from units
    223251
    224         ArrayType * at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
     252        BasicType::Kind strtype = BasicType::Char;                      // default string type
     253        switch ( str[0] ) {                                                                     // str has >= 2 characters, i.e, null string ""
     254          case 'u':
     255                if ( str[1] == '8' ) break;                                             // utf-8 characters
     256                strtype = BasicType::ShortUnsignedInt;
     257                break;
     258          case 'U':
     259                strtype = BasicType::UnsignedInt;
     260                break;
     261          case 'L':
     262                strtype = BasicType::SignedInt;
     263                break;
     264        } // switch
     265        ArrayType * at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), strtype ),
    225266                                                                        new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
    226267                                                                        false, false );
    227         ConstantExpr * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); // constant 0 is ignored for pure string value
    228 // ROB: type mismatch
    229         // if ( units.length() != 0 ) {
    230         //      ret = new UntypedExpr( new NameExpr( units, ret ) );
    231         // } // if
     268        Expression * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); // constant 0 is ignored for pure string value
     269        if ( units.length() != 0 ) {
     270                ret = new UntypedExpr( new NameExpr( units ), { ret } );
     271        } // if
    232272
    233273        delete &str;                                                                            // created by lex
     
    235275} // build_constantStr
    236276
    237 Expression * build_field_name_FLOATINGconstant( const std::string & str ) {
     277Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
     278        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
     279        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
     280        delete &str;
     281        return ret;
     282} // build_field_name_FLOATING_FRACTIONconstant
     283
     284Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
     285        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
     286        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
     287        delete &str;
     288        return ret;
     289} // build_field_name_FLOATING_DECIMALconstant
     290
     291Expression * build_field_name_FLOATINGconstant( const string & str ) {
    238292        // str is of the form A.B -> separate at the . and return member expression
    239293        int a, b;
    240294        char dot;
    241         std::stringstream ss( str );
     295        stringstream ss( str );
    242296        ss >> a >> dot >> b;
    243297        UntypedMemberExpr * ret = new UntypedMemberExpr( new ConstantExpr( Constant::from_int( b ) ), new ConstantExpr( Constant::from_int( a ) ) );
     
    253307                } else {
    254308                        return new UntypedMemberExpr( fracts, fieldName );
    255                 }
    256         }
     309                } // if
     310        } // if
    257311        return fieldName;
    258312} // make_field_name_fraction_constants
     
    261315        return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
    262316} // build_field_name_fraction_constants
    263 
    264 Expression * build_field_name_REALFRACTIONconstant( const std::string & str ) {
    265         if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
    266         Expression * ret = build_constantInteger( *new std::string( str.substr(1) ) );
    267         delete &str;
    268         return ret;
    269 } // build_field_name_REALFRACTIONconstant
    270 
    271 Expression * build_field_name_REALDECIMALconstant( const std::string & str ) {
    272         if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
    273         Expression * ret = build_constantInteger( *new std::string( str.substr( 0, str.size()-1 ) ) );
    274         delete &str;
    275         return ret;
    276 } // build_field_name_REALDECIMALconstant
    277317
    278318NameExpr * build_varref( const string * name ) {
     
    353393
    354394Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) {
    355         std::list< Expression * > args;
     395        list< Expression * > args;
    356396        args.push_back( maybeMoveBuild< Expression >(expr_node) );
    357397        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     
    359399
    360400Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
    361         std::list< Expression * > args;
     401        list< Expression * > args;
    362402        args.push_back(  maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code.
    363403        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     
    365405
    366406Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
    367         std::list< Expression * > args;
     407        list< Expression * > args;
    368408        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
    369409        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
     
    372412
    373413Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
    374         std::list< Expression * > args;
     414        list< Expression * > args;
    375415        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
    376416        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
     
    395435
    396436Expression * build_tuple( ExpressionNode * expr_node ) {
    397         std::list< Expression * > exprs;
     437        list< Expression * > exprs;
    398438        buildMoveList( expr_node, exprs );
    399439        return new UntypedTupleExpr( exprs );;
     
    401441
    402442Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
    403         std::list< Expression * > args;
     443        list< Expression * > args;
    404444        buildMoveList( expr_node, args );
    405445        return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
     
    410450} // build_range
    411451
    412 Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand ) {
     452Expression * build_asmexpr( ExpressionNode * inout, Expression * constraint, ExpressionNode * operand ) {
    413453        return new AsmExpr( maybeMoveBuild< Expression >( inout ), constraint, maybeMoveBuild< Expression >(operand) );
    414454} // build_asmexpr
  • src/Parser/ParseNode.h

    ra506df4 rb3c7963  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 31 17:42:49 2017
    13 // Update Count     : 797
     12// Last Modified On : Sun Sep 10 09:56:32 2017
     13// Update Count     : 801
    1414//
    1515
     
    165165Expression * build_constantFloat( std::string &str );
    166166Expression * build_constantChar( std::string &str );
    167 ConstantExpr * build_constantStr( std::string &str );
     167Expression * build_constantStr( std::string &str );
     168Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
     169Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
    168170Expression * build_field_name_FLOATINGconstant( const std::string & str );
    169171Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
    170 Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
    171 Expression * build_field_name_REALDECIMALconstant( const std::string & str );
    172172
    173173NameExpr * build_varref( const std::string * name );
     
    197197Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
    198198Expression * build_range( ExpressionNode * low, ExpressionNode * high );
    199 Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
     199Expression * build_asmexpr( ExpressionNode * inout, Expression * constraint, ExpressionNode * operand );
    200200Expression * build_valexpr( StatementNode * s );
    201201Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
     
    330330        bool hasEllipsis;
    331331        LinkageSpec::Spec linkage;
    332         ConstantExpr *asmName;
     332        Expression *asmName;
    333333        std::list< Attribute * > attributes;
    334334        InitializerNode * initializer;
     
    413413Statement * build_finally( StatementNode * stmt );
    414414Statement * build_compound( StatementNode * first );
    415 Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
     415Statement * build_asmstmt( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
    416416WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
    417417WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
  • src/Parser/StatementNode.cc

    ra506df4 rb3c7963  
    1010// Created On       : Sat May 16 14:59:41 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 17 16:01:31 2017
    13 // Update Count     : 345
     12// Last Modified On : Fri Sep  1 23:25:23 2017
     13// Update Count     : 346
    1414//
    1515
     
    300300}
    301301
    302 Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output, ExpressionNode *input, ExpressionNode *clobber, LabelNode *gotolabels ) {
     302Statement *build_asmstmt( bool voltile, Expression *instruction, ExpressionNode *output, ExpressionNode *input, ExpressionNode *clobber, LabelNode *gotolabels ) {
    303303        std::list< Expression * > out, in;
    304304        std::list< ConstantExpr * > clob;
  • src/Parser/TypeData.cc

    ra506df4 rb3c7963  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 15:12:51 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Aug 14 10:41:00 2017
    13 // Update Count     : 568
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Sep  1 23:13:38 2017
     13// Update Count     : 569
    1414//
    1515
     
    814814} // buildTypeof
    815815
    816 Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
     816Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
    817817        if ( td->kind == TypeData::Function ) {
    818818                if ( td->function.idList ) {                                    // KR function ?
  • src/Parser/TypeData.h

    ra506df4 rb3c7963  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 15:18:36 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Aug 14 10:38:00 2017
    13 // Update Count     : 189
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Sep  1 23:33:45 2017
     13// Update Count     : 190
    1414//
    1515
     
    118118TupleType * buildTuple( const TypeData * );
    119119TypeofType * buildTypeof( const TypeData * );
    120 Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
     120Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, Expression * asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
    121121FunctionType * buildFunction( const TypeData * );
    122122void buildKRFunction( const TypeData::Function_t & function );
  • src/Parser/lex.ll

    ra506df4 rb3c7963  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu Aug 31 21:30:10 2017
    13  * Update Count     : 598
     12 * Last Modified On : Sun Sep 10 22:29:15 2017
     13 * Update Count     : 620
    1414 */
    1515
     
    9393                                // numeric constants, CFA: '_' in constant
    9494hex_quad {hex}("_"?{hex}){3}
    95 integer_suffix_opt ("_"?(([uU](("ll"|"LL"|[lL])[iI]|[iI]?("ll"|"LL"|[lL])?))|([iI](("ll"|"LL"|[lL])[uU]|[uU]?("ll"|"LL"|[lL])?))|(("ll"|"LL"|[lL])([iI][uU]|[uU]?[iI]?))))?
     95length ("ll"|"LL"|[lL])|("hh"|"HH"|[hH])
     96integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?{user_suffix_opt}
    9697
    9798octal_digits ({octal})|({octal}({octal}|"_")*{octal})
    9899octal_prefix "0""_"?
    99 octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix_opt}{user_suffix_opt}
     100octal_constant (("0")|({octal_prefix}{octal_digits})){integer_suffix_opt}
    100101
    101102nonzero_digits ({nonzero})|({nonzero}({decimal}|"_")*{decimal})
    102 decimal_constant {nonzero_digits}{integer_suffix_opt}{user_suffix_opt}
     103decimal_constant {nonzero_digits}{integer_suffix_opt}
    103104
    104105hex_digits ({hex})|({hex}({hex}|"_")*{hex})
    105106hex_prefix "0"[xX]"_"?
    106 hex_constant {hex_prefix}{hex_digits}{integer_suffix_opt}{user_suffix_opt}
     107hex_constant {hex_prefix}{hex_digits}{integer_suffix_opt}
    107108
    108109                                // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
    109 floating_suffix_opt ("_"?([fFdDlL][iI]?|[iI][lLfFdD]?|"DL"))?
     110exponent "_"?[eE]"_"?[+-]?{decimal_digits}
     111floating_suffix ([fFdDlL]?[iI]?)|([iI][lLfFdD])
     112floating_suffix_opt ("_"?({floating_suffix}|"DL"))?{user_suffix_opt}
    110113decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
    111 real_decimal {decimal_digits}"."{exponent}?{floating_suffix_opt}{user_suffix_opt}
    112 real_fraction "."{decimal_digits}{exponent}?{floating_suffix_opt}{user_suffix_opt}
    113 real_constant {decimal_digits}{real_fraction}
    114 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
    115 floating_constant (({real_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix_opt}{user_suffix_opt}
     114floating_decimal {decimal_digits}"."{exponent}?{floating_suffix_opt}
     115floating_fraction "."{decimal_digits}{exponent}?{floating_suffix_opt}
     116floating_constant ({decimal_digits}{exponent}{floating_suffix_opt})|({decimal_digits}{floating_fraction})
    116117
    117118binary_exponent "_"?[pP]"_"?[+-]?{decimal_digits}
    118 hex_fractional_constant ({hex_digits}?"."{hex_digits})|({hex_digits}".")
    119 hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})|({hex_digits}{binary_exponent})){floating_suffix_opt}
     119hex_floating_suffix_opt ("_"?({floating_suffix}))?{user_suffix_opt}
     120hex_floating_fraction ({hex_digits}?"."{hex_digits})|({hex_digits}".")
     121hex_floating_constant {hex_prefix}(({hex_floating_fraction}{binary_exponent})|({hex_digits}{binary_exponent})){hex_floating_suffix_opt}
    120122
    121123                                // character escape sequence, GCC: \e => esc character
    122124simple_escape "\\"[abefnrtv'"?\\]
    123                                 // ' stop highlighting
     125                                // ' stop editor highlighting
    124126octal_escape "\\"{octal}("_"?{octal}){0,2}
    125127hex_escape "\\""x""_"?{hex_digits}
     
    154156                                /* line directives */
    155157^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["].*"\n" {
    156         /* " stop highlighting */
     158        /* " stop editor highlighting */
    157159        static char filename[FILENAME_MAX];                                     // temporarily store current source-file name
    158160        char *end_num;
     
    310312{octal_constant} { NUMERIC_RETURN(INTEGERconstant); }
    311313{hex_constant}  { NUMERIC_RETURN(INTEGERconstant); }
    312 {real_decimal}  { NUMERIC_RETURN(REALDECIMALconstant); } // must appear before floating_constant
    313 {real_fraction} { NUMERIC_RETURN(REALFRACTIONconstant); } // must appear before floating_constant
     314{floating_decimal}      { NUMERIC_RETURN(FLOATING_DECIMALconstant); } // must appear before floating_constant
     315{floating_fraction}     { NUMERIC_RETURN(FLOATING_FRACTIONconstant); } // must appear before floating_constant
    314316{floating_constant}     { NUMERIC_RETURN(FLOATINGconstant); }
    315317{hex_floating_constant} { NUMERIC_RETURN(FLOATINGconstant); }
     
    319321<QUOTE>[^'\\\n]* { strtext->append( yytext, yyleng ); }
    320322<QUOTE>['\n]{user_suffix_opt}   { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
    321                                 /* ' stop highlighting */
     323                                /* ' stop editor highlighting */
    322324
    323325                                /* string constant */
     
    325327<STRING>[^"\\\n]* { strtext->append( yytext, yyleng ); }
    326328<STRING>["\n]{user_suffix_opt}  { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
    327                                 /* " stop highlighting */
     329                                /* " stop editor highlighting */
    328330
    329331                                /* common character/string constant */
  • src/Parser/parser.yy

    ra506df4 rb3c7963  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 30 07:04:19 2017
    13 // Update Count     : 2740
     12// Last Modified On : Mon Sep 11 18:12:00 2017
     13// Update Count     : 2787
    1414//
    1515
     
    4343#define YYDEBUG_LEXER_TEXT (yylval)                                             // lexer loads this up each time
    4444#define YYDEBUG 1                                                                               // get the pretty debugging code to compile
     45#define YYERROR_VERBOSE
    4546
    4647#undef __GNUC_MINOR__
     
    6263stack< LinkageSpec::Spec > linkageStack;
    6364
    64 void appendStr( string *to, string *from ) {
    65         // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
    66         to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) );
     65bool appendStr( string & to, string & from ) {
     66        // 1. Multiple strings are concatenated into a single string but not combined internally. The reason is that
     67        //    "\x12" "3" is treated as 2 characters versus 1 because "escape sequences are converted into single members of
     68        //    the execution character set just prior to adjacent string literal concatenation" (C11, Section 6.4.5-8). It is
     69        //    easier to let the C compiler handle this case.
     70        //
     71        // 2. String encodings are transformed into canonical form (one encoding at start) so the encoding can be found
     72        //    without searching the string, e.g.: "abc" L"def" L"ghi" => L"abc" "def" "ghi". Multiple encodings must match,
     73        //    i.e., u"a" U"b" L"c" is disallowed.
     74
     75        if ( from[0] != '"' ) {                                                         // encoding ?
     76                if ( to[0] != '"' ) {                                                   // encoding ?
     77                        if ( to[0] != from[0] || to[1] != from[1] ) { // different encodings ?
     78                                yyerror( "non-matching string encodings for string-literal concatenation" );
     79                                return false;                                                   // parse error, must call YYERROR in action
     80                        } else if ( from[1] == '8' ) {
     81                                from.erase( 0, 1 );                                             // remove 2nd encoding
     82                        } // if
     83                } else {
     84                        if ( from[1] == '8' ) {                                         // move encoding to start
     85                                to = "u8" + to;
     86                                from.erase( 0, 1 );                                             // remove 2nd encoding
     87                        } else {
     88                                to = from[0] + to;
     89                        } // if
     90                } // if
     91                from.erase( 0, 1 );                                                             // remove 2nd encoding
     92        } // if
     93        to += " " + from;                                                                       // concatenated into single string
     94        return true;
    6795} // appendStr
    6896
     
    89117%}
    90118
     119%define parse.error verbose
     120
    91121// Types declaration
    92122%union
     
    100130        StatementNode * sn;
    101131        WaitForStmt * wfs;
    102         ConstantExpr * constant;
     132        Expression * constant;
    103133        IfCtl * ifctl;
    104134        ForCtl * fctl;
     
    146176// overloading constants 0/1, e.g., x.1 is lexed as (x)(.1), where (.1) is a factional constant, but is semantically
    147177// converted into the tuple index (.)(1). e.g., 3.x
    148 %token<tok>     REALDECIMALconstant     REALFRACTIONconstant    FLOATINGconstant
     178%token<tok>     FLOATING_DECIMALconstant        FLOATING_FRACTIONconstant       FLOATINGconstant
    149179
    150180// multi-character operators
     
    315345%precedence ELSE        // token precedence for start of else clause in IF/WAITFOR statement
    316346
     347
    317348%start translation_unit                                                                 // parse-tree root
    318349
     
    321352
    322353// The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal symbols
    323 // "identifier" and "TYPEDEFname" that are lexically identical.  While it is possible to write a purely context-free
    324 // grammar, such a grammar would obscure the relationship between syntactic and semantic constructs.  Hence, this
    325 // grammar uses the ANSI style.
     354// "identifier", "TYPEDEFname", and "TYPEGENname" that are lexically identical.  While it is possible to write a purely
     355// context-free grammar, such a grammar would obscure the relationship between syntactic and semantic constructs.
     356// Hence, this grammar uses the ANSI style.
    326357//
    327358// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, those
     
    360391                // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
    361392        INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
    362         | REALDECIMALconstant                                           { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
    363         | REALFRACTIONconstant                                          { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
     393        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
     394        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
    364395        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
    365396        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
     
    390421        | string_literal_list STRINGliteral
    391422                {
    392                         appendStr( $1, $2 );                                            // append 2nd juxtaposed string to 1st
     423                        if ( ! appendStr( *$1, *$2 ) ) YYERROR;         // append 2nd juxtaposed string to 1st
    393424                        delete $2;                                                                      // allocated by lexer
    394425                        $$ = $1;                                                                        // conversion from tok to str
     
    434465        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    435466                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
    436         | postfix_expression REALFRACTIONconstant                       // CFA, tuple index
    437                 { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_REALFRACTIONconstant( *$2 ) ) ); }
     467        | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
     468                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
    438469        | postfix_expression ARROW no_attr_identifier
    439470                {
     
    479510field:                                                                                                  // CFA, tuple field selector
    480511        field_name
    481         | REALDECIMALconstant field
    482                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
    483         | REALDECIMALconstant '[' push field_list pop ']'
    484                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
     512        | FLOATING_DECIMALconstant field
     513                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
     514        | FLOATING_DECIMALconstant '[' push field_list pop ']'
     515                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
    485516        | field_name '.' field
    486517                { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
     
    507538        // empty
    508539                { $$ = nullptr; }
    509         | fraction_constants REALFRACTIONconstant
    510                 {
    511                         Expression * constant = build_field_name_REALFRACTIONconstant( *$2 );
     540        | fraction_constants FLOATING_FRACTIONconstant
     541                {
     542                        Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
    512543                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
    513544                }
  • src/SynTree/BasicType.cc

    ra506df4 rb3c7963  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb  1 17:12:15 2017
    13 // Update Count     : 8
     12// Last Modified On : Mon Sep 11 12:52:05 2017
     13// Update Count     : 9
    1414//
    1515
     
    2525
    2626void BasicType::print( std::ostream &os, int indent ) const {
    27         static const char *kindNames[] = {     
    28                 "_Bool", "char", "signed char", "unsigned char", "short signed int", "short unsigned int",
    29                 "signed int", "unsigned int", "long signed int", "long unsigned int", "long long signed int",
    30                 "long long unsigned int", "float", "double", "long double", "float _Complex", "double _Complex",
    31                 "long double _Complex", "float _Imaginary", "double _Imaginary", "long double _Imaginary"
    32         };
    33 
    3427        Type::print( os, indent );
    35         os << kindNames[ kind ];
     28        os << BasicType::typeNames[ kind ];
    3629}
    3730
  • src/SynTree/Declaration.h

    ra506df4 rb3c7963  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Aug 14 10:15:00 2017
    13 // Update Count     : 128
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun Sep  3 19:24:06 2017
     13// Update Count     : 131
    1414//
    1515
     
    8282        int scopeLevel = 0;
    8383
    84         ConstantExpr *asmName;
     84        Expression *asmName;
    8585        std::list< Attribute * > attributes;
    8686
     
    9797        DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
    9898
    99         ConstantExpr *get_asmName() const { return asmName; }
    100         DeclarationWithType * set_asmName( ConstantExpr *newValue ) { asmName = newValue; return this; }
     99        Expression *get_asmName() const { return asmName; }
     100        DeclarationWithType * set_asmName( Expression *newValue ) { asmName = newValue; return this; }
    101101
    102102        std::list< Attribute * >& get_attributes() { return attributes; }
  • src/SynTree/Expression.h

    ra506df4 rb3c7963  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Aug  8 11:54:00 2017
    13 // Update Count     : 44
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun Sep  3 19:23:46 2017
     13// Update Count     : 48
    1414//
     15
    1516#pragma once
    1617
     
    539540  public:
    540541        Expression * inout;
    541         ConstantExpr * constraint;
     542        Expression * constraint;
    542543        Expression * operand;
    543544
    544         AsmExpr( Expression * inout, ConstantExpr * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
     545        AsmExpr( Expression * inout, Expression * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
    545546        AsmExpr( const AsmExpr & other );
    546547        virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
     
    549550        void set_inout( Expression * newValue ) { inout = newValue; }
    550551
    551         ConstantExpr * get_constraint() const { return constraint; }
    552         void set_constraint( ConstantExpr * newValue ) { constraint = newValue; }
     552        Expression * get_constraint() const { return constraint; }
     553        void set_constraint( Expression * newValue ) { constraint = newValue; }
    553554
    554555        Expression * get_operand() const { return operand; }
  • src/SynTree/Statement.cc

    ra506df4 rb3c7963  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 17 16:17:20 2017
    13 // Update Count     : 67
     12// Last Modified On : Sun Sep  3 20:46:44 2017
     13// Update Count     : 68
    1414//
    1515
     
    5252
    5353
    54 AsmStmt::AsmStmt( std::list<Label> labels, bool voltile, ConstantExpr *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement( labels ), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
     54AsmStmt::AsmStmt( std::list<Label> labels, bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement( labels ), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
    5555
    5656AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
  • src/SynTree/Statement.h

    ra506df4 rb3c7963  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 17 15:37:53 2017
    13 // Update Count     : 72
     12// Last Modified On : Sun Sep  3 20:46:46 2017
     13// Update Count     : 77
    1414//
    1515
     
    9898  public:
    9999        bool voltile;
    100         ConstantExpr *instruction;
     100        Expression *instruction;
    101101        std::list<Expression *> output, input;
    102102        std::list<ConstantExpr *> clobber;
    103103        std::list<Label> gotolabels;
    104104
    105         AsmStmt( std::list<Label> labels, bool voltile, ConstantExpr *instruction, std::list<Expression *> input, std::list<Expression *> output, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
     105        AsmStmt( std::list<Label> labels, bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
    106106        AsmStmt( const AsmStmt &other );
    107107        virtual ~AsmStmt();
     
    109109        bool get_voltile() { return voltile; }
    110110        void set_voltile( bool newValue ) { voltile = newValue; }
    111         ConstantExpr *get_instruction() { return instruction; }
    112         void set_instruction( ConstantExpr *newValue ) { instruction = newValue; }
    113         std::list<Expression *> &get_output() { return output; }
    114         void set_output( const std::list<Expression *> &newValue ) { output = newValue; }
    115         std::list<Expression *> &get_input() { return input; }
     111        Expression * get_instruction() { return instruction; }
     112        void set_instruction( Expression * newValue ) { instruction = newValue; }
     113        std::list<Expression *> & get_output() { return output; }
     114        void set_output( const std::list<Expression *> & newValue ) { output = newValue; }
     115        std::list<Expression *> & get_input() { return input; }
    116116        void set_input( const std::list<Expression *> &newValue ) { input = newValue; }
    117         std::list<ConstantExpr *> &get_clobber() { return clobber; }
     117        std::list<ConstantExpr *> & get_clobber() { return clobber; }
    118118        void set_clobber( const std::list<ConstantExpr *> &newValue ) { clobber = newValue; }
    119         std::list<Label> &get_gotolabels() { return gotolabels; }
     119        std::list<Label> & get_gotolabels() { return gotolabels; }
    120120        void set_gotolabels( const std::list<Label> &newValue ) { gotolabels = newValue; }
    121121
    122         virtual AsmStmt *clone() const { return new AsmStmt( *this ); }
    123         virtual void accept( Visitor &v ) { v.visit( this ); }
    124         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    125         virtual void print( std::ostream &os, int indent = 0 ) const;
     122        virtual AsmStmt * clone() const { return new AsmStmt( *this ); }
     123        virtual void accept( Visitor & v ) { v.visit( this ); }
     124        virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     125        virtual void print( std::ostream & os, int indent = 0 ) const;
    126126};
    127127
  • src/SynTree/Type.cc

    ra506df4 rb3c7963  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Aug  2 11:11:00 2017
    13 // Update Count     : 29
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Sep 11 13:21:25 2017
     13// Update Count     : 37
    1414//
    1515#include "Type.h"
     
    2626        "_Bool",
    2727        "char",
    28         "char",
     28        "signed char",
    2929        "unsigned char",
    30         "short",
    31         "short unsigned",
    32         "int",
     30        "signed short int",
     31        "unsigned short int",
     32        "signed int",
    3333        "unsigned int",
    34         "long int",
    35         "long unsigned int",
    36         "long long int",
    37         "long long unsigned int",
     34        "signed long int",
     35        "unsigned long int",
     36        "signed long long int",
     37        "unsigned long long int",
    3838        "float",
    3939        "double",
     
    6565
    6666Type * Type::stripDeclarator() {
    67         Type * type = this;
    68         while ( Type * at = InitTweak::getPointerBase( type ) ) {
    69                 type = at;
    70         }
     67        Type * type, * at;
     68        for ( type = this; (at = InitTweak::getPointerBase( type )); type = at );
    7169        return type;
    7270}
    7371
    7472Type * Type::stripReferences() {
    75         Type * type = this;
    76         while ( ReferenceType * ref = dynamic_cast<ReferenceType *>( type ) ) {
    77                 type = ref->get_base();
    78         }
     73        Type * type;
     74        ReferenceType * ref;
     75        for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->get_base() );
    7976        return type;
    8077}
  • src/benchmark/Makefile.am

    ra506df4 rb3c7963  
    3131
    3232ctxswitch-coroutine$(EXEEXT):
    33         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 CorCtxSwitch.c
    34         @for number in 1 2 3 4 5 6 7 8 9 10; do \
    35                 ./a.out ; \
     33        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 CorCtxSwitch.c
     34        @rm -f .result.log
     35        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
     36                ./a.out | tee -a .result.log ; \
    3637        done
    37         @rm -f ./a.out
     38        @./stat.py .result.log
     39        @rm -f a.out .result.log
    3840
    3941ctxswitch-thread$(EXEEXT):
    40         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 ThrdCtxSwitch.c
    41         @for number in 1 2 3 4 5 6 7 8 9 10; do \
    42                 ./a.out ; \
     42        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 ThrdCtxSwitch.c
     43        @rm -f .result.log
     44        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
     45                ./a.out | tee -a .result.log ; \
    4346        done
    44         @rm -f ./a.out
     47        @./stat.py .result.log
     48        @rm -f a.out .result.log
    4549
    4650sched-int$(EXEEXT):
    47         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 SchedInt.c
    48         @for number in 1 2 3 4 5 6 7 8 9 10; do \
    49                 ./a.out ; \
     51        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 SchedInt.c
     52        @rm -f .result.log
     53        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
     54                ./a.out | tee -a .result.log ; \
    5055        done
    51         @rm -f ./a.out
     56        @./stat.py .result.log
     57        @rm -f a.out .result.log
    5258
    5359monitor$(EXEEXT):
    54         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 Monitor.c
    55         @for number in 1 2 3 4 5 6 7 8 9 10; do \
    56                 ./a.out ; \
     60        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 Monitor.c
     61        @rm -f .result.log
     62        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
     63                ./a.out | tee -a .result.log ; \
    5764        done
    58         @rm -f ./a.out
     65        @./stat.py .result.log
     66        @rm -f a.out .result.log
    5967
    6068csv-data$(EXEEXT):
    61         @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=10000000 csv-data.c
     69        @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=50000000 csv-data.c
    6270        @./a.out
    6371        @rm -f ./a.out
  • src/benchmark/Makefile.in

    ra506df4 rb3c7963  
    581581
    582582ctxswitch-coroutine$(EXEEXT):
    583         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 CorCtxSwitch.c
    584         @for number in 1 2 3 4 5 6 7 8 9 10; do \
    585                 ./a.out ; \
     583        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 CorCtxSwitch.c
     584        @rm -f .result.log
     585        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
     586                ./a.out | tee -a .result.log ; \
    586587        done
    587         @rm -f ./a.out
     588        @./stat.py .result.log
     589        @rm -f a.out .result.log
    588590
    589591ctxswitch-thread$(EXEEXT):
    590         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 ThrdCtxSwitch.c
    591         @for number in 1 2 3 4 5 6 7 8 9 10; do \
    592                 ./a.out ; \
     592        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 ThrdCtxSwitch.c
     593        @rm -f .result.log
     594        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
     595                ./a.out | tee -a .result.log ; \
    593596        done
    594         @rm -f ./a.out
     597        @./stat.py .result.log
     598        @rm -f a.out .result.log
    595599
    596600sched-int$(EXEEXT):
    597         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 SchedInt.c
    598         @for number in 1 2 3 4 5 6 7 8 9 10; do \
    599                 ./a.out ; \
     601        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 SchedInt.c
     602        @rm -f .result.log
     603        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
     604                ./a.out | tee -a .result.log ; \
    600605        done
    601         @rm -f ./a.out
     606        @./stat.py .result.log
     607        @rm -f a.out .result.log
    602608
    603609monitor$(EXEEXT):
    604         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=10000000 Monitor.c
    605         @for number in 1 2 3 4 5 6 7 8 9 10; do \
    606                 ./a.out ; \
     610        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 Monitor.c
     611        @rm -f .result.log
     612        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
     613                ./a.out | tee -a .result.log ; \
    607614        done
    608         @rm -f ./a.out
     615        @./stat.py .result.log
     616        @rm -f a.out .result.log
    609617
    610618csv-data$(EXEEXT):
    611         @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=10000000 csv-data.c
     619        @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=50000000 csv-data.c
    612620        @./a.out
    613621        @rm -f ./a.out
  • src/libcfa/gmp

    ra506df4 rb3c7963  
    1010// Created On       : Tue Apr 19 08:43:43 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 24 09:24:51 2017
    13 // Update Count     : 16
     12// Last Modified On : Mon Sep  4 09:54:33 2017
     13// Update Count     : 20
    1414//
    1515
     
    3232static inline void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
    3333static inline void ^?{}( Int & this ) { mpz_clear( this.mpz ); }
     34
     35// literal
     36static inline Int ?`mp( signed long int init ) { return (Int){ init }; }
     37static inline Int ?`mp( unsigned long int init ) { return (Int){ init }; }
     38static inline Int ?`mp( const char * init ) { return (Int){ init }; }
    3439
    3540// assignment
  • src/libcfa/iostream

    ra506df4 rb3c7963  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 24 08:14:29 2017
    13 // Update Count     : 133
     12// Last Modified On : Mon Sep 11 09:17:07 2017
     13// Update Count     : 137
    1414//
    1515
    1616#pragma once
    1717
     18#include <uchar.h>
     19#include <wchar.h>
    1820#include "iterator"
    1921
     
    7880
    7981forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char * );
     82forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char16_t * );
     83forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char32_t * );
     84forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const wchar_t * );
    8085forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );
    8186
     
    118123
    119124forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char & );
     125forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, signed char & );
     126forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned char & );
    120127
    121128forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, short int & );
  • src/libcfa/iostream.c

    ra506df4 rb3c7963  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 24 08:41:53 2017
    13 // Update Count     : 405
     12// Last Modified On : Mon Sep 11 09:21:24 2017
     13// Update Count     : 420
    1414//
    1515
     
    145145
    146146forall( dtype ostype | ostream( ostype ) )
    147 ostype * ?|?( ostype * os, const char * cp ) {
     147ostype * ?|?( ostype * os, const char * str ) {
    148148        enum { Open = 1, Close, OpenClose };
    149149        static const unsigned char mask[256] @= {
     
    161161        }; // mask
    162162
    163   if ( cp[0] == '\0' ) { sepOff( os ); return os; }             // null string => no separator
     163  if ( str[0] == '\0' ) { sepOff( os ); return os; }            // null string => no separator
    164164
    165165        // first character IS NOT spacing or closing punctuation => add left separator
    166         unsigned char ch = cp[0];                                                       // must make unsigned
     166        unsigned char ch = str[0];                                                      // must make unsigned
    167167        if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
    168168                fmt( os, "%s", sepGetCur( os ) );
     
    173173
    174174        // last character IS spacing or opening punctuation => turn off separator for next item
    175         size_t len = strlen( cp );
    176         ch = cp[len - 1];                                                                       // must make unsigned
     175        size_t len = strlen( str );
     176        ch = str[len - 1];                                                                      // must make unsigned
    177177        if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
    178178                sepOn( os );
     
    181181        } // if
    182182        if ( ch == '\n' ) setNL( os, true );                            // check *AFTER* sepPrt call above as it resets NL flag
    183         return write( os, cp, len );
     183        return write( os, str, len );
     184} // ?|?
     185
     186forall( dtype ostype | ostream( ostype ) )
     187ostype * ?|?( ostype * os, const char16_t * str ) {
     188        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     189        fmt( os, "%ls", str );
     190        return os;
     191} // ?|?
     192
     193forall( dtype ostype | ostream( ostype ) )
     194ostype * ?|?( ostype * os, const char32_t * str ) {
     195        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     196        fmt( os, "%ls", str );
     197        return os;
     198} // ?|?
     199
     200forall( dtype ostype | ostream( ostype ) )
     201ostype * ?|?( ostype * os, const wchar_t * str ) {
     202        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     203        fmt( os, "%ls", str );
     204        return os;
    184205} // ?|?
    185206
     
    277298
    278299forall( dtype istype | istream( istype ) )
     300istype * ?|?( istype * is, signed char & sc ) {
     301        fmt( is, "%hhd", &sc );
     302        return is;
     303} // ?|?
     304
     305forall( dtype istype | istream( istype ) )
     306istype * ?|?( istype * is, unsigned char & usc ) {
     307        fmt( is, "%hhu", &usc );
     308        return is;
     309} // ?|?
     310
     311forall( dtype istype | istream( istype ) )
    279312istype * ?|?( istype * is, short int & si ) {
    280313        fmt( is, "%hd", &si );
  • src/tests/.expect/64/KRfunctions.txt

    ra506df4 rb3c7963  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 int __f0__Fi_iPCii__1(int __a__i_1, const int *__b__PCi_1, int __c__i_1){
    8     __attribute__ ((unused)) int ___retval_f0__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){
     8    __attribute__ ((unused)) signed int ___retval_f0__i_1;
    99}
    10 int __f1__Fi_PiiPi__1(int *__a__Pi_1, __attribute__ ((unused)) int __b__i_1, int *__c__Pi_1){
    11     __attribute__ ((unused)) int ___retval_f1__i_1;
     10signed int __f1__Fi_PiiPi__1(signed int *__a__Pi_1, __attribute__ ((unused)) signed int __b__i_1, signed int *__c__Pi_1){
     11    __attribute__ ((unused)) signed int ___retval_f1__i_1;
    1212}
    13 int __f2__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    14     __attribute__ ((unused)) int ___retval_f2__i_1;
     13signed int __f2__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     14    __attribute__ ((unused)) signed int ___retval_f2__i_1;
    1515}
    1616struct S {
    17     int __i__i_1;
     17    signed int __i__i_1;
    1818};
    1919static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
     
    3636    return ((struct S )___ret__2sS_1);
    3737}
    38 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __i__i_1){
     38static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
    3939    ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
    4040}
    41 int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){
    42     __attribute__ ((unused)) int ___retval_f3__i_1;
     41signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
     42    __attribute__ ((unused)) signed int ___retval_f3__i_1;
    4343    struct S __s__2sS_2;
    4444}
    45 int __f4__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    46     __attribute__ ((unused)) int ___retval_f4__i_1;
     45signed int __f4__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     46    __attribute__ ((unused)) signed int ___retval_f4__i_1;
    4747}
    48 int __f5__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    49     __attribute__ ((unused)) int ___retval_f5__i_1;
     48signed int __f5__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     49    __attribute__ ((unused)) signed int ___retval_f5__i_1;
    5050}
    51 int (*__f6__FPFi_i__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __anonymous_object0){
    52     __attribute__ ((unused)) int (*___retval_f6__PFi_i__1)(int __anonymous_object1);
     51signed int (*__f6__FPFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
     52    __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1);
    5353}
    54 int (*__f7__FPFi_ii__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __a__i_1, int __b__i_1){
    55     __attribute__ ((unused)) int (*___retval_f7__PFi_ii__1)(int __a__i_1, int __b__i_1);
     54signed int (*__f7__FPFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
     55    __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1);
    5656}
    57 int *__f8__FPi_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1){
    58     __attribute__ ((unused)) int *___retval_f8__Pi_1;
     57signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     58    __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
    5959}
    60 int *const __f9__FCPi_PiiPi__1(int *__a__Pi_1, int __b__i_1, int *__c__Pi_1){
    61     __attribute__ ((unused)) int *const ___retval_f9__CPi_1;
     60signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
     61    __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
    6262}
    63 int *(*__f10__FPFPi_ii__iPiPid__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1, double __y__d_1))(int __x__i_1, int __y__i_1){
    64     __attribute__ ((unused)) int *(*___retval_f10__PFPi_ii__1)(int __x__i_1, int __y__i_1);
    65     int *__x__FPi_ii__2(int __anonymous_object2, int __anonymous_object3);
     63signed int *(*__f10__FPFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
     64    __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
     65    signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    6666    ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
    67     return ((int *(*)(int __x__i_1, int __y__i_1))___retval_f10__PFPi_ii__1);
     67    return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
    6868}
    69 int (*__f11__FPA0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[]{
    70     __attribute__ ((unused)) int (*___retval_f11__PA0i_1)[];
     69signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
     70    __attribute__ ((unused)) signed int (*___retval_f11__PA0i_1)[];
    7171}
    72 int (*__f12__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
    73     __attribute__ ((unused)) int (*___retval_f12__PA0A0i_1)[][((long unsigned int )10)];
     72signed int (*__f12__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
     73    __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned long int )10)];
    7474}
    75 int (*__f13__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
    76     __attribute__ ((unused)) int (*___retval_f13__PA0A0i_1)[][((long unsigned int )10)];
     75signed int (*__f13__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
     76    __attribute__ ((unused)) signed int (*___retval_f13__PA0A0i_1)[][((unsigned long int )10)];
    7777}
    78 int (*__f14__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))[][((long unsigned int )10)]{
    79     __attribute__ ((unused)) int (*___retval_f14__PA0A0i_1)[][((long unsigned int )10)];
     78signed int (*__f14__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
     79    __attribute__ ((unused)) signed int (*___retval_f14__PA0A0i_1)[][((unsigned long int )10)];
    8080}
    81 int __f15__Fi_iii__1(int __a__i_1, int __b__i_1, int __c__i_1){
    82     __attribute__ ((unused)) int ___retval_f15__i_1;
     81signed int __f15__Fi_iii__1(signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
     82    __attribute__ ((unused)) signed int ___retval_f15__i_1;
    8383}
    84 const int __fred__FCi___1(){
    85     __attribute__ ((unused)) const int ___retval_fred__Ci_1;
    86     int *(*__x__PFPi_ii__2)(int __anonymous_object4, int __anonymous_object5);
    87     int __a__i_2;
    88     int __b__i_2;
    89     int *(*_tmp_cp_ret0)(int __x__i_1, int __y__i_1);
     84const signed int __fred__FCi___1(){
     85    __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
     86    signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
     87    signed int __a__i_2;
     88    signed int __b__i_2;
     89    signed int *(*_tmp_cp_ret0)(signed int __x__i_1, signed int __y__i_1);
    9090    ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret0)));
    9191    ((void)(_tmp_cp_ret0) /* ^?{} */);
    92     const int __f1__FCi_iPiPi__2(int __a__i_2, int *__b__Pi_2, int *__c__Pi_2){
    93         __attribute__ ((unused)) const int ___retval_f1__Ci_2;
     92    const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
     93        __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
    9494    }
    95     const int __f2__FCi_iii__2(int __a__i_2, int __b__i_2, int __c__i_2){
    96         __attribute__ ((unused)) const int ___retval_f2__Ci_2;
     95    const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     96        __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
    9797    }
    9898}
  • src/tests/.expect/64/attributes.txt

    ra506df4 rb3c7963  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 int __la__Fi___1(){
    8     __attribute__ ((unused)) int ___retval_la__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7signed int __la__Fi___1(){
     8    __attribute__ ((unused)) signed int ___retval_la__i_1;
    99    L: __attribute__ ((unused)) ((void)1);
    1010}
     
    5454__attribute__ ((unused)) struct __anonymous3;
    5555struct Fdl {
    56     __attribute__ ((unused)) int __f1__i_1;
    57     __attribute__ ((unused)) int __f2__i_1;
    58     __attribute__ ((unused,unused)) int __f3__i_1;
    59     __attribute__ ((unused)) int __f4__i_1;
    60     __attribute__ ((unused,unused)) int __f5__i_1;
    61     __attribute__ ((used,packed)) int __f6__i_1;
    62     __attribute__ ((used,unused,unused)) int __f7__i_1;
    63     __attribute__ ((used,used,unused)) int __f8__i_1;
    64     __attribute__ ((unused)) int __anonymous_object0;
    65     __attribute__ ((unused,unused)) int *__f9__Pi_1;
     56    __attribute__ ((unused)) signed int __f1__i_1;
     57    __attribute__ ((unused)) signed int __f2__i_1;
     58    __attribute__ ((unused,unused)) signed int __f3__i_1;
     59    __attribute__ ((unused)) signed int __f4__i_1;
     60    __attribute__ ((unused,unused)) signed int __f5__i_1;
     61    __attribute__ ((used,packed)) signed int __f6__i_1;
     62    __attribute__ ((used,unused,unused)) signed int __f7__i_1;
     63    __attribute__ ((used,used,unused)) signed int __f8__i_1;
     64    __attribute__ ((unused)) signed int __anonymous_object0;
     65    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
    6666};
    6767static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
     
    116116    return ((struct Fdl )___ret__4sFdl_1);
    117117}
    118 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1){
     118static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
    119119    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    120120    ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
     
    127127    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    128128}
    129 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1){
     129static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1){
    130130    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    131131    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    138138    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    139139}
    140 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1){
     140static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1){
    141141    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    142142    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    149149    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    150150}
    151 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1){
    152     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    153     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    154     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    155     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    156     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    157     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    158     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    159     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    160     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    161 }
    162 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1){
    163     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    164     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    165     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    166     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    167     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    168     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    169     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    170     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    171     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    172 }
    173 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1){
     151static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1){
     152    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     153    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     154    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     155    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     156    ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     157    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
     158    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     159    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
     160    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
     161}
     162static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1){
     163    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     164    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     165    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     166    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     167    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     168    ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
     169    ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     170    ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
     171    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
     172}
     173static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1){
    174174    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    175175    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    182182    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    183183}
    184 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1){
     184static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1){
    185185    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    186186    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    193193    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    194194}
    195 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1){
     195static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1){
    196196    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    197197    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    204204    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    205205}
    206 static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1, int *__f9__Pi_1){
     206static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int *__f9__Pi_1){
    207207    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    208208    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     
    215215    ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
    216216}
    217 __attribute__ ((unused)) int __f__Fi___1() asm ( "xyz" );
    218 __attribute__ ((used,used)) const int __vd1__Ci_1;
    219 __attribute__ ((used,unused)) const int __vd2__Ci_1;
    220 __attribute__ ((used,used,used,used)) const int *__vd3__PCi_1;
    221 __attribute__ ((used,used,unused,used,unused)) const int *__vd4__PCi_1;
    222 __attribute__ ((used,used,used)) const int __vd5__A0Ci_1[((long unsigned int )5)];
    223 __attribute__ ((used,used,unused,used)) const int __vd6__A0Ci_1[((long unsigned int )5)];
    224 __attribute__ ((used,used,used,used)) const int (*__vd7__PFCi___1)();
    225 __attribute__ ((used,used,unused,used,used)) const int (*__vd8__PFCi___1)();
    226 __attribute__ ((unused,used)) int __f1__Fi___1();
    227 __attribute__ ((unused)) int __f1__Fi___1(){
    228     __attribute__ ((unused)) int ___retval_f1__i_1;
    229 }
    230 __attribute__ ((unused,unused,unused,used)) int **const __f2__FCPPi___1();
    231 __attribute__ ((unused,unused,unused)) int **const __f2__FCPPi___1(){
    232     __attribute__ ((unused)) int **const ___retval_f2__CPPi_1;
    233 }
    234 __attribute__ ((unused,used,unused)) int (*__f3__FPA0i_i__1(int __anonymous_object1))[];
    235 __attribute__ ((unused,unused)) int (*__f3__FPA0i_i__1(int __p__i_1))[]{
    236     __attribute__ ((unused)) int (*___retval_f3__PA0i_1)[];
    237 }
    238 __attribute__ ((unused,used,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object2);
    239 __attribute__ ((unused,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object3){
    240     __attribute__ ((unused)) int (*___retval_f4__PFi_i__1)(int __anonymous_object4);
    241 }
    242 int __vtr__Fi___1(){
    243     __attribute__ ((unused)) int ___retval_vtr__i_1;
    244     __attribute__ ((unused,unused,used)) int __t1__i_2;
    245     __attribute__ ((unused,unused,unused,unused,unused)) int **__t2__PPi_2;
    246     __attribute__ ((unused,unused,unused)) int __t3__A0i_2[((long unsigned int )5)];
    247     __attribute__ ((unused,unused,unused,unused,unused)) int **__t4__A0PPi_2[((long unsigned int )5)];
    248     __attribute__ ((unused,unused,unused)) int __t5__Fi___2();
    249     __attribute__ ((unused,unused,unused,unused)) int *__t6__FPi___2();
    250 }
    251 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1);
    252 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused)) int __q__i_1){
    253     __attribute__ ((unused)) int ___retval_ipd1__i_1;
    254 }
    255 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
    256 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
    257     __attribute__ ((unused)) int ___retval_ipd2__i_1;
    258 }
    259 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1);
    260 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused)) int *__q__Pi_1){
    261     __attribute__ ((unused)) int ___retval_ipd3__i_1;
    262 }
    263 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)());
    264 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) int (*__q__PFi___1)()){
    265     __attribute__ ((unused)) int ___retval_ipd4__i_1;
    266 }
    267 int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) int __Foo__i_1);
    268 int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) int **__Foo__PPi_1);
    269 int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) int *__Foo__Pi_1);
    270 int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) int (*__anonymous_object5)(__attribute__ ((unused,unused)) int __anonymous_object6[((long unsigned int )5)]));
    271 int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
    272 int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) int (*__Foo__PFi___1)());
    273 int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) int (*__anonymous_object7)(__attribute__ ((unused)) int (*__anonymous_object8)(__attribute__ ((unused,unused)) int __anonymous_object9)));
    274 int __ad__Fi___1(){
    275     __attribute__ ((unused)) int ___retval_ad__i_1;
    276     __attribute__ ((used,unused)) int __ad1__i_2;
    277     __attribute__ ((unused,unused,unused)) int *__ad2__Pi_2;
    278     __attribute__ ((unused,unused,unused)) int __ad3__A0i_2[((long unsigned int )5)];
    279     __attribute__ ((unused,unused,unused,unused,unused)) int (*__ad4__PA0i_2)[((long unsigned int )10)];
    280     __attribute__ ((unused,unused,unused,unused,used)) int __ad5__i_2;
    281     __attribute__ ((unused,unused,unused,unused,unused)) int __ad6__Fi___2();
    282     ((void)sizeof(__attribute__ ((unused,unused)) int ));
    283     ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) int **));
    284     ((void)sizeof(__attribute__ ((unused,unused,unused)) int [5]));
    285     ((void)sizeof(__attribute__ ((unused,unused,unused)) int (*)[10]));
    286     ((void)sizeof(__attribute__ ((unused,unused,unused)) int ()));
     217__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
     218__attribute__ ((used,used)) const signed int __vd1__Ci_1;
     219__attribute__ ((used,unused)) const signed int __vd2__Ci_1;
     220__attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1;
     221__attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1;
     222__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned long int )5)];
     223__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned long int )5)];
     224__attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)();
     225__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)();
     226__attribute__ ((unused,used)) signed int __f1__Fi___1();
     227__attribute__ ((unused)) signed int __f1__Fi___1(){
     228    __attribute__ ((unused)) signed int ___retval_f1__i_1;
     229}
     230__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1();
     231__attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){
     232    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
     233}
     234__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[];
     235__attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     236    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
     237}
     238__attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2);
     239__attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){
     240    __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4);
     241}
     242signed int __vtr__Fi___1(){
     243    __attribute__ ((unused)) signed int ___retval_vtr__i_1;
     244    __attribute__ ((unused,unused,used)) signed int __t1__i_2;
     245    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2;
     246    __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned long int )5)];
     247    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned long int )5)];
     248    __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2();
     249    __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2();
     250}
     251signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1);
     252signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){
     253    __attribute__ ((unused)) signed int ___retval_ipd1__i_1;
     254}
     255signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     256signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     257    __attribute__ ((unused)) signed int ___retval_ipd2__i_1;
     258}
     259signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     260signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     261    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
     262}
     263signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)());
     264signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){
     265    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
     266}
     267signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1);
     268signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
     269signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
     270signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned long int )5)]));
     271signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
     272signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
     273signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object7)(__attribute__ ((unused)) signed int (*__anonymous_object8)(__attribute__ ((unused,unused)) signed int __anonymous_object9)));
     274signed int __ad__Fi___1(){
     275    __attribute__ ((unused)) signed int ___retval_ad__i_1;
     276    __attribute__ ((used,unused)) signed int __ad1__i_2;
     277    __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2;
     278    __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned long int )5)];
     279    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned long int )10)];
     280    __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2;
     281    __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2();
     282    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
     283    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
     284    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [5]));
     285    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10]));
     286    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    287287    __attribute__ ((unused)) struct __anonymous4 {
    288         int __i__i_2;
     288        signed int __i__i_2;
    289289    };
    290290    inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
     
    303303        return ((struct __anonymous4 )___ret__13s__anonymous4_2);
    304304    }
    305     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, int __i__i_2){
     305    inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
    306306        ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
    307307    }
     
    324324    ((void)sizeof(enum __anonymous5 ));
    325325}
    326 int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object10, __attribute__ ((unused,unused,unused)) int *__anonymous_object11);
    327 int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) int **__anonymous_object13);
    328 int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object14, __attribute__ ((unused,unused,unused)) int *__anonymous_object15);
    329 int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object17)());
    330 int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object18)(__attribute__ ((unused)) int __anonymous_object19), __attribute__ ((unused,unused,unused)) int (*__anonymous_object20)(__attribute__ ((unused)) int __anonymous_object21));
    331 int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) int (*__anonymous_object23)());
    332 int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object24)(__attribute__ ((unused)) int __anonymous_object25), __attribute__ ((unused,unused,unused)) int (*__anonymous_object26)(__attribute__ ((unused)) int __anonymous_object27));
     326signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11);
     327signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13);
     328signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
     329signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)());
     330signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object18)(__attribute__ ((unused)) signed int __anonymous_object19), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(__attribute__ ((unused)) signed int __anonymous_object21));
     331signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)());
     332signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(__attribute__ ((unused)) signed int __anonymous_object27));
    333333struct Vad {
    334     __attribute__ ((unused)) int __anonymous_object28;
    335     __attribute__ ((unused,unused)) int *__anonymous_object29;
    336     __attribute__ ((unused,unused)) int __anonymous_object30[((long unsigned int )10)];
    337     __attribute__ ((unused,unused)) int (*__anonymous_object31)();
     334    __attribute__ ((unused)) signed int __anonymous_object28;
     335    __attribute__ ((unused,unused)) signed int *__anonymous_object29;
     336    __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned long int )10)];
     337    __attribute__ ((unused,unused)) signed int (*__anonymous_object31)();
    338338};
    339339static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
  • src/tests/.expect/64/declarationSpecifier.txt

    ra506df4 rb3c7963  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 volatile const short __x1__CVs_1;
    8 static volatile const short __x2__CVs_1;
    9 static volatile const short __x3__CVs_1;
    10 static volatile const short __x4__CVs_1;
    11 static volatile const short __x5__CVs_1;
    12 static volatile const short __x6__CVs_1;
    13 static volatile const short __x7__CVs_1;
    14 static volatile const short __x8__CVs_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7volatile const signed short int __x1__CVs_1;
     8static volatile const signed short int __x2__CVs_1;
     9static volatile const signed short int __x3__CVs_1;
     10static volatile const signed short int __x4__CVs_1;
     11static volatile const signed short int __x5__CVs_1;
     12static volatile const signed short int __x6__CVs_1;
     13static volatile const signed short int __x7__CVs_1;
     14static volatile const signed short int __x8__CVs_1;
    1515struct __anonymous0 {
    16     int __i__i_1;
     16    signed int __i__i_1;
    1717};
    1818static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
     
    3535    return ((struct __anonymous0 )___ret__13s__anonymous0_1);
    3636}
    37 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, int __i__i_1){
     37static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
    3838    ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
    3939}
    4040volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
    4141struct __anonymous1 {
    42     int __i__i_1;
     42    signed int __i__i_1;
    4343};
    4444static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
     
    6161    return ((struct __anonymous1 )___ret__13s__anonymous1_1);
    6262}
    63 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, int __i__i_1){
     63static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
    6464    ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
    6565}
    6666volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
    6767struct __anonymous2 {
    68     int __i__i_1;
     68    signed int __i__i_1;
    6969};
    7070static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
     
    8787    return ((struct __anonymous2 )___ret__13s__anonymous2_1);
    8888}
    89 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, int __i__i_1){
     89static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
    9090    ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
    9191}
    9292volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
    9393struct __anonymous3 {
    94     int __i__i_1;
     94    signed int __i__i_1;
    9595};
    9696static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
     
    113113    return ((struct __anonymous3 )___ret__13s__anonymous3_1);
    114114}
    115 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, int __i__i_1){
     115static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
    116116    ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
    117117}
    118118static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
    119119struct __anonymous4 {
    120     int __i__i_1;
     120    signed int __i__i_1;
    121121};
    122122static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
     
    139139    return ((struct __anonymous4 )___ret__13s__anonymous4_1);
    140140}
    141 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, int __i__i_1){
     141static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
    142142    ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
    143143}
    144144static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
    145145struct __anonymous5 {
    146     int __i__i_1;
     146    signed int __i__i_1;
    147147};
    148148static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
     
    165165    return ((struct __anonymous5 )___ret__13s__anonymous5_1);
    166166}
    167 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, int __i__i_1){
     167static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
    168168    ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
    169169}
    170170static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
    171171struct __anonymous6 {
    172     int __i__i_1;
     172    signed int __i__i_1;
    173173};
    174174static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
     
    191191    return ((struct __anonymous6 )___ret__13s__anonymous6_1);
    192192}
    193 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, int __i__i_1){
     193static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
    194194    ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
    195195}
    196196static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
    197197struct __anonymous7 {
    198     int __i__i_1;
     198    signed int __i__i_1;
    199199};
    200200static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
     
    217217    return ((struct __anonymous7 )___ret__13s__anonymous7_1);
    218218}
    219 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, int __i__i_1){
     219static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
    220220    ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
    221221}
    222222static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
    223 volatile const short __x20__CVs_1;
    224 static volatile const short __x21__CVs_1;
    225 static volatile const short __x22__CVs_1;
    226 static volatile const short __x23__CVs_1;
    227 static volatile const short __x24__CVs_1;
    228 static volatile const short __x25__CVs_1;
    229 static volatile const short __x26__CVs_1;
    230 static volatile const short __x27__CVs_1;
     223volatile const signed short int __x20__CVs_1;
     224static volatile const signed short int __x21__CVs_1;
     225static volatile const signed short int __x22__CVs_1;
     226static volatile const signed short int __x23__CVs_1;
     227static volatile const signed short int __x24__CVs_1;
     228static volatile const signed short int __x25__CVs_1;
     229static volatile const signed short int __x26__CVs_1;
     230static volatile const signed short int __x27__CVs_1;
    231231struct __anonymous8 {
    232     short __i__s_1;
     232    signed short int __i__s_1;
    233233};
    234234static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
     
    251251    return ((struct __anonymous8 )___ret__13s__anonymous8_1);
    252252}
    253 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, short __i__s_1){
     253static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
    254254    ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
    255255}
    256256volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
    257257struct __anonymous9 {
    258     short __i__s_1;
     258    signed short int __i__s_1;
    259259};
    260260static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
     
    277277    return ((struct __anonymous9 )___ret__13s__anonymous9_1);
    278278}
    279 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, short __i__s_1){
     279static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
    280280    ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
    281281}
    282282volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
    283283struct __anonymous10 {
    284     short __i__s_1;
     284    signed short int __i__s_1;
    285285};
    286286static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
     
    303303    return ((struct __anonymous10 )___ret__14s__anonymous10_1);
    304304}
    305 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, short __i__s_1){
     305static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
    306306    ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
    307307}
    308308volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
    309309struct __anonymous11 {
    310     short __i__s_1;
     310    signed short int __i__s_1;
    311311};
    312312static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
     
    329329    return ((struct __anonymous11 )___ret__14s__anonymous11_1);
    330330}
    331 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, short __i__s_1){
     331static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
    332332    ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
    333333}
    334334static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
    335335struct __anonymous12 {
    336     short __i__s_1;
     336    signed short int __i__s_1;
    337337};
    338338static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
     
    355355    return ((struct __anonymous12 )___ret__14s__anonymous12_1);
    356356}
    357 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, short __i__s_1){
     357static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
    358358    ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
    359359}
    360360static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
    361361struct __anonymous13 {
    362     short __i__s_1;
     362    signed short int __i__s_1;
    363363};
    364364static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
     
    381381    return ((struct __anonymous13 )___ret__14s__anonymous13_1);
    382382}
    383 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, short __i__s_1){
     383static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
    384384    ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
    385385}
    386386static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
    387387struct __anonymous14 {
    388     short __i__s_1;
     388    signed short int __i__s_1;
    389389};
    390390static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
     
    407407    return ((struct __anonymous14 )___ret__14s__anonymous14_1);
    408408}
    409 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, short __i__s_1){
     409static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
    410410    ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
    411411}
    412412static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
    413413struct __anonymous15 {
    414     short __i__s_1;
     414    signed short int __i__s_1;
    415415};
    416416static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
     
    433433    return ((struct __anonymous15 )___ret__14s__anonymous15_1);
    434434}
    435 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, short __i__s_1){
     435static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
    436436    ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
    437437}
    438438static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
    439 static inline volatile const int __f11__FCVi___1();
    440 static inline volatile const int __f12__FCVi___1();
    441 static inline volatile const int __f13__FCVi___1();
    442 static inline volatile const int __f14__FCVi___1();
    443 static inline volatile const int __f15__FCVi___1();
    444 static inline volatile const int __f16__FCVi___1();
    445 static inline volatile const int __f17__FCVi___1();
    446 static inline volatile const int __f18__FCVi___1();
    447 static inline volatile const short __f21__FCVs___1();
    448 static inline volatile const short __f22__FCVs___1();
    449 static inline volatile const short __f23__FCVs___1();
    450 static inline volatile const short __f24__FCVs___1();
    451 static inline volatile const short __f25__FCVs___1();
    452 static inline volatile const short __f26__FCVs___1();
    453 static inline volatile const short __f27__FCVs___1();
    454 static inline volatile const short __f28__FCVs___1();
     439static inline volatile const signed int __f11__FCVi___1();
     440static inline volatile const signed int __f12__FCVi___1();
     441static inline volatile const signed int __f13__FCVi___1();
     442static inline volatile const signed int __f14__FCVi___1();
     443static inline volatile const signed int __f15__FCVi___1();
     444static inline volatile const signed int __f16__FCVi___1();
     445static inline volatile const signed int __f17__FCVi___1();
     446static inline volatile const signed int __f18__FCVi___1();
     447static inline volatile const signed short int __f21__FCVs___1();
     448static inline volatile const signed short int __f22__FCVs___1();
     449static inline volatile const signed short int __f23__FCVs___1();
     450static inline volatile const signed short int __f24__FCVs___1();
     451static inline volatile const signed short int __f25__FCVs___1();
     452static inline volatile const signed short int __f26__FCVs___1();
     453static inline volatile const signed short int __f27__FCVs___1();
     454static inline volatile const signed short int __f28__FCVs___1();
    455455struct __anonymous16 {
    456     int __i__i_1;
     456    signed int __i__i_1;
    457457};
    458458static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
     
    475475    return ((struct __anonymous16 )___ret__14s__anonymous16_1);
    476476}
    477 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, int __i__i_1){
     477static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
    478478    ((void)((*___dst__R14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
    479479}
    480480static inline volatile const struct __anonymous16 __f31__FCV14s__anonymous16___1();
    481481struct __anonymous17 {
    482     int __i__i_1;
     482    signed int __i__i_1;
    483483};
    484484static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
     
    501501    return ((struct __anonymous17 )___ret__14s__anonymous17_1);
    502502}
    503 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, int __i__i_1){
     503static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
    504504    ((void)((*___dst__R14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
    505505}
    506506static inline volatile const struct __anonymous17 __f32__FCV14s__anonymous17___1();
    507507struct __anonymous18 {
    508     int __i__i_1;
     508    signed int __i__i_1;
    509509};
    510510static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
     
    527527    return ((struct __anonymous18 )___ret__14s__anonymous18_1);
    528528}
    529 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, int __i__i_1){
     529static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
    530530    ((void)((*___dst__R14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
    531531}
    532532static inline volatile const struct __anonymous18 __f33__FCV14s__anonymous18___1();
    533533struct __anonymous19 {
    534     int __i__i_1;
     534    signed int __i__i_1;
    535535};
    536536static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
     
    553553    return ((struct __anonymous19 )___ret__14s__anonymous19_1);
    554554}
    555 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, int __i__i_1){
     555static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
    556556    ((void)((*___dst__R14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
    557557}
    558558static inline volatile const struct __anonymous19 __f34__FCV14s__anonymous19___1();
    559559struct __anonymous20 {
    560     int __i__i_1;
     560    signed int __i__i_1;
    561561};
    562562static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
     
    579579    return ((struct __anonymous20 )___ret__14s__anonymous20_1);
    580580}
    581 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, int __i__i_1){
     581static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
    582582    ((void)((*___dst__R14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
    583583}
    584584static inline volatile const struct __anonymous20 __f35__FCV14s__anonymous20___1();
    585585struct __anonymous21 {
    586     int __i__i_1;
     586    signed int __i__i_1;
    587587};
    588588static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
     
    605605    return ((struct __anonymous21 )___ret__14s__anonymous21_1);
    606606}
    607 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, int __i__i_1){
     607static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
    608608    ((void)((*___dst__R14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
    609609}
    610610static inline volatile const struct __anonymous21 __f36__FCV14s__anonymous21___1();
    611611struct __anonymous22 {
    612     int __i__i_1;
     612    signed int __i__i_1;
    613613};
    614614static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
     
    631631    return ((struct __anonymous22 )___ret__14s__anonymous22_1);
    632632}
    633 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, int __i__i_1){
     633static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
    634634    ((void)((*___dst__R14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
    635635}
    636636static inline volatile const struct __anonymous22 __f37__FCV14s__anonymous22___1();
    637637struct __anonymous23 {
    638     int __i__i_1;
     638    signed int __i__i_1;
    639639};
    640640static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
     
    657657    return ((struct __anonymous23 )___ret__14s__anonymous23_1);
    658658}
    659 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, int __i__i_1){
     659static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
    660660    ((void)((*___dst__R14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
    661661}
    662662static inline volatile const struct __anonymous23 __f38__FCV14s__anonymous23___1();
    663 static inline volatile const short __f41__FCVs___1();
    664 static inline volatile const short __f42__FCVs___1();
    665 static inline volatile const short __f43__FCVs___1();
    666 static inline volatile const short __f44__FCVs___1();
    667 static inline volatile const short __f45__FCVs___1();
    668 static inline volatile const short __f46__FCVs___1();
    669 static inline volatile const short __f47__FCVs___1();
    670 static inline volatile const short __f48__FCVs___1();
    671 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
    672     __attribute__ ((unused)) int ___retval_main__i_1;
    673     ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
    674     return ((int )___retval_main__i_1);
     663static inline volatile const signed short int __f41__FCVs___1();
     664static inline volatile const signed short int __f42__FCVs___1();
     665static inline volatile const signed short int __f43__FCVs___1();
     666static inline volatile const signed short int __f44__FCVs___1();
     667static inline volatile const signed short int __f45__FCVs___1();
     668static inline volatile const signed short int __f46__FCVs___1();
     669static inline volatile const signed short int __f47__FCVs___1();
     670static inline volatile const signed short int __f48__FCVs___1();
     671signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     672    __attribute__ ((unused)) signed int ___retval_main__i_1;
     673    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     674    return ((signed int )___retval_main__i_1);
    675675    ((void)(___retval_main__i_1=0) /* ?{} */);
    676     return ((int )___retval_main__i_1);
     676    return ((signed int )___retval_main__i_1);
    677677}
    678678static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
    679 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     679__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    680680__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    681681__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    682 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    683 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    684 extern int printf(const char *__restrict __format, ...);
    685 static inline int invoke_main(int argc, char **argv, char **envp);
    686 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
    687     __attribute__ ((unused)) int ___retval_main__i_1;
    688     int _tmp_cp_ret0;
     682__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     683__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     684extern signed int printf(const char *__restrict __format, ...);
     685static inline signed int invoke_main(signed int argc, char **argv, char **envp);
     686signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     687    __attribute__ ((unused)) signed int ___retval_main__i_1;
     688    signed int _tmp_cp_ret0;
    689689    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
    690690    ((void)(_tmp_cp_ret0) /* ^?{} */);
    691     return ((int )___retval_main__i_1);
    692 }
     691    return ((signed int )___retval_main__i_1);
     692}
  • src/tests/.expect/64/extension.txt

    ra506df4 rb3c7963  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 __extension__ int __a__i_1;
    8 __extension__ int __b__i_1;
    9 __extension__ int __c__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7__extension__ signed int __a__i_1;
     8__extension__ signed int __b__i_1;
     9__extension__ signed int __c__i_1;
    1010__extension__ struct S {
    11     __extension__ int __a__i_1;
    12     __extension__ int __b__i_1;
    13     __extension__ int __c__i_1;
     11    __extension__ signed int __a__i_1;
     12    __extension__ signed int __b__i_1;
     13    __extension__ signed int __c__i_1;
    1414};
    1515static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
     
    4040    return ((struct S )___ret__2sS_1);
    4141}
    42 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __a__i_1){
     42static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
    4343    ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
    4444    ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */);
    4545    ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
    4646}
    47 static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1){
     47static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1){
    4848    ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
    4949    ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
    5050    ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
    5151}
    52 static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1, int __c__i_1){
     52static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
    5353    ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
    5454    ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     
    5656}
    5757__extension__ union U {
    58     __extension__ int __a__i_1;
    59     __extension__ int __b__i_1;
    60     __extension__ int __c__i_1;
     58    __extension__ signed int __a__i_1;
     59    __extension__ signed int __b__i_1;
     60    __extension__ signed int __c__i_1;
    6161};
    6262static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
     
    7373    return ((union U )___ret__2uU_1);
    7474}
    75 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, int __src__i_1){
    76     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(int )));
     75static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){
     76    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int )));
    7777}
    7878__extension__ enum E {
     
    8181    __B__C2eE_1,
    8282};
    83 __extension__ int __f__Fi___1();
    84 __extension__ int i;
    85 __extension__ int j;
    86 __extension__ int __fred__Fi_i__1(int __p__i_1){
    87     __attribute__ ((unused)) int ___retval_fred__i_1;
     83__extension__ signed int __f__Fi___1();
     84__extension__ signed int i;
     85__extension__ signed int j;
     86__extension__ signed int __fred__Fi_i__1(signed int __p__i_1){
     87    __attribute__ ((unused)) signed int ___retval_fred__i_1;
    8888    __extension__ struct S {
    89         __extension__ int __a__i_2;
    90         __extension__ int __b__i_2;
    91         __extension__ int __c__i_2;
    92         __extension__ int *__x__Pi_2;
    93         __extension__ int *__y__Pi_2;
    94         __extension__ int *__z__Pi_2;
     89        __extension__ signed int __a__i_2;
     90        __extension__ signed int __b__i_2;
     91        __extension__ signed int __c__i_2;
     92        __extension__ signed int *__x__Pi_2;
     93        __extension__ signed int *__y__Pi_2;
     94        __extension__ signed int *__z__Pi_2;
    9595    };
    96     int __i__i_2 = ((int )(__extension__ __a__i_1+__extension__ 3));
     96    signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3));
    9797    ((void)__extension__ 3);
    9898    ((void)__extension__ __a__i_1);
    99     __extension__ int __a__i_2;
    100     __extension__ int __b__i_2;
    101     __extension__ int __c__i_2;
     99    __extension__ signed int __a__i_2;
     100    __extension__ signed int __b__i_2;
     101    __extension__ signed int __c__i_2;
    102102    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
    103     int _tmp_cp_ret0;
     103    signed int _tmp_cp_ret0;
    104104    ((void)(((void)(_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret0));
    105105    ((void)(_tmp_cp_ret0) /* ^?{} */);
    106     __extension__ int __mary__Fi_i__2(int __p__i_2){
    107         __attribute__ ((unused)) int ___retval_mary__i_2;
     106    __extension__ signed int __mary__Fi_i__2(signed int __p__i_2){
     107        __attribute__ ((unused)) signed int ___retval_mary__i_2;
    108108    }
    109109    ((void)__extension__ sizeof(3));
    110     ((void)__extension__ (((int )(3!=((int )0))) || ((int )(4!=((int )0)))));
     110    ((void)__extension__ (((signed int )(3!=((signed int )0))) || ((signed int )(4!=((signed int )0)))));
    111111    ((void)__extension__ __alignof__(__extension__ __a__i_2));
    112     ((void)(((int )(__extension__ __a__i_2!=((int )0))) || ((int )((((int )(__extension__ __b__i_2!=((int )0))) && ((int )(__extension__ __c__i_2!=((int )0))))!=((int )0)))));
    113     ((void)(((int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     112    ((void)(((signed int )(__extension__ __a__i_2!=((signed int )0))) || ((signed int )((((signed int )(__extension__ __b__i_2!=((signed int )0))) && ((signed int )(__extension__ __c__i_2!=((signed int )0))))!=((signed int )0)))));
     113    ((void)(((signed int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
    114114    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
    115115    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
  • src/tests/.expect/64/gccExtensions.txt

    ra506df4 rb3c7963  
    1 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     1__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    22__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    33__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    6 extern int printf(const char *__restrict __format, ...);
    7 extern int __x__i_1 asm ( "xx" );
    8 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){
    9     __attribute__ ((unused)) int ___retval_main__i_1;
     4__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     5__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     6extern signed int printf(const char *__restrict __format, ...);
     7extern signed int __x__i_1 asm ( "xx" );
     8signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     9    __attribute__ ((unused)) signed int ___retval_main__i_1;
    1010    asm ( "nop" :  :  :  );
    1111    asm ( "nop" :  :  :  );
    1212    asm ( "nop" :  :  :  );
    13     static int __y__i_2 asm ( "yy" );
    14     static int *__z__Pi_2 asm ( "zz" );
    15     int __src__i_2;
    16     int __dst__i_2;
    17     asm volatile ( "mov %1, %0\n\tadd $1, %0" :  :  :  );
    18     asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) :  :  );
    19     asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
    20     asm ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
     13    static signed int __y__i_2 asm ( "yy" );
     14    static signed int *__z__Pi_2 asm ( "zz" );
     15    signed int __src__i_2;
     16    signed int __dst__i_2;
     17    asm volatile ( "mov %1, %0\n\t" "add $1, %0" :  :  :  );
     18    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( __dst__i_2 ) :  :  );
     19    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
     20    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
    2121    L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( __src__i_2 ), "r" ( (&__dst__i_2) ) : "r5", "memory" : L1, L2 );
    2222    double _Complex __c1__Xd_2;
    2323    double _Complex __c2__Xd_2;
    24     const int __i1__Ci_2;
    25     const int __i2__Ci_2;
    26     const int __i3__Ci_2;
    27     inline int __f1__Fi___2(){
    28         __attribute__ ((unused)) int ___retval_f1__i_2;
     24    const signed int __i1__Ci_2;
     25    const signed int __i2__Ci_2;
     26    const signed int __i3__Ci_2;
     27    inline signed int __f1__Fi___2(){
     28        __attribute__ ((unused)) signed int ___retval_f1__i_2;
    2929    }
    30     inline int __f2__Fi___2(){
    31         __attribute__ ((unused)) int ___retval_f2__i_2;
     30    inline signed int __f2__Fi___2(){
     31        __attribute__ ((unused)) signed int ___retval_f2__i_2;
    3232    }
    33     int __s1__i_2;
    34     int __s2__i_2;
    35     volatile int __v1__Vi_2;
    36     volatile int __v2__Vi_2;
    37     int __t1___2;
    38     int __t2___2;
    39     __extension__ const int __ex__Ci_2;
     33    signed int __s1__i_2;
     34    signed int __s2__i_2;
     35    volatile signed int __v1__Vi_2;
     36    volatile signed int __v2__Vi_2;
     37    signed int __t1___2;
     38    signed int __t2___2;
     39    __extension__ const signed int __ex__Ci_2;
    4040    struct S {
    41         __extension__ int __a__i_2;
    42         __extension__ int __b__i_2;
    43         __extension__ int __c__i_2;
     41        __extension__ signed int __a__i_2;
     42        __extension__ signed int __b__i_2;
     43        __extension__ signed int __c__i_2;
    4444    };
    4545    inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
     
    6666        return ((struct S )___ret__2sS_2);
    6767    }
    68     inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, int __a__i_2){
     68    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
    6969        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
    7070        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
    7171        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
    7272    }
    73     inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2){
     73    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){
    7474        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
    7575        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
    7676        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
    7777    }
    78     inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2, int __c__i_2){
     78    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
    7979        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
    8080        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
    8181        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
    8282    }
    83     int __i__i_2 = ((int )__extension__ 3);
    84     __extension__ int __a__i_2;
    85     __extension__ int __b__i_2;
    86     __extension__ int __c__i_2;
     83    signed int __i__i_2 = ((signed int )__extension__ 3);
     84    __extension__ signed int __a__i_2;
     85    __extension__ signed int __b__i_2;
     86    __extension__ signed int __c__i_2;
    8787    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
    8888    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
    8989    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
    90     int __a1__i_2;
    91     const int __a2__Ci_2;
    92     static const int __a3__Ci_2;
    93     static const int __a4__Ci_2;
    94     static const int __a5__Ci_2;
    95     static const int __a6__Ci_2;
    96     static const int __a7__Ci_2;
    97     int *__p1__Pi_2;
    98     int *__p2__Pi_2;
     90    signed int __a1__i_2;
     91    const signed int __a2__Ci_2;
     92    static const signed int __a3__Ci_2;
     93    static const signed int __a4__Ci_2;
     94    static const signed int __a5__Ci_2;
     95    static const signed int __a6__Ci_2;
     96    static const signed int __a7__Ci_2;
     97    signed int *__p1__Pi_2;
     98    signed int *__p2__Pi_2;
    9999    struct s1;
    100100    struct s2 {
    101         int __i__i_2;
     101        signed int __i__i_2;
    102102    };
    103103    inline void ___constructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
     
    116116        return ((struct s2 )___ret__3ss2_2);
    117117    }
    118     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, int __i__i_2){
     118    inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
    119119        ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
    120120    }
    121121    struct s3 {
    122         int __i__i_2;
     122        signed int __i__i_2;
    123123    };
    124124    inline void ___constructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
     
    137137        return ((struct s3 )___ret__3ss3_2);
    138138    }
    139     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, int __i__i_2){
     139    inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
    140140        ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
    141141    }
     
    143143    struct s3 __y1__3ss3_2;
    144144    struct s4 {
    145         int __i__i_2;
     145        signed int __i__i_2;
    146146    };
    147147    inline void ___constructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
     
    160160        return ((struct s4 )___ret__3ss4_2);
    161161    }
    162     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, int __i__i_2){
     162    inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
    163163        ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
    164164    }
    165165    struct s4 __x2__3ss4_2;
    166166    struct s4 __y2__3ss4_2;
    167     int __m1__A0i_2[((long unsigned int )10)];
    168     int __m2__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
    169     int __m3__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
    170     ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
    171     return ((int )___retval_main__i_1);
     167    signed int __m1__A0i_2[((unsigned long int )10)];
     168    signed int __m2__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
     169    signed int __m3__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
     170    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     171    return ((signed int )___retval_main__i_1);
    172172    ((void)(___retval_main__i_1=0) /* ?{} */);
    173     return ((int )___retval_main__i_1);
     173    return ((signed int )___retval_main__i_1);
    174174}
    175175static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
    176 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(long unsigned int __size);
     176__attribute__ ((__nothrow__,__leaf__,__malloc__)) extern void *malloc(unsigned long int __size);
    177177__attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr);
    178178__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void);
    179 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));
    180 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(int __status);
    181 extern int printf(const char *__restrict __format, ...);
    182 static inline int invoke_main(int argc, char **argv, char **envp);
    183 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
    184     __attribute__ ((unused)) int ___retval_main__i_1;
    185     int _tmp_cp_ret0;
     179__attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void));
     180__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
     181extern signed int printf(const char *__restrict __format, ...);
     182static inline signed int invoke_main(signed int argc, char **argv, char **envp);
     183signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     184    __attribute__ ((unused)) signed int ___retval_main__i_1;
     185    signed int _tmp_cp_ret0;
    186186    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
    187187    ((void)(_tmp_cp_ret0) /* ^?{} */);
    188     return ((int )___retval_main__i_1);
     188    return ((signed int )___retval_main__i_1);
    189189}
  • src/tests/.expect/64/gmp.txt

    ra506df4 rb3c7963  
    55y:97
    66y:12345678901234567890123456789
     7y:200
     8y:-400
     9y:24691357802469135780246913578
    710y:3
    811y:-3
  • src/tests/.expect/io.txt

    ra506df4 rb3c7963  
    2727
    2828output basic types
    29 A
     29A 23 93
    30301 2 3 4 5 6 7 8
    31311.1 1.2 1.3
  • src/tests/Makefile.am

    ra506df4 rb3c7963  
    1111## Created On       : Sun May 31 09:08:15 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Thu Jun  8 07:41:43 2017
    14 ## Update Count     : 44
     13## Last Modified On : Mon Sep 11 16:17:16 2017
     14## Update Count     : 45
    1515###############################################################################
    1616
     
    101101        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
    102102
     103literals : literals.c @CFA_BINDIR@/@CFA_NAME@
     104        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
     105
    103106gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
    104107        ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}
  • src/tests/Makefile.in

    ra506df4 rb3c7963  
    853853        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
    854854
     855literals : literals.c @CFA_BINDIR@/@CFA_NAME@
     856        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
     857
    855858gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
    856859        ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}
  • src/tests/gmp.c

    ra506df4 rb3c7963  
    1010// Created On       : Tue Apr 19 08:55:51 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug 25 12:50:01 2017
    13 // Update Count     : 544
     12// Last Modified On : Mon Sep  4 09:51:18 2017
     13// Update Count     : 550
    1414//
    1515
     
    2929        sout | "y:" | y | endl;
    3030        y = "12345678901234567890123456789";
     31        sout | "y:" | y | endl;
     32        y = 100`mp + 100`mp;
     33        sout | "y:" | y | endl;
     34        y = -200u`mp + -200u`mp;
     35        sout | "y:" | y | endl;
     36        y = "12345678901234567890123456789"`mp + "12345678901234567890123456789"`mp;
    3137        sout | "y:" | y | endl;
    3238        y = si;
  • src/tests/io.c

    ra506df4 rb3c7963  
    1010// Created On       : Wed Mar  2 16:56:02 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 23 21:27:50 2017
    13 // Update Count     : 79
     12// Last Modified On : Mon Sep 11 08:53:41 2017
     13// Update Count     : 81
    1414//
    1515
     
    1818int main() {
    1919        char c;                                                                                         // basic types
     20        signed char sc;
     21        unsigned char usc;
    2022        short int si;
    2123        unsigned short int usi;
     
    8991
    9092        sout | "input bacis types" | endl;
    91         &in | c                                                                                         // character
     93        &in | c | sc | usc                                                                      // character
    9294                | si | usi | i | ui | li | uli | lli | ulli             // integral
    9395                | f | d | ld                                                                    // floating point
     
    9799
    98100        sout | "output basic types" | endl;
    99         sout | c | ' ' | endl                                                           // character
     101        sout | c | ' ' | sc | ' ' | usc | endl                          // character
    100102                | si | usi | i | ui | li | uli | lli | ulli | endl // integral
    101103                | f | d | ld | endl                                                             // floating point
  • src/tests/io.data

    ra506df4 rb3c7963  
    1 A 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz
     1A 23 93 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz
Note: See TracChangeset for help on using the changeset viewer.