Open64: osprey/common/com/NVISA/targ

00001 /*
00002  * Copyright 2005-2008 NVIDIA Corporation.  All rights reserved.
00003  */
00004 
00005 /*
00006  * Copyright 2003, 2004, 2005 PathScale, Inc.  All Rights Reserved.
00007  */
00008 
00009 /*
00010 
00011   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00012 
00013   This program is free software; you can redistribute it and/or modify it
00014   under the terms of version 2 of the GNU General Public License as
00015   published by the Free Software Foundation.
00016 
00017   This program is distributed in the hope that it would be useful, but
00018   WITHOUT ANY WARRANTY; without even the implied warranty of
00019   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00020 
00021   Further, this software is distributed without any warranty that it is
00022   free of the rightful claim of any third person regarding infringement 
00023   or the like.  Any license provided herein, whether implied or 
00024   otherwise, applies only to this software file.  Patent licenses, if 
00025   any, provided herein do not apply to combinations of this program with 
00026   other software, or any other product whatsoever.  
00027 
00028   You should have received a copy of the GNU General Public License along
00029   with this program; if not, write the Free Software Foundation, Inc., 59
00030   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00031 
00032   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00033   Mountain View, CA 94043, or:
00034 
00035   http://www.sgi.com
00036 
00037   For further information regarding this notice, see:
00038 
00039   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00040 
00041 */
00042 
00043 
00044 /*
00045  * This defines the ABI subprogram interface,
00046  * and is used to determine how parameters and results are passed.
00047  * We have an array of tables, where each table describes the info
00048  * for one abi.  The array is indexed by the TARGET_ABI enumeration.
00049  * The register values are the PREG offsets, so these values can be
00050  * used in WHIRL.
00051  */
00052 
00053 #define TRACE_ENTRY(x)
00054 #define TRACE_EXIT(x)
00055 #define TRACE_EXIT_i(x,i)
00056 
00057 #define __STDC_LIMIT_MACROS
00058 #include <stdint.h>
00059 #include <limits.h>
00060 #include "defs.h"
00061 #include "mtypes.h"
00062 #include "errors.h"
00063 #include "erglob.h"
00064 #include "stab.h"
00065 #include "config_targ.h"
00066 #include "targ_sim.h"
00067 
00068 #include "targ_sim_body.h"
00069 
00070 #define IP0 First_Int32_Preg_Param_Offset
00071 #define LP0 First_Int64_Preg_Param_Offset
00072 #define FP0 First_Float32_Preg_Param_Offset
00073 #define DP0 First_Float64_Preg_Param_Offset
00074 #define IR0 First_Int32_Preg_Return_Offset
00075 #define LR0 First_Int64_Preg_Return_Offset
00076 #define FR0 First_Float32_Preg_Return_Offset
00077 #define DR0 First_Float64_Preg_Return_Offset
00078 #define NP1 MAX_NUMBER_OF_REGISTER_PARAMETERS-1
00079 #define NR1 MAX_NUMBER_OF_REGISTERS_FOR_RETURN-1
00080 
00081 #if (__GNUC__ == 2)
00082 static
00083 #endif /* _LP64 */
00084 SIM SIM_Info[] = {
00085   /* flags */
00086   /* int args, int64 args, flt args, dbl args */
00087   /* int res , int64 res, flt res, dbl res */
00088   /* int type, int64 type, flt type, dbl type */
00089   /* save area, formal-area, var ofst */
00090   /* struct arg, struct res, slink, pic */
00091   {/* ABI_UNDEF */
00092     0,
00093     {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0},
00094     {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0},
00095     0, 0, 0, 0,
00096     0, 0, 0, 
00097     0, 0, 0, 0
00098   },
00099 
00100   { /* ABI_n32 */
00101     SIM_FLT_AFTER_INT | SIM_COORD_MEM_REG 
00102     | SIM_REG_STRUCTS | SIM_FLT_RTN_COMPLEX 
00103     | SIM_FLT_REG_FIELDS | SIM_DBL_REG_FIELDS | SIM_VARARGS_FLOATS ,
00104     {IP0,IP0+NP1,1}, {LP0,LP0+NP1,1}, {FP0,FP0+NP1,1}, {DP0,DP0+NP1,1},
00105     {IR0,IR0+NR1,1}, {LR0,LR0+NR1,1}, {FR0,FR0+NR1,1}, {DR0,DR0+NR1,1},
00106     MTYPE_I4, MTYPE_I8, MTYPE_F4, MTYPE_F8,
00107     0, 0, -64/*TODO*/, 
00108     128, 128, 0, 0
00109   },
00110 
00111   { /* ABI_n64 */
00112     SIM_FLT_AFTER_INT | SIM_COORD_MEM_REG 
00113     | SIM_REG_STRUCTS | SIM_FLT_RTN_COMPLEX 
00114     | SIM_FLT_REG_FIELDS | SIM_DBL_REG_FIELDS | SIM_VARARGS_FLOATS ,
00115     {IP0,IP0+NP1,1}, {LP0,LP0+NP1,1}, {FP0,FP0+NP1,1}, {DP0,DP0+NP1,1},
00116     {IR0,IR0+NR1,1}, {LR0,LR0+NR1,1}, {FR0,FR0+NR1,1}, {DR0,DR0+NR1,1},
00117     MTYPE_I4, MTYPE_I8, MTYPE_F4, MTYPE_F8,
00118     0, 64/*TODO*/, -64/*TODO*/, 
00119     128, 128, 0, 0
00120   },
00121   { /* ABI_w64 */
00122     SIM_FLT_AFTER_INT | SIM_COORD_MEM_REG 
00123     | SIM_REG_STRUCTS | SIM_FLT_RTN_COMPLEX 
00124     | SIM_FLT_REG_FIELDS | SIM_DBL_REG_FIELDS | SIM_VARARGS_FLOATS ,
00125     {IP0,IP0+NP1,1}, {LP0,LP0+NP1,1}, {FP0,FP0+NP1,1}, {DP0,DP0+NP1,1},
00126     {IR0,IR0+NR1,1}, {LR0,LR0+NR1,1}, {FR0,FR0+NR1,1}, {DR0,DR0+NR1,1},
00127     MTYPE_I4, MTYPE_I8, MTYPE_F4, MTYPE_F8,
00128     0, 64/*TODO*/, -64/*TODO*/, 
00129     128, 128, 0, 0
00130   }
00131 };
00132 
00133 /* return whether preg is a return preg */
00134 extern BOOL 
00135 Is_Return_Preg (PREG_NUM preg)
00136 {
00137   return (preg >= First_Int32_Preg_Return_Offset &&
00138           preg <= Last_Int32_Preg_Return_Offset) || 
00139          (preg >= First_Float32_Preg_Return_Offset && 
00140     preg <= Last_Float32_Preg_Return_Offset) ||
00141          (preg >= First_Int64_Preg_Return_Offset && 
00142     preg <= Last_Int64_Preg_Return_Offset) ||
00143          (preg >= First_Float64_Preg_Return_Offset && 
00144     preg <= Last_Float64_Preg_Return_Offset);
00145 }
00146 
00147 /* return whether preg is an output preg */
00148 extern BOOL 
00149 Is_Int_Output_Preg (PREG_NUM preg)
00150 {
00151   Fail_FmtAssertion (
00152     ("Is_Int_Output_Preg not applicable to x8664 targets"));
00153   return FALSE;
00154 }
00155 
00156 /* return whether preg is an input preg */
00157 extern BOOL
00158 Is_Formal_Preg (PREG_NUM preg)
00159 {
00160   return (preg >= First_Int32_Preg_Param_Offset && 
00161     preg <= Last_Int32_Preg_Param_Offset) || 
00162          (preg >= First_Float32_Preg_Param_Offset && 
00163     preg <= Last_Float32_Preg_Param_Offset) ||
00164          (preg >= First_Int64_Preg_Param_Offset && 
00165     preg <= Last_Int64_Preg_Param_Offset) || 
00166          (preg >= First_Float64_Preg_Param_Offset && 
00167     preg <= Last_Float64_Preg_Param_Offset);
00168 }
00169 
00170 
00171 /* This routine figures out the mtypes of the return registers that are 
00172  * used for returning an object of the given type.
00173  * This returns the mtypes to use for the CALL opcode in high-level whirl.
00174  * This means that returns of simulated objects, like FQ, are just shown
00175  * as returning FQ, which will later be split into F8F8.
00176  * However, structures that return in registers are specified explicitly.
00177  */
00178 /*ARGSUSED*/
00179 extern void
00180 Get_Return_Mtypes (
00181   TY_IDX rtype,   /* The result type */
00182   Mtype_Return_Level level, /* whether to lower the mtypes */
00183   TYPE_ID *mreg1, /* out: mtype for result register 1 */
00184   TYPE_ID *mreg2) /* out: mtype for result register 2 */
00185 {
00186   Fail_FmtAssertion (
00187     ("Get_Return_Mtypes should not be invoked; invoke Get_Return_Info instead"));
00188 }
00189 
00190 /* This routine figures out which return registers are to be used
00191  * for returning an object with the given mtypes.
00192  * It is assumed that the mtypes will be determined by calling
00193  * Get_Return_Mtypes.
00194  */
00195 /*ARGSUSED*/
00196 extern void
00197 Get_Return_Pregs (
00198   TYPE_ID mreg1,  /* in:  mtype for result register 1 */
00199   TYPE_ID mreg2,  /* in:  mtype for result register 2 */
00200   PREG_NUM *rreg1,  /* out: result register 1 */
00201   PREG_NUM *rreg2)  /* out: result register 2 */
00202 {
00203   Fail_FmtAssertion (
00204     ("Get_Return_Pregs should not be invoked; invoke Get_Return_Info instead"));
00205 }
00206 
00207 RETURN_INFO
00208 Get_Return_Info(TY_IDX rtype, Mtype_Return_Level level)
00209 {
00210   TYPE_ID mtype = TY_mtype (rtype);
00211   RETURN_INFO info;
00212   INT32 i; 
00213   INT64 size;
00214 
00215   info.return_via_first_arg = FALSE;
00216 
00217   switch (mtype) {
00218 
00219     case MTYPE_UNKNOWN:
00220 
00221       // FORTRAN character array
00222       info.count = 0;
00223       // f90 already has made visible the arg for arrays
00224       // info.return_via_first_arg = TRUE;
00225       break;
00226 
00227     case MTYPE_FQ:
00228 
00229       info.count = 1;
00230       info.mtype[0] = mtype;
00231       info.preg[0] = PR_first_reg(SIM_INFO.flt_results);
00232       break;
00233 
00234     case MTYPE_V:
00235 
00236       info.count = 0;
00237       break;
00238 
00239     case MTYPE_I8:
00240     case MTYPE_U8:
00241     case MTYPE_A8:
00242       info.count = 1;
00243       info.mtype [0] = mtype;
00244       info.preg  [0] = PR_first_reg(SIM_INFO.int64_results);
00245       break;
00246 
00247     case MTYPE_I1:
00248     case MTYPE_I2:
00249     case MTYPE_I4:
00250     case MTYPE_U1:
00251     case MTYPE_U2:
00252     case MTYPE_U4:
00253     case MTYPE_A4:
00254 
00255       info.count = 1;
00256       info.mtype [0] = mtype;
00257       info.preg  [0] = PR_first_reg(SIM_INFO.int_results);
00258       break;
00259 
00260     case MTYPE_F4:
00261 #ifdef TARG_SUPPORTS_VECTORS
00262     case MTYPE_V16F4:
00263 #endif
00264       info.count = 1;
00265       info.mtype [0] = mtype;
00266       info.preg  [0] = PR_first_reg(SIM_INFO.flt_results);
00267       break;
00268     case MTYPE_F8:
00269 #ifdef TARG_SUPPORTS_VECTORS
00270     case MTYPE_V16F8:
00271 #endif
00272       info.count = 1;
00273       info.mtype [0] = mtype;
00274       info.preg  [0] = PR_first_reg(SIM_INFO.dbl_results);
00275       break;
00276 
00277     case MTYPE_C4:
00278       if (Is_Target_32bit()) {
00279   /* Under -m32 for C and C++, if type "float _Complex" is passed as argument,
00280      there is no need to introduce a fake first parameter; and if it is a return
00281      value, the real part and the imaginary part are set aside in
00282      %eax and %edx, respectively.    (bug#2707)
00283    */
00284   if( PU_c_lang(Get_Current_PU()) ||
00285       PU_cxx_lang(Get_Current_PU()) ){
00286 
00287     if( level == Use_Simulated ){
00288       info.count = 1;
00289       info.mtype[0] = mtype;
00290       info.preg[0] = PR_first_reg(SIM_INFO.flt_results);
00291 
00292     } else {
00293       info.count = 2;
00294       info.mtype[0] = info.mtype[1] = SIM_INFO.int_type;
00295       info.preg[0] = PR_first_reg(SIM_INFO.int_results);
00296       info.preg[1] = info.preg[0] + PR_skip_value(SIM_INFO.int_results);
00297     }
00298 
00299   } else {
00300     info.count = 0;
00301     info.return_via_first_arg = TRUE;
00302   }
00303       } else if( level == Use_Simulated ){
00304   info.count     = 1;
00305   info.mtype [0] = mtype;
00306   info.preg  [0] = PR_first_reg(SIM_INFO.flt_results);
00307 
00308       } else {
00309   // For bug:143
00310   
00311         info.count     = 2;
00312         info.mtype [0] = Mtype_complex_to_real(mtype);
00313         info.mtype [1] = Mtype_complex_to_real(mtype);
00314         info.preg  [0] = PR_first_reg(SIM_INFO.flt_results);
00315         info.preg  [1] =   PR_first_reg(SIM_INFO.flt_results)
00316                          + PR_skip_value(SIM_INFO.flt_results);
00317       }
00318 
00319       break;
00320 
00321     case MTYPE_C8:
00322       if (Is_Target_32bit()) {
00323         info.count = 0;
00324         info.return_via_first_arg = TRUE;
00325       } else if (level == Use_Simulated) {
00326 
00327         info.count     = 1;
00328         info.mtype [0] = mtype;
00329         info.preg  [0] = PR_first_reg(SIM_INFO.dbl_results);
00330       }
00331 
00332       else {
00333 
00334         info.count     = 2;
00335         info.mtype [0] = Mtype_complex_to_real(mtype);
00336         info.mtype [1] = Mtype_complex_to_real(mtype);
00337         info.preg  [0] = PR_first_reg(SIM_INFO.dbl_results);
00338         info.preg  [1] =   PR_first_reg(SIM_INFO.dbl_results)
00339                          + PR_skip_value(SIM_INFO.dbl_results);
00340       }
00341       break;
00342 
00343     case MTYPE_CQ:
00344       if (Is_Target_32bit()) {
00345         info.count = 0;
00346         info.return_via_first_arg = TRUE;
00347       }
00348       else if (level == Use_Simulated) {
00349 
00350         info.count     = 1;
00351         info.mtype [0] = mtype;
00352         info.preg  [0] = PR_first_reg(SIM_INFO.flt_results);
00353       }
00354 
00355       else {
00356 
00357         info.count     = 2;
00358         info.mtype [0] = Mtype_complex_to_real(mtype);
00359         info.mtype [1] = Mtype_complex_to_real(mtype);
00360         info.preg  [0] = PR_first_reg(SIM_INFO.flt_results);
00361         info.preg  [1] =   PR_first_reg(SIM_INFO.flt_results)
00362                          + PR_skip_value(SIM_INFO.flt_results);
00363       }
00364       break;
00365 
00366     case MTYPE_M:
00367 
00368       info.count = 0;
00369 
00370       size = TY_size(Ty_Table[rtype]);
00371       if (size == 0)
00372   break;
00373 
00374       if (size*8 <= SIM_INFO.max_struct_result
00375         && TY_can_be_vector(rtype) 
00376         && TY_vector_count(rtype) <= MAX_NUMBER_OF_REGISTERS_FOR_RETURN) 
00377       {
00378         Preg_Range prange;
00379         TYPE_ID etype = TY_mtype(TY_vector_elem_ty(rtype));
00380         switch (etype) {
00381         case MTYPE_F4:
00382           prange = SIM_INFO.flt_results; break;
00383         case MTYPE_F8:
00384           prange = SIM_INFO.dbl_results; break;
00385         case MTYPE_I4:
00386         case MTYPE_U4:
00387           prange = SIM_INFO.int_results; break;
00388         case MTYPE_I8:
00389         case MTYPE_U8:
00390           prange = SIM_INFO.int64_results; break;
00391         default:
00392           FmtAssert(FALSE,("NYI"));
00393         }
00394         PREG_NUM preg = PR_first_reg(prange);
00395         info.count = TY_vector_count(rtype);
00396         for (i = 0; i < info.count; i++) {
00397           info.mtype [i] = etype;
00398           info.preg  [i] = preg;
00399           preg += PR_skip_value(prange);
00400         }
00401       }
00402       else {
00403         info.return_via_first_arg = TRUE;
00404       }
00405       break;
00406 
00407     default:
00408 
00409       info.count = 0;
00410       Fail_FmtAssertion ("Invalid return mtype %s encountered",
00411                          (MTYPE_name(mtype)));
00412       break;
00413   } /* switch (mtype) */
00414 
00415   for (i = info.count; i < MAX_NUMBER_OF_REGISTERS_FOR_RETURN; i++) {
00416 
00417     info.mtype [i] = MTYPE_V;
00418     info.preg  [i] = 0;
00419   }
00420 
00421   return info;
00422 } /* Get_Return_Info */
00423 
00424 static PLOC
00425 Setup_Parameter_Locations (TY_IDX pu_type)
00426 {
00427     static PLOC plocNULL;
00428 
00429     TY_IDX ret_type = (TY_kind(pu_type) == KIND_FUNCTION ? TY_ret_type(pu_type)
00430       : pu_type);
00431     RETURN_INFO info = Get_Return_Info (ret_type, No_Simulated);
00432     if (TY_is_varargs (pu_type)) {
00433   // find last fixed parameter
00434   TYLIST_IDX idx = TY_tylist (pu_type);
00435   Last_Fixed_Param = -1;
00436   for (++idx; Tylist_Table[idx] != 0; ++idx)
00437       ++Last_Fixed_Param;
00438   // old style varargs is counting va_alist and should not
00439   if ( ! TY_has_prototype(pu_type))
00440       --Last_Fixed_Param;
00441   // account for functions returning to first parameter
00442   if (TY_return_to_param (pu_type))
00443       ++Last_Fixed_Param;
00444     } else
00445   Last_Fixed_Param = INT_MAX;
00446 
00447     Current_Param_Num = -1;   // count all parameters
00448     Last_Param_Offset = 0;
00449     return plocNULL;
00450 } // Setup_Parameter_Locations
00451 
00452 
00453 static PLOC
00454 Get_Parameter_Location (TY_IDX ty, BOOL is_output)
00455 {
00456     PLOC ploc;        // return location
00457 
00458     ploc.reg = 0;
00459     ploc.start_offset = Last_Param_Offset;
00460     ploc.size = 0;
00461     ploc.vararg_reg = 0;               // to silence purify
00462     if (TY_kind (ty) == KIND_VOID) {
00463   return ploc;
00464     }
00465 
00466     /* check for array case where fe doesn't fill in right btype */
00467     TYPE_ID pmtype = Fix_TY_mtype (ty); /* Target type */
00468     ploc.size = MTYPE_RegisterSize(pmtype);
00469 
00470     ++Current_Param_Num;
00471 
00472     INT rpad = 0;     /* padding to right of object */
00473 
00474     // do need to pad when start offset not already aligned
00475     rpad = (ploc.start_offset % TY_align(ty));
00476 
00477     switch (pmtype) {
00478   
00479     case MTYPE_I1:
00480     case MTYPE_U1:
00481     case MTYPE_I2:
00482     case MTYPE_U2:
00483     case MTYPE_I4:
00484     case MTYPE_U4:
00485     case MTYPE_A4:
00486   ploc.reg = PR_first_reg(SIM_INFO.int_args) + Current_Param_Num;
00487   if (ploc.reg > PR_last_reg(SIM_INFO.int_args)) 
00488     ploc.reg = 0;
00489   break;
00490 
00491     case MTYPE_I8:
00492     case MTYPE_U8:
00493     case MTYPE_A8:
00494   ploc.reg = PR_first_reg(SIM_INFO.int64_args) + Current_Param_Num;
00495   if (ploc.reg > PR_last_reg(SIM_INFO.int64_args)) 
00496     ploc.reg = 0;
00497   break;
00498   
00499 #ifdef TARG_SUPPORTS_VECTORS
00500     case MTYPE_V16I4:
00501     case MTYPE_V16F4:
00502 #endif
00503     case MTYPE_F4:
00504   ploc.reg = PR_first_reg(SIM_INFO.flt_args) + Current_Param_Num;
00505   if (ploc.reg > PR_last_reg(SIM_INFO.flt_args)) {
00506     ploc.reg = 0;
00507     /* ptx param space has no padding */
00508     // if( Is_Target_64bit() )
00509     //   rpad = MTYPE_RegisterSize(SIM_INFO.flt_type) - ploc.size;
00510   }
00511   break;
00512 #ifdef TARG_SUPPORTS_VECTORS
00513     case MTYPE_V16F8:
00514 #endif
00515     case MTYPE_F8:
00516   ploc.reg = PR_first_reg(SIM_INFO.dbl_args) + Current_Param_Num;
00517   if (ploc.reg > PR_last_reg(SIM_INFO.dbl_args)) {
00518     ploc.reg = 0;
00519   }
00520   break;
00521 
00522 #ifdef TARG_SUPPORTS_VECTORS
00523     case MTYPE_V8I1:
00524     case MTYPE_V8I2:
00525     case MTYPE_V8I4:
00526       ploc.reg = 0; // pass in memory
00527       break;
00528 #endif
00529 
00530     case MTYPE_CQ:
00531     case MTYPE_FQ:
00532       ploc.reg = 0;  /* pass in memory */
00533       break;
00534 
00535     case MTYPE_C4:
00536         ++Current_Param_Num;
00537   ploc.reg = PR_first_reg(SIM_INFO.flt_args) + Current_Param_Num;
00538   if (ploc.reg > PR_last_reg(SIM_INFO.flt_args)) 
00539     ploc.reg = 0;
00540   break;
00541   
00542     case MTYPE_C8:
00543         ++Current_Param_Num;
00544   ploc.reg = PR_first_reg(SIM_INFO.dbl_args) + Current_Param_Num;
00545   if (ploc.reg > PR_last_reg(SIM_INFO.dbl_args)) {
00546           --Current_Param_Num;
00547     ploc.reg = 0; /* pass in memory */
00548   }
00549   else {
00550           ++Current_Param_Num;
00551   }
00552   break;
00553 
00554     case MTYPE_M:
00555   ploc.size = TY_size (ty);
00556   /* default is to pass whole struct in memory */
00557   ploc.reg = 0;
00558 
00559         if (ploc.size*8 <= SIM_INFO.max_struct_size
00560           && TY_can_be_vector(ty) 
00561           && (Current_Param_Num + TY_vector_count(ty)) 
00562             <= MAX_NUMBER_OF_REGISTER_PARAMETERS)
00563         {
00564           Preg_Range prange;
00565           switch (TY_mtype(TY_vector_elem_ty(ty))) {
00566           case MTYPE_F4:
00567             prange = SIM_INFO.flt_args; break;
00568           case MTYPE_F8:
00569             prange = SIM_INFO.dbl_args; break;
00570           case MTYPE_I4:
00571           case MTYPE_U4:
00572           case MTYPE_I2:
00573           case MTYPE_U2:
00574           case MTYPE_I1:
00575           case MTYPE_U1:
00576             prange = SIM_INFO.int_args; break;
00577           case MTYPE_I8:
00578           case MTYPE_U8:
00579             prange = SIM_INFO.int64_args; break;
00580           default:
00581             FmtAssert(FALSE,("NYI"));
00582           }
00583           ploc.reg = PR_first_reg(prange) + Current_Param_Num;
00584           Current_Param_Num += TY_vector_count(ty) - 1;
00585         }
00586   break;
00587   
00588     default:
00589   FmtAssert (FALSE, ("Get_Parameter_Location:  mtype %s",
00590          MTYPE_name(pmtype)));
00591     }
00592     if (ploc.reg == 0)
00593       Last_Param_Offset = ploc.start_offset + ploc.size + rpad;
00594     return ploc;
00595 } // Get_Parameter_Location
00596 
00597 struct PSTRUCT {
00598   BOOL  first_call;
00599   TYPE_ID fldtype;
00600   INT64 size;
00601   INT64 offset;
00602 };
00603 
00604 struct PSTRUCT pstruct;
00605 
00606 static void
00607 Setup_Struct_Parameter_Locations (TY_IDX struct_ty)
00608 {
00609   pstruct.first_call = TRUE;
00610   pstruct.size = TY_size(struct_ty);
00611   if (TY_can_be_vector(struct_ty)) 
00612     pstruct.fldtype = TY_mtype(TY_vector_elem_ty(struct_ty));
00613   else
00614     pstruct.fldtype = MTYPE_U4; // default to 32bit int
00615 }
00616 
00617 static PLOC 
00618 Get_Struct_Parameter_Location (PLOC prev)
00619 {
00620   PLOC next;
00621   PLOC_size(next) = MTYPE_RegisterSize(pstruct.fldtype);
00622   if (pstruct.first_call) {
00623     pstruct.first_call = FALSE;
00624     PLOC_offset(next) = PLOC_offset(prev);
00625     pstruct.offset = PLOC_offset(prev);
00626     PLOC_reg(next) = PLOC_reg(prev);
00627   }
00628   else {
00629     PLOC_offset(next) = PLOC_offset(prev) + PLOC_size(prev);
00630     PLOC_reg(next) = PLOC_reg(prev) + 1;
00631   }
00632   if (PLOC_reg(prev) == 0)
00633     PLOC_reg(next) = 0;
00634   if (PLOC_offset(next) >= pstruct.offset + pstruct.size) {
00635     PLOC_size(next) = 0;
00636     return next;
00637   }
00638 
00639   return next;
00640 } // Get_Struct_Parameter_Location
00641 
00642 
00643 /* Iterate over vararg non-fixed parameters */
00644 static PLOC
00645 Get_Vararg_Parameter_Location (PLOC prev)
00646 {
00647   FmtAssert(FALSE, ("varargs not supported"));
00648 }
00649 
00650 BOOL Is_Caller_Save_GP;  /* whether GP is caller-save */
00651 
00652 INT Formal_Save_Area_Size = 0;
00653 INT Stack_Offset_Adjustment = 0;
00654 
00655 extern void 
00656 Init_Targ_Sim (void)
00657 {
00658   Is_Caller_Save_GP = SIM_caller_save_gp;
00659 }
00660
osprey/common/com/NVISA/targ_sim.cxx
