testasmcomp/ia64.S

   1 /***********************************************************************/
   2 /*                                                                     */
   3 /*                           Objective Caml                            */
   4 /*                                                                     */
   5 /*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         */
   6 /*                                                                     */
   7 /*  Copyright 1996 Institut National de Recherche en Informatique et   */
   8 /*  en Automatique.  All rights reserved.  This file is distributed    */
   9 /*  under the terms of the Q Public License version 1.0.               */
  10 /*                                                                     */
  11 /***********************************************************************/
  12
  13 /* $Id$ */
  14
  15 #define ST8OFF(a,b,d) st8 [a] = b, d
  16 #define LD8OFF(a,b,d) ld8 a = [b], d
  17 #define STFDOFF(a,b,d) stfd [a] = b, d
  18 #define LDFDOFF(a,b,d) ldfd a = [b], d
  19 #define STFSPILLOFF(a,b,d) stf.spill [a] = b, d
  20 #define LDFFILLOFF(a,b,d) ldf.fill a = [b], d
  21
  22         .text
  23         .align 16
  24
  25         .global call_gen_code#
  26         .proc   call_gen_code#
  27
  28 call_gen_code:
  29         /* Allocate 64 "out" registers (for the Caml code) and no locals */
  30         alloc   r3 = ar.pfs, 0, 0, 64, 0
  31
  32         /* Save PFS, return address and GP on stack */
  33         add     sp = -368, sp ;;
  34         add     r2 = 16, sp ;;
  35         ST8OFF(r2,r3,8) ;;
  36         mov     r3 = b0 ;;
  37         ST8OFF(r2,r3,8) ;;
  38         ST8OFF(r2,gp,8) ;;
  39
  40         /* Save predicates on stack */
  41         mov     r3 = pr ;;
  42         st8     [r2] = r3
  43
  44         /* Save callee-save floating-point registers on stack */
  45         add     r2 = 48, sp
  46         add     r3 = 64, sp ;;
  47         STFSPILLOFF(r2,f2,16) ;;
  48         STFSPILLOFF(r3,f3,16) ;;
  49         STFSPILLOFF(r2,f4,16) ;;
  50         STFSPILLOFF(r3,f5,16) ;;
  51         STFSPILLOFF(r2,f16,16) ;;
  52         STFSPILLOFF(r3,f17,16) ;;
  53         STFSPILLOFF(r2,f18,16) ;;
  54         STFSPILLOFF(r3,f19,16) ;;
  55         STFSPILLOFF(r2,f20,16) ;;
  56         STFSPILLOFF(r3,f21,16) ;;
  57         STFSPILLOFF(r2,f22,16) ;;
  58         STFSPILLOFF(r3,f23,16) ;;
  59         STFSPILLOFF(r2,f24,16) ;;
  60         STFSPILLOFF(r3,f25,16) ;;
  61         STFSPILLOFF(r2,f26,16) ;;
  62         STFSPILLOFF(r3,f27,16) ;;
  63         STFSPILLOFF(r2,f28,16) ;;
  64         STFSPILLOFF(r3,f29,16) ;;
  65         STFSPILLOFF(r2,f30,16) ;;
  66         STFSPILLOFF(r3,f31,16) ;;
  67
  68         /* Recover entry point and gp from the function pointer in in0 */
  69         LD8OFF(r2,r32,8) ;;
  70         ld8     r3 = [r32] ;;
  71         mov     b6 = r2
  72         mov     gp = r3 ;;
  73
  74         /* Shift arguments r33 ... r35 to r32 ... r34 */
  75         mov     r32 = r33
  76         mov     r33 = r34
  77         mov     r34 = r35
  78
  79         /* Do the call */
  80         br.call.sptk b0 = b6 ;;
  81
  82         /* Restore the saved floating-point registers */
  83         add     r2 = 48, sp
  84         add     r3 = 64, sp ;;
  85         LDFFILLOFF(f2,r2,16) ;;
  86         LDFFILLOFF(f3,r3,16) ;;
  87         LDFFILLOFF(f4,r2,16) ;;
  88         LDFFILLOFF(f5,r3,16) ;;
  89         LDFFILLOFF(f16,r2,16) ;;
  90         LDFFILLOFF(f17,r3,16) ;;
  91         LDFFILLOFF(f18,r2,16) ;;
  92         LDFFILLOFF(f19,r3,16) ;;
  93         LDFFILLOFF(f20,r2,16) ;;
  94         LDFFILLOFF(f21,r3,16) ;;
  95         LDFFILLOFF(f22,r2,16) ;;
  96         LDFFILLOFF(f23,r3,16) ;;
  97         LDFFILLOFF(f24,r2,16) ;;
  98         LDFFILLOFF(f25,r3,16) ;;
  99         LDFFILLOFF(f26,r2,16) ;;
 100         LDFFILLOFF(f27,r3,16) ;;
 101         LDFFILLOFF(f28,r2,16) ;;
 102         LDFFILLOFF(f29,r3,16) ;;
 103         LDFFILLOFF(f30,r2,16) ;;
 104         LDFFILLOFF(f31,r3,16) ;;
 105
 106         /* Restore gp, predicates and return */
 107         add     r2 = 16, sp ;;
 108         LD8OFF(r3,r2,8) ;;
 109         mov     ar.pfs = r3
 110         LD8OFF(r3,r2,8) ;;
 111         mov     b0 = r3
 112         LD8OFF(gp,r2,8) ;;
 113         LD8OFF(r3,r2,8) ;;
 114         mov     pr = r3, -1
 115
 116         br.ret.sptk.many b0 ;;
 117
 118         .endp   call_gen_code#