home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / Misc / CLISP-2.LHA / CLISP960530-ki.lha / ffcall / avcall / avcall-m68k-amiga-orig.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-15  |  5.3 KB  |  151 lines
  1. #ifndef _avcall_m68k_amiga_c                /*-*- C -*-*/
  2. #define _avcall_m68k_amiga_c "$Id: avcall-m68k-amiga.c,v 1.1.1.1 1995/09/10 10:59:00 marcus Exp $"
  3. /**
  4.   Copyright 1993 Bill Triggs, <bill@robots.oxford.ac.uk>,
  5.   Oxford University Robotics Group, Oxford OX1 3PJ, U.K.
  6.  
  7.   Copyright 1995 Bruno Haible, <haible@ma2s2.mathematik.uni-karlsruhe.de>
  8.  
  9.   This is free software distributed under the GNU General Public
  10.   Licence described in the file COPYING. Contact the author if
  11.   you don't have this or can't live with it. There is ABSOLUTELY
  12.   NO WARRANTY, explicit or implied, on this software.
  13. **/
  14. /*----------------------------------------------------------------------
  15.   !!! THIS ROUTINE MUST BE COMPILED gcc -O !!!
  16.  
  17.   Foreign function interface for a m68k Amiga with gcc.
  18.  
  19.   This calls a C function with an argument list built up using macros
  20.   defined in av_call.h.
  21.  
  22.   M68k Argument Passing Conventions:
  23.  
  24.   All arguments are passed on the stack with word alignment. Doubles take
  25.   two words. Structure args are passed as true structures embedded in the
  26.   argument stack. To return a structure, the called function copies the
  27.   return value to the address supplied in register "a1". Gcc without
  28.   -fpcc-struct-return returns <= 4 byte structures as integers.
  29.  
  30.   Some specific arguments may be passed in registers.
  31.  
  32.   Compile this routine with gcc -O (or -O2 or -g -O) to get the right
  33.   register variables, or use the assembler version.
  34.   ----------------------------------------------------------------------*/
  35. #include "avcall.h.in"
  36.  
  37. #define RETURN(TYPE,VAL)    (*(TYPE*)l->raddr = (TYPE)(VAL))
  38.  
  39. int
  40. __builtin_avcall(av_alist* l)
  41. {
  42.   register __avword*    sp    __asm__("sp");  /* C names for registers */
  43.   register __avword*    sret    __asm__("a1");    /* structure return pointer */
  44.   register __avword    iret    __asm__("d0");
  45.   register __avword    iret2    __asm__("d1");
  46.   register float    fret    __asm__("d0");    /* d0 */
  47.   register double    dret    __asm__("d0");    /* d0,d1 */
  48.  
  49.   __avword regspace[3+4];        /* temp space for saving registers */
  50.   __avword space[__AV_ALIST_WORDS];    /* space for callee's stack frame */
  51.   __avword* argframe = sp;        /* stack offset for argument list */
  52.   int arglen = l->aptr - l->args;
  53.   int i;
  54.  
  55.   for (i = 0; i < arglen; i++)        /* push function args onto stack */
  56.     argframe[i] = l->args[i];
  57.  
  58.   if (l->rtype == __AVstruct)        /* push struct return address */
  59.     l->regargs[8+1] = (__avword)(l->raddr);
  60.  
  61.   /* Save some registers by hand. There is no way to persuade gcc that
  62.    * they are clobbered by the big moveml below.
  63.    */
  64.   __asm__("moveml #x470f,%0" /* 0x470f == d0-d3/a0-a2/a6 */
  65.           : "=m" (regspace[0]) : );
  66.  
  67.   __asm__("movel %0,sp@-" : : "g" (&&return_here)); /* prepare function call */
  68.   __asm__("movel %0,sp@-" : : "g" (l->func));
  69.  
  70.                     /* put some arguments into registers */
  71.   __asm__("moveml %0,#0x7fff" /* 0x7fff == d0-d7/a0-a6 */
  72.           :
  73.           : "m" (l->regargs[0])
  74.           : /*"d0","d1","d2","d3",*/"d4","d5","d6","d7",/*"a0","a1","a2",*/"a3","a4","a5"/*,"a6"*/
  75.         /* This long clobber list ensures that the function prologue
  76.          * contains a                 "moveml #0x3f3e,sp@-"  d2-d7/a2-a6
  77.          * and the epilogue contains  "moveml sp@+,#0x7cfc"  d2-d7/a2-a6
  78.          */
  79.          );
  80.  
  81.   __asm__("rts");        /* call function */
  82.   return_here:            /* function returns here */
  83.  
  84.   __asm__("moveml %0,#x470f" /* 0x470f == d0-d3/a0-a2/a6 */
  85.           : : "m" (regspace[0]) );    /* restore some registers */
  86.  
  87.   switch (l->rtype)            /* save return value */
  88.   {
  89.   case __AVvoid:                    break;
  90.   case __AVword:    RETURN(__avword,    iret);    break;
  91.   case __AVchar:    RETURN(char,        iret);    break;
  92.   case __AVschar:    RETURN(signed char,    iret);    break;
  93.   case __AVuchar:    RETURN(unsigned char,    iret);    break;
  94.   case __AVshort:    RETURN(short,        iret);    break;
  95.   case __AVushort:    RETURN(unsigned short,    iret);    break;
  96.   case __AVint:        RETURN(int,        iret);    break;
  97.   case __AVuint:    RETURN(unsigned int,    iret);    break;
  98.   case __AVlong:    RETURN(long,        iret);    break;
  99.   case __AVulong:    RETURN(unsigned long,    iret);    break;
  100.   case __AVfloat:
  101.     if (l->flags & __AV_SUNCC_FLOAT_RETURN)
  102.       RETURN(float, (float)dret);
  103.     else
  104.       RETURN(float, fret);
  105.     break;
  106.   case __AVdouble:    RETURN(double,        dret);    break;
  107.   case __AVvoidp:    RETURN(void*,        iret);    break;
  108.   case __AVstruct:
  109.     if (l->flags & __AV_PCC_STRUCT_RETURN)
  110.     { /* pcc struct return convention: need a  *(TYPE*)l->raddr = *(TYPE*)i;  */
  111.       switch (l->rsize)
  112.       {
  113.       case sizeof(char):  RETURN(char,    *(char*)iret);    break;
  114.       case sizeof(short): RETURN(short,    *(short*)iret);    break;
  115.       case sizeof(int):      RETURN(int,    *(int*)iret);    break;
  116.       case sizeof(double):
  117.     ((int*)l->raddr)[0] = ((int*)iret)[0];
  118.     ((int*)l->raddr)[1] = ((int*)iret)[1];
  119.     break;
  120.       default:
  121.     {
  122.       int n = (l->rsize + sizeof(__avword)-1)/sizeof(__avword);
  123.       while (--n >= 0)
  124.         ((__avword*)l->raddr)[n] = ((__avword*)iret)[n];
  125.     }
  126.     break;
  127.       }
  128.     }
  129.     else
  130.     { /* normal struct return convention */
  131.       if (l->flags & __AV_REGISTER_STRUCT_RETURN)
  132.     switch (l->rsize)
  133.     {
  134.     case sizeof(char):  RETURN(char,  iret);    break;
  135.     case sizeof(short): RETURN(short, iret);    break;
  136.     case sizeof(int):   RETURN(int,   iret);    break;
  137.     case 2*sizeof(__avword):
  138.       ((__avword*)l->raddr)[0] = iret;
  139.       ((__avword*)l->raddr)[1] = iret2;
  140.       break;
  141.     default:                    break;
  142.     }
  143.     }
  144.     break;
  145.   default:                        break;
  146.   }
  147.   return 0;
  148. }
  149.  
  150. #endif /*_avcall_m68k_amiga_c */
  151.