Return to va-mips.h CVS log

Up to [GCC 1.x] / gcc

Annotation of gcc/va-mips.h, revision 1.1.1.1

1.1       root        1: /* ---------------------------------------- */
                      2: /*           VARARGS  for MIPS/GNU CC       */
                      3: /*                                          */
                      4: /*                                          */
                      5: /*                                          */
                      6: /*                                          */
                      7: /* ---------------------------------------- */
                      8: 
                      9: /* WARNING: THIS depends heavily on in register parameter
                     10:    passing conventions of the MIPS.  This is compatible with MIPS
                     11:    programs, including printf; but differs from MIPS
                     12:    implementation. */
                     13: 
                     14: /*            PROLOGUE FOR VARARGS PROGRAMS:
                     15:              
                     16:                                         ;;;; META COMMENTS
                     17:       .align 0
                     18:                                         ;;;; Purpose: identify varargs pgm
                     19:                                         ;;;; to codegen. I'd rather have a
                     20:                                        ;;;; Flag in the compiler than this.
                     21: 
                     22: __vd_alist.0:
                     23:       .ascii "__%%VARARGS\0"
                     24:       .ent    zrintf
                     25: zrintf:
                     26:  #PROLOGUE
                     27:       add     $8,$0,$29
                     28:                                         ;;;; Leave extra space in frame
                     29:                                        ;;;; to save f12 f14
                     30:       subu    $29,112 #temp=   76,saveregs=   32, sfo=   -4
                     31:  #    .mask   0xc0010000
                     32:       sw      $31,4($29)
                     33:       sw      $30,8($29)
                     34:                                         ;;;; Purpose:save stack size on stack
                     35:                                         ;;;; for easier retrieval
                     36:       addi    $9,$0,112       #Varargs suspicion
                     37:       sw      $9,-4($8)       #Varargs suspicion
                     38:                                         ;;;; save floating point registers
                     39:                                         ;;;; into extra stack space (in the
                     40:                                        ;;;; varargs callee frame, NOT in the
                     41:                                        ;;;; space saved by caller for register
                     42:                                        ;;;; argument write back. Thus, we
                     43:                                        ;;;; can write back both, and let the
                     44:                                        ;;;; va_arg macro decide what is
                     45:                                        ;;;; required.
                     46: 
                     47:       s.d     $f12,16($29)    #Varargs Suspicion
                     48:       s.d     $f14,24($29)    #Varargs Suspicion
                     49: 
                     50:       sw      $16,28($29)
                     51:  #    .fmask  0x0
                     52:       add     $30,$0,$8
                     53:  #END PROLOGUE
                     54:                                         ;;;; Write back of r4-r7 due to
                     55:                                        ;;;; the va_dcl, va_start combination
                     56: 
                     57:       sw      $4,0($30)       #movsi $4 -> 0($30)
                     58:       sw      $5,4($30)       #movsi $5 -> 4($30)
                     59:       sw      $6,8($30)       #movsi $6 -> 8($30)
                     60:       sw      $7,12($30)      #movsi $7 -> 12($30)
                     61:   
                     62: */
                     63: 
                     64: typedef struct 
                     65: { int pnt;
                     66:   char *stack;
                     67:   double *fpregs;  
                     68:    } va_list  ;
                     69:                                /* Used to push R4-R7 to stack  */
                     70:                                /* and to access argument list on stack */
                     71: #define va_alist _va_alist, __va_alist,__vb_alist,__vc_alist
                     72: 
                     73: #define va_dcl int _va_alist, __va_alist,__vb_alist,__vc_alist; 
                     74: 
                     75: 
                     76: #define va_start(list) {\
                     77:        static char __vd_alist[16] = "__%%VARARGS";  /* Identify to codegen */\
                     78:        &__va_alist,&__vb_alist,&__vc_alist,         /* write back to stack */\
                     79:        (list).pnt = 0,                              /* start from first    */\
                     80:        (list).stack =  (char *) &_va_alist,         /* Access parameter list*/\
                     81:        (list).fpregs =  (double *)((list).stack -\
                     82:                                   *(int *)((list).stack -4) +  16),       \
                     83:        (list).stack;}         
                     84: 
                     85: #define va_end(list)
                     86: 
                     87:                                /* For argument passing convention see */
                     88:                                /* both tm.h and Jerry Kane's book     */
                     89: 
                     90: #define va_arg(list,mode) (((mode *)\
                     91:               (((sizeof(mode) > 4) ?\
                     92:                    (((list).pnt == 0 )?(((list).pnt = -1),\
                     93:                                       (list).stack = (char *)\
                     94:                                                       (((int)((list).stack)\
                     95:                                                      + 2*8 - 1) & -8),\
                     96:                                       (char *)((list).fpregs+1)\
                     97:                                       )\
                     98:                       :((list).pnt == -1) ?((list).pnt = 2,\
                     99:                                       (list).stack = (char *)\
                    100:                                                      (((int)((list).stack)\
                    101:                                                      + 2*8 - 1) & -8),\
                    102:                                       (char *)((list).fpregs+2) \
                    103:                                       )\
                    104:                              :(((list).pnt > 0 )?\
                    105:                                ((list).pnt =((list).pnt +1),\
                    106:                                                 (list).stack =(char *)\
                    107:                                                   (((int)((list).stack)\
                    108:                                                      + 2*8 - 1) & -8) \
                    109:                                                ):(char *)abort()))\
                    110:                :((list).pnt = (((list).pnt >=0) ? ((list).pnt +1)\
                    111:                                 :((list).pnt == -1) ? 2 :3),\
                    112:                 (list).stack =  (char *)(((int)((list).stack)+ 2*4 - 1) & -4)\
                    113:                )\
                    114:                )))[-1])\

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.