microsoft types are just synonyms for default types

[r18966]

diff --git a/ast2firm.c b/ast2firm.c
index 9584f9f..aac4a31 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -245,17 +245,6 @@ static void init_atomic_modes(void) {
        _atomic_modes[ATOMIC_TYPE_LONG_DOUBLE] = mode_E;
        _atomic_modes[ATOMIC_TYPE_BOOL]        = get_umode(int_size);
 
-       _atomic_modes[ATOMIC_TYPE_INT8]        = get_smode(1);
-       _atomic_modes[ATOMIC_TYPE_INT16]       = get_smode(2);
-       _atomic_modes[ATOMIC_TYPE_INT32]       = get_smode(4);
-       _atomic_modes[ATOMIC_TYPE_INT64]       = get_smode(8);
-       _atomic_modes[ATOMIC_TYPE_INT128]      = get_smode(16);
-       _atomic_modes[ATOMIC_TYPE_UINT8]       = get_umode(1);
-       _atomic_modes[ATOMIC_TYPE_UINT16]      = get_umode(2);
-       _atomic_modes[ATOMIC_TYPE_UINT32]      = get_umode(4);
-       _atomic_modes[ATOMIC_TYPE_UINT64]      = get_umode(8);
-       _atomic_modes[ATOMIC_TYPE_UINT128]     = get_umode(16);
-
        _atomic_modes[ATOMIC_TYPE_BOOL]                  = _atomic_modes[ATOMIC_TYPE_INT];
        _atomic_modes[ATOMIC_TYPE_FLOAT_IMAGINARY]       = _atomic_modes[ATOMIC_TYPE_FLOAT];
        _atomic_modes[ATOMIC_TYPE_DOUBLE_IMAGINARY]      = _atomic_modes[ATOMIC_TYPE_DOUBLE];
@@ -2592,17 +2581,6 @@ static ir_node *classify_type_to_firm(const classify_type_expression_t *const ex
                                case ATOMIC_TYPE_LONGLONG:
                                case ATOMIC_TYPE_ULONGLONG:
                                case ATOMIC_TYPE_BOOL:      /* gcc handles this as integer */
-                               /* microsoft types */
-                               case ATOMIC_TYPE_INT8:
-                               case ATOMIC_TYPE_INT16:
-                               case ATOMIC_TYPE_INT32:
-                               case ATOMIC_TYPE_INT64:
-                               case ATOMIC_TYPE_INT128:
-                               case ATOMIC_TYPE_UINT8:
-                               case ATOMIC_TYPE_UINT16:
-                               case ATOMIC_TYPE_UINT32:
-                               case ATOMIC_TYPE_UINT64:
-                               case ATOMIC_TYPE_UINT128:
                                        tc = integer_type_class;
                                        goto make_const;
 

diff --git a/parser.c b/parser.c
index 0d012db..2c8c173 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -760,23 +760,6 @@ static type_t *promote_integer(type_t *type)
        if(type->kind == TYPE_BITFIELD)
                type = type->bitfield.base;
 
-       /* handle microsofts explicit size types */
-       atomic_type_kind_t kind = type->atomic.akind;
-       if(kind >= ATOMIC_TYPE_INT8 && kind <= ATOMIC_TYPE_UINT128) {
-               unsigned size = get_atomic_type_size(kind);
-               if(kind <= ATOMIC_TYPE_INT128) {
-                       if(size <= get_atomic_type_size(ATOMIC_TYPE_INT)) {
-                               return type_int;
-                       }
-               } else {
-                       if(size <= get_atomic_type_size(ATOMIC_TYPE_UINT)) {
-                               return type_unsigned_int;
-                       }
-               }
-
-               return type;
-       }
-
        if(get_rank(type) < ATOMIC_TYPE_INT)
                type = type_int;
 
@@ -2441,48 +2424,48 @@ finish_specifiers:
                        break;
 
                case SPECIFIER_UNSIGNED | SPECIFIER_INT8:
-                       atomic_type = ATOMIC_TYPE_UINT8;
+                       atomic_type = unsigned_int8_type_kind;
                        break;
 
                case SPECIFIER_UNSIGNED | SPECIFIER_INT16:
-                       atomic_type = ATOMIC_TYPE_UINT16;
+                       atomic_type = unsigned_int16_type_kind;
                        break;
 
                case SPECIFIER_UNSIGNED | SPECIFIER_INT32:
-                       atomic_type = ATOMIC_TYPE_UINT32;
+                       atomic_type = unsigned_int32_type_kind;
                        break;
 
                case SPECIFIER_UNSIGNED | SPECIFIER_INT64:
-                       atomic_type = ATOMIC_TYPE_UINT64;
+                       atomic_type = unsigned_int64_type_kind;
                        break;
 
                case SPECIFIER_UNSIGNED | SPECIFIER_INT128:
-                       atomic_type = ATOMIC_TYPE_UINT128;
+                       atomic_type = unsigned_int128_type_kind;
                        break;
 
                case SPECIFIER_INT8:
                case SPECIFIER_SIGNED | SPECIFIER_INT8:
-                       atomic_type = ATOMIC_TYPE_INT8;
+                       atomic_type = int8_type_kind;
                        break;
 
                case SPECIFIER_INT16:
                case SPECIFIER_SIGNED | SPECIFIER_INT16:
-                       atomic_type = ATOMIC_TYPE_INT16;
+                       atomic_type = int16_type_kind;
                        break;
 
                case SPECIFIER_INT32:
                case SPECIFIER_SIGNED | SPECIFIER_INT32:
-                       atomic_type = ATOMIC_TYPE_INT32;
+                       atomic_type = int32_type_kind;
                        break;
 
                case SPECIFIER_INT64:
                case SPECIFIER_SIGNED | SPECIFIER_INT64:
-                       atomic_type = ATOMIC_TYPE_INT64;
+                       atomic_type = int64_type_kind;
                        break;
 
                case SPECIFIER_INT128:
                case SPECIFIER_SIGNED | SPECIFIER_INT128:
-                       atomic_type = ATOMIC_TYPE_INT128;
+                       atomic_type = int128_type_kind;
                        break;
 
                case SPECIFIER_FLOAT:

diff --git a/type.c b/type.c
index 2ef7b85..8910878 100644 (file)
--- a/type.c
+++ b/type.c
@@ -93,16 +93,6 @@ void print_atomic_type(const atomic_type_t *type)
        case ATOMIC_TYPE_LONG_DOUBLE:           s = "long double";        break;
        case ATOMIC_TYPE_FLOAT:                 s = "float";              break;
        case ATOMIC_TYPE_DOUBLE:                s = "double";             break;
-       case ATOMIC_TYPE_INT8:                  s = "__int8";             break;
-       case ATOMIC_TYPE_INT16:                 s = "__int16";            break;
-       case ATOMIC_TYPE_INT32:                 s = "__int32";            break;
-       case ATOMIC_TYPE_INT64:                 s = "__int64";            break;
-       case ATOMIC_TYPE_INT128:                s = "__int128";           break;
-       case ATOMIC_TYPE_UINT8:                 s = "unsigned __int8";    break;
-       case ATOMIC_TYPE_UINT16:                s = "unsigned __int16";   break;
-       case ATOMIC_TYPE_UINT32:                s = "unsigned __int32";   break;
-       case ATOMIC_TYPE_UINT64:                s = "unsigned __int64";   break;
-       case ATOMIC_TYPE_UINT128:               s = "unsigned __int128";  break;
        case ATOMIC_TYPE_FLOAT_COMPLEX:         s = "_Complex float";     break;
        case ATOMIC_TYPE_DOUBLE_COMPLEX:        s = "_Complex float";     break;
        case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:   s = "_Complex float";     break;
@@ -594,16 +584,6 @@ bool is_type_integer(const type_t *type)
        case ATOMIC_TYPE_ULONG:
        case ATOMIC_TYPE_LONGLONG:
        case ATOMIC_TYPE_ULONGLONG:
-       case ATOMIC_TYPE_INT8:
-       case ATOMIC_TYPE_INT16:
-       case ATOMIC_TYPE_INT32:
-       case ATOMIC_TYPE_INT64:
-       case ATOMIC_TYPE_INT128:
-       case ATOMIC_TYPE_UINT8:
-       case ATOMIC_TYPE_UINT16:
-       case ATOMIC_TYPE_UINT32:
-       case ATOMIC_TYPE_UINT64:
-       case ATOMIC_TYPE_UINT128:
                return true;
 
        case ATOMIC_TYPE_INVALID:
@@ -662,16 +642,6 @@ bool is_type_float(const type_t *type)
        case ATOMIC_TYPE_ULONG:
        case ATOMIC_TYPE_LONGLONG:
        case ATOMIC_TYPE_ULONGLONG:
-       case ATOMIC_TYPE_INT8:
-       case ATOMIC_TYPE_INT16:
-       case ATOMIC_TYPE_INT32:
-       case ATOMIC_TYPE_INT64:
-       case ATOMIC_TYPE_INT128:
-       case ATOMIC_TYPE_UINT8:
-       case ATOMIC_TYPE_UINT16:
-       case ATOMIC_TYPE_UINT32:
-       case ATOMIC_TYPE_UINT64:
-       case ATOMIC_TYPE_UINT128:
                return false;
        }
 
@@ -705,11 +675,6 @@ bool is_type_signed(const type_t *type)
        case ATOMIC_TYPE_FLOAT:
        case ATOMIC_TYPE_DOUBLE:
        case ATOMIC_TYPE_LONG_DOUBLE:
-       case ATOMIC_TYPE_INT8:
-       case ATOMIC_TYPE_INT16:
-       case ATOMIC_TYPE_INT32:
-       case ATOMIC_TYPE_INT64:
-       case ATOMIC_TYPE_INT128:
        case ATOMIC_TYPE_FLOAT_COMPLEX:
        case ATOMIC_TYPE_DOUBLE_COMPLEX:
        case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
@@ -724,11 +689,6 @@ bool is_type_signed(const type_t *type)
        case ATOMIC_TYPE_UINT:
        case ATOMIC_TYPE_ULONG:
        case ATOMIC_TYPE_ULONGLONG:
-       case ATOMIC_TYPE_UINT8:
-       case ATOMIC_TYPE_UINT16:
-       case ATOMIC_TYPE_UINT32:
-       case ATOMIC_TYPE_UINT64:
-       case ATOMIC_TYPE_UINT128:
                return false;
 
        case ATOMIC_TYPE_VOID:
@@ -1011,28 +971,12 @@ unsigned get_atomic_type_size(atomic_type_kind_t kind)
        case ATOMIC_TYPE_CHAR:
        case ATOMIC_TYPE_SCHAR:
        case ATOMIC_TYPE_UCHAR:
-       case ATOMIC_TYPE_INT8:
-       case ATOMIC_TYPE_UINT8:
                return 1;
 
        case ATOMIC_TYPE_SHORT:
        case ATOMIC_TYPE_USHORT:
-       case ATOMIC_TYPE_INT16:
-       case ATOMIC_TYPE_UINT16:
                return 2;
 
-       case ATOMIC_TYPE_INT32:
-       case ATOMIC_TYPE_UINT32:
-               return 4;
-
-       case ATOMIC_TYPE_INT64:
-       case ATOMIC_TYPE_UINT64:
-               return 8;
-
-       case ATOMIC_TYPE_INT128:
-       case ATOMIC_TYPE_UINT128:
-               return 16;
-
        case ATOMIC_TYPE_BOOL:
        case ATOMIC_TYPE_INT:
        case ATOMIC_TYPE_UINT:
@@ -1076,6 +1020,60 @@ unsigned get_atomic_type_size(atomic_type_kind_t kind)
        panic("Trying to determine size of invalid atomic type");
 }
 
