home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / gcc / ginclude / va-sparc.h < prev    next >
C/C++ Source or Header  |  1996-12-17  |  7KB  |  211 lines
  1. /* This is just like the default gvarargs.h
  2.    except for differences described below.  */
  3.  
  4. /* Define __gnuc_va_list.  */
  5.  
  6. #ifndef __GNUC_VA_LIST
  7. #define __GNUC_VA_LIST
  8.  
  9. #ifdef __sparc_v9__
  10. typedef long long __va_greg;
  11. typedef double __va_freg;
  12. typedef struct {
  13.   __va_greg * __va_next_o;        /* next available %o* register */
  14.   __va_greg * __va_next_o_limit;    /* past last available %o* register */
  15.   __va_freg * __va_next_fp;        /* next available %f* register */
  16.   __va_freg * __va_next_fp_limit;    /* last available %f* register */
  17.   __va_greg * __va_next_stack;        /* next extended word on stack */
  18. } __gnuc_va_list;
  19. #else
  20. #ifndef __svr4__
  21. /* This has to be a char * to be compatible with Sun.
  22.    i.e., we have to pass a `va_list' to vsprintf.  */
  23. typedef char * __gnuc_va_list;
  24. #else
  25. /* This has to be a void * to be compatible with Sun svr4.
  26.    i.e., we have to pass a `va_list' to vsprintf.  */
  27. typedef void * __gnuc_va_list;
  28. #endif
  29. #endif /* not __sparc_v9__ */
  30. #endif /* not __GNUC_VA_LIST */
  31.  
  32. #ifdef NeXT_PDO
  33. #define NULL_VALIST ((__gnuc_va_list)0)
  34. #endif
  35.  
  36. /* If this is for internal libc use, don't define anything but
  37.    __gnuc_va_list.  */
  38. #if defined (_STDARG_H) || defined (_VARARGS_H)
  39.  
  40. #ifdef _STDARG_H
  41.  
  42. #ifdef __sparc_v9__
  43. #define va_start(AP, LASTARG) \
  44. __extension__ \
  45.   ({ \
  46.      AP.__va_next_o = (__va_greg *) __builtin_saveregs (); \
  47.      AP.__va_next_o_limit = (AP.__va_next_o + \
  48.                  (__builtin_args_info (0) < 6 ? 6 - __builtin_args_info (0) : 0)); \
  49.      AP.__va_next_fp = (__va_freg *) AP.__va_next_o_limit; \
  50.      AP.__va_next_fp_limit = (AP.__va_next_fp + \
  51.                   (__builtin_args_info (1) < 16 ? (16 - __builtin_args_info (1) + 1) / 2 : 0)); \
  52.      AP.__va_next_stack = (__va_greg *) __builtin_next_arg (LASTARG); \
  53.   })
  54. #else
  55. /* Call __builtin_next_arg even though we aren't using its value, so that
  56.    we can verify that LASTARG is correct.  */
  57. #ifdef __GCC_NEW_VARARGS__
  58. #define va_start(AP, LASTARG) \
  59.   (__builtin_next_arg (LASTARG), AP = (char *) __builtin_saveregs ())
  60. #if defined(NeXT_PDO)
  61. #undef va_start
  62. #define va_start(AP, LASTARG)    (AP = (char *) __builtin_saveregs ())
  63. #endif
  64. #else
  65. #define va_start(AP, LASTARG)                    \
  66.   (__builtin_saveregs (), AP = ((char *) __builtin_next_arg ()))
  67. #endif
  68. #endif /* not __sparc_v9__ */
  69.  
  70. #else
  71.  
  72. #define va_alist  __builtin_va_alist
  73. #define va_dcl    int __builtin_va_alist;...
  74.  
  75. #ifdef __sparc_v9__
  76. #define va_start(AP) \
  77. __extension__ \
  78.   ({ \
  79.      AP.__va_next_o = (__va_greg *) __builtin_saveregs (); \
  80.      AP.__va_next_o_limit = (AP.__va_next_o + \
  81.                  (__builtin_args_info (0) < 6 ? 6 - __builtin_args_info (0) : 0)); \
  82.      AP.__va_next_fp = (__va_freg *) AP.__va_next_o_limit; \
  83.      AP.__va_next_fp_limit = (AP.__va_next_fp + \
  84.                   (__builtin_args_info (1) < 16 ? (16 - __builtin_args_info (1) + 1) / 2 : 0)); \
  85.      AP.__va_next_stack = (__va_greg *) __builtin_next_arg (__builtin_va_alist) \
  86.        - (__builtin_args_info (0) >= 6 || __builtin_args_info (1) >= 16 ? 1 : 0); \
  87.   })
  88. #else
  89. #ifdef __GCC_NEW_VARARGS__
  90. #define va_start(AP)        ((AP) = (char *) __builtin_saveregs ())
  91. #else
  92. #define va_start(AP)                         \
  93.  (__builtin_saveregs (), (AP) = ((char *) &__builtin_va_alist))
  94. #endif
  95. #endif /* not __sparc_v9__ */
  96.  
  97. #endif
  98.  
  99. #ifndef va_end
  100. void va_end (__gnuc_va_list);        /* Defined in libgcc.a */
  101.  
  102. /* Values returned by __builtin_classify_type.  */
  103.  
  104. enum __va_type_classes {
  105.   __no_type_class = -1,
  106.   __void_type_class,
  107.   __integer_type_class,
  108.   __char_type_class,
  109.   __enumeral_type_class,
  110.   __boolean_type_class,
  111.   __pointer_type_class,
  112.   __reference_type_class,
  113.   __offset_type_class,
  114.   __real_type_class,
  115.   __complex_type_class,
  116.   __function_type_class,
  117.   __method_type_class,
  118.   __record_type_class,
  119.   __union_type_class,
  120.   __array_type_class,
  121.   __string_type_class,
  122.   __set_type_class,
  123.   __file_type_class,
  124.   __lang_type_class
  125. };
  126.  
  127. #endif
  128. #define va_end(pvar)
  129.  
  130. /* Avoid errors if compiling GCC v2 with GCC v1.  */
  131. #if __GNUC__ == 1
  132. #define __extension__
  133. #endif
  134.  
  135. /* RECORD_TYPE args passed using the C calling convention are
  136.    passed by invisible reference.  ??? RECORD_TYPE args passed
  137.    in the stack are made to be word-aligned; for an aggregate that is
  138.    not word-aligned, we advance the pointer to the first non-reg slot.  */
  139.  
  140. #ifdef __sparc_v9__
  141.  
  142. #define va_arg(pvar,TYPE)                    \
  143. __extension__                            \
  144. (*({int __type = __builtin_classify_type (* (TYPE *) 0);    \
  145.   void * __result;                        \
  146.   if (__type == __real_type_class)        /* float? */    \
  147.     {                                \
  148.       __va_freg *__r;                        \
  149.       /* see PASS_IN_REG_P in gcc's sparc.h */            \
  150.       if (pvar.__va_next_fp < pvar.__va_next_fp_limit        \
  151.       && ((__r = (__va_freg *) (((__va_greg) pvar.__va_next_fp + sizeof (TYPE) - 1) & ~(__va_greg) (sizeof (TYPE) - 1))) \
  152.           < pvar.__va_next_fp_limit))            \
  153.     {                            \
  154.       pvar.__va_next_fp = __r + (sizeof (TYPE) + 7) / 8;    \
  155.     }                            \
  156.       else                            \
  157.     {                            \
  158.       __r = (__va_freg *) pvar.__va_next_stack;        \
  159.       pvar.__va_next_stack += (sizeof (TYPE) + 7) / 8;    \
  160.     }                            \
  161.       __result = __r;                        \
  162.     }                                \
  163.   else if (__type < __record_type_class)    /* integer? */    \
  164.     {                                \
  165.       __va_greg *__r;                        \
  166.       if (pvar.__va_next_o < pvar.__va_next_o_limit)        \
  167.     __r = pvar.__va_next_o++;                \
  168.       else                            \
  169.     __r = pvar.__va_next_stack++;                \
  170.       /* adjust for 4 byte ints */                \
  171.       __result = (char *) __r + 8 - sizeof (TYPE);        \
  172.     }                                \
  173.   else /* aggregate object */                    \
  174.     {                                \
  175.       void **__r;                        \
  176.       if (pvar.__va_next_o < pvar.__va_next_o_limit)        \
  177.     __r = (void **) pvar.__va_next_o++;            \
  178.       else                            \
  179.     __r = (void **) pvar.__va_next_stack++;            \
  180.       __result = *__r;                        \
  181.     }                                \
  182.   (TYPE *) __result;}))
  183.  
  184. #else /* not __sparc_v9__ */
  185.  
  186. #define __va_rounded_size(TYPE)  \
  187.   (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
  188.  
  189. /* We don't declare the union member `d' to have type TYPE
  190.    because that would lose in C++ if TYPE has a constructor.  */
  191. /* We cast to void * and then to TYPE * because this avoids
  192.    a warning about increasing the alignment requirement.
  193.    The casts to char * avoid warnings about invalid pointer arithmetic.  */
  194. #define va_arg(pvar,TYPE)                    \
  195. __extension__                            \
  196. ({ TYPE __va_temp;                        \
  197.    ((__builtin_classify_type (__va_temp) >= 12)            \
  198.     ? ((pvar) = (char *)(pvar) + __va_rounded_size (TYPE *),    \
  199.        **(TYPE **) (void *) ((char *)(pvar) - __va_rounded_size (TYPE *))) \
  200.     : __va_rounded_size (TYPE) == 8                \
  201.     ? ({ union {char __d[sizeof (TYPE)]; int __i[2];} __u;    \
  202.      __u.__i[0] = ((int *) (void *) (pvar))[0];        \
  203.      __u.__i[1] = ((int *) (void *) (pvar))[1];        \
  204.      (pvar) = (char *)(pvar) + 8;                \
  205.      *(TYPE *) (void *) __u.__d; })                \
  206.     : ((pvar) = (char *)(pvar) + __va_rounded_size (TYPE),    \
  207.        *((TYPE *) (void *) ((char *)(pvar) - __va_rounded_size (TYPE)))));})
  208. #endif /* not __sparc_v9__ */
  209.  
  210. #endif /* defined (_STDARG_H) || defined (_VARARGS_H) */
  211.