sm64

A Super Mario 64 decompilation
Log | Files | Refs | README | LICENSE

stdarg.h (13469B)


      1 #ifndef STDARG_H
      2 #define STDARG_H
      3 
      4 // When not building with IDO, use the builtin vaarg macros for portability.
      5 #if !defined(__sgi) && (__GNUC__ > 2)
      6 #define va_list __builtin_va_list
      7 #define va_start __builtin_va_start
      8 #define va_arg __builtin_va_arg
      9 #define va_end __builtin_va_end
     10 
     11 #elif (__GNUC__ == 2)
     12 
     13 typedef void *__gnuc_va_list;
     14 typedef __gnuc_va_list va_list;
     15 
     16 #ifndef _VA_MIPS_H_ENUM
     17 #define _VA_MIPS_H_ENUM
     18 enum {
     19   __no_type_class = -1,
     20   __void_type_class,
     21   __integer_type_class,
     22   __char_type_class,
     23   __enumeral_type_class,
     24   __boolean_type_class,
     25   __pointer_type_class,
     26   __reference_type_class,
     27   __offset_type_class,
     28   __real_type_class,
     29   __complex_type_class,
     30   __function_type_class,
     31   __method_type_class,
     32   __record_type_class,
     33   __union_type_class,
     34   __array_type_class,
     35   __string_type_class,
     36   __set_type_class,
     37   __file_type_class,
     38   __lang_type_class
     39 };
     40 #endif
     41 
     42 /* In GCC version 2, we want an ellipsis at the end of the declaration
     43    of the argument list.  GCC version 1 can't parse it.  */
     44 
     45 #if __GNUC__ > 1
     46 #define __va_ellipsis ...
     47 #else
     48 #define __va_ellipsis
     49 #endif
     50 
     51 #ifdef __mips64
     52 #define __va_rounded_size(__TYPE)  \
     53   (((sizeof (__TYPE) + 8 - 1) / 8) * 8)
     54 #else
     55 #define __va_rounded_size(__TYPE)  \
     56   (((sizeof (__TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
     57 #endif
     58 
     59 #ifdef __mips64
     60 #define __va_reg_size 8
     61 #else
     62 #define __va_reg_size 4
     63 #endif
     64 
     65 /* Get definitions for _MIPS_SIM_ABI64 etc.  */
     66 #ifdef _MIPS_SIM
     67 //#include <sgidefs.h>
     68 #endif
     69 
     70 #ifdef STDARG_H
     71 #if defined (__mips_eabi)
     72 #if ! defined (__mips_soft_float) && ! defined (__mips_single_float)
     73 #ifdef __mips64
     74 #define va_start(__AP, __LASTARG)                                        \
     75   (__AP.__gp_regs = ((char *) __builtin_next_arg (__LASTARG)                \
     76                      - (__builtin_args_info (2) < 8                        \
     77                         ? (8 - __builtin_args_info (2)) * __va_reg_size        \
     78                         : 0)),                                                \
     79    __AP.__fp_left = 8 - __builtin_args_info (3),                        \
     80    __AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * __va_reg_size)
     81 #else /* ! defined (__mips64) */
     82 #define va_start(__AP, __LASTARG)                                        \
     83   (__AP.__gp_regs = ((char *) __builtin_next_arg (__LASTARG)                \
     84                      - (__builtin_args_info (2) < 8                        \
     85                         ? (8 - __builtin_args_info (2)) * __va_reg_size        \
     86                         : 0)),                                                \
     87    __AP.__fp_left = (8 - __builtin_args_info (3)) / 2,                        \
     88    __AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * 8,                \
     89    __AP.__fp_regs = (char *) ((int) __AP.__fp_regs & -8))
     90 #endif /* ! defined (__mips64) */
     91 #else /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float) ) */
     92 #define va_start(__AP, __LASTARG)                                        \
     93   (__AP = ((__gnuc_va_list) __builtin_next_arg (__LASTARG)                \
     94            - (__builtin_args_info (2) >= 8 ? 0                                \
     95               : (8 - __builtin_args_info (2)) * __va_reg_size)))
     96 #endif /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float) ) */
     97 #else /* ! defined (__mips_eabi) */
     98 #define va_start(__AP, __LASTARG) \
     99   (__AP = (__gnuc_va_list) __builtin_next_arg (__LASTARG))
    100 #endif /* ! (defined (__mips_eabi) && ! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
    101 #else /* ! _STDARG_H */
    102 #define va_alist  __builtin_va_alist
    103 #ifdef __mips64
    104 /* This assumes that `long long int' is always a 64 bit type.  */
    105 #define va_dcl    long long int __builtin_va_alist; __va_ellipsis
    106 #else
    107 #define va_dcl    int __builtin_va_alist; __va_ellipsis
    108 #endif
    109 #if defined (__mips_eabi)
    110 #if ! defined (__mips_soft_float) && ! defined (__mips_single_float)
    111 #ifdef __mips64
    112 #define va_start(__AP)                                                        \
    113   (__AP.__gp_regs = ((char *) __builtin_next_arg ()                        \
    114                      - (__builtin_args_info (2) < 8                        \
    115                         ? (8 - __builtin_args_info (2)) * __va_reg_size        \
    116                         : __va_reg_size)),                                \
    117    __AP.__fp_left = 8 - __builtin_args_info (3),                        \
    118    __AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * __va_reg_size)
    119 #else /* ! defined (__mips64) */
    120 #define va_start(__AP)                                                        \
    121   (__AP.__gp_regs = ((char *) __builtin_next_arg ()                        \
    122                      - (__builtin_args_info (2) < 8                        \
    123                         ? (8 - __builtin_args_info (2)) * __va_reg_size        \
    124                         : __va_reg_size)),                                \
    125    __AP.__fp_left = (8 - __builtin_args_info (3)) / 2,                        \
    126    __AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * 8,                \
    127    __AP.__fp_regs = (char *) ((int) __AP.__fp_regs & -8))
    128 #endif /* ! defined (__mips64) */
    129 #else /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
    130 #define va_start(__AP)                                                        \
    131   (__AP = ((__gnuc_va_list) __builtin_next_arg ()                        \
    132            - (__builtin_args_info (2) >= 8 ? __va_reg_size                \
    133               : (8 - __builtin_args_info (2)) * __va_reg_size)))
    134 #endif /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
    135 /* Need alternate code for _MIPS_SIM_ABI64.  */
    136 #elif defined(_MIPS_SIM) && (_MIPS_SIM == _MIPS_SIM_ABI64 || _MIPS_SIM == _MIPS_SIM_NABI32)
    137 #define va_start(__AP)                                                        \
    138   (__AP = (__gnuc_va_list) __builtin_next_arg ()                        \
    139    + (__builtin_args_info (2) >= 8 ? -8 : 0))
    140 #else
    141 #define va_start(__AP)  __AP = (char *) &__builtin_va_alist
    142 #endif
    143 #endif /* ! _STDARG_H */
    144 
    145 #ifndef va_end
    146 void va_end (__gnuc_va_list);                /* Defined in libgcc.a */
    147 #endif
    148 #define va_end(__AP)        ((void)0)
    149 
    150 #if defined (__mips_eabi)
    151 
    152 #if ! defined (__mips_soft_float) && ! defined (__mips_single_float)
    153 #ifdef __mips64
    154 #define __va_next_addr(__AP, __type)                                        \
    155   ((__builtin_classify_type (*(__type *) 0) == __real_type_class        \
    156     && __AP.__fp_left > 0)                                                \
    157    ? (--__AP.__fp_left, (__AP.__fp_regs += 8) - 8)                        \
    158    : (__AP.__gp_regs += __va_reg_size) - __va_reg_size)
    159 #else
    160 #define __va_next_addr(__AP, __type)                                        \
    161   ((__builtin_classify_type (*(__type *) 0) == __real_type_class        \
    162     && __AP.__fp_left > 0)                                                \
    163    ? (--__AP.__fp_left, (__AP.__fp_regs += 8) - 8)                        \
    164    : (((__builtin_classify_type (* (__type *) 0) < __record_type_class        \
    165         && __alignof__ (__type) > 4)                                        \
    166        ? __AP.__gp_regs = (char *) (((int) __AP.__gp_regs + 8 - 1) & -8) \
    167        : (char *) 0),                                                        \
    168       (__builtin_classify_type (* (__type *) 0) >= __record_type_class        \
    169        ? (__AP.__gp_regs += __va_reg_size) - __va_reg_size                \
    170        : ((__AP.__gp_regs += __va_rounded_size (__type))                \
    171           - __va_rounded_size (__type)))))
    172 #endif
    173 #else /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
    174 #ifdef __mips64
    175 #define __va_next_addr(__AP, __type)                                        \
    176   ((__AP += __va_reg_size) - __va_reg_size)
    177 #else
    178 #define __va_next_addr(__AP, __type)                                        \
    179   (((__builtin_classify_type (* (__type *) 0) < __record_type_class        \
    180      && __alignof__ (__type) > 4)                                        \
    181     ? __AP = (char *) (((__PTRDIFF_TYPE__) __AP + 8 - 1) & -8)                \
    182     : (char *) 0),                                                        \
    183    (__builtin_classify_type (* (__type *) 0) >= __record_type_class        \
    184     ? (__AP += __va_reg_size) - __va_reg_size                                \
    185     : ((__AP += __va_rounded_size (__type))                                \
    186        - __va_rounded_size (__type))))
    187 #endif
    188 #endif /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
    189 
    190 #ifdef __MIPSEB__
    191 #define va_arg(__AP, __type)                                                \
    192   ((__va_rounded_size (__type) <= __va_reg_size)                        \
    193    ? *(__type *) (void *) (__va_next_addr (__AP, __type)                \
    194                            + __va_reg_size                                \
    195                            - sizeof (__type))                                \
    196    : (__builtin_classify_type (*(__type *) 0) >= __record_type_class        \
    197       ? **(__type **) (void *) (__va_next_addr (__AP, __type)                \
    198                                 + __va_reg_size                                \
    199                                 - sizeof (char *))                        \
    200       : *(__type *) (void *) __va_next_addr (__AP, __type)))
    201 #else
    202 #define va_arg(__AP, __type)                                                \
    203   ((__va_rounded_size (__type) <= __va_reg_size)                        \
    204    ? *(__type *) (void *) __va_next_addr (__AP, __type)                \
    205    : (__builtin_classify_type (* (__type *) 0) >= __record_type_class        \
    206       ? **(__type **) (void *) __va_next_addr (__AP, __type)                \
    207       : *(__type *) (void *) __va_next_addr (__AP, __type)))
    208 #endif
    209 
    210 #else /* ! defined (__mips_eabi) */
    211 
    212 /* We cast to void * and then to TYPE * because this avoids
    213    a warning about increasing the alignment requirement.  */
    214 /* The __mips64 cases are reversed from the 32 bit cases, because the standard
    215    32 bit calling convention left-aligns all parameters smaller than a word,
    216    whereas the __mips64 calling convention does not (and hence they are
    217    right aligned).  */
    218 #ifdef __mips64
    219 #ifdef __MIPSEB__
    220 #define va_arg(__AP, __type)                                    \
    221   ((__type *) (void *) (__AP = (char *)                         \
    222                        ((((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8) \
    223                            + __va_rounded_size (__type))))[-1]
    224 #else
    225 #define va_arg(__AP, __type)                                    \
    226   ((__AP = (char *) ((((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8)        \
    227                      + __va_rounded_size (__type))),                \
    228    *(__type *) (void *) (__AP - __va_rounded_size (__type)))
    229 #endif
    230 
    231 #else /* not __mips64 */
    232 
    233 #ifdef __MIPSEB__
    234 /* For big-endian machines.  */
    235 #define va_arg(__AP, __type)                                        \
    236   ((__AP = (char *) ((__alignof__ (__type) > 4                        \
    237                       ? ((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8        \
    238                       : ((__PTRDIFF_TYPE__)__AP + 4 - 1) & -4)        \
    239                      + __va_rounded_size (__type))),                \
    240    *(__type *) (void *) (__AP - __va_rounded_size (__type)))
    241 #else
    242 /* For little-endian machines.  */
    243 #define va_arg(__AP, __type)                                                    \
    244   ((__type *) (void *) (__AP = (char *) ((__alignof__(__type) > 4            \
    245                                 ? ((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8            \
    246                                 : ((__PTRDIFF_TYPE__)__AP + 4 - 1) & -4)    \
    247                                          + __va_rounded_size(__type))))[-1]
    248 #endif
    249 #endif
    250 #endif /* ! defined (__mips_eabi)  */
    251 
    252 /* Copy __gnuc_va_list into another variable of this type.  */
    253 #define __va_copy(dest, src) (dest) = (src)
    254 
    255 #else
    256 
    257 typedef char *va_list;
    258 #define _FP 1
    259 #define _INT 0
    260 #define _STRUCT 2
    261 
    262 #define _VA_FP_SAVE_AREA 0x10
    263 #define _VA_ALIGN(p, a) (((unsigned int)(((char *)p) + ((a) > 4 ? (a) : 4) - 1)) & -((a) > 4 ? (a) : 4))
    264 #define va_start(vp, parmN) (vp = ((va_list)&parmN + sizeof(parmN)))
    265 
    266 #define __va_stack_arg(list, mode)                          \
    267     (                                                       \
    268         ((list) = (char *)_VA_ALIGN(list, __builtin_alignof(mode)) + \
    269                   _VA_ALIGN(sizeof(mode), 4)),              \
    270         (((char *)list) - (_VA_ALIGN(sizeof(mode), 4) - sizeof(mode))))
    271 
    272 #define __va_double_arg(list, mode)                                                                    \
    273     (                                                                                                  \
    274         (((long)list & 0x1) /* 1 byte aligned? */                                                      \
    275              ? (list = (char *)((long)list + 7), (char *)((long)list - 6 - _VA_FP_SAVE_AREA))          \
    276              : (((long)list & 0x2) /* 2 byte aligned? */                                               \
    277                     ? (list = (char *)((long)list + 10), (char *)((long)list - 24 - _VA_FP_SAVE_AREA)) \
    278                     : __va_stack_arg(list, mode))))
    279 
    280 #define va_arg(list, mode) ((mode *)(((__builtin_classof(mode) == _FP &&          \
    281                                        __builtin_alignof(mode) == sizeof(double)) \
    282                                           ? __va_double_arg(list, mode)           \
    283                                           : __va_stack_arg(list, mode))))[-1]
    284 #define va_end(__list)
    285 
    286 #endif
    287 #endif