+/**
+ * Find the atomic type kind representing a given size (signed).
+ */
+atomic_type_kind_t find_signed_int_atomic_type_kind_for_size(unsigned size) {
+       static atomic_type_kind_t kinds[32];
+
+       assert(size < 32);
+       atomic_type_kind_t kind = kinds[size];
+       if(kind == ATOMIC_TYPE_INVALID) {
+               static const possible_kinds[] = {
+                       ATOMIC_TYPE_SCHAR,
+                       ATOMIC_TYPE_SHORT,
+                       ATOMIC_TYPE_INT,
+                       ATOMIC_TYPE_LONG,
+                       ATOMIC_TYPE_LONGLONG
+               };
+               for(int i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) {
+                       if(get_atomic_type_size(possible_kinds[i]) == size) {
+                               kind = possible_kinds[i];
+                               break;
+                       }
+               }
+               kinds[size] = kind;
+       }
+       return kind;
+}
+
+/**
+ * Find the atomic type kind representing a given size (signed).
+ */
+atomic_type_kind_t find_unsigned_int_atomic_type_kind_for_size(unsigned size) {
+       static atomic_type_kind_t kinds[32];
+
+       assert(size < 32);
+       atomic_type_kind_t kind = kinds[size];
+       if(kind == ATOMIC_TYPE_INVALID) {
+               static const possible_kinds[] = {
+                       ATOMIC_TYPE_UCHAR,
+                       ATOMIC_TYPE_USHORT,
+                       ATOMIC_TYPE_UINT,
+                       ATOMIC_TYPE_ULONG,
+                       ATOMIC_TYPE_ULONGLONG
+               };
+               for(int i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) {
+                       if(get_atomic_type_size(possible_kinds[i]) == size) {
+                               kind = possible_kinds[i];
+                               break;
+                       }
+               }
+               kinds[size] = kind;
+       }
+       return kind;
+}
+
 /**
  * Hash the given type and return the "singleton" version
  * of it.
@@ -1105,7 +1103,7 @@ type_t *make_atomic_type(atomic_type_kind_t atype, type_qualifiers_t qualifiers)
        type->base.alignment  = 0;
        type->atomic.akind    = atype;
 
-       /* TODO: set the aligmnent depending on the atype here */
+       /* TODO: set the alignment depending on the atype here */
 
        return identify_new_type(type);
 }
