Changes in tools/autotool.py [a4a0f1d:2429e4a] in mainline


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • tools/autotool.py

    ra4a0f1d r2429e4a  
    4949
    5050PACKAGE_BINUTILS = "usually part of binutils"
    51 PACKAGE_GCC = "preferably version 4.7.0 or newer"
     51PACKAGE_GCC = "preferably version 4.5.1 or newer"
    5252PACKAGE_CROSS = "use tools/toolchain.sh to build the cross-compiler toolchain"
    5353
     
    6666
    6767#define DECLARE_BUILTIN_TYPE(tag, type) \\
    68         AUTOTOOL_DECLARE("builtin_size", "", tag, STRING(type), "", "", sizeof(type)); \\
    69         AUTOTOOL_DECLARE("builtin_sign", "unsigned long long int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned long long int)); \\
    70         AUTOTOOL_DECLARE("builtin_sign", "unsigned long int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned long int)); \\
    71         AUTOTOOL_DECLARE("builtin_sign", "unsigned int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned int)); \\
    72         AUTOTOOL_DECLARE("builtin_sign", "unsigned short int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned short int)); \\
    73         AUTOTOOL_DECLARE("builtin_sign", "unsigned char", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned char)); \\
    74         AUTOTOOL_DECLARE("builtin_sign", "signed long long int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed long long int)); \\
    75         AUTOTOOL_DECLARE("builtin_sign", "signed long int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed long int)); \\
    76         AUTOTOOL_DECLARE("builtin_sign", "signed int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed int)); \\
    77         AUTOTOOL_DECLARE("builtin_sign", "signed short int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed short int)); \\
    78         AUTOTOOL_DECLARE("builtin_sign", "signed char", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed char));
     68        AUTOTOOL_DECLARE("builtin", "", tag, STRING(type), "", "", sizeof(type));
    7969
    8070#define DECLARE_INTSIZE(tag, type, strc, conc) \\
    8171        AUTOTOOL_DECLARE("intsize", "unsigned", tag, #type, strc, conc, sizeof(unsigned type)); \\
    8272        AUTOTOOL_DECLARE("intsize", "signed", tag, #type, strc, conc, sizeof(signed type));
    83 
    84 #define DECLARE_FLOATSIZE(tag, type) \\
    85         AUTOTOOL_DECLARE("floatsize", "", tag, #type, "", "", sizeof(type));
    8673
    8774int main(int argc, char *argv[])
     
    197184        sys.stderr.write("ok\n")
    198185
    199 def check_app_alternatives(alts, args, name, details):
    200         "Check whether an application can be executed (use several alternatives)"
    201        
    202         tried = []
    203         found = None
    204        
    205         for alt in alts:
    206                 working = True
    207                 cmdline = [alt] + args
    208                 tried.append(" ".join(cmdline))
    209                
    210                 try:
    211                         sys.stderr.write("Checking for %s ... " % alt)
    212                         subprocess.Popen(cmdline, stdout = subprocess.PIPE, stderr = subprocess.PIPE).wait()
    213                 except:
    214                         sys.stderr.write("failed\n")
    215                         working = False
    216                
    217                 if (working):
    218                         sys.stderr.write("ok\n")
    219                         found = alt
    220                         break
    221        
    222         if (found is None):
    223                 print_error(["%s is missing." % name,
    224                              "",
    225                              "Please make sure that it is installed in your",
    226                              "system (%s)." % details,
    227                              "",
    228                              "The following alternatives were tried:"] + tried)
    229        
    230         return found
    231 
    232186def check_gcc(path, prefix, common, details):
    233187        "Check for GCC"
     
    275229        return int(value, base)
    276230
    277 def probe_compiler(common, intsizes, floatsizes):
     231def probe_compiler(common, sizes):
    278232        "Generate, compile and parse probing source"
    279233       
     
    283237        outf.write(PROBE_HEAD)
    284238       
    285         for typedef in intsizes:
     239        for typedef in sizes:
    286240                outf.write("\tDECLARE_INTSIZE(\"%s\", %s, %s, %s);\n" % (typedef['tag'], typedef['type'], typedef['strc'], typedef['conc']))
    287        
    288         for typedef in floatsizes:
    289                 outf.write("\nDECLARE_FLOATSIZE(\"%s\", %s);\n" % (typedef['tag'], typedef['type']))
    290241       
    291242        outf.write(PROBE_TAIL)
     
    331282        signed_concs = {}
    332283       
    333         float_tags = {}
    334        
    335         builtin_sizes = {}
    336         builtin_signs = {}
     284        builtins = {}
    337285       
    338286        for j in range(len(lines)):
     
    371319                                                print_error(["Unexpected keyword \"%s\" in \"%s\" on line %s." % (subcategory, PROBE_OUTPUT, j), COMPILER_FAIL])
    372320                               
    373                                 if (category == "floatsize"):
     321                                if (category == "builtin"):
    374322                                        try:
    375323                                                value_int = decode_value(value)
     
    377325                                                print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
    378326                                       
    379                                         float_tags[tag] = value_int
    380                                
    381                                 if (category == "builtin_size"):
    382                                         try:
    383                                                 value_int = decode_value(value)
    384                                         except:
    385                                                 print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
    386                                        
    387                                         builtin_sizes[tag] = {'name': name, 'value': value_int}
    388                                
    389                                 if (category == "builtin_sign"):
    390                                         try:
    391                                                 value_int = decode_value(value)
    392                                         except:
    393                                                 print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
    394                                        
    395                                         if (value_int == 1):
    396                                                 if (not tag in builtin_signs):
    397                                                         builtin_signs[tag] = strc;
    398                                                 elif (builtin_signs[tag] != strc):
    399                                                         print_error(["Inconsistent builtin type detection in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
    400        
    401         return {'unsigned_sizes': unsigned_sizes, 'signed_sizes': signed_sizes, 'unsigned_tags': unsigned_tags, 'signed_tags': signed_tags, 'unsigned_strcs': unsigned_strcs, 'signed_strcs': signed_strcs, 'unsigned_concs': unsigned_concs, 'signed_concs': signed_concs, 'float_tags': float_tags, 'builtin_sizes': builtin_sizes, 'builtin_signs': builtin_signs}
    402 
    403 def detect_sizes(probe, bytes, inttags, floattags):
    404         "Detect correct types for fixed-size types"
     327                                        builtins[tag] = {'name': name, 'value': value_int}
     328       
     329        return {'unsigned_sizes': unsigned_sizes, 'signed_sizes': signed_sizes, 'unsigned_tags': unsigned_tags, 'signed_tags': signed_tags, 'unsigned_strcs': unsigned_strcs, 'signed_strcs': signed_strcs, 'unsigned_concs': unsigned_concs, 'signed_concs': signed_concs, 'builtins': builtins}
     330
     331def detect_uints(probe, bytes, tags):
     332        "Detect correct types for fixed-size integer types"
    405333       
    406334        macros = []
     
    409337        for b in bytes:
    410338                if (not b in probe['unsigned_sizes']):
    411                         print_error(['Unable to find appropriate unsigned integer type for %u bytes.' % b,
     339                        print_error(['Unable to find appropriate unsigned integer type for %u bytes' % b,
    412340                                     COMPILER_FAIL])
    413341               
    414342                if (not b in probe['signed_sizes']):
    415                         print_error(['Unable to find appropriate signed integer type for %u bytes.' % b,
     343                        print_error(['Unable to find appropriate signed integer type for %u bytes' % b,
    416344                                     COMPILER_FAIL])
    417345               
    418346                if (not b in probe['unsigned_strcs']):
    419                         print_error(['Unable to find appropriate unsigned printf formatter for %u bytes.' % b,
     347                        print_error(['Unable to find appropriate unsigned printf formatter for %u bytes' % b,
    420348                                     COMPILER_FAIL])
    421349               
    422350                if (not b in probe['signed_strcs']):
    423                         print_error(['Unable to find appropriate signed printf formatter for %u bytes.' % b,
     351                        print_error(['Unable to find appropriate signed printf formatter for %u bytes' % b,
    424352                                     COMPILER_FAIL])
    425353               
    426354                if (not b in probe['unsigned_concs']):
    427                         print_error(['Unable to find appropriate unsigned literal macro for %u bytes.' % b,
     355                        print_error(['Unable to find appropriate unsigned literal macro for %u bytes' % b,
    428356                                     COMPILER_FAIL])
    429357               
    430358                if (not b in probe['signed_concs']):
    431                         print_error(['Unable to find appropriate signed literal macro for %u bytes.' % b,
     359                        print_error(['Unable to find appropriate signed literal macro for %u bytes' % b,
    432360                                     COMPILER_FAIL])
    433361               
     
    456384                        macros.append({'oldmacro': "c ## %s" % name, 'newmacro': "INT%u_C(c)" % (b * 8)})
    457385       
    458         for tag in inttags:
     386        for tag in tags:
    459387                newmacro = "U%s" % tag
    460388                if (not tag in probe['unsigned_tags']):
    461                         print_error(['Unable to find appropriate size macro for %s.' % newmacro,
     389                        print_error(['Unable to find appropriate size macro for %s' % newmacro,
    462390                                     COMPILER_FAIL])
    463391               
     
    465393                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
    466394                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
    467                 macros.append({'oldmacro': "1", 'newmacro': 'U%s_SIZE_%s' % (tag, probe['unsigned_tags'][tag] * 8)})
    468395               
    469396                newmacro = tag
    470                 if (not tag in probe['signed_tags']):
     397                if (not tag in probe['unsigned_tags']):
    471398                        print_error(['Unable to find appropriate size macro for %s' % newmacro,
    472399                                     COMPILER_FAIL])
     
    475402                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
    476403                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
    477                 macros.append({'oldmacro': "1", 'newmacro': '%s_SIZE_%s' % (tag, probe['signed_tags'][tag] * 8)})
    478        
    479         for tag in floattags:
    480                 if (not tag in probe['float_tags']):
    481                         print_error(['Unable to find appropriate size macro for %s' % tag,
    482                                      COMPILER_FAIL])
    483                
    484                 macros.append({'oldmacro': "1", 'newmacro': '%s_SIZE_%s' % (tag, probe['float_tags'][tag] * 8)})
    485        
    486         if (not 'size' in probe['builtin_signs']):
    487                 print_error(['Unable to determine whether size_t is signed or unsigned.',
    488                              COMPILER_FAIL])
    489        
    490         if (probe['builtin_signs']['size'] != 'unsigned'):
    491                 print_error(['The type size_t is not unsigned.',
    492                              COMPILER_FAIL])
    493404       
    494405        fnd = True
    495406       
    496         if (not 'wchar' in probe['builtin_sizes']):
     407        if (not 'wchar' in probe['builtins']):
    497408                print_warning(['The compiler does not provide the macro __WCHAR_TYPE__',
    498409                               'for defining the compiler-native type wchar_t. We are',
     
    501412                fnd = False
    502413       
    503         if (probe['builtin_sizes']['wchar']['value'] != 4):
     414        if (probe['builtins']['wchar']['value'] != 4):
    504415                print_warning(['The compiler provided macro __WCHAR_TYPE__ for defining',
    505416                               'the compiler-native type wchar_t is not compliant with',
     
    514425                macros.append({'oldmacro': "__WCHAR_TYPE__", 'newmacro': "wchar_t"})
    515426       
    516         if (not 'wchar' in probe['builtin_signs']):
    517                 print_error(['Unable to determine whether wchar_t is signed or unsigned.',
    518                              COMPILER_FAIL])
    519        
    520         if (probe['builtin_signs']['wchar'] == 'unsigned'):
    521                 macros.append({'oldmacro': "1", 'newmacro': 'WCHAR_IS_UNSIGNED'})
    522         if (probe['builtin_signs']['wchar'] == 'signed'):
    523                 macros.append({'oldmacro': "1", 'newmacro': 'WCHAR_IS_SIGNED'})
    524        
    525427        fnd = True
    526428       
    527         if (not 'wint' in probe['builtin_sizes']):
     429        if (not 'wint' in probe['builtins']):
    528430                print_warning(['The compiler does not provide the macro __WINT_TYPE__',
    529431                               'for defining the compiler-native type wint_t. We are',
     
    532434                fnd = False
    533435       
    534         if (probe['builtin_sizes']['wint']['value'] != 4):
     436        if (probe['builtins']['wint']['value'] != 4):
    535437                print_warning(['The compiler provided macro __WINT_TYPE__ for defining',
    536438                               'the compiler-native type wint_t is not compliant with',
     
    545447                macros.append({'oldmacro': "__WINT_TYPE__", 'newmacro': "wint_t"})
    546448       
    547         if (not 'wint' in probe['builtin_signs']):
    548                 print_error(['Unable to determine whether wint_t is signed or unsigned.',
    549                              COMPILER_FAIL])
    550        
    551         if (probe['builtin_signs']['wint'] == 'unsigned'):
    552                 macros.append({'oldmacro': "1", 'newmacro': 'WINT_IS_UNSIGNED'})
    553         if (probe['builtin_signs']['wint'] == 'signed'):
    554                 macros.append({'oldmacro': "1", 'newmacro': 'WINT_IS_SIGNED'})
    555        
    556449        return {'macros': macros, 'typedefs': typedefs}
    557450
     
    566459       
    567460        for key, value in common.items():
    568                 if (type(value) is list):
    569                         outmk.write('%s = %s\n' % (key, " ".join(value)))
    570                 else:
    571                         outmk.write('%s = %s\n' % (key, value))
     461                outmk.write('%s = %s\n' % (key, value))
    572462       
    573463        outmk.close()
     
    645535                               
    646536                                if (config['CROSS_TARGET'] == "arm32"):
    647                                         gnu_target = "arm-linux-gnueabi"
     537                                        gnu_target = "arm-linux-gnu"
    648538                               
    649539                                if (config['CROSS_TARGET'] == "ia32"):
     
    660550                        if (config['PLATFORM'] == "arm32"):
    661551                                target = config['PLATFORM']
    662                                 gnu_target = "arm-linux-gnueabi"
     552                                gnu_target = "arm-linux-gnu"
    663553                       
    664554                        if (config['PLATFORM'] == "ia32"):
     
    734624                # Platform-specific utilities
    735625                if ((config['BARCH'] == "amd64") or (config['BARCH'] == "ia32") or (config['BARCH'] == "ppc32") or (config['BARCH'] == "sparc64")):
    736                         common['GENISOIMAGE'] = check_app_alternatives(["mkisofs", "genisoimage"], ["--version"], "ISO 9660 creation utility", "usually part of genisoimage")
     626                        check_app(["mkisofs", "--version"], "ISO 9660 creation utility", "usually part of genisoimage")
    737627               
    738628                probe = probe_compiler(common,
     
    743633                                {'type': 'short int', 'tag': 'SHORT', 'strc': '"h"', 'conc': '"@"'},
    744634                                {'type': 'char', 'tag': 'CHAR', 'strc': '"hh"', 'conc': '"@@"'}
    745                         ],
    746                         [
    747                                 {'type': 'long double', 'tag': 'LONG_DOUBLE'},
    748                                 {'type': 'double', 'tag': 'DOUBLE'},
    749                                 {'type': 'float', 'tag': 'FLOAT'}
    750635                        ]
    751636                )
    752637               
    753                 maps = detect_sizes(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'], ['LONG_DOUBLE', 'DOUBLE', 'FLOAT'])
     638                maps = detect_uints(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'])
    754639               
    755640        finally:
Note: See TracChangeset for help on using the changeset viewer.