开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 信息检索与抽取 > 查看源码
avcall.h.in
资源名称：swarm-2.2.tar.gz　[点击查看]
上传用户：shenzhenrh
上传日期：2013-05-12
资源大小：2904k
文件大小：55k
源码类别：

信息检索与抽取

开发平台：

Unix_Linux

avcall.h.in：源码内容
  1. #ifndef _avcall_h /*-*- C -*-*/
  2. #define _avcall_h
  3. /**
  4.   Copyright 1993 Bill Triggs, <Bill.Triggs@inrialpes.fr>
  6.   Copyright 1995-2004 Bruno Haible, <bruno@clisp.org>
  8.   This is free software distributed under the GNU General Public
  9.   Licence described in the file COPYING. Contact the author if
  10.   you don't have this or can't live with it. There is ABSOLUTELY
  11.   NO WARRANTY, explicit or implied, on this software.
  12. **/
  13. /*----------------------------------------------------------------------
  14.   av_call() foreign function interface.
  16.   Varargs-style macros to build a C argument list incrementally
  17.   and call a function on it.
  18.  ----------------------------------------------------------------------*/
  21. /* These definitions are adjusted by `configure' automatically. */
  23. /* CPU */
  24. #ifndef __i386__
  25. #undef __i386__
  26. #endif
  27. #ifndef __m68k__
  28. #undef __m68k__
  29. #endif
  30. #ifndef __mips__
  31. #undef __mips__
  32. #endif
  33. #ifndef __mipsn32__
  34. #undef __mipsn32__
  35. #endif
  36. #ifndef __mips64__
  37. #undef __mips64__
  38. #endif
  39. #ifndef __sparc__
  40. #undef __sparc__
  41. #endif
  42. #ifndef __sparc64__
  43. #undef __sparc64__
  44. #endif
  45. #ifndef __alpha__
  46. #undef __alpha__
  47. #endif
  48. #ifndef __hppa__
  49. #undef __hppa__
  50. #endif
  51. #ifndef __arm__
  52. #undef __arm__
  53. #endif
  54. #ifndef __rs6000__
  55. #undef __rs6000__
  56. #endif
  57. #ifndef __s390__
  58. #undef __s390__
  59. #endif
  60. #ifndef __m88k__
  61. #undef __m88k__
  62. #endif
  63. #ifndef __convex__
  64. #undef __convex__
  65. #endif
  66. #ifndef __ia64__
  67. #undef __ia64__
  68. #endif
  69. #ifndef __x86_64__
  70. #undef __x86_64__
  71. #endif
  73. /* Calling convention */
  74. /* Define if using pcc non-reentrant struct return convention */
  75. #undef __PCC_STRUCT_RETURN__
  76. /* Define if small structs are returned in registers */
  77. #undef __SMALL_STRUCT_RETURN__
  78. /* Define if floating-point results are returned in the integer registers */
  79. #undef __IREG_FLOAT_RETURN__
  81. /* CL_LONGLONG */
  82. /* Define if your compiler supports the `long long' type. */
  83. #undef HAVE_LONGLONG
  85. /* End of definitions adjusted by `configure'. */
  88. /* Max # words in argument-list and temporary structure storage.
  89.  */
  90. #ifndef __AV_ALIST_WORDS
  91. #define __AV_ALIST_WORDS  256
  92. #endif
  94. /* Determine the alignment of a type at compile time.
  95.  */
  96. #if defined(__GNUC__)
  97. #define __AV_alignof __alignof__
  98. #else
  99. #if defined(__mips__) || defined(__mipsn32__) || defined(__mips64__) /* SGI compiler */
  100. #define __AV_alignof __builtin_alignof
  101. #else
  102. #define __AV_offsetof(type,ident)  ((unsigned long)&(((type*)0)->ident))
  103. #define __AV_alignof(type)  __AV_offsetof(struct { char __slot1; type __slot2; }, __slot2)
  104. #endif
  105. #endif
  107. /* C builtin types.
  108.  */
  109. #if defined(__mipsn32__)
  110. typedef long long __avword;
  111. #else
  112. typedef long __avword;
  113. #endif
  115. enum __AVtype
  116. {
  117.   __AVword,
  118.   __AVvoid,
  119.   __AVchar,
  120.   __AVschar,
  121.   __AVuchar,
  122.   __AVshort,
  123.   __AVushort,
  124.   __AVint,
  125.   __AVuint,
  126.   __AVlong,
  127.   __AVulong,
  128.   __AVlonglong,
  129.   __AVulonglong,
  130.   __AVfloat,
  131.   __AVdouble,
  132.   __AVvoidp,
  133.   __AVstruct
  134. };
  136. enum __AV_alist_flags
  137. {
  139.   /* how to return structs */
  140.   /* There are basically 3 ways to return structs:
  141.    * a. The called function returns a pointer to static data. Not reentrant.
  142.    * b. The caller passes the return structure address in a dedicated register
  143.    *    or as a first (or last), invisible argument. The called function stores
  144.    *    its result there.
  145.    * c. Like b, and the called function also returns the return structure
  146.    *    address in the return value register. (This is not very distinguishable
  147.    *    from b.)
  148.    * Independently of this,
  149.    * r. small structures (<= 4 or <= 8 bytes) may be returned in the return
  150.    *    value register(s), or
  151.    * m. even small structures are passed in memory.
  152.    */
  153.   /* gcc-2.6.3 employs the following strategy:
  154.    *   - If PCC_STATIC_STRUCT_RETURN is defined in the machine description
  155.    *     it uses method a, else method c.
  156.    *   - If flag_pcc_struct_return is set (either by -fpcc-struct-return or if
  157.    *     DEFAULT_PCC_STRUCT_RETURN is defined to 1 in the machine description)
  158.    *     it uses method m, else (either by -freg-struct-return or if
  159.    *     DEFAULT_PCC_STRUCT_RETURN is defined to 0 in the machine description)
  160.    *     method r.
  161.    */
  162.   __AV_PCC_STRUCT_RETURN = 1<<0, /* a: need to copy the struct */
  163.   __AV_SMALL_STRUCT_RETURN = 1<<1, /* r: special case for small structs */
  164.   __AV_GCC_STRUCT_RETURN = 1<<2, /* consider 8 byte structs as small */
  165. #if defined(__sparc__) && !defined(__sparc64__)
  166.   __AV_SUNCC_STRUCT_RETURN = 1<<3,
  167.   __AV_SUNPROCC_STRUCT_RETURN = 1<<4,
  168. #endif
  169. #if defined(__i386__)
  170.   __AV_NEXTGCC_STRUCT_RETURN = 1<<3,
  171.   __AV_MSVC_STRUCT_RETURN = 1<<4,
  172. #endif
  173. #if defined(__hppa__)
  174.   __AV_OLDGCC_STRUCT_RETURN = 1<<3,
  175. #endif
  176.   /* the default way to return structs */
  177.   /* This choice here is based on the assumption that the function you are
  178.    * going to call has been compiled with the same compiler you are using to
  179.    * include this file.
  180.    * If you want to call functions with another struct returning convention,
  181.    * just  #define __AV_STRUCT_RETURN ...
  182.    * before or after #including <avcall.h>.
  183.    */
  184. #ifndef __AV_STRUCT_RETURN
  185.   __AV_STRUCT_RETURN =
  186. #if defined(__sparc__) && !defined(__sparc64__) && defined(sun) && defined(__SUNPRO_C) /* SUNWspro cc */
  187.   __AV_SUNPROCC_STRUCT_RETURN,
  188. #else
  189. #if defined(__PCC_STRUCT_RETURN__) /* defined through configure, see above */
  190.   __AV_PCC_STRUCT_RETURN |
  191. #if defined(__sparc__) && !defined(__sparc64__) && defined(sun) && !(defined(__STDC__) || defined(__GNUC__)) /* sun cc */
  192.      __AV_SUNCC_STRUCT_RETURN,
  193. #else
  194.      0,
  195. #endif
  196. #else
  197. #if defined(__SMALL_STRUCT_RETURN__) || defined(__mipsn32__) || defined(__mips64__) /* defined through configure, see above */
  198.   __AV_SMALL_STRUCT_RETURN |
  199. #endif
  200. #if defined(__GNUC__)
  201.   __AV_GCC_STRUCT_RETURN |
  202. #endif
  203. #if defined(__i386__) && defined(NeXT) && defined(__GNUC__) /* NeXT gcc-2.5.8 */
  204.   __AV_NEXTGCC_STRUCT_RETURN |
  205. #endif
  206. #if defined(__i386__) && defined(_MSC_VER) /* MSVC 4.0 */
  207.   __AV_MSVC_STRUCT_RETURN |
  208. #endif
  209. #if defined(__hppa__) && defined(__GNUC__) && (__GNUC__ < 3) && (__GNUC_MINOR__ < 7)
  210.   __AV_OLDGCC_STRUCT_RETURN |
  211. #endif
  212.      0,
  213. #endif
  214. #endif
  215. #endif
  217.   /* how to return floats */
  218. #if defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__))
  219.   __AV_SUNCC_FLOAT_RETURN = 1<<5,
  220. #endif
  221. #if defined(__m68k__)
  222.   __AV_FREG_FLOAT_RETURN = 1<<6,
  223. #endif
  224.   /* the default way to return floats */
  225.   /* This choice here is based on the assumption that the function you are
  226.    * going to call has been compiled with the same compiler you are using to
  227.    * include this file.
  228.    * If you want to call functions with another float returning convention,
  229.    * just  #define __AV_FLOAT_RETURN ...
  230.    * before or after #including <avcall.h>.
  231.    */
  232. #ifndef __AV_FLOAT_RETURN
  233. #if (defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__))) && !defined(__GNUC__) && defined(sun) && !defined(__SUNPRO_C)  /* sun cc */
  234.   __AV_FLOAT_RETURN = __AV_SUNCC_FLOAT_RETURN,
  235. #elif (defined(__m68k__) && !defined(__IREG_FLOAT_RETURN__))
  236.   __AV_FLOAT_RETURN = __AV_FREG_FLOAT_RETURN,
  237. #else
  238.   __AV_FLOAT_RETURN = 0,
  239. #endif
  240. #endif
  242.   /* how to pass structs */
  243. #if defined(__mips__) || defined(__mipsn32__) || defined(__mips64__)
  244.   __AV_SGICC_STRUCT_ARGS = 1<<7,
  245. #endif
  246. #if defined(__rs6000__)
  247.   __AV_AIXCC_STRUCT_ARGS = 1<<7,
  248. #endif
  249.   /* the default way to pass floats */
  250.   /* This choice here is based on the assumption that the function you are
  251.    * going to call has been compiled with the same compiler you are using to
  252.    * include this file.
  253.    * If you want to call functions with another float passing convention,
  254.    * just  #define __AV_STRUCT_ARGS ...
  255.    * before or after #including <avcall.h>.
  256.    */
  257. #ifndef __AV_STRUCT_ARGS
  258. #if (defined(__mips__) || defined(__mipsn32__) || defined(__mips64__)) && !defined(__GNUC__) /* SGI mips cc */
  259.   __AV_STRUCT_ARGS = __AV_SGICC_STRUCT_ARGS,
  260. #else
  261. #if defined(__rs6000__) && defined(_AIX) && !defined(__GNUC__) /* AIX cc, xlc */
  262.   __AV_STRUCT_ARGS = __AV_AIXCC_STRUCT_ARGS,
  263. #else
  264.   __AV_STRUCT_ARGS = 0,
  265. #endif
  266. #endif
  267. #endif
  269.   /* how to pass floats */
  270.   /* ANSI C compilers and GNU gcc pass floats as floats.
  271.    * K&R C compilers pass floats as doubles.
  272.    * (Except some compilers like SGI MIPS "cc" and "cc -cckr" if a prototype is
  273.    * known for the called functions. But to compile a program with prototypes,
  274.    * "cc -ansi" is better anyway.
  275.    */
  276.   __AV_ANSI_FLOAT_ARGS = 0,    /* pass floats as floats */
  277.   __AV_TRADITIONAL_FLOAT_ARGS = 1<<8, /* pass floats as doubles */
  278.   /* the default way to pass floats */
  279.   /* This choice here is based on the assumption that the function you are
  280.    * going to call has been compiled with the same compiler you are using to
  281.    * include this file.
  282.    * If you want to call functions with another float passing convention,
  283.    * just  #define __AV_FLOAT_ARGS ...
  284.    * before or after #including <avcall.h>.
  285.    */
  286. #ifndef __AV_FLOAT_ARGS
  287. #if defined(__STDC__) || defined(__GNUC__) /* what about hppa "cc -Aa" ?? */
  288.   __AV_FLOAT_ARGS = __AV_ANSI_FLOAT_ARGS,
  289. #else
  290.   __AV_FLOAT_ARGS = __AV_TRADITIONAL_FLOAT_ARGS,
  291. #endif
  292. #endif
  294.   /* how to pass and return small integer arguments */
  295.   __AV_ANSI_INTEGERS = 0, /* no promotions */
  296.   __AV_TRADITIONAL_INTEGERS = 0, /* promote [u]char, [u]short to [u]int */
  297.   /* Fortunately these two methods are compatible. Our macros work with both. */
  298.   /* the default way to pass and return small integer arguments */
  299.   /* This choice here is based on the assumption that the function you are
  300.    * going to call has been compiled with the same compiler you are using to
  301.    * include this file.
  302.    * If you want to call functions with another float passing convention,
  303.    * just  #define __AV_INTEGERS ...
  304.    * before or after #including <avcall.h>.
  305.    */
  306. #ifndef __AV_INTEGERS
  307. #if defined(__STDC__) || defined(__GNUC__)
  308.   __AV_INTEGERS = __AV_ANSI_INTEGERS,
  309. #else
  310.   __AV_INTEGERS = __AV_TRADITIONAL_INTEGERS,
  311. #endif
  312. #endif
  314.   /* stack cleanup policy */
  315.   __AV_CDECL_CLEANUP = 0, /* caller pops args after return */
  316.   __AV_STDCALL_CLEANUP = 0, /* callee pops args before return */
  317.      /* currently only supported on __i386__ */
  318. #ifndef __AV_CLEANUP
  319.   __AV_CLEANUP = __AV_CDECL_CLEANUP,
  320. #endif
  322.   /* These are for internal use only */
  323. #if defined(__i386__) || defined(__m68k__) || defined(__mipsn32__) || defined(__mips64__) || defined(__sparc64__) || defined(__alpha__) || defined(__arm__) || defined(__rs6000__) || defined(__convex__) || defined(__ia64__) || defined(__x86_64__) || defined(__s390__)
  324.   __AV_REGISTER_STRUCT_RETURN = 1<<9,
  325. #endif
  326. #if defined(__mips__) && !defined(__mipsn32__)
  327.   __AV_FLOAT_1 = 1<<10,
  328.   __AV_FLOAT_2 = 1<<11,
  329. #endif
  331.   __AV_flag_for_broken_compilers_that_dont_like_trailing_commas
  332. };
  334. typedef struct
  335. {
  336.   /* function to be called */
  337.   __avword (*func)();
  338.   /* some av_... macros need these flags */
  339.   int flags;
  340.   /* return type, address for the result */
  341.   void* raddr;
  342.   enum __AVtype rtype;
  343.   unsigned long rsize;
  344.   /* current pointer into the args[] array */
  345.   __avword* aptr;
  346. #if defined(__sparc__) || defined(__sparc64__) || defined(__hppa__) || (defined(__rs6000__) && !defined(_AIX) && !(defined(__MACH__) && defined(__APPLE__))) || defined(__s390__)
  347.   /* limit pointer into the args[] array */
  348.   __avword* eptr;
  349. #endif
  350. #if defined(__i386__) && 0
  351.   /* Filler word, needed if the numbers of words up to now in this structure */
  352.   /* is odd (because on MSVC, alignof(double) = 8, normally = 4).            */
  353.   __avword filler1;
  354. #endif
  355. #if defined(__i386__) || defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__hppa__) || defined(__arm__) || defined(__rs6000__) || defined(__convex__) || defined(__s390__)
  356.   /* temporary storage, used to split doubles into two words */
  357.   union {
  358.     double _double;
  359. #if defined(__sparc__) && !defined(__sparc64__) && defined(HAVE_LONGLONG)
  360.     long long _longlong;
  361. #endif
  362.     __avword words[2];
  363.   } tmp;
  364. #endif
  365. #if defined(__x86_64__)
  366.   /* store the integer arguments in an extra array */
  367.   __avword* iaptr;
  368.   __avword iargs[6];
  369. #endif
  370. #if defined(__mips__) && !defined(__mipsn32__)
  371.   /* store the floating-point arguments in an extra array */
  372.   int anum;
  373.   double floatarg[2];
  374. #endif
  375. #if defined(__mipsn32__) || defined(__mips64__)
  376.   /* store the floating-point arguments in an extra array */
  377.   int anum; /* redundant: (LIST).aptr = &(LIST).args[(LIST).anum] */
  378.   unsigned int farg_mask; /* bitmask of those entries in farg[] which have a value */
  379.   unsigned int darg_mask; /* bitmask of those entries in args[] which have a double value */
  380.   float farg[8];
  381. #endif
  382. #if defined(__sparc64__)
  383.   /* store the floating-point arguments in an extra array */
  384.   int anum; /* redundant: (LIST).aptr = &(LIST).args[(LIST).anum] */
  385.   unsigned int farg_mask; /* bitmask of those entries in farg[] which have a value */
  386.   unsigned int darg_mask; /* bitmask of those entries in args[] which have a double value */
  387. #endif
  388. #if defined(__ia64__) || defined(__x86_64__)
  389.   /* store the floating-point arguments in an extra array */
  390.   double* faptr;
  391.   double fargs[8];
  392. #endif
  393.   __avword args[__AV_ALIST_WORDS]; /* sizeof(double)-aligned */
  394. #if defined(__rs6000__)
  395.   /* store the floating-point arguments in an extra array */
  396.   double* faptr;
  397.   double fargs[13];
  398. #endif
  399. #if defined(__s390__)
  400.   /* store the floating-point arguments in an extra array */
  401.   int    fargwords;
  402.   float* faptr;
  403.   float  fargs[2];
  404.   int* fargsusedptr;
  405.   int fargsused[2];
  406.   double* daptr;
  407.   double dargs[2];
  408.   int* dargsusedptr;
  409.   int dargsused[2];
  410. #endif
  411. #if defined(AMIGA)
  412.   /* store the arguments passed in registers in an extra array */
  413.   __avword regargs[8+7];
  414. #endif
  415. } av_alist;
  417. /* The limit for the pointer into the args[] array. */
  418. #if defined(__sparc__) || defined(__sparc64__) || defined(__hppa__) || (defined(__rs6000__) && !defined(_AIX) && !(defined(__MACH__) && defined(__APPLE__))) || defined(__s390)
  419. #define __av_eptr(LIST) ((LIST).eptr)
  420. #else
  421. #define __av_eptr(LIST) (&(LIST).args[__AV_ALIST_WORDS])
  422. #endif
  424. /* Delayed overflow detection */
  425. #if defined(__hppa__)
  426. #define av_overflown(LIST) ((LIST).aptr < __av_eptr(LIST))
  427. #else
  428. #define av_overflown(LIST) ((LIST).aptr > __av_eptr(LIST))
  429. #endif
  432. /*
  433.  *  av_start_<type> macros which specify the return type
  434.  */
  436. #define __AV_START_FLAGS  
  437.   __AV_STRUCT_RETURN | __AV_FLOAT_RETURN | __AV_STRUCT_ARGS | __AV_FLOAT_ARGS | __AV_INTEGERS | __AV_CLEANUP
  439. #define __av_start(LIST,FUNC,RADDR,RETTYPE)
  440.   ((LIST).func = (__avword(*)())(FUNC),
  441.    (LIST).raddr = (void*)(RADDR),
  442.    (LIST).rtype = (RETTYPE),
  443.    __av_start1(LIST)
  444.    (LIST).flags = __AV_START_FLAGS)
  446. #if defined(__i386__) || defined(__m68k__) || defined(__alpha__) || defined(__arm__) || defined(__m88k__) || defined(__convex__)
  447. #define __av_start1(LIST)
  448.    (LIST).aptr = &(LIST).args[0],
  449. #endif
  450. #if defined(__mips__) && !defined(__mipsn32__)
  451. #define __av_start1(LIST)
  452.    (LIST).anum = 0,
  453.    (LIST).aptr = &(LIST).args[0],
  454. #endif
  455. #if defined(__mipsn32__) || defined(__mips64__)
  456. #define __av_start1(LIST)
  457.    (LIST).anum = 0,
  458.    (LIST).farg_mask = 0,
  459.    (LIST).darg_mask = 0,
  460.    (LIST).aptr = &(LIST).args[0],
  461. #endif
  462. #if defined(__sparc__) && !defined(__sparc64__)
  463. #define __av_start1(LIST)
  464.    (LIST).aptr = &(LIST).args[0],
  465.    (LIST).eptr = &(LIST).args[__AV_ALIST_WORDS],
  466. #endif
  467. #if defined(__sparc64__)
  468. #define __av_start1(LIST)
  469.    (LIST).anum = 0,
  470.    (LIST).farg_mask = 0,
  471.    (LIST).darg_mask = 0,
  472.    (LIST).aptr = &(LIST).args[0],
  473.    (LIST).eptr = &(LIST).args[__AV_ALIST_WORDS],
  474. #endif
  475. #if defined(__hppa__)
  476. #define __av_start1(LIST)
  477.    (LIST).aptr = &(LIST).args[__AV_ALIST_WORDS],
  478.    (LIST).eptr = &(LIST).args[0],
  479. #endif
  480. #if defined(__rs6000__)
  481. #if defined(_AIX) || (defined(__MACH__) && defined(__APPLE__))
  482. #define __av_start1(LIST)
  483.    (LIST).aptr = &(LIST).args[0],
  484.    (LIST).faptr = &(LIST).fargs[0],
  485. #else
  486. #define __av_start1(LIST)
  487.    (LIST).aptr = &(LIST).args[0],
  488.    (LIST).faptr = &(LIST).fargs[0],                                     
  489.    (LIST).eptr = &(LIST).args[__AV_ALIST_WORDS],
  490. #endif
  491. #endif
  492. #if defined(__s390__)
  493. #define __av_start1(LIST)
  494.    (LIST).aptr = &(LIST).args[0],
  495.    (LIST).fargwords = 0,
  496.    (LIST).faptr = &(LIST).fargs[0],                                     
  497.    (LIST).daptr = &(LIST).dargs[0],                                     
  498.    (LIST).fargsusedptr = &(LIST).fargsused[0],                          
  499.    (LIST).dargsusedptr = &(LIST).dargsused[0],                          
  500.    (LIST).eptr = &(LIST).args[__AV_ALIST_WORDS],
  501. #endif
  502. #if defined(__ia64__)
  503. #define __av_start1(LIST)
  504.    (LIST).aptr = &(LIST).args[0],
  505.    (LIST).faptr = &(LIST).fargs[0],
  506. #endif
  507. #if defined(__x86_64__)
  508. #define __av_start1(LIST)
  509.    (LIST).aptr = &(LIST).args[0],
  510.    (LIST).iaptr = &(LIST).iargs[0],
  511.    (LIST).faptr = &(LIST).fargs[0],
  512. #endif
  514. #define av_start_void(LIST,FUNC) __av_start(LIST,FUNC,0,    __AVvoid)
  515. #define av_start_char(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVchar)
  516. #define av_start_schar(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVschar)
  517. #define av_start_uchar(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVuchar)
  518. #define av_start_short(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVshort)
  519. #define av_start_ushort(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVushort)
  520. #define av_start_int(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVint)
  521. #define av_start_uint(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVuint)
  522. #define av_start_long(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVlong)
  523. #define av_start_ulong(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVulong)
  524. #define av_start_longlong(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVlonglong)
  525. #define av_start_ulonglong(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVulonglong)
  526. #define av_start_float(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVfloat)
  527. #define av_start_double(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVdouble)
  528. #define av_start_ptr(LIST,FUNC,TYPE,RADDR) __av_start(LIST,FUNC,RADDR,__AVvoidp)
  530. #define av_start_struct(LIST,FUNC,TYPE,TYPE_SPLITTABLE,RADDR)
  531.   _av_start_struct(LIST,FUNC,sizeof(TYPE),TYPE_SPLITTABLE,RADDR)
  532. #define _av_start_struct(LIST,FUNC,TYPE_SIZE,TYPE_SPLITTABLE,RADDR)
  533.   (__av_start(LIST,FUNC,RADDR,__AVstruct),
  534.    (LIST).rsize = TYPE_SIZE,
  535.    __av_start_struct1(LIST,TYPE_SIZE,TYPE_SPLITTABLE),
  536.    0)
  538. #define __av_start_struct1(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  539.   ((LIST).flags & __AV_PCC_STRUCT_RETURN
  540.    ? /* pcc struct return convention:
  541.       * called function returns pointer to value, we'll copy its contents afterwards. 
  542.       */
  543.      0
  544.    : __av_start_struct2(LIST,TYPE_SIZE,TYPE_SPLITTABLE)
  545.   )
  546. #if (defined(__sparc__) && !defined(__sparc64__)) || defined(__m88k__)
  547. /* Return structure pointer is passed in a special register.
  548.  */
  549. #define __av_start_struct2(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  0
  550. #else
  551. #define __av_start_struct2(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  552.   (((LIST).flags & __AV_SMALL_STRUCT_RETURN)
  553.    && __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)
  554.    ? /* <= Word-sized structures are returned in a register. */
  555.      __av_start_struct3(LIST)
  556.    : __av_start_struct4(LIST,TYPE_SIZE)
  557.   )
  558. /* Determines whether a structure is returned in registers,
  559.  * depending on its size and its word-splittable flag.
  560.  */
  561. #if (defined(__i386__) && defined(_WIN32))
  562. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  563.   ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4
  564.    || ((TYPE_SIZE) == 8
  565.        && (((LIST).flags & __AV_MSVC_STRUCT_RETURN)
  566.            || ((TYPE_SPLITTABLE)
  567.                && ((LIST).flags & __AV_GCC_STRUCT_RETURN)
  568.   )   )   )   )
  569. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  570.  * and the struct will actually be returned in registers.
  571.  */
  572. #define __av_start_struct3(LIST)  
  573.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  574. #endif
  575. #if (defined(__i386__) && !defined(_WIN32)) || defined(__m68k__) || defined(__arm__) || defined(__rs6000__) || defined(__convex__) || defined(__s390__)
  576. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  577.   ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4
  578.    || ((TYPE_SIZE) == 8 && (TYPE_SPLITTABLE)
  579.        && ((LIST).flags & __AV_GCC_STRUCT_RETURN)
  580.   )   )
  581. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  582.  * and the struct will actually be returned in registers.
  583.  */
  584. #define __av_start_struct3(LIST)  
  585.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  586. #endif
  587. #if defined(__alpha__)
  588. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  589.   ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4 || (TYPE_SIZE) == 8
  590.    || ((TYPE_SIZE) == 16 && (TYPE_SPLITTABLE)
  591.        && ((LIST).flags & __AV_GCC_STRUCT_RETURN)
  592.   )   )
  593. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  594.  * and the struct will actually be returned in registers.
  595.  */
  596. #define __av_start_struct3(LIST)  
  597.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  598. #endif
  599. #if defined(__hppa__)
  600. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  601.   ((LIST).flags & __AV_OLDGCC_STRUCT_RETURN
  602.    ? ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4)
  603.    : ((TYPE_SIZE) <= 8)
  604.   )
  605. /* Test both __AV_OLDGCC_STRUCT_RETURN and __AV_SMALL_STRUCT_RETURN at run time. */
  606. #define __av_start_struct3(LIST)  
  607.   0
  608. #endif
  609. #if defined(__mips__) && !defined(__mipsn32__)
  610. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  611.   ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4)
  612. /* Test __AV_SMALL_STRUCT_RETURN instead of __AV_REGISTER_STRUCT_RETURN. */
  613. #define __av_start_struct3(LIST)  
  614.   0
  615. #endif
  616. #if defined(__mipsn32__) || defined(__mips64__)
  617. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  618.   ((LIST).flags & __AV_GCC_STRUCT_RETURN
  619.    ? ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4 || (TYPE_SIZE) == 8) 
  620.    : ((TYPE_SIZE) <= 16)
  621.   )
  622. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  623.  * and the struct will actually be returned in registers.
  624.  */
  625. #define __av_start_struct3(LIST)  
  626.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  627. #endif
  628. #if defined(__sparc64__) || defined(__ia64__)
  629. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  630.   ((TYPE_SIZE) <= 32)
  631. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  632.  * and the struct will actually be returned in registers.
  633.  */
  634. #define __av_start_struct3(LIST)  
  635.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  636. #endif
  637. #if defined(__x86_64__)
  638. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  639.   ((TYPE_SIZE) <= 16)
  640. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  641.  * and the struct will actually be returned in registers.
  642.  */
  643. #define __av_start_struct3(LIST)  
  644.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  645. #endif
  646. #if defined(__i386__)
  647. /* Return structure pointer is passed in a special register or as first arg. */
  648. #define __av_start_struct4(LIST,TYPE_SIZE)
  649.   ((LIST).flags & __AV_NEXTGCC_STRUCT_RETURN
  650.    ? 0  /* special register */
  651.    : (*(LIST).aptr++ = (__avword)((LIST).raddr), 0) /* first arg */
  652.   )
  653. #endif
  654. #if defined(__m68k__) || defined(__hppa__) || defined(__ia64__)
  655. /* Return structure pointer is passed in a special register.
  656.  */
  657. #define __av_start_struct4(LIST,TYPE_SIZE)  0
  658. #endif
  659. /* Return structure pointer is passed as first arg.
  660.  */
  661. #if defined(__alpha__) || defined(__arm__) || defined(__rs6000__) || defined(__convex__) || defined(__s390__)
  662. #define __av_start_struct4(LIST,TYPE_SIZE)
  663.    (*(LIST).aptr++ = (__avword)((LIST).raddr), 0)
  664. #endif
  665. #if defined(__mips__) || defined(__mipsn32__) || defined(__mips64__) || defined(__sparc64__)
  666. #define __av_start_struct4(LIST,TYPE_SIZE)
  667.    (*(LIST).aptr++ = (__avword)((LIST).raddr),
  668.     (LIST).anum++,
  669.     0
  670.    )
  671. #endif
  672. #if defined(__x86_64__)
  673. #define __av_start_struct4(LIST,TYPE_SIZE)
  674.    (*(LIST).iaptr++ = (__avword)((LIST).raddr), 0)
  675. #endif
  676. #endif
  679. /*
  680.  * av_<type> macros which specify the argument and its type
  681.  */
  683. /*
  684.  * scalar argument types
  685.  */
  687. #if defined(__i386__) || defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__alpha__) || defined(__arm__) || defined(__rs6000__) || defined(__m88k__) || defined(__convex__) || defined(__ia64__) || defined(__x86_64__) || defined(__s390__)
  688. /* Floats and all integer types are passed as words,
  689.  * doubles as two words.
  690.  */
  691. #define __av_word(LIST,VAL)
  692.   (++(LIST).aptr > __av_eptr(LIST)
  693.    ? -1 : ((LIST).aptr[-1] = (__avword)(VAL), 0))
  694. #endif
  695. #if defined(__mips__) || defined(__mipsn32__) || defined(__mips64__) || defined(__sparc64__)
  696. /* Most things are passed as integers:
  697.  */
  698. #define __av_word(LIST,VAL)
  699.   (++(LIST).aptr > __av_eptr(LIST)
  700.    ? -1 : ((LIST).anum++, (LIST).aptr[-1] = (__avword)(VAL), 0))
  701. #endif
  702. #if defined(__hppa__)
  703. /* Floats and all integer types are passed as words,
  704.  * doubles as two words.
  705.  */
  706. #define __av_word(LIST,VAL)
  707.   (--(LIST).aptr < __av_eptr(LIST)
  708.    ? -1 : (*(LIST).aptr = (__avword)(VAL), 0))
  709. #endif
  710. #if defined(AMIGA)
  711. /* Some arguments are passed in registers. Query the macro AV_ARG_REGNUM.
  712.  * This should really be an argument to __av_word.
  713.  */
  714. #undef __av_word /**/
  715. #define __av_word(LIST,VAL)
  716.   ((AV_ARG_REGNUM) >= 0
  717.    ? ((AV_ARG_REGNUM) < 8+7
  718.       ? -1 : ((LIST).regargs[(AV_ARG_REGNUM)] = (__avword)(VAL), 0))
  719.    : (++(LIST).aptr > __av_eptr(LIST)
  720.       ? -1 : ((LIST).aptr[-1] = (__avword)(VAL), 0)))
  721. #endif
  723. /* integer argument types */
  725. #if defined(__x86_64__)
  726. /* The first 6 integer arguments are passed in registers. */
  727. #define av_long(LIST,VAL)
  728.   ((LIST).iaptr < &(LIST).iargs[6]
  729.    ? (*(LIST).iaptr++ = (long)(VAL), 0)
  730.    : __av_word(LIST,(long)(VAL)))
  731. #else
  732. #define av_long(LIST,VAL) __av_word(LIST,(long)(VAL))
  733. #endif
  735. #if defined(__x86_64__)
  736. /* The first 6 integer arguments are passed in registers. */
  737. #define av_ulong(LIST,VAL)
  738.   ((LIST).iaptr < &(LIST).iargs[6]
  739.    ? (*(LIST).iaptr++ = (unsigned long)(VAL), 0)
  740.    : __av_word(LIST,(unsigned long)(VAL)))
  741. #else
  742. #define av_ulong(LIST,VAL) __av_word(LIST,(unsigned long)(VAL))
  743. #endif
  745. #if defined(__x86_64__)
  746. /* The first 6 integer arguments are passed in registers. */
  747. #define av_ptr(LIST,TYPE,VAL)
  748.   ((LIST).iaptr < &(LIST).iargs[6]
  749.    ? (*(LIST).iaptr++ = (__avword)(TYPE)(VAL), 0)
  750.    : __av_word(LIST,(TYPE)(VAL)))
  751. #else
  752. #define av_ptr(LIST,TYPE,VAL) __av_word(LIST,(TYPE)(VAL))
  753. #endif
  755. #define av_char av_long
  756. #define av_schar av_long
  757. #define av_short av_long
  758. #define av_int av_long
  759. #define av_uchar av_ulong
  760. #define av_ushort av_ulong
  761. #define av_uint av_ulong
  763. #if defined(__mips64__) || defined(__sparc64__) || defined(__alpha__) || defined(__ia64__) || defined(__x86_64__)
  764. /* `long long' and `long' are identical. */
  765. #define av_longlong av_long
  766. #define av_ulonglong av_ulong
  767. #elif defined(__mipsn32__)
  768. /* `long long' fits in __avword. */
  769. #define av_longlong __av_word
  770. #define av_ulonglong(LIST,VAL) __av_word(LIST,(unsigned long long)(VAL))
  771. #elif defined(__i386__) || defined(__m68k__) || defined(__mips__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__hppa__) || defined(__arm__) || defined(__rs6000__) || defined(__m88k__) || defined(__convex__) || defined(__s390__)
  772. /* `long long's are passed embedded on the arg stack. */
  773. #define av_longlong(LIST,VAL) __av_longlong(LIST,long long,VAL)
  774. #define av_ulonglong(LIST,VAL) __av_longlong(LIST,unsigned long long,VAL)
  775. #if defined(__i386__) || defined(__m68k__) || defined(__arm__) || (defined(__rs6000__) && (defined(_AIX) || (defined(__MACH__) && defined(__APPLE__)))) || defined(__convex__)
  776. /* `long long's are (at most) word-aligned. */
  777. #define __av_longlong(LIST,TYPE,VAL)
  778.   (((LIST).aptr += sizeof(TYPE)/sizeof(__avword)) > __av_eptr(LIST)
  779.    ? -1 : (((TYPE*)(LIST).aptr)[-1] = (TYPE)(VAL), 0))
  780. #endif
  781. #if defined(__mips__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__hppa__) || (defined(__rs6000__) && !(defined(_AIX) || (defined(__MACH__) && defined(__APPLE__)))) || defined(__m88k__) || defined(__s390__)
  782. /* `long long's have alignment 8. */
  783. #if defined(__mips__)
  784. #define __av_longlong(LIST,TYPE,VAL)
  785.   (((LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(TYPE)+__AV_alignof(TYPE)-1) & -(long)__AV_alignof(TYPE))) > __av_eptr(LIST) 
  786.    ? -1 : ((LIST).anum++, ((TYPE*)(LIST).aptr)[-1] = (TYPE)(VAL), 0))
  787. #endif
  788. #if defined(__sparc__) && !defined(__sparc64__)
  789. /* Within the arg stack, the alignment is only 4, not 8. */
  790. /* This assumes sizeof(long long) == 2*sizeof(__avword). */
  791. #define __av_longlong(LIST,TYPE,VAL)
  792.   (((LIST).aptr += sizeof(TYPE)/sizeof(__avword)) > __av_eptr(LIST)
  793.    ? -1 :
  794.    ((LIST).tmp._longlong = (TYPE)(VAL),
  795.     (LIST).aptr[-2] = (LIST).tmp.words[0],
  796.     (LIST).aptr[-1] = (LIST).tmp.words[1],
  797.     0))
  798. #endif
  799. #if defined(__hppa__)
  800. #define __av_longlong(LIST,TYPE,VAL)
  801.   (((LIST).aptr = (__avword*)(((__avword)(LIST).aptr & -(long)__AV_alignof(TYPE)) - sizeof(TYPE))) < __av_eptr(LIST) 
  802.    ? -1 : (*(TYPE*)(LIST).aptr = (TYPE)(VAL), 0))
  803. #endif
  804. #if (defined(__rs6000__) && !(defined(_AIX) || (defined(__MACH__) && defined(__APPLE__)))) || defined(__m88k__)
  805. #define __av_longlong(LIST,TYPE,VAL)
  806.   (((LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(TYPE)+__AV_alignof(TYPE)-1) & -(long)__AV_alignof(TYPE))) > __av_eptr(LIST) 
  807.    ? -1 : (((TYPE*)(LIST).aptr)[-1] = (TYPE)(VAL), 0))
  808. #endif
  809. #if defined(__s390__)
  810. #define __av_longlong(LIST,TYPE,VAL)
  811.   (((LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(TYPE)+__AV_alignof(TYPE)-1) & -(long)__AV_alignof(TYPE))) > __av_eptr(LIST) 
  812.    ? -1 :
  813.    (((LIST).aptr - (LIST).args - (LIST).fargwords == 4 ? ++(LIST).aptr,0 : 0), 
  814.     (((TYPE*)(LIST).aptr)[-1] = (TYPE)(VAL), 0)))
  815. #endif
  816. #endif
  817. #endif
  819. /* floating-point argument types */
  821. #define av_float(LIST,VAL)
  822.   ((LIST).flags & __AV_TRADITIONAL_FLOAT_ARGS
  823.    ? av_double(LIST,(float)(VAL))
  824.    : __av_float(LIST,VAL))
  826. #if defined(__i386__) || defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__arm__) || defined(__convex__)
  828. #define __av_float(LIST,VAL)
  829.   (++(LIST).aptr > __av_eptr(LIST)
  830.    ? -1 : (((float*)(LIST).aptr)[-1] = (float)(VAL), 0))
  832. /* This assumes sizeof(double) == 2*sizeof(__avword). */
  833. #define av_double(LIST,VAL)
  834.    (((LIST).aptr += 2) > __av_eptr(LIST)
  835.     ? -1 :
  836.     ((LIST).tmp._double = (double)(VAL),
  837.      (LIST).aptr[-2] = (LIST).tmp.words[0],
  838.      (LIST).aptr[-1] = (LIST).tmp.words[1],
  839.      0))
  841. #endif
  843. #if defined(__mips__) && !defined(__mipsn32__)
  845. /* Up to 2 leading float or double non-varargs args can be passed in
  846.  * float registers, but we also push them into the corresponding int
  847.  * registers in case of varargs. For doubles we need to align the aptr
  848.  * to an even boundary.
  849.  */
  850. #define __av_float(LIST,VAL)
  851.   (++(LIST).aptr > __av_eptr(LIST)
  852.    ? -1 : ((++(LIST).anum == 1
  853.     ? ((LIST).flags |= __AV_FLOAT_1,
  854.        ((float*)(LIST).floatarg)[1] = ((float*)(LIST).aptr)[-1] = (float)(VAL))
  855.     : (LIST).anum == 2 && ((LIST).flags & __AV_FLOAT_1)
  856.     ? ((LIST).flags |= __AV_FLOAT_2,
  857.        ((float*)(LIST).floatarg)[3] = ((float*)(LIST).aptr)[-1] = (float)(VAL))
  858.     : (*(float*)&(LIST).aptr[-1] = (float)(VAL))),
  859.    0))
  861. #define av_double(LIST,VAL)
  862.   (((LIST).aptr = (__avword*)(((__avword)(LIST).aptr+15)&-8))
  863.    > __av_eptr(LIST)
  864.    ? -1 : ((++(LIST).anum == 1
  865.     ? ((LIST).flags |= __AV_FLOAT_1,
  866.        (LIST).floatarg[0] = ((double*)(LIST).aptr)[-1] = (double)(VAL))
  867.     : (LIST).anum == 2 && ((LIST).flags & __AV_FLOAT_1)
  868.     ? ((LIST).flags |= __AV_FLOAT_2,
  869.        (LIST).floatarg[1] = ((double*)(LIST).aptr)[-1] = (double)(VAL))
  870.     : (((double*)(LIST).aptr)[-1] = (double)(VAL))),
  871.    0))
  873. #endif
  875. #if defined(__mipsn32__) || defined(__mips64__)
  877. /* Up to 8 leading float or double non-varargs args can be passed in
  878.  * float registers, but we also push them into the corresponding int
  879.  * registers in case of varargs.
  880.  */
  881. #define __av_float(LIST,VAL)
  882.   ((LIST).aptr >= __av_eptr(LIST)
  883.    ? -1 : (((LIST).anum < 8
  884.     ? ((LIST).farg_mask |= (1 << (LIST).anum),
  885.        (LIST).farg[(LIST).anum] = *(float*)(LIST).aptr = (float)(VAL)) 
  886.     : (*(float*)(LIST).aptr = (float)(VAL))),
  887.    (LIST).anum++,
  888.    (LIST).aptr++,
  889.    0))
  891. #define av_double(LIST,VAL)
  892.   ((LIST).aptr >= __av_eptr(LIST)
  893.    ? -1 : (((LIST).anum < 8 && ((LIST).darg_mask |= (1 << (LIST).anum))), 
  894.    *(double*)(LIST).aptr = (double)(VAL),
  895.    (LIST).anum++,
  896.    (LIST).aptr++,
  897.    0))
  899. #endif
  901. #if defined(__sparc64__)
  903. /* Up to 16 leading float or double non-varargs args can be passed in
  904.  * float registers, but we also push them into the corresponding int
  905.  * registers in case of varargs.
  906.  */
  907. #define __av_float(LIST,VAL)
  908.   ((LIST).aptr >= __av_eptr(LIST)
  909.    ? -1 : (((LIST).anum < 16 && ((LIST).farg_mask |= (1 << (LIST).anum))), 
  910.    (*(float*)(LIST).aptr = (float)(VAL)),
  911.    (LIST).anum++,
  912.    (LIST).aptr++,
  913.    0))
  915. #define av_double(LIST,VAL)
  916.   ((LIST).aptr >= __av_eptr(LIST)
  917.    ? -1 : (((LIST).anum < 16 && ((LIST).darg_mask |= (1 << (LIST).anum))), 
  918.    *(double*)(LIST).aptr = (double)(VAL),
  919.    (LIST).anum++,
  920.    (LIST).aptr++,
  921.    0))
  923. #endif
  925. #if defined(__alpha__)
  927. #define av_double(LIST,VAL)
  928.   (++(LIST).aptr > __av_eptr(LIST)
  929.    ? -1 : (((double*)(LIST).aptr)[-1] = (double)(VAL), 0))
  931. #define __av_float(LIST,VAL)
  932.   (++(LIST).aptr > __av_eptr(LIST)
  933.    ? -1
  934.    : (((LIST).aptr > &(LIST).args[6]
  935.        ? /* These args will be fetched from memory using "lds" instructions */ 
  936.  /* therefore store them as floats */
  937.  (*(float*)((LIST).aptr-1) = (float)(VAL))
  938.        : /* The first 6 args will be put into registers by "ldt" instructions */ 
  939.  /* (see avcall-alpha.c!). Therefore store them as doubles. */
  940.  /* When viewed as floats, the value will be the correct one. */
  941.  (*(double*)((LIST).aptr-1) = (double)(float)(VAL))
  942.      ), 0))
  944. #endif
  946. #if defined(__hppa__)
  948. #define __av_float(LIST,VAL)
  949.   (--(LIST).aptr < __av_eptr(LIST)
  950.    ? -1 : (*(float*)(LIST).aptr = (float)(VAL), 0))
  952. #define av_double(LIST,VAL)
  953.   (((LIST).aptr = (__avword*)(((long)(LIST).aptr-sizeof(double)) & -(long)sizeof(double))) 
  954.     < __av_eptr(LIST)
  955.     ? -1 : (*(double*)(LIST).aptr = (double)(VAL), 0))
  957. #endif
  959. #if defined(__rs6000__) && (defined(_AIX) || (defined(__MACH__) && defined(__APPLE__)))
  961. /* Up to 13 float or double non-varargs args can be passed in
  962.  * float registers, but we also push them into the corresponding int
  963.  * registers in case of varargs.
  964.  */
  966. #define __av_float(LIST,VAL)
  967.   (++(LIST).aptr > __av_eptr(LIST)
  968.    ? -1 : (((float*)(LIST).aptr)[-1] = (float)(VAL),
  969.    (LIST).faptr < &(LIST).fargs[13] &&
  970. (*(LIST).faptr++ = (double)(float)(VAL)),
  971.    0))
  973. #define av_double(LIST,VAL)
  974.    (((LIST).aptr += 2) > __av_eptr(LIST)
  975.     ? -1 :
  976.     ((LIST).tmp._double = (double)(VAL),
  977.      (LIST).aptr[-2] = (LIST).tmp.words[0],
  978.      (LIST).aptr[-1] = (LIST).tmp.words[1],
  979.      (LIST).faptr < &(LIST).fargs[13] &&
  980. (*(LIST).faptr++ = (LIST).tmp._double),
  981.      0))
  983. #endif
  985. #if defined(__rs6000__) && !(defined(_AIX) || (defined(__MACH__) && defined(__APPLE__)))
  987. /* Up to 8 float or double non-varargs args can be passed in
  988.  * float registers, without occupying space in the general registers.
  989.  */
  991. #define __av_float(LIST,VAL)
  992.   ((LIST).faptr < &(LIST).fargs[8]
  993.    ? ((*(LIST).faptr++ = (double)(float)(VAL)), 0)
  994.    : (++(LIST).aptr > __av_eptr(LIST)
  995.       ? -1 : (((float*)(LIST).aptr)[-1] = (float)(VAL), 0)))
  997. #define av_double(LIST,VAL)
  998.   ((LIST).faptr < &(LIST).fargs[8]
  999.    ? ((*(LIST).faptr++ = (double)(VAL)), 0)
  1000.    : (((LIST).aptr += 2) > __av_eptr(LIST)
  1001.       ? -1 :
  1002.       ((LIST).tmp._double = (double)(VAL),
  1003.        (LIST).aptr[-2] = (LIST).tmp.words[0],
  1004.        (LIST).aptr[-1] = (LIST).tmp.words[1],
  1005.        0)))
  1007. #endif
  1009. #if defined(__s390__)
  1011. /* Up to 2 float or double non-varargs args can be passed in
  1012.  * float registers, without occupying space in the general registers.
  1013.  */
  1015. #define __av_float(LIST,VAL)
  1016.   ((LIST).faptr < &(LIST).fargs[2]
  1017.    ? (LIST).daptr++, *(LIST).fargsusedptr++ = 1, *(LIST).dargsusedptr++ = 0, ((*(LIST).faptr++ = (float)(VAL)), 0)
  1018.    : (++(LIST).aptr > __av_eptr(LIST)
  1019.       ? -1 : ((LIST).fargwords++, ((float*)(LIST).aptr)[-1] = (float)(VAL), 0)))
  1021. #define av_double(LIST,VAL)
  1022.   ((LIST).daptr < &(LIST).dargs[2]
  1023.    ? (LIST).faptr++, *(LIST).dargsusedptr++ = 1, *(LIST).fargsusedptr++ = 0, ((*(LIST).daptr++ = (double)(VAL)), 0)
  1024.    : (((LIST).aptr += 2) > __av_eptr(LIST)
  1025.       ? -1 :
  1026.       ((LIST).fargwords+=2, (LIST).tmp._double = (double)(VAL),
  1027.        (LIST).aptr[-2] = (LIST).tmp.words[0],
  1028.        (LIST).aptr[-1] = (LIST).tmp.words[1],
  1029.        0)))
  1031. #endif
  1033. #if defined(__m88k__)
  1035. #define __av_float(LIST,VAL)
  1036.   (++(LIST).aptr > __av_eptr(LIST)
  1037.    ? -1 : (((float*)(LIST).aptr)[-1] = (float)(VAL), 0))
  1039. #define av_double(LIST,VAL)
  1040.    (((LIST).aptr = (__avword*)(((long)(LIST).aptr+sizeof(double)+sizeof(double)-1) & -(long)sizeof(double))) 
  1041.     > __av_eptr(LIST)
  1042.     ? -1 : (((double*)(LIST).aptr)[-1] = (double)(VAL), 0))
  1044. #endif
  1046. #if defined(__ia64__)
  1048. /* Up to 8 leading float or double non-varargs args can be passed in
  1049.  * float registers, but we also push them into the corresponding int
  1050.  * registers in case of varargs.
  1051.  */
  1052. #define __av_float(LIST,VAL)
  1053.   ((LIST).aptr >= __av_eptr(LIST)
  1054.    ? -1 : ((*(float*)(LIST).aptr = (float)(VAL)),
  1055.    ((LIST).faptr < &(LIST).fargs[8] && (*(LIST).faptr = *(float*)(LIST).aptr, (LIST).faptr++)), 
  1056.    (LIST).aptr++,
  1057.    0))
  1059. #define av_double(LIST,VAL)
  1060.   ((LIST).aptr >= __av_eptr(LIST)
  1061.    ? -1 : (*(double*)(LIST).aptr = (double)(VAL),
  1062.    ((LIST).faptr < &(LIST).fargs[8] && (*(LIST).faptr = *(double*)(LIST).aptr, (LIST).faptr++)), 
  1063.    (LIST).aptr++,
  1064.    0))
  1066. #endif
  1068. #if defined(__x86_64__)
  1070. /* Up to 8 leading float or double args can be passed in float registers.
  1071.  */
  1072. #define __av_float(LIST,VAL)
  1073.   ((LIST).faptr < &(LIST).fargs[8]
  1074.    ? (*(LIST).faptr = 0.0, *(float*)(LIST).faptr = (float)(VAL),
  1075.       (LIST).faptr++,
  1076.       0)
  1077.    : ((LIST).aptr >= __av_eptr(LIST)
  1078.       ? -1 : ((*(float*)(LIST).aptr = (float)(VAL)),
  1079.       (LIST).aptr++,
  1080.       0)))
  1082. #define av_double(LIST,VAL)
  1083.   ((LIST).faptr < &(LIST).fargs[8]
  1084.    ? (*(LIST).faptr = (double)(VAL),
  1085.       (LIST).faptr++,
  1086.       0)
  1087.    : ((LIST).aptr >= __av_eptr(LIST)
  1088.       ? -1 : ((*(double*)(LIST).aptr = (double)(VAL)),
  1089.       (LIST).aptr++,
  1090.       0)))
  1092. #endif
  1094. /*
  1095.  * structure argument types
  1096.  */
  1098. #define av_struct(LIST,TYPE,VAL)
  1099.   __av_struct(LIST,TYPE,sizeof(TYPE),__AV_alignof(TYPE),__av_struct_assign,VAL)
  1100. #define __av_struct_assign(TYPE,TYPE_SIZE,TYPE_ALIGN,PLACE,VAL)
  1101.   *(TYPE*)(PLACE) = (VAL)
  1102. /* _av_struct() is like av_struct(), except that you pass the type's size and alignment
  1103.  * and the value's address instead of the type and the value themselves.
  1104.  */
  1105. #define _av_struct(LIST,TYPE_SIZE,TYPE_ALIGN,VAL_ADDR)
  1106.   __av_struct(LIST,unknown,TYPE_SIZE,TYPE_ALIGN,__av_struct_copy,VAL_ADDR)
  1107. #define __av_struct_copy(TYPE,TYPE_SIZE,TYPE_ALIGN,PLACE,VAL_ADDR)
  1108.   __structcpy(PLACE,VAL_ADDR,TYPE_SIZE,TYPE_ALIGN)
  1109. /* Structure argument alignment. */
  1110. #if defined(__i386__) && defined(_MSC_VER)
  1111. /* In MSVC, doubles inside structures have alignment 8, i.e.
  1112.  * __AV_alignof(double) = 8, but doubles (and also structures containing
  1113.  * doubles) are passed on the stack with alignment 4. Looks really weird.
  1114.  */
  1115. #define __av_struct_alignment(TYPE_ALIGN)  
  1116.   ((TYPE_ALIGN) <= 4 ? (TYPE_ALIGN) : 4)
  1117. #else
  1118. #define __av_struct_alignment(TYPE_ALIGN)  
  1119.   (TYPE_ALIGN)
  1120. #endif
  1121. #if defined(__i386__) || defined(__mips__) || defined(__mipsn32__) || defined(__mips64__) || defined(__alpha__) || (defined(__rs6000__) && (defined(_AIX) || (defined(__MACH__) && defined(__APPLE__)))) || defined(__m88k__) || defined(__ia64__) || defined(__s390__)
  1122. /* Structures are passed as fully aligned structures on the arg stack.
  1123.  * We align the aptr, store the structure, then fill to word alignment.
  1124.  * Single-small-integer structures are NOT promoted to integers and have
  1125.  * different alignment.
  1126.  */
  1127. /* little endian -> small structures < 1 word are adjusted to the left */
  1128. #if defined(__i386__) || defined(__alpha__) || defined(__x86_64__)
  1129. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1130.   (((LIST).aptr =
  1131.     (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+__av_struct_alignment(TYPE_ALIGN)-1) & -(long)__av_struct_alignment(TYPE_ALIGN)))
  1132.    > __av_eptr(LIST)
  1133.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1134.    (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1135.    0))
  1136. #endif
  1137. #if defined(__ia64__)
  1138. /* Types larger than a word have 2-word alignment. */
  1139. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1140.   ((LIST).aptr = (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+__av_struct_alignment(TYPE_ALIGN)-1) & -(long)__av_struct_alignment(TYPE_ALIGN)), 
  1141.    ((TYPE_SIZE) > sizeof(__avword) && (((LIST).aptr - &(LIST).args[0]) & 1) ? ++(LIST).aptr : 0), 
  1142.    ((LIST).aptr > __av_eptr(LIST)
  1143.     ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1144.     (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1145.     0)))
  1146. #endif
  1147. /* small structures < 1 word are adjusted depending on compiler */
  1148. #if defined(__mips__) && !defined(__mipsn32__)
  1149. #define __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1150.   (((LIST).aptr =
  1151.     (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)))
  1152.    > __av_eptr(LIST)
  1153.    ? -1 : (++(LIST).anum,
  1154.    ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1155.    (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1156.    0))
  1157. #define __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1158.   (((LIST).aptr =
  1159.     (__avword*)(((((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN))
  1160.  +sizeof(__avword)-1) & -(long)sizeof(__avword)))
  1161.    > __av_eptr(LIST)
  1162.    ? -1 : (++(LIST).anum,
  1163.    ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1164.    0))
  1165. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1166.   ((LIST).flags & __AV_SGICC_STRUCT_ARGS
  1167.    ? /* SGI MIPS cc passes small structures left-adjusted, although big-endian! */
  1168.      __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1169.    : /* SGI MIPS gcc passes small structures within the first four words left-   
  1170.       * adjusted, for compatibility with cc. But structures in memory are passed  
  1171.       * right-adjusted!! See gcc-2.6.3/config/mips/mips.c:function_arg().   
  1172.       */   
  1173.      ((LIST).aptr < &(LIST).args[4]
  1174.       ? __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1175.       : __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)))
  1176. #endif
  1177. #if defined(__mipsn32__) || defined(__mips64__)
  1178. /* When a structure is passed (partially) in registers, it is passed in the
  1179.  * integer registers, except that doubles within the structure are passed in
  1180.  * the floating point registers. Instead of distinguishing these cases, we
  1181.  * always pass the structure in both the integer and the floating point
  1182.  * registers.
  1183.  */
  1184. #define __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1185.   (((LIST).aptr =
  1186.     (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)))
  1187.    > __av_eptr(LIST)
  1188.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1189.    (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1190.    ((LIST).anum < 8 && ((LIST).darg_mask |= (-1 << (LIST).anum))), 
  1191.    (LIST).anum += (((((TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)) + sizeof(__avword)-1) & -(long)sizeof(__avword))/sizeof(__avword),
  1192.    (LIST).darg_mask &= (1 << ((LIST).anum < 8 ? (LIST).anum : 8)) - 1, 
  1193.    0))
  1194. #define __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1195.   (((LIST).aptr =
  1196.     (__avword*)(((((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN))
  1197.  +sizeof(__avword)-1) & -(long)sizeof(__avword)))
  1198.    > __av_eptr(LIST)
  1199.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1200.    ((LIST).anum < 8 && ((LIST).darg_mask |= (-1 << (LIST).anum))), 
  1201.    (LIST).anum += (((((TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)) + sizeof(__avword)-1) & -(long)sizeof(__avword))/sizeof(__avword),
  1202.    (LIST).darg_mask &= (1 << ((LIST).anum < 8 ? (LIST).anum : 8)) - 1, 
  1203.    0))
  1204. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1205.   ((LIST).flags & __AV_SGICC_STRUCT_ARGS
  1206.    ? /* SGI MIPS cc passes small structures left-adjusted, although big-endian! */
  1207.      __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1208.    : /* SGI MIPS gcc passes small structures right-adjusted. */
  1209.      __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL))
  1210. #endif
  1211. #if defined(__rs6000__)
  1212. #define __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1213.   (((LIST).aptr =
  1214.     (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)))
  1215.    > __av_eptr(LIST)
  1216.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1217.    (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1218.    0))
  1219. #define __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1220.   (((LIST).aptr =
  1221.     (__avword*)(((((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN))
  1222.  +sizeof(__avword)-1) & -(long)sizeof(__avword)))
  1223.    > __av_eptr(LIST)
  1224.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1225.    0))
  1226. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1227.   ((LIST).flags & __AV_AIXCC_STRUCT_ARGS
  1228.    ? /* AIX cc and xlc pass small structures left-adjusted, although big-endian! */
  1229.      __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1230.    : /* gcc passes small structures right-adjusted. */
  1231.      __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL))
  1232. #endif
  1233. #if defined(__s390__)
  1234. #define __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1235.   (((LIST).aptr =
  1236.     (__avword*)(((((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN))
  1237.  +sizeof(__avword)-1) & -(long)sizeof(__avword)))
  1238.    > __av_eptr(LIST)
  1239.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1240.    0))
  1241. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1242. ((TYPE_SIZE) != 1 && (TYPE_SIZE) != 2 && (TYPE_SIZE) != 4 && (TYPE_SIZE) != 8 
  1243.  ? (++(LIST).aptr
  1244.     > ((LIST).eptr = (__avword*)((long)(LIST).eptr - (((TYPE_SIZE)+7)&-8)))
  1245.     ? -1 :
  1246.     (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).eptr,VAL),
  1247.      (LIST).aptr[-1] = (__avword)(LIST).eptr,
  1248.      0))
  1249.  : (((TYPE_SIZE) == 8 && (LIST).aptr - (LIST).args - (LIST).fargwords == 4 ? ++(LIST).aptr,0 : 0), 
  1250.     __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)))
  1251. #endif
  1252. /* big endian -> small structures < 1 word are adjusted to the right */
  1253. #if defined(__m88k__)
  1254. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1255.   (((LIST).aptr =
  1256.     (__avword*)(((((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN))
  1257.  +sizeof(__avword)-1) & -(long)sizeof(__avword)))
  1258.    > __av_eptr(LIST)
  1259.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1260.    0))
  1261. #endif
  1262. #endif
  1263. #if defined(__m68k__) || defined(__arm__) || defined(__convex__)
  1264. /* Structures are passed as embedded copies on the arg stack.
  1265.  */
  1266. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1267.   (((LIST).aptr = (__avword*)(((long)(LIST).aptr+(TYPE_SIZE)+sizeof(__avword)-1) & -(long)sizeof(__avword))) 
  1268.     > __av_eptr(LIST)
  1269.     ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1270.     0))
  1271. #endif
  1272. #if (defined(__sparc__) && !defined(__sparc64__)) || (defined(__rs6000__) && !(defined(_AIX) || (defined(__MACH__) && defined(__APPLE__))))
  1273. /* Structures are passed as pointers to caller-made local copies. We
  1274.  * grab space for the copies from the end of the argument list space
  1275.  * and always use maximal (double) alignment.
  1276.  */
  1277. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1278.    (++(LIST).aptr
  1279.     > ((LIST).eptr = (__avword*)((long)(LIST).eptr - (((TYPE_SIZE)+7)&-8)))
  1280.     ? -1 :
  1281.     (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).eptr,VAL),
  1282.      (LIST).aptr[-1] = (__avword)(LIST).eptr,
  1283.      0))
  1284. #endif
  1285. #if defined(__sparc64__)
  1286. /* Structures <= 16 bytes are passed as embedded copies on the arg stack,
  1287.  * left-adjusted (although big-endian!).
  1288.  * When a structure is passed (partially) in registers, it is passed in the
  1289.  * integer registers, except that floats and doubles within the structure
  1290.  * are passed in the floating point registers. Instead of distinguishing
  1291.  * these cases, we always pass the structure in both the integer and the
  1292.  * floating point registers.
  1293.  * Big structures are passed as pointers to caller-made local copies.
  1294.  * FIXME: Shouldn't (LIST).anum be incremented in sync with (LIST).aptr ?
  1295.  */
  1296. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1297.   ((TYPE_SIZE) > 16
  1298.    ? (++(LIST).aptr
  1299.       > ((LIST).eptr = (__avword*)((long)(LIST).eptr - (((TYPE_SIZE)+7)&-8)))
  1300.       ? -1 :
  1301.       (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).eptr,VAL),
  1302.        (LIST).aptr[-1] = (__avword)(LIST).eptr,
  1303.        0))
  1304.    : (((LIST).aptr =
  1305.        (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)))
  1306.       > __av_eptr(LIST)
  1307.       ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1308.       (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1309.       ((LIST).anum < 16
  1310. && ((LIST).farg_mask |= (-1 << (LIST).anum),
  1311.     (LIST).darg_mask |= (-1 << (LIST).anum))),
  1312.       (LIST).anum += (((((TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)) + sizeof(__avword)-1) & -(long)sizeof(__avword))/sizeof(__avword),
  1313.       (LIST).farg_mask &= (1 << ((LIST).anum < 16 ? (LIST).anum : 16)) - 1, 
  1314.       (LIST).darg_mask &= (1 << ((LIST).anum < 16 ? (LIST).anum : 16)) - 1, 
  1315.       0)))
  1316. #endif
  1317. #if defined(__hppa__)
  1318. /* Structures <= 8 bytes are passed as embedded copies on the arg stack.
  1319.  * Big structures are passed as pointers to caller-made local copies.
  1320.  */
  1321. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1322.   ((TYPE_SIZE) > 8
  1323.    ? (--(LIST).aptr
  1324.       < ((LIST).eptr = (__avword*)((long)(LIST).eptr + (((TYPE_SIZE) + 7) & -8))) 
  1325.       ? -1
  1326.       : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((long)(LIST).eptr - (((TYPE_SIZE) + 7) & -8)), VAL), 
  1327.  *(LIST).aptr = (__avword)((long)(LIST).eptr - (((TYPE_SIZE) + 7) & -8)), 
  1328.  0))
  1329.    : ((TYPE_SIZE) > 4
  1330.       ? (((LIST).aptr = (__avword*)((((long)(LIST).aptr & -8) - (long)(TYPE_SIZE)) & -8)) 
  1331.   < &(LIST).args[0]
  1332.   ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).aptr,VAL), 0))
  1333.       : /* FIXME: gcc-2.6.3 passes structures <= 4 bytes in memory left-adjusted! ?? */
  1334.         (((LIST).aptr = (__avword*)(((long)(LIST).aptr & -4) - (long)(TYPE_SIZE))) 
  1335.   < &(LIST).args[0]
  1336.   ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).aptr,VAL),
  1337.   (LIST).aptr = (__avword*)((long)(LIST).aptr & -4),
  1338.   0))))
  1339. #endif
  1340. #if defined(__x86_64__)
  1341. /* Structures <= 16 bytes can be passed in integer or floating-point registers
  1342.    if there is enough room for the whole number of words needed by the structure
  1343.    in the corresponding iargs/fargs block. We can't distinguish the two cases
  1344.    and support only passing in integer registers. Other structures are passed
  1345.    on the arg stack. */
  1346. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1347.   ((LIST).iaptr + ((TYPE_SIZE) + sizeof(__avword)-1) / sizeof(__avword) <= &(LIST).iargs[6] 
  1348.    ? (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).iaptr,VAL),
  1349.       (LIST).iaptr += ((TYPE_SIZE) + sizeof(__avword)-1) / sizeof(__avword),
  1350.       0)
  1351.    : ((LIST).aptr = (__avword*)((__avword)(LIST).aptr + (((TYPE_SIZE)+__av_struct_alignment(TYPE_ALIGN)-1) & -(long)__av_struct_alignment(TYPE_ALIGN))), 
  1352.       ((LIST).aptr > __av_eptr(LIST)
  1353.        ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr - (((TYPE_SIZE)+__av_struct_alignment(TYPE_ALIGN)-1) & -(long)__av_struct_alignment(TYPE_ALIGN))),VAL),
  1354.        0))))
  1355. #endif
  1357. /*
  1358.  * calling the function
  1359.  */
  1361. #define av_call(LIST) __builtin_avcall(&(LIST))
  1363. /* Determine whether a struct type is word-splittable, i.e. whether each of
  1364.  * its components fit into a register.
  1365.  * The entire computation is done at compile time.
  1366.  */
  1367. #define av_word_splittable_1(slot1)  
  1368.   (__av_offset1(slot1)/sizeof(__avword) == (__av_offset1(slot1)+sizeof(slot1)-1)/sizeof(__avword))
  1369. #define av_word_splittable_2(slot1,slot2)  
  1370.   ((__av_offset1(slot1)/sizeof(__avword) == (__av_offset1(slot1)+sizeof(slot1)-1)/sizeof(__avword)) 
  1371.    && (__av_offset2(slot1,slot2)/sizeof(__avword) == (__av_offset2(slot1,slot2)+sizeof(slot2)-1)/sizeof(__avword)) 
  1372.   )
  1373. #define av_word_splittable_3(slot1,slot2,slot3)  
  1374.   ((__av_offset1(slot1)/sizeof(__avword) == (__av_offset1(slot1)+sizeof(slot1)-1)/sizeof(__avword)) 
  1375.    && (__av_offset2(slot1,slot2)/sizeof(__avword) == (__av_offset2(slot1,slot2)+sizeof(slot2)-1)/sizeof(__avword)) 
  1376.    && (__av_offset3(slot1,slot2,slot3)/sizeof(__avword) == (__av_offset3(slot1,slot2,slot3)+sizeof(slot3)-1)/sizeof(__avword)) 
  1377.   )
  1378. #define av_word_splittable_4(slot1,slot2,slot3,slot4)  
  1379.   ((__av_offset1(slot1)/sizeof(__avword) == (__av_offset1(slot1)+sizeof(slot1)-1)/sizeof(__avword)) 
  1380.    && (__av_offset2(slot1,slot2)/sizeof(__avword) == (__av_offset2(slot1,slot2)+sizeof(slot2)-1)/sizeof(__avword)) 
  1381.    && (__av_offset3(slot1,slot2,slot3)/sizeof(__avword) == (__av_offset3(slot1,slot2,slot3)+sizeof(slot3)-1)/sizeof(__avword)) 
  1382.    && (__av_offset4(slot1,slot2,slot3,slot4)/sizeof(__avword) == (__av_offset4(slot1,slot2,slot3,slot4)+sizeof(slot4)-1)/sizeof(__avword)) 
  1383.   )
  1384. #define __av_offset1(slot1)  
  1385.   0
  1386. #define __av_offset2(slot1,slot2)  
  1387.   ((__av_offset1(slot1)+sizeof(slot1)+__AV_alignof(slot2)-1) & -(long)__AV_alignof(slot2))
  1388. #define __av_offset3(slot1,slot2,slot3)  
  1389.   ((__av_offset2(slot1,slot2)+sizeof(slot2)+__AV_alignof(slot3)-1) & -(long)__AV_alignof(slot3))
  1390. #define __av_offset4(slot1,slot2,slot3,slot4)  
  1391.   ((__av_offset3(slot1,slot2,slot3)+sizeof(slot3)+__AV_alignof(slot4)-1) & -(long)__AV_alignof(slot4))
  1393. /*
  1394.  * Miscellaneous declarations.
  1395.  */
  1397. #if defined(__STDC__) || defined(__GNUC__) || defined(__cplusplus)
  1398. extern int __builtin_avcall (av_alist* l);
  1399. extern void __structcpy (void* dest, void* src, unsigned long size, unsigned long alignment);
  1400. #else
  1401. extern int __builtin_avcall ();
  1402. extern void __structcpy ();
  1403. #endif
  1405. #endif /*_avcall_h */