@@ -1113,7 +1111,7 @@ type_t *make_atomic_type(atomic_type_kind_t atype, type_qualifiers_t qualifiers)
 /**
  * Creates a new pointer type.
  *
- * @param points_to   The points-to type for teh new type.
+ * @param points_to   The points-to type for the new type.
  * @param qualifiers  Type qualifiers for the new type.
  */
 type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers)

diff --git a/type.h b/type.h
index 2cd6c28..4a9860b 100644 (file)
--- a/type.h
+++ b/type.h
@@ -45,17 +45,6 @@ typedef enum {
        ATOMIC_TYPE_DOUBLE,
        ATOMIC_TYPE_LONG_DOUBLE,
        ATOMIC_TYPE_BOOL,
-       /* microsoft extensions */
-       ATOMIC_TYPE_INT8,
-       ATOMIC_TYPE_INT16,
-       ATOMIC_TYPE_INT32,
-       ATOMIC_TYPE_INT64,
-       ATOMIC_TYPE_INT128,
-       ATOMIC_TYPE_UINT8,
-       ATOMIC_TYPE_UINT16,
-       ATOMIC_TYPE_UINT32,
-       ATOMIC_TYPE_UINT64,
-       ATOMIC_TYPE_UINT128,
 
        ATOMIC_TYPE_FLOAT_COMPLEX,
        ATOMIC_TYPE_DOUBLE_COMPLEX,
@@ -155,4 +144,14 @@ unsigned get_atomic_type_size(atomic_type_kind_t kind);
  */
 unsigned get_atomic_type_align(atomic_type_kind_t kind);
 
+/**
+ * Find the atomic type kind representing a given size (signed).
+ */
+atomic_type_kind_t find_signed_int_atomic_type_kind_for_size(unsigned size);
+
+/**
+ * Find the atomic type kind representing a given size (unsigned).
+ */
+atomic_type_kind_t find_unsigned_int_atomic_type_kind_for_size(unsigned size);
+
 #endif

diff --git a/types.c b/types.c
index 6ac6f59..e49a689 100644 (file)
--- a/types.c
+++ b/types.c
@@ -19,6 +19,7 @@
  */
 #include "type_t.h"
 #include "types.h"
+#include "lang_features.h"
 
 /** The error type. */
 type_t *type_error_type;
@@ -62,6 +63,17 @@ type_t *type_ssize_t_ptr;
 type_t *type_wchar_t_ptr;
 
 /* microsoft types */
+atomic_type_kind_t int8_type_kind            = ATOMIC_TYPE_INVALID;
+atomic_type_kind_t int16_type_kind           = ATOMIC_TYPE_INVALID;
+atomic_type_kind_t int32_type_kind           = ATOMIC_TYPE_INVALID;
+atomic_type_kind_t int64_type_kind           = ATOMIC_TYPE_INVALID;
+atomic_type_kind_t int128_type_kind          = ATOMIC_TYPE_INVALID;
+atomic_type_kind_t unsigned_int8_type_kind   = ATOMIC_TYPE_INVALID;
+atomic_type_kind_t unsigned_int16_type_kind  = ATOMIC_TYPE_INVALID;
+atomic_type_kind_t unsigned_int32_type_kind  = ATOMIC_TYPE_INVALID;
+atomic_type_kind_t unsigned_int64_type_kind  = ATOMIC_TYPE_INVALID;
+atomic_type_kind_t unsigned_int128_type_kind = ATOMIC_TYPE_INVALID;
+
 type_t *type_int8;
 type_t *type_int16;
 type_t *type_int32;
@@ -92,14 +104,24 @@ void init_basic_types(void)
        type_void               = make_atomic_type(ATOMIC_TYPE_VOID,        TYPE_QUALIFIER_NONE);
 
        /* microsoft types */
-       type_int8               = make_atomic_type(ATOMIC_TYPE_CHAR,        TYPE_QUALIFIER_NONE);
-       type_int16              = make_atomic_type(ATOMIC_TYPE_SHORT,       TYPE_QUALIFIER_NONE);
-       type_int32              = make_atomic_type(ATOMIC_TYPE_INT,         TYPE_QUALIFIER_NONE);
-       type_int64              = make_atomic_type(ATOMIC_TYPE_LONGLONG,    TYPE_QUALIFIER_NONE);
-       type_unsigned_int8      = make_atomic_type(ATOMIC_TYPE_UCHAR,       TYPE_QUALIFIER_NONE);
-       type_unsigned_int16     = make_atomic_type(ATOMIC_TYPE_USHORT,      TYPE_QUALIFIER_NONE);
-       type_unsigned_int32     = make_atomic_type(ATOMIC_TYPE_UINT,        TYPE_QUALIFIER_NONE);
-       type_unsigned_int64     = make_atomic_type(ATOMIC_TYPE_ULONGLONG,   TYPE_QUALIFIER_NONE);
+       if(c_mode & _MS) {
+               int8_type_kind           = find_signed_int_atomic_type_kind_for_size(1);
+               type_int8                = make_atomic_type(int8_type_kind, TYPE_QUALIFIER_NONE);
+               int16_type_kind          = find_signed_int_atomic_type_kind_for_size(2);
+               type_int16               = make_atomic_type(int16_type_kind, TYPE_QUALIFIER_NONE);
+               int32_type_kind          = find_signed_int_atomic_type_kind_for_size(4);
+               type_int32               = make_atomic_type(int32_type_kind, TYPE_QUALIFIER_NONE);
+               int64_type_kind          = find_signed_int_atomic_type_kind_for_size(8);
+               type_int64               = make_atomic_type(int64_type_kind, TYPE_QUALIFIER_NONE);
+               unsigned_int8_type_kind  = find_unsigned_int_atomic_type_kind_for_size(1);
+               type_unsigned_int8       = make_atomic_type(unsigned_int8_type_kind, TYPE_QUALIFIER_NONE);
+               unsigned_int16_type_kind = find_unsigned_int_atomic_type_kind_for_size(2);
+               type_unsigned_int16      = make_atomic_type(unsigned_int16_type_kind, TYPE_QUALIFIER_NONE);
+               unsigned_int32_type_kind = find_unsigned_int_atomic_type_kind_for_size(4);
+               type_unsigned_int32      = make_atomic_type(unsigned_int32_type_kind, TYPE_QUALIFIER_NONE);
+               unsigned_int64_type_kind = find_unsigned_int_atomic_type_kind_for_size(8);
+               type_unsigned_int64      = make_atomic_type(unsigned_int64_type_kind, TYPE_QUALIFIER_NONE);
+       }
 
        /* pointer types */
        type_void_ptr           = make_pointer_type(type_void,              TYPE_QUALIFIER_NONE);

diff --git a/types.h b/types.h
index 1a17572..9ca2b5a 100644 (file)
--- a/types.h
+++ b/types.h
@@ -64,14 +64,27 @@ extern type_t *type_ssize_t_ptr;
 extern type_t *type_wchar_t_ptr;
 
 /* microsoft types */
+extern atomic_type_kind_t int8_type_kind;
+extern atomic_type_kind_t int16_type_kind;
+extern atomic_type_kind_t int32_type_kind;
+extern atomic_type_kind_t int64_type_kind;
+extern atomic_type_kind_t int128_type_kind;
+extern atomic_type_kind_t unsigned_int8_type_kind;
+extern atomic_type_kind_t unsigned_int16_type_kind;
+extern atomic_type_kind_t unsigned_int32_type_kind;
+extern atomic_type_kind_t unsigned_int64_type_kind;
+extern atomic_type_kind_t unsigned_int128_type_kind;
+
 extern type_t *type_int8;
 extern type_t *type_int16;
 extern type_t *type_int32;
 extern type_t *type_int64;
+extern type_t *type_int128;
 extern type_t *type_unsigned_int8;
 extern type_t *type_unsigned_int16;
 extern type_t *type_unsigned_int32;
 extern type_t *type_unsigned_int64;
+extern type_t *type_unsigned_int128;
 
 void init_basic_types(void);