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

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

信息检索与抽取

开发平台：

Unix_Linux

avcall.h.msvc：源码内容
  1. #ifndef _avcall_h /*-*- C -*-*/
  2. #define _avcall_h
  3. /**
  4.   Copyright 1993 Bill Triggs, <Bill.Triggs@inrialpes.fr>
  6.   Copyright 1995-2001 Bruno Haible, <haible@clisp.cons.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. #define __i386__ 1
  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 __m88k__
  58. #undef __m88k__
  59. #endif
  60. #ifndef __convex__
  61. #undef __convex__
  62. #endif
  63. #ifndef __ia64__
  64. #undef __ia64__
  65. #endif
  67. /* Darwin uses same ABI as AIX */
  68. #ifdef __APPLE__
  69. #define _AIX
  70. #endif
  72. /* Calling convention */
  73. /* Define if using pcc non-reentrant struct return convention */
  74. #undef __PCC_STRUCT_RETURN__
  75. /* Define if small structs are returned in registers */
  76. #define __SMALL_STRUCT_RETURN__ 1
  77. /* Define if floating-point results are returned in the integer registers */
  78. #undef __IREG_FLOAT_RETURN__
  80. /* CL_LONGLONG */
  81. /* Define if your compiler supports the `long long' type. */
  82. #undef HAVE_LONGLONG
  84. /* End of definitions adjusted by `configure'. */
  87. /* Max # words in argument-list and temporary structure storage.
  88.  */
  89. #ifndef __AV_ALIST_WORDS
  90. #define __AV_ALIST_WORDS  256
  91. #endif
  93. /* Determine the alignment of a type at compile time.
  94.  */
  95. #if defined(__GNUC__)
  96. #define __AV_alignof __alignof__
  97. #else
  98. #if defined(__mips__) || defined(__mipsn32__) || defined(__mips64__) /* SGI compiler */
  99. #define __AV_alignof __builtin_alignof
  100. #else
  101. #define __AV_offsetof(type,ident)  ((unsigned long)&(((type*)0)->ident))
  102. #define __AV_alignof(type)  __AV_offsetof(struct { char __slot1; type __slot2; }, __slot2)
  103. #endif
  104. #endif
  106. /* C builtin types.
  107.  */
  108. #if defined(__mipsn32__)
  109. typedef long long __avword;
  110. #else
  111. typedef long __avword;
  112. #endif
  114. enum __AVtype
  115. {
  116.   __AVword,
  117.   __AVvoid,
  118.   __AVchar,
  119.   __AVschar,
  120.   __AVuchar,
  121.   __AVshort,
  122.   __AVushort,
  123.   __AVint,
  124.   __AVuint,
  125.   __AVlong,
  126.   __AVulong,
  127.   __AVlonglong,
  128.   __AVulonglong,
  129.   __AVfloat,
  130.   __AVdouble,
  131.   __AVvoidp,
  132.   __AVstruct
  133. };
  135. enum __AV_alist_flags
  136. {
  138.   /* how to return structs */
  139.   /* There are basically 3 ways to return structs:
  140.    * a. The called function returns a pointer to static data. Not reentrant.
  141.    * b. The caller passes the return structure address in a dedicated register
  142.    *    or as a first (or last), invisible argument. The called function stores
  143.    *    its result there.
  144.    * c. Like b, and the called function also returns the return structure
  145.    *    address in the return value register. (This is not very distinguishable
  146.    *    from b.)
  147.    * Independently of this,
  148.    * r. small structures (<= 4 or <= 8 bytes) may be returned in the return
  149.    *    value register(s), or
  150.    * m. even small structures are passed in memory.
  151.    */
  152.   /* gcc-2.6.3 employs the following strategy:
  153.    *   - If PCC_STATIC_STRUCT_RETURN is defined in the machine description
  154.    *     it uses method a, else method c.
  155.    *   - If flag_pcc_struct_return is set (either by -fpcc-struct-return or if
  156.    *     DEFAULT_PCC_STRUCT_RETURN is defined to 1 in the machine description)
  157.    *     it uses method m, else (either by -freg-struct-return or if
  158.    *     DEFAULT_PCC_STRUCT_RETURN is defined to 0 in the machine description)
  159.    *     method r.
  160.    */
  161.   __AV_PCC_STRUCT_RETURN = 1<<0, /* a: need to copy the struct */
  162.   __AV_SMALL_STRUCT_RETURN = 1<<1, /* r: special case for small structs */
  163.   __AV_GCC_STRUCT_RETURN = 1<<2, /* consider 8 byte structs as small */
  164. #if defined(__sparc__) && !defined(__sparc64__)
  165.   __AV_SUNCC_STRUCT_RETURN = 1<<3,
  166.   __AV_SUNPROCC_STRUCT_RETURN = 1<<4,
  167. #endif
  168. #if defined(__i386__)
  169.   __AV_NEXTGCC_STRUCT_RETURN = 1<<3,
  170.   __AV_MSVC_STRUCT_RETURN = 1<<4,
  171. #endif
  172. #if defined(__hppa__)
  173.   __AV_OLDGCC_STRUCT_RETURN = 1<<3,
  174. #endif
  175.   /* the default way to return structs */
  176.   /* This choice here is based on the assumption that the function you are
  177.    * going to call has been compiled with the same compiler you are using to
  178.    * include this file.
  179.    * If you want to call functions with another struct returning convention,
  180.    * just  #define __AV_STRUCT_RETURN ...
  181.    * before or after #including <avcall.h>.
  182.    */
  183. #ifndef __AV_STRUCT_RETURN
  184.   __AV_STRUCT_RETURN =
  185. #if defined(__sparc__) && !defined(__sparc64__) && defined(sun) && defined(__SUNPRO_C) /* SUNWspro cc */
  186.   __AV_SUNPROCC_STRUCT_RETURN,
  187. #else
  188. #if defined(__PCC_STRUCT_RETURN__) /* defined through configure, see above */
  189.   __AV_PCC_STRUCT_RETURN |
  190. #if defined(__sparc__) && !defined(__sparc64__) && defined(sun) && !(defined(__STDC__) || defined(__GNUC__)) /* sun cc */
  191.      __AV_SUNCC_STRUCT_RETURN,
  192. #else
  193.      0,
  194. #endif
  195. #else
  196. #if defined(__SMALL_STRUCT_RETURN__) || defined(__mipsn32__) || defined(__mips64__) /* defined through configure, see above */
  197.   __AV_SMALL_STRUCT_RETURN |
  198. #endif
  199. #if defined(__GNUC__)
  200.   __AV_GCC_STRUCT_RETURN |
  201. #endif
  202. #if defined(__i386__) && defined(NeXT) && defined(__GNUC__) /* NeXT gcc-2.5.8 */
  203.   __AV_NEXTGCC_STRUCT_RETURN |
  204. #endif
  205. #if defined(__i386__) && defined(_MSC_VER) /* MSVC 4.0 */
  206.   __AV_MSVC_STRUCT_RETURN |
  207. #endif
  208. #if defined(__hppa__) && defined(__GNUC__) && (__GNUC_MINOR__ < 7)
  209.   __AV_OLDGCC_STRUCT_RETURN |
  210. #endif
  211.      0,
  212. #endif
  213. #endif
  214. #endif
  216.   /* how to return floats */
  217. #if defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__))
  218.   __AV_SUNCC_FLOAT_RETURN = 1<<5,
  219. #endif
  220. #if defined(__m68k__)
  221.   __AV_FREG_FLOAT_RETURN = 1<<6,
  222. #endif
  223.   /* the default way to return floats */
  224.   /* This choice here is based on the assumption that the function you are
  225.    * going to call has been compiled with the same compiler you are using to
  226.    * include this file.
  227.    * If you want to call functions with another float returning convention,
  228.    * just  #define __AV_FLOAT_RETURN ...
  229.    * before or after #including <avcall.h>.
  230.    */
  231. #ifndef __AV_FLOAT_RETURN
  232. #if (defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__))) && !defined(__GNUC__) && defined(sun) && !defined(__SUNPRO_C)  /* sun cc */
  233.   __AV_FLOAT_RETURN = __AV_SUNCC_FLOAT_RETURN,
  234. #elif (defined(__m68k__) && !defined(__IREG_FLOAT_RETURN__))
  235.   __AV_FLOAT_RETURN = __AV_FREG_FLOAT_RETURN,
  236. #else
  237.   __AV_FLOAT_RETURN = 0,
  238. #endif
  239. #endif
  241.   /* how to pass structs */
  242. #if defined(__mips__) || defined(__mipsn32__) || defined(__mips64__)
  243.   __AV_SGICC_STRUCT_ARGS = 1<<7,
  244. #endif
  245. #if defined(__rs6000__)
  246.   __AV_AIXCC_STRUCT_ARGS = 1<<7,
  247. #endif
  248.   /* the default way to pass floats */
  249.   /* This choice here is based on the assumption that the function you are
  250.    * going to call has been compiled with the same compiler you are using to
  251.    * include this file.
  252.    * If you want to call functions with another float passing convention,
  253.    * just  #define __AV_STRUCT_ARGS ...
  254.    * before or after #including <avcall.h>.
  255.    */
  256. #ifndef __AV_STRUCT_ARGS
  257. #if (defined(__mips__) || defined(__mipsn32__) || defined(__mips64__)) && !defined(__GNUC__) /* SGI mips cc */
  258.   __AV_STRUCT_ARGS = __AV_SGICC_STRUCT_ARGS,
  259. #else
  260. #if defined(__rs6000__) && defined(_AIX) && !defined(__GNUC__) /* AIX cc, xlc */
  261.   __AV_STRUCT_ARGS = __AV_AIXCC_STRUCT_ARGS,
  262. #else
  263.   __AV_STRUCT_ARGS = 0,
  264. #endif
  265. #endif
  266. #endif
  268.   /* how to pass floats */
  269.   /* ANSI C compilers and GNU gcc pass floats as floats.
  270.    * K&R C compilers pass floats as doubles.
  271.    * (Except some compilers like SGI MIPS "cc" and "cc -cckr" if a prototype is
  272.    * known for the called functions. But to compile a program with prototypes,
  273.    * "cc -ansi" is better anyway.
  274.    */
  275.   __AV_ANSI_FLOAT_ARGS = 0,    /* pass floats as floats */
  276.   __AV_TRADITIONAL_FLOAT_ARGS = 1<<8, /* pass floats as doubles */
  277.   /* the default way to pass floats */
  278.   /* This choice here is based on the assumption that the function you are
  279.    * going to call has been compiled with the same compiler you are using to
  280.    * include this file.
  281.    * If you want to call functions with another float passing convention,
  282.    * just  #define __AV_FLOAT_ARGS ...
  283.    * before or after #including <avcall.h>.
  284.    */
  285. #ifndef __AV_FLOAT_ARGS
  286. #if defined(__STDC__) || defined(__GNUC__) /* what about hppa "cc -Aa" ?? */
  287.   __AV_FLOAT_ARGS = __AV_ANSI_FLOAT_ARGS,
  288. #else
  289.   __AV_FLOAT_ARGS = __AV_TRADITIONAL_FLOAT_ARGS,
  290. #endif
  291. #endif
  293.   /* how to pass and return small integer arguments */
  294.   __AV_ANSI_INTEGERS = 0, /* no promotions */
  295.   __AV_TRADITIONAL_INTEGERS = 0, /* promote [u]char, [u]short to [u]int */
  296.   /* Fortunately these two methods are compatible. Our macros work with both. */
  297.   /* the default way to pass and return small integer arguments */
  298.   /* This choice here is based on the assumption that the function you are
  299.    * going to call has been compiled with the same compiler you are using to
  300.    * include this file.
  301.    * If you want to call functions with another float passing convention,
  302.    * just  #define __AV_INTEGERS ...
  303.    * before or after #including <avcall.h>.
  304.    */
  305. #ifndef __AV_INTEGERS
  306. #if defined(__STDC__) || defined(__GNUC__)
  307.   __AV_INTEGERS = __AV_ANSI_INTEGERS,
  308. #else
  309.   __AV_INTEGERS = __AV_TRADITIONAL_INTEGERS,
  310. #endif
  311. #endif
  313.   /* stack cleanup policy */
  314.   __AV_CDECL_CLEANUP = 0, /* caller pops args after return */
  315.   __AV_STDCALL_CLEANUP = 0, /* callee pops args before return */
  316.      /* currently only supported on __i386__ */
  317. #ifndef __AV_CLEANUP
  318.   __AV_CLEANUP = __AV_CDECL_CLEANUP,
  319. #endif
  321.   /* These are for internal use only */
  322. #if defined(__i386__) || defined(__m68k__) || defined(__mipsn32__) || defined(__mips64__) || defined(__sparc64__) || defined(__alpha__) || defined(__arm__) || defined(__rs6000__) || defined(__convex__) || defined(__ia64__)
  323.   __AV_REGISTER_STRUCT_RETURN = 1<<9,
  324. #endif
  325. #if defined(__mips__) && !defined(__mipsn32__)
  326.   __AV_FLOAT_1 = 1<<10,
  327.   __AV_FLOAT_2 = 1<<11,
  328. #endif
  330.   __AV_flag_for_broken_compilers_that_dont_like_trailing_commas
  331. };
  333. typedef struct
  334. {
  335.   /* function to be called */
  336.   __avword (*func)();
  337.   /* some av_... macros need these flags */
  338.   int flags;
  339.   /* return type, address for the result */
  340.   void* raddr;
  341.   enum __AVtype rtype;
  342.   unsigned long rsize;
  343.   /* current pointer into the args[] array */
  344.   __avword* aptr;
  345. #if defined(__sparc__) || defined(__sparc64__) || defined(__hppa__) || (defined(__rs6000__) && !defined(_AIX))
  346.   /* limit pointer into the args[] array */
  347.   __avword* eptr;
  348. #endif
  349. #if defined(__i386__) && 0
  350.   /* Filler word, needed if the numbers of words up to now in this structure */
  351.   /* is odd (because on MSVC, alignof(double) = 8, normally = 4).            */
  352.   __avword filler1;
  353. #endif
  354. #if defined(__i386__) || defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__hppa__) || defined(__arm__) || defined(__rs6000__) || defined(__convex__)
  355.   /* temporary storage, used to split doubles into two words */
  356.   union {
  357.     double _double;
  358. #if defined(__sparc__) && !defined(__sparc64__) && defined(HAVE_LONGLONG)
  359.     long long _longlong;
  360. #endif
  361.     __avword words[2];
  362.   } tmp;
  363. #endif
  364. #if defined(__mips__) && !defined(__mipsn32__)
  365.   /* store the floating-point arguments in an extra array */
  366.   int anum;
  367.   double floatarg[2];
  368. #endif
  369. #if defined(__mipsn32__) || defined(__mips64__)
  370.   /* store the floating-point arguments in an extra array */
  371.   int anum; /* redundant: (LIST).aptr = &(LIST).args[(LIST).anum] */
  372.   unsigned int farg_mask; /* bitmask of those entries in farg[] which have a value */
  373.   unsigned int darg_mask; /* bitmask of those entries in args[] which have a double value */
  374.   float farg[8];
  375. #endif
  376. #if defined(__sparc64__)
  377.   /* store the floating-point arguments in an extra array */
  378.   int anum; /* redundant: (LIST).aptr = &(LIST).args[(LIST).anum] */
  379.   unsigned int farg_mask; /* bitmask of those entries in farg[] which have a value */
  380.   unsigned int darg_mask; /* bitmask of those entries in args[] which have a double value */
  381. #endif
  382. #if defined(__ia64__)
  383.   /* store the floating-point arguments in an extra array */
  384.   double* faptr;
  385.   double fargs[8];
  386. #endif
  387.   __avword args[__AV_ALIST_WORDS]; /* sizeof(double)-aligned */
  388. #if defined(__rs6000__)
  389.   /* store the floating-point arguments in an extra array */
  390.   double* faptr;
  391.   double fargs[13];
  392. #endif
  393. #if defined(AMIGA)
  394.   /* store the arguments passed in registers in an extra array */
  395.   __avword regargs[8+7];
  396. #endif
  397. } av_alist;
  399. /* The limit for the pointer into the args[] array. */
  400. #if defined(__sparc__) || defined(__sparc64__) || defined(__hppa__) || (defined(__rs6000__) && !defined(_AIX))
  401. #define __av_eptr(LIST) ((LIST).eptr)
  402. #else
  403. #define __av_eptr(LIST) (&(LIST).args[__AV_ALIST_WORDS])
  404. #endif
  407. /*
  408.  *  av_start_<type> macros which specify the return type
  409.  */
  411. #define __AV_START_FLAGS  
  412.   __AV_STRUCT_RETURN | __AV_FLOAT_RETURN | __AV_STRUCT_ARGS | __AV_FLOAT_ARGS | __AV_INTEGERS | __AV_CLEANUP
  414. #define __av_start(LIST,FUNC,RADDR,RETTYPE)
  415.   ((LIST).func = (__avword(*)())(FUNC),
  416.    (LIST).raddr = (void*)(RADDR),
  417.    (LIST).rtype = (RETTYPE),
  418.    __av_start1(LIST)
  419.    (LIST).flags = __AV_START_FLAGS)
  421. #if defined(__i386__) || defined(__m68k__) || defined(__alpha__) || defined(__arm__) || defined(__m88k__) || defined(__convex__)
  422. #define __av_start1(LIST)
  423.    (LIST).aptr = &(LIST).args[0],
  424. #endif
  425. #if defined(__mips__) && !defined(__mipsn32__)
  426. #define __av_start1(LIST)
  427.    (LIST).anum = 0,
  428.    (LIST).aptr = &(LIST).args[0],
  429. #endif
  430. #if defined(__mipsn32__) || defined(__mips64__)
  431. #define __av_start1(LIST)
  432.    (LIST).anum = 0,
  433.    (LIST).farg_mask = 0,
  434.    (LIST).darg_mask = 0,
  435.    (LIST).aptr = &(LIST).args[0],
  436. #endif
  437. #if defined(__sparc__) && !defined(__sparc64__)
  438. #define __av_start1(LIST)
  439.    (LIST).aptr = &(LIST).args[0],
  440.    (LIST).eptr = &(LIST).args[__AV_ALIST_WORDS],
  441. #endif
  442. #if defined(__sparc64__)
  443. #define __av_start1(LIST)
  444.    (LIST).anum = 0,
  445.    (LIST).farg_mask = 0,
  446.    (LIST).darg_mask = 0,
  447.    (LIST).aptr = &(LIST).args[0],
  448.    (LIST).eptr = &(LIST).args[__AV_ALIST_WORDS],
  449. #endif
  450. #if defined(__hppa__)
  451. #define __av_start1(LIST)
  452.    (LIST).aptr = &(LIST).args[__AV_ALIST_WORDS],
  453.    (LIST).eptr = &(LIST).args[0],
  454. #endif
  455. #if defined(__rs6000__)
  456. #if defined(_AIX)
  457. #define __av_start1(LIST)
  458.    (LIST).aptr = &(LIST).args[0],
  459.    (LIST).faptr = &(LIST).fargs[0],
  460. #else
  461. #define __av_start1(LIST)
  462.    (LIST).aptr = &(LIST).args[0],
  463.    (LIST).faptr = &(LIST).fargs[0],                                     
  464.    (LIST).eptr = &(LIST).args[__AV_ALIST_WORDS],
  465. #endif
  466. #endif
  467. #if defined(__ia64__)
  468. #define __av_start1(LIST)
  469.    (LIST).aptr = &(LIST).args[0],
  470.    (LIST).faptr = &(LIST).fargs[0],
  471. #endif
  473. #define av_start_void(LIST,FUNC) __av_start(LIST,FUNC,0,    __AVvoid)
  474. #define av_start_char(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVchar)
  475. #define av_start_schar(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVschar)
  476. #define av_start_uchar(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVuchar)
  477. #define av_start_short(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVshort)
  478. #define av_start_ushort(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVushort)
  479. #define av_start_int(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVint)
  480. #define av_start_uint(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVuint)
  481. #define av_start_long(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVlong)
  482. #define av_start_ulong(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVulong)
  483. #define av_start_longlong(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVlonglong)
  484. #define av_start_ulonglong(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVulonglong)
  485. #define av_start_float(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVfloat)
  486. #define av_start_double(LIST,FUNC,RADDR) __av_start(LIST,FUNC,RADDR,__AVdouble)
  487. #define av_start_ptr(LIST,FUNC,TYPE,RADDR) __av_start(LIST,FUNC,RADDR,__AVvoidp)
  489. #define av_start_struct(LIST,FUNC,TYPE,TYPE_SPLITTABLE,RADDR)
  490.   _av_start_struct(LIST,FUNC,sizeof(TYPE),TYPE_SPLITTABLE,RADDR)
  491. #define _av_start_struct(LIST,FUNC,TYPE_SIZE,TYPE_SPLITTABLE,RADDR)
  492.   (__av_start(LIST,FUNC,RADDR,__AVstruct),
  493.    (LIST).rsize = TYPE_SIZE,
  494.    __av_start_struct1(LIST,TYPE_SIZE,TYPE_SPLITTABLE),
  495.    0)
  497. #define __av_start_struct1(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  498.   ((LIST).flags & __AV_PCC_STRUCT_RETURN
  499.    ? /* pcc struct return convention:
  500.       * called function returns pointer to value, we'll copy its contents afterwards. 
  501.       */
  502.      0
  503.    : __av_start_struct2(LIST,TYPE_SIZE,TYPE_SPLITTABLE)
  504.   )
  505. #if (defined(__sparc__) && !defined(__sparc64__)) || defined(__m88k__)
  506. /* Return structure pointer is passed in a special register.
  507.  */
  508. #define __av_start_struct2(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  0
  509. #else
  510. #define __av_start_struct2(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  511.   (((LIST).flags & __AV_SMALL_STRUCT_RETURN)
  512.    && __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)
  513.    ? /* <= Word-sized structures are returned in a register. */
  514.      __av_start_struct3(LIST)
  515.    : __av_start_struct4(LIST,TYPE_SIZE)
  516.   )
  517. /* Determines whether a structure is returned in registers,
  518.  * depending on its size and its word-splittable flag.
  519.  */
  520. #if (defined(__i386__) && defined(_WIN32))
  521. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  522.   ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4
  523.    || ((TYPE_SIZE) == 8
  524.        && (((LIST).flags & __AV_MSVC_STRUCT_RETURN)
  525.            || ((TYPE_SPLITTABLE)
  526.                && ((LIST).flags & __AV_GCC_STRUCT_RETURN)
  527.   )   )   )   )
  528. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  529.  * and the struct will actually be returned in registers.
  530.  */
  531. #define __av_start_struct3(LIST)  
  532.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  533. #endif
  534. #if (defined(__i386__) && !defined(_WIN32)) || defined(__m68k__) || defined(__arm__) || defined(__rs6000__) || defined(__convex__)
  535. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  536.   ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4
  537.    || ((TYPE_SIZE) == 8 && (TYPE_SPLITTABLE)
  538.        && ((LIST).flags & __AV_GCC_STRUCT_RETURN)
  539.   )   )
  540. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  541.  * and the struct will actually be returned in registers.
  542.  */
  543. #define __av_start_struct3(LIST)  
  544.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  545. #endif
  546. #if defined(__alpha__)
  547. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  548.   ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4 || (TYPE_SIZE) == 8
  549.    || ((TYPE_SIZE) == 16 && (TYPE_SPLITTABLE)
  550.        && ((LIST).flags & __AV_GCC_STRUCT_RETURN)
  551.   )   )
  552. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  553.  * and the struct will actually be returned in registers.
  554.  */
  555. #define __av_start_struct3(LIST)  
  556.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  557. #endif
  558. #if defined(__hppa__)
  559. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  560.   ((LIST).flags & __AV_OLDGCC_STRUCT_RETURN
  561.    ? ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4)
  562.    : ((TYPE_SIZE) <= 8)
  563.   )
  564. /* Test both __AV_OLDGCC_STRUCT_RETURN and __AV_SMALL_STRUCT_RETURN at run time. */
  565. #define __av_start_struct3(LIST)  
  566.   0
  567. #endif
  568. #if defined(__mips__) && !defined(__mipsn32__)
  569. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  570.   ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4)
  571. /* Test __AV_SMALL_STRUCT_RETURN instead of __AV_REGISTER_STRUCT_RETURN. */
  572. #define __av_start_struct3(LIST)  
  573.   0
  574. #endif
  575. #if defined(__mipsn32__) || defined(__mips64__)
  576. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  577.   ((LIST).flags & __AV_GCC_STRUCT_RETURN
  578.    ? ((TYPE_SIZE) == 1 || (TYPE_SIZE) == 2 || (TYPE_SIZE) == 4 || (TYPE_SIZE) == 8) 
  579.    : ((TYPE_SIZE) <= 16)
  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(__sparc64__) || defined(__ia64__)
  588. #define __av_reg_struct_return(LIST,TYPE_SIZE,TYPE_SPLITTABLE)  
  589.   ((TYPE_SIZE) <= 32)
  590. /* Turn on __AV_REGISTER_STRUCT_RETURN if __AV_SMALL_STRUCT_RETURN was set
  591.  * and the struct will actually be returned in registers.
  592.  */
  593. #define __av_start_struct3(LIST)  
  594.   ((LIST).flags |= __AV_REGISTER_STRUCT_RETURN, 0)
  595. #endif
  596. #if defined(__i386__)
  597. /* Return structure pointer is passed in a special register or as first arg. */
  598. #define __av_start_struct4(LIST,TYPE_SIZE)
  599.   ((LIST).flags & __AV_NEXTGCC_STRUCT_RETURN
  600.    ? 0  /* special register */
  601.    : (*(LIST).aptr++ = (__avword)((LIST).raddr), 0) /* first arg */
  602.   )
  603. #endif
  604. #if defined(__m68k__) || defined(__hppa__) || defined(__ia64__)
  605. /* Return structure pointer is passed in a special register.
  606.  */
  607. #define __av_start_struct4(LIST,TYPE_SIZE)  0
  608. #endif
  609. /* Return structure pointer is passed as first arg.
  610.  */
  611. #if defined(__alpha__) || defined(__arm__) || defined(__rs6000__) || defined(__convex__)
  612. #define __av_start_struct4(LIST,TYPE_SIZE)
  613.    (*(LIST).aptr++ = (__avword)((LIST).raddr), 0)
  614. #endif
  615. #if defined(__mips__) || defined(__mipsn32__) || defined(__mips64__) || defined(__sparc64__)
  616. #define __av_start_struct4(LIST,TYPE_SIZE)
  617.    (*(LIST).aptr++ = (__avword)((LIST).raddr),
  618.     (LIST).anum++,
  619.     0
  620.    )
  621. #endif
  622. #endif
  625. /*
  626.  * av_<type> macros which specify the argument and its type
  627.  */
  629. /*
  630.  * scalar argument types
  631.  */
  633. #if defined(__i386__) || defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__alpha__) || defined(__arm__) || defined(__rs6000__) || defined(__m88k__) || defined(__convex__) || defined(__ia64__)
  634. /* Floats and all integer types are passed as words,
  635.  * doubles as two words.
  636.  */
  637. #define __av_word(LIST,VAL)
  638.   (++(LIST).aptr > __av_eptr(LIST)
  639.    ? -1 : ((LIST).aptr[-1] = (__avword)(VAL), 0))
  640. #endif
  641. #if defined(__mips__) || defined(__mipsn32__) || defined(__mips64__) || defined(__sparc64__)
  642. /* Most things are passed as integers:
  643.  */
  644. #define __av_word(LIST,VAL)
  645.   (++(LIST).aptr > __av_eptr(LIST)
  646.    ? -1 : ((LIST).anum++, (LIST).aptr[-1] = (__avword)(VAL), 0))
  647. #endif
  648. #if defined(__hppa__)
  649. /* Floats and all integer types are passed as words,
  650.  * doubles as two words.
  651.  */
  652. #define __av_word(LIST,VAL)
  653.   (--(LIST).aptr < __av_eptr(LIST)
  654.    ? -1 : (*(LIST).aptr = (__avword)(VAL), 0))
  655. #endif
  656. #if defined(AMIGA)
  657. /* Some arguments are passed in registers. Query the macro AV_ARG_REGNUM.
  658.  * This should really be an argument to __av_word.
  659.  */
  660. #undef __av_word
  661. #define __av_word(LIST,VAL)
  662.   ((AV_ARG_REGNUM) >= 0
  663.    ? ((AV_ARG_REGNUM) < 8+7
  664.       ? -1 : ((LIST).regargs[(AV_ARG_REGNUM)] = (__avword)(VAL), 0))
  665.    : (++(LIST).aptr > __av_eptr(LIST)
  666.       ? -1 : ((LIST).aptr[-1] = (__avword)(VAL), 0)))
  667. #endif
  669. /* integer argument types */
  671. #define av_long __av_word
  672. #define av_ulong(LIST,VAL) __av_word(LIST,(unsigned long)(VAL))
  673. #define av_ptr(LIST,TYPE,VAL) __av_word(LIST,(TYPE)(VAL))
  674. #define av_char av_long
  675. #define av_schar av_long
  676. #define av_short av_long
  677. #define av_int av_long
  678. #define av_uchar av_ulong
  679. #define av_ushort av_ulong
  680. #define av_uint av_ulong
  682. #if defined(__mips64__) || defined(__sparc64__) || defined(__alpha__) || defined(__ia64__)
  683. /* `long long' and `long' are identical. */
  684. #define av_longlong av_long
  685. #define av_ulonglong av_ulong
  686. #elif defined(__mipsn32__)
  687. /* `long long' fits in __avword. */
  688. #define av_longlong __av_word
  689. #define av_ulonglong(LIST,VAL) __av_word(LIST,(unsigned long long)(VAL))
  690. #elif defined(__i386__) || defined(__m68k__) || defined(__mips__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__hppa__) || defined(__arm__) || defined(__rs6000__) || defined(__m88k__) || defined(__convex__)
  691. /* `long long's are passed embedded on the arg stack. */
  692. #define av_longlong(LIST,VAL) __av_longlong(LIST,long long,VAL)
  693. #define av_ulonglong(LIST,VAL) __av_longlong(LIST,unsigned long long,VAL)
  694. #if defined(__i386__) || defined(__m68k__) || defined(__arm__) || (defined(__rs6000__) && defined(_AIX)) || defined(__convex__)
  695. /* `long long's are (at most) word-aligned. */
  696. #define __av_longlong(LIST,TYPE,VAL)
  697.   (((LIST).aptr += sizeof(TYPE)/sizeof(__avword)) > __av_eptr(LIST)
  698.    ? -1 : (((TYPE*)(LIST).aptr)[-1] = (TYPE)(VAL), 0))
  699. #endif
  700. #if defined(__mips__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__hppa__) || (defined(__rs6000__) && !defined(_AIX)) || defined(__m88k__)
  701. /* `long long's have alignment 8. */
  702. #if defined(__mips__)
  703. #define __av_longlong(LIST,TYPE,VAL)
  704.   (((LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(TYPE)+__AV_alignof(TYPE)-1) & -(long)__AV_alignof(TYPE))) > __av_eptr(LIST) 
  705.    ? -1 : ((LIST).anum++, ((TYPE*)(LIST).aptr)[-1] = (TYPE)(VAL), 0))
  706. #endif
  707. #if defined(__sparc__) && !defined(__sparc64__)
  708. /* Within the arg stack, the alignment is only 4, not 8. */
  709. /* This assumes sizeof(long long) == 2*sizeof(__avword). */
  710. #define __av_longlong(LIST,TYPE,VAL)
  711.   (((LIST).aptr += sizeof(TYPE)/sizeof(__avword)) > __av_eptr(LIST)
  712.    ? -1 :
  713.    ((LIST).tmp._longlong = (TYPE)(VAL),
  714.     (LIST).aptr[-2] = (LIST).tmp.words[0],
  715.     (LIST).aptr[-1] = (LIST).tmp.words[1],
  716.     0))
  717. #endif
  718. #if defined(__hppa__)
  719. #define __av_longlong(LIST,TYPE,VAL)
  720.   (((LIST).aptr = (__avword*)(((__avword)(LIST).aptr & -(long)__AV_alignof(TYPE)) - sizeof(TYPE))) < __av_eptr(LIST) 
  721.    ? -1 : (*(TYPE*)(LIST).aptr = (TYPE)(VAL), 0))
  722. #endif
  723. #if (defined(__rs6000__) && !defined(_AIX)) || defined(__m88k__)
  724. #define __av_longlong(LIST,TYPE,VAL)
  725.   (((LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(TYPE)+__AV_alignof(TYPE)-1) & -(long)__AV_alignof(TYPE))) > __av_eptr(LIST) 
  726.    ? -1 : (((TYPE*)(LIST).aptr)[-1] = (TYPE)(VAL), 0))
  727. #endif
  728. #endif
  729. #endif
  731. /* floating-point argument types */
  733. #define av_float(LIST,VAL)
  734.   ((LIST).flags & __AV_TRADITIONAL_FLOAT_ARGS
  735.    ? av_double(LIST,(float)(VAL))
  736.    : __av_float(LIST,VAL))
  738. #if defined(__i386__) || defined(__m68k__) || (defined(__sparc__) && !defined(__sparc64__)) || defined(__arm__) || defined(__convex__)
  740. #define __av_float(LIST,VAL)
  741.   (++(LIST).aptr > __av_eptr(LIST)
  742.    ? -1 : (((float*)(LIST).aptr)[-1] = (float)(VAL), 0))
  744. /* This assumes sizeof(double) == 2*sizeof(__avword). */
  745. #define av_double(LIST,VAL)
  746.    (((LIST).aptr += 2) > __av_eptr(LIST)
  747.     ? -1 :
  748.     ((LIST).tmp._double = (double)(VAL),
  749.      (LIST).aptr[-2] = (LIST).tmp.words[0],
  750.      (LIST).aptr[-1] = (LIST).tmp.words[1],
  751.      0))
  753. #endif
  755. #if defined(__mips__) && !defined(__mipsn32__)
  757. /* Up to 2 leading float or double non-varargs args can be passed in
  758.  * float registers, but we also push them into the corresponding int
  759.  * registers in case of varargs. For doubles we need to align the aptr
  760.  * to an even boundary.
  761.  */
  762. #define __av_float(LIST,VAL)
  763.   (++(LIST).aptr > __av_eptr(LIST)
  764.    ? -1 : ((++(LIST).anum == 1
  765.     ? ((LIST).flags |= __AV_FLOAT_1,
  766.        ((float*)(LIST).floatarg)[1] = ((float*)(LIST).aptr)[-1] = (float)(VAL))
  767.     : (LIST).anum == 2 && ((LIST).flags & __AV_FLOAT_1)
  768.     ? ((LIST).flags |= __AV_FLOAT_2,
  769.        ((float*)(LIST).floatarg)[3] = ((float*)(LIST).aptr)[-1] = (float)(VAL))
  770.     : (*(float*)&(LIST).aptr[-1] = (float)(VAL))),
  771.    0))
  773. #define av_double(LIST,VAL)
  774.   (((LIST).aptr = (__avword*)(((__avword)(LIST).aptr+15)&-8))
  775.    > __av_eptr(LIST)
  776.    ? -1 : ((++(LIST).anum == 1
  777.     ? ((LIST).flags |= __AV_FLOAT_1,
  778.        (LIST).floatarg[0] = ((double*)(LIST).aptr)[-1] = (double)(VAL))
  779.     : (LIST).anum == 2 && ((LIST).flags & __AV_FLOAT_1)
  780.     ? ((LIST).flags |= __AV_FLOAT_2,
  781.        (LIST).floatarg[1] = ((double*)(LIST).aptr)[-1] = (double)(VAL))
  782.     : (((double*)(LIST).aptr)[-1] = (double)(VAL))),
  783.    0))
  785. #endif
  787. #if defined(__mipsn32__) || defined(__mips64__)
  789. /* Up to 8 leading float or double non-varargs args can be passed in
  790.  * float registers, but we also push them into the corresponding int
  791.  * registers in case of varargs.
  792.  */
  793. #define __av_float(LIST,VAL)
  794.   ((LIST).aptr >= __av_eptr(LIST)
  795.    ? -1 : (((LIST).anum < 8
  796.     ? ((LIST).farg_mask |= (1 << (LIST).anum),
  797.        (LIST).farg[(LIST).anum] = *(float*)(LIST).aptr = (float)(VAL)) 
  798.     : (*(float*)(LIST).aptr = (float)(VAL))),
  799.    (LIST).anum++,
  800.    (LIST).aptr++,
  801.    0))
  803. #define av_double(LIST,VAL)
  804.   ((LIST).aptr >= __av_eptr(LIST)
  805.    ? -1 : (((LIST).anum < 8 && ((LIST).darg_mask |= (1 << (LIST).anum))), 
  806.    *(double*)(LIST).aptr = (double)(VAL),
  807.    (LIST).anum++,
  808.    (LIST).aptr++,
  809.    0))
  811. #endif
  813. #if defined(__sparc64__)
  815. /* Up to 16 leading float or double non-varargs args can be passed in
  816.  * float registers, but we also push them into the corresponding int
  817.  * registers in case of varargs.
  818.  */
  819. #define __av_float(LIST,VAL)
  820.   ((LIST).aptr >= __av_eptr(LIST)
  821.    ? -1 : (((LIST).anum < 16 && ((LIST).farg_mask |= (1 << (LIST).anum))), 
  822.    (*(float*)(LIST).aptr = (float)(VAL)),
  823.    (LIST).anum++,
  824.    (LIST).aptr++,
  825.    0))
  827. #define av_double(LIST,VAL)
  828.   ((LIST).aptr >= __av_eptr(LIST)
  829.    ? -1 : (((LIST).anum < 16 && ((LIST).darg_mask |= (1 << (LIST).anum))), 
  830.    *(double*)(LIST).aptr = (double)(VAL),
  831.    (LIST).anum++,
  832.    (LIST).aptr++,
  833.    0))
  835. #endif
  837. #if defined(__alpha__)
  839. #define av_double(LIST,VAL)
  840.   (++(LIST).aptr > __av_eptr(LIST)
  841.    ? -1 : (((double*)(LIST).aptr)[-1] = (double)(VAL), 0))
  843. #define __av_float(LIST,VAL)
  844.   (++(LIST).aptr > __av_eptr(LIST)
  845.    ? -1
  846.    : (((LIST).aptr > &(LIST).args[6]
  847.        ? /* These args will be fetched from memory using "lds" instructions */ 
  848.  /* therefore store them as floats */
  849.  (*(float*)((LIST).aptr-1) = (float)(VAL))
  850.        : /* The first 6 args will be put into registers by "ldt" instructions */ 
  851.  /* (see avcall-alpha.c!). Therefore store them as doubles. */
  852.  /* When viewed as floats, the value will be the correct one. */
  853.  (*(double*)((LIST).aptr-1) = (double)(float)(VAL))
  854.      ), 0))
  856. #endif
  858. #if defined(__hppa__)
  860. #define __av_float(LIST,VAL)
  861.   (--(LIST).aptr < __av_eptr(LIST)
  862.    ? -1 : (*(float*)(LIST).aptr = (float)(VAL), 0))
  864. #define av_double(LIST,VAL)
  865.   (((LIST).aptr = (__avword*)(((long)(LIST).aptr-sizeof(double)) & -(long)sizeof(double))) 
  866.     < __av_eptr(LIST)
  867.     ? -1 : (*(double*)(LIST).aptr = (double)(VAL), 0))
  869. #endif
  871. #if defined(__rs6000__) && defined(_AIX)
  873. /* Up to 13 float or double non-varargs args can be passed in
  874.  * float registers, but we also push them into the corresponding int
  875.  * registers in case of varargs.
  876.  */
  878. #define __av_float(LIST,VAL)
  879.   (++(LIST).aptr > __av_eptr(LIST)
  880.    ? -1 : (((float*)(LIST).aptr)[-1] = (float)(VAL),
  881.    (LIST).faptr < &(LIST).fargs[13] &&
  882. (*(LIST).faptr++ = (double)(float)(VAL)),
  883.    0))
  885. #define av_double(LIST,VAL)
  886.    (((LIST).aptr += 2) > __av_eptr(LIST)
  887.     ? -1 :
  888.     ((LIST).tmp._double = (double)(VAL),
  889.      (LIST).aptr[-2] = (LIST).tmp.words[0],
  890.      (LIST).aptr[-1] = (LIST).tmp.words[1],
  891.      (LIST).faptr < &(LIST).fargs[13] &&
  892. (*(LIST).faptr++ = (LIST).tmp._double),
  893.      0))
  895. #endif
  897. #if defined(__rs6000__) && !defined(_AIX)
  899. /* Up to 8 float or double non-varargs args can be passed in
  900.  * float registers, without occupying space in the general registers.
  901.  */
  903. #define __av_float(LIST,VAL)
  904.   ((LIST).faptr < &(LIST).fargs[8]
  905.    ? ((*(LIST).faptr++ = (double)(float)(VAL)), 0)
  906.    : (++(LIST).aptr > __av_eptr(LIST)
  907.       ? -1 : (((float*)(LIST).aptr)[-1] = (float)(VAL), 0)))
  909. #define av_double(LIST,VAL)
  910.   ((LIST).faptr < &(LIST).fargs[8]
  911.    ? ((*(LIST).faptr++ = (double)(VAL)), 0)
  912.    : (((LIST).aptr += 2) > __av_eptr(LIST)
  913.       ? -1 :
  914.       ((LIST).tmp._double = (double)(VAL),
  915.        (LIST).aptr[-2] = (LIST).tmp.words[0],
  916.        (LIST).aptr[-1] = (LIST).tmp.words[1],
  917.        0)))
  919. #endif
  921. #if defined(__m88k__)
  923. #define __av_float(LIST,VAL)
  924.   (++(LIST).aptr > __av_eptr(LIST)
  925.    ? -1 : (((float*)(LIST).aptr)[-1] = (float)(VAL), 0))
  927. #define av_double(LIST,VAL)
  928.    (((LIST).aptr = (__avword*)(((long)(LIST).aptr+sizeof(double)+sizeof(double)-1) & -(long)sizeof(double))) 
  929.     > __av_eptr(LIST)
  930.     ? -1 : (((double*)(LIST).aptr)[-1] = (double)(VAL), 0))
  932. #endif
  934. #if defined(__ia64__)
  936. /* Up to 8 leading float or double non-varargs args can be passed in
  937.  * float registers, but we also push them into the corresponding int
  938.  * registers in case of varargs.
  939.  */
  940. #define __av_float(LIST,VAL)
  941.   ((LIST).aptr >= __av_eptr(LIST)
  942.    ? -1 : ((*(float*)(LIST).aptr = (float)(VAL)),
  943.    ((LIST).faptr < &(LIST).fargs[8] && (*(LIST).faptr = *(float*)(LIST).aptr, (LIST).faptr++)), 
  944.    (LIST).aptr++,
  945.    0))
  947. #define av_double(LIST,VAL)
  948.   ((LIST).aptr >= __av_eptr(LIST)
  949.    ? -1 : (*(double*)(LIST).aptr = (double)(VAL),
  950.    ((LIST).faptr < &(LIST).fargs[8] && (*(LIST).faptr = *(double*)(LIST).aptr, (LIST).faptr++)), 
  951.    (LIST).aptr++,
  952.    0))
  954. #endif
  956. /*
  957.  * structure argument types
  958.  */
  960. #define av_struct(LIST,TYPE,VAL)
  961.   __av_struct(LIST,TYPE,sizeof(TYPE),__AV_alignof(TYPE),__av_struct_assign,VAL)
  962. #define __av_struct_assign(TYPE,TYPE_SIZE,TYPE_ALIGN,PLACE,VAL)
  963.   *(TYPE*)(PLACE) = (VAL)
  964. /* _av_struct() is like av_struct(), except that you pass the type's size and alignment
  965.  * and the value's address instead of the type and the value themselves.
  966.  */
  967. #define _av_struct(LIST,TYPE_SIZE,TYPE_ALIGN,VAL_ADDR)
  968.   __av_struct(LIST,unknown,TYPE_SIZE,TYPE_ALIGN,__av_struct_copy,VAL_ADDR)
  969. #define __av_struct_copy(TYPE,TYPE_SIZE,TYPE_ALIGN,PLACE,VAL_ADDR)
  970.   __structcpy(PLACE,VAL_ADDR,TYPE_SIZE,TYPE_ALIGN)
  971. /* Structure argument alignment. */
  972. #if defined(__i386__) && defined(_MSC_VER)
  973. /* In MSVC, doubles inside structures have alignment 8, i.e.
  974.  * __AV_alignof(double) = 8, but doubles (and also structures containing
  975.  * doubles) are passed on the stack with alignment 4. Looks really weird.
  976.  */
  977. #define __av_struct_alignment(TYPE_ALIGN)  
  978.   ((TYPE_ALIGN) <= 4 ? (TYPE_ALIGN) : 4)
  979. #else
  980. #define __av_struct_alignment(TYPE_ALIGN)  
  981.   (TYPE_ALIGN)
  982. #endif
  983. #if defined(__i386__) || defined(__mips__) || defined(__mipsn32__) || defined(__mips64__) || defined(__alpha__) || (defined(__rs6000__) && defined(_AIX)) || defined(__m88k__) || defined(__ia64__)
  984. /* Structures are passed as fully aligned structures on the arg stack.
  985.  * We align the aptr, store the structure, then fill to word alignment.
  986.  * Single-small-integer structures are NOT promoted to integers and have
  987.  * different alignment.
  988.  */
  989. /* little endian -> small structures < 1 word are adjusted to the left */
  990. #if defined(__i386__) || defined(__alpha__)
  991. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  992.   (((LIST).aptr =
  993.     (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+__av_struct_alignment(TYPE_ALIGN)-1) & -(long)__av_struct_alignment(TYPE_ALIGN)))
  994.    > __av_eptr(LIST)
  995.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  996.    (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  997.    0))
  998. #endif
  999. #if defined(__ia64__)
  1000. /* Types larger than a word have 2-word alignment. */
  1001. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1002.   ((LIST).aptr = (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+__av_struct_alignment(TYPE_ALIGN)-1) & -(long)__av_struct_alignment(TYPE_ALIGN)), 
  1003.    ((TYPE_SIZE) > sizeof(__avword) && (((LIST).aptr - &(LIST).args[0]) & 1) ? ++(LIST).aptr : 0), 
  1004.    ((LIST).aptr > __av_eptr(LIST)
  1005.     ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1006.     (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1007.     0)))
  1008. #endif
  1009. /* small structures < 1 word are adjusted depending on compiler */
  1010. #if defined(__mips__) && !defined(__mipsn32__)
  1011. #define __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1012.   (((LIST).aptr =
  1013.     (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)))
  1014.    > __av_eptr(LIST)
  1015.    ? -1 : (++(LIST).anum,
  1016.    ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1017.    (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1018.    0))
  1019. #define __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1020.   (((LIST).aptr =
  1021.     (__avword*)(((((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN))
  1022.  +sizeof(__avword)-1) & -(long)sizeof(__avword)))
  1023.    > __av_eptr(LIST)
  1024.    ? -1 : (++(LIST).anum,
  1025.    ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1026.    0))
  1027. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1028.   ((LIST).flags & __AV_SGICC_STRUCT_ARGS
  1029.    ? /* SGI MIPS cc passes small structures left-adjusted, although big-endian! */
  1030.      __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1031.    : /* SGI MIPS gcc passes small structures within the first four words left-   
  1032.       * adjusted, for compatibility with cc. But structures in memory are passed  
  1033.       * right-adjusted!! See gcc-2.6.3/config/mips/mips.c:function_arg().   
  1034.       */   
  1035.      ((LIST).aptr < &(LIST).args[4]
  1036.       ? __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1037.       : __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)))
  1038. #endif
  1039. #if defined(__mipsn32__) || defined(__mips64__)
  1040. /* When a structure is passed (partially) in registers, it is passed in the
  1041.  * integer registers, except that doubles within the structure are passed in
  1042.  * the floating point registers. Instead of distinguishing these cases, we
  1043.  * always pass the structure in both the integer and the floating point
  1044.  * registers.
  1045.  */
  1046. #define __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1047.   (((LIST).aptr =
  1048.     (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)))
  1049.    > __av_eptr(LIST)
  1050.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1051.    (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1052.    ((LIST).anum < 8 && ((LIST).darg_mask |= (-1 << (LIST).anum))), 
  1053.    (LIST).anum += (((((TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)) + sizeof(__avword)-1) & -(long)sizeof(__avword))/sizeof(__avword),
  1054.    (LIST).darg_mask &= (1 << ((LIST).anum < 8 ? (LIST).anum : 8)) - 1, 
  1055.    0))
  1056. #define __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1057.   (((LIST).aptr =
  1058.     (__avword*)(((((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN))
  1059.  +sizeof(__avword)-1) & -(long)sizeof(__avword)))
  1060.    > __av_eptr(LIST)
  1061.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1062.    ((LIST).anum < 8 && ((LIST).darg_mask |= (-1 << (LIST).anum))), 
  1063.    (LIST).anum += (((((TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)) + sizeof(__avword)-1) & -(long)sizeof(__avword))/sizeof(__avword),
  1064.    (LIST).darg_mask &= (1 << ((LIST).anum < 8 ? (LIST).anum : 8)) - 1, 
  1065.    0))
  1066. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1067.   ((LIST).flags & __AV_SGICC_STRUCT_ARGS
  1068.    ? /* SGI MIPS cc passes small structures left-adjusted, although big-endian! */
  1069.      __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1070.    : /* SGI MIPS gcc passes small structures right-adjusted. */
  1071.      __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL))
  1072. #endif
  1073. #if defined(__rs6000__)
  1074. #define __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1075.   (((LIST).aptr =
  1076.     (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)))
  1077.    > __av_eptr(LIST)
  1078.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1079.    (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1080.    0))
  1081. #define __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1082.   (((LIST).aptr =
  1083.     (__avword*)(((((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN))
  1084.  +sizeof(__avword)-1) & -(long)sizeof(__avword)))
  1085.    > __av_eptr(LIST)
  1086.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1087.    0))
  1088. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1089.   ((LIST).flags & __AV_AIXCC_STRUCT_ARGS
  1090.    ? /* AIX cc and xlc pass small structures left-adjusted, although big-endian! */
  1091.      __av_struct_leftadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL) 
  1092.    : /* gcc passes small structures right-adjusted. */
  1093.      __av_struct_rightadjusted(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL))
  1094. #endif
  1095. /* big endian -> small structures < 1 word are adjusted to the right */
  1096. #if defined(__m88k__)
  1097. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1098.   (((LIST).aptr =
  1099.     (__avword*)(((((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN))
  1100.  +sizeof(__avword)-1) & -(long)sizeof(__avword)))
  1101.    > __av_eptr(LIST)
  1102.    ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1103.    0))
  1104. #endif
  1105. #endif
  1106. #if defined(__m68k__) || defined(__arm__) || defined(__convex__)
  1107. /* Structures are passed as embedded copies on the arg stack.
  1108.  */
  1109. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1110.   (((LIST).aptr = (__avword*)(((long)(LIST).aptr+(TYPE_SIZE)+sizeof(__avword)-1) & -(long)sizeof(__avword))) 
  1111.     > __av_eptr(LIST)
  1112.     ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1113.     0))
  1114. #endif
  1115. #if (defined(__sparc__) && !defined(__sparc64__)) || (defined(__rs6000__) && !defined(_AIX))
  1116. /* Structures are passed as pointers to caller-made local copies. We
  1117.  * grab space for the copies from the end of the argument list space
  1118.  * and always use maximal (double) alignment.
  1119.  */
  1120. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1121.    (++(LIST).aptr
  1122.     > ((LIST).eptr = (__avword*)((long)(LIST).eptr - (((TYPE_SIZE)+7)&-8)))
  1123.     ? -1 :
  1124.     (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).eptr,VAL),
  1125.      (LIST).aptr[-1] = (__avword)(LIST).eptr,
  1126.      0))
  1127. #endif
  1128. #if defined(__sparc64__)
  1129. /* Structures <= 16 bytes are passed as embedded copies on the arg stack,
  1130.  * left-adjusted (although big-endian!).
  1131.  * When a structure is passed (partially) in registers, it is passed in the
  1132.  * integer registers, except that floats and doubles within the structure
  1133.  * are passed in the floating point registers. Instead of distinguishing
  1134.  * these cases, we always pass the structure in both the integer and the
  1135.  * floating point registers.
  1136.  * Big structures are passed as pointers to caller-made local copies.
  1137.  * FIXME: Shouldn't (LIST).anum be incremented in sync with (LIST).aptr ?
  1138.  */
  1139. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1140.   ((TYPE_SIZE) > 16
  1141.    ? (++(LIST).aptr
  1142.       > ((LIST).eptr = (__avword*)((long)(LIST).eptr - (((TYPE_SIZE)+7)&-8)))
  1143.       ? -1 :
  1144.       (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).eptr,VAL),
  1145.        (LIST).aptr[-1] = (__avword)(LIST).eptr,
  1146.        0))
  1147.    : (((LIST).aptr =
  1148.        (__avword*)(((__avword)(LIST).aptr+(TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)))
  1149.       > __av_eptr(LIST)
  1150.       ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((__avword)(LIST).aptr-(TYPE_SIZE)),VAL),
  1151.       (LIST).aptr = (__avword*)(((__avword)(LIST).aptr+sizeof(__avword)-1) & -(long)sizeof(__avword)),
  1152.       ((LIST).anum < 16
  1153. && ((LIST).farg_mask |= (-1 << (LIST).anum),
  1154.     (LIST).darg_mask |= (-1 << (LIST).anum))),
  1155.       (LIST).anum += (((((TYPE_SIZE)+(TYPE_ALIGN)-1) & -(long)(TYPE_ALIGN)) + sizeof(__avword)-1) & -(long)sizeof(__avword))/sizeof(__avword),
  1156.       (LIST).farg_mask &= (1 << ((LIST).anum < 16 ? (LIST).anum : 16)) - 1, 
  1157.       (LIST).darg_mask &= (1 << ((LIST).anum < 16 ? (LIST).anum : 16)) - 1, 
  1158.       0)))
  1159. #endif
  1160. #if defined(__hppa__)
  1161. /* Structures <= 8 bytes are passed as embedded copies on the arg stack.
  1162.  * Big structures are passed as pointers to caller-made local copies.
  1163.  */
  1164. #define __av_struct(LIST,TYPE,TYPE_SIZE,TYPE_ALIGN,ASSIGN,VAL)
  1165.   ((TYPE_SIZE) > 8
  1166.    ? (--(LIST).aptr
  1167.       < ((LIST).eptr = (__avword*)((long)(LIST).eptr + (((TYPE_SIZE) + 7) & -8))) 
  1168.       ? -1
  1169.       : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)((long)(LIST).eptr - (((TYPE_SIZE) + 7) & -8)), VAL), 
  1170.  *(LIST).aptr = (__avword)((long)(LIST).eptr - (((TYPE_SIZE) + 7) & -8)), 
  1171.  0))
  1172.    : ((TYPE_SIZE) > 4
  1173.       ? (((LIST).aptr = (__avword*)((((long)(LIST).aptr & -8) - (long)(TYPE_SIZE)) & -8)) 
  1174.   < &(LIST).args[0]
  1175.   ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).aptr,VAL), 0))
  1176.       : /* FIXME: gcc-2.6.3 passes structures <= 4 bytes in memory left-adjusted! ?? */
  1177.         (((LIST).aptr = (__avword*)(((long)(LIST).aptr & -4) - (long)(TYPE_SIZE))) 
  1178.   < &(LIST).args[0]
  1179.   ? -1 : (ASSIGN(TYPE,TYPE_SIZE,TYPE_ALIGN,(void*)(LIST).aptr,VAL),
  1180.   (LIST).aptr = (__avword*)((long)(LIST).aptr & -4),
  1181.   0))))
  1182. #endif
  1184. /*
  1185.  * calling the function
  1186.  */
  1188. #define av_call(LIST) __builtin_avcall(&(LIST))
  1190. /* Determine whether a struct type is word-splittable, i.e. whether each of
  1191.  * its components fit into a register.
  1192.  * The entire computation is done at compile time.
  1193.  */
  1194. #define av_word_splittable_1(slot1)  
  1195.   (__av_offset1(slot1)/sizeof(__avword) == (__av_offset1(slot1)+sizeof(slot1)-1)/sizeof(__avword))
  1196. #define av_word_splittable_2(slot1,slot2)  
  1197.   ((__av_offset1(slot1)/sizeof(__avword) == (__av_offset1(slot1)+sizeof(slot1)-1)/sizeof(__avword)) 
  1198.    && (__av_offset2(slot1,slot2)/sizeof(__avword) == (__av_offset2(slot1,slot2)+sizeof(slot2)-1)/sizeof(__avword)) 
  1199.   )
  1200. #define av_word_splittable_3(slot1,slot2,slot3)  
  1201.   ((__av_offset1(slot1)/sizeof(__avword) == (__av_offset1(slot1)+sizeof(slot1)-1)/sizeof(__avword)) 
  1202.    && (__av_offset2(slot1,slot2)/sizeof(__avword) == (__av_offset2(slot1,slot2)+sizeof(slot2)-1)/sizeof(__avword)) 
  1203.    && (__av_offset3(slot1,slot2,slot3)/sizeof(__avword) == (__av_offset3(slot1,slot2,slot3)+sizeof(slot3)-1)/sizeof(__avword)) 
  1204.   )
  1205. #define av_word_splittable_4(slot1,slot2,slot3,slot4)  
  1206.   ((__av_offset1(slot1)/sizeof(__avword) == (__av_offset1(slot1)+sizeof(slot1)-1)/sizeof(__avword)) 
  1207.    && (__av_offset2(slot1,slot2)/sizeof(__avword) == (__av_offset2(slot1,slot2)+sizeof(slot2)-1)/sizeof(__avword)) 
  1208.    && (__av_offset3(slot1,slot2,slot3)/sizeof(__avword) == (__av_offset3(slot1,slot2,slot3)+sizeof(slot3)-1)/sizeof(__avword)) 
  1209.    && (__av_offset4(slot1,slot2,slot3,slot4)/sizeof(__avword) == (__av_offset4(slot1,slot2,slot3,slot4)+sizeof(slot4)-1)/sizeof(__avword)) 
  1210.   )
  1211. #define __av_offset1(slot1)  
  1212.   0
  1213. #define __av_offset2(slot1,slot2)  
  1214.   ((__av_offset1(slot1)+sizeof(slot1)+__AV_alignof(slot2)-1) & -(long)__AV_alignof(slot2))
  1215. #define __av_offset3(slot1,slot2,slot3)  
  1216.   ((__av_offset2(slot1,slot2)+sizeof(slot2)+__AV_alignof(slot3)-1) & -(long)__AV_alignof(slot3))
  1217. #define __av_offset4(slot1,slot2,slot3,slot4)  
  1218.   ((__av_offset3(slot1,slot2,slot3)+sizeof(slot3)+__AV_alignof(slot4)-1) & -(long)__AV_alignof(slot4))
  1220. /*
  1221.  * Miscellaneous declarations.
  1222.  */
  1224. #if defined(__STDC__) || defined(__GNUC__) || defined(__cplusplus)
  1225. extern int __builtin_avcall (av_alist* l);
  1226. extern void __structcpy (void* dest, void* src, unsigned long size, unsigned long alignment);
  1227. #else
  1228. extern int __builtin_avcall ();
  1229. extern void __structcpy ();
  1230. #endif
  1232. #endif /*_avcall_h */