Open64: osprey/be/lno/x8664/lnotarget.cxx Source File

00001 /*
00002  * Copyright 2003, 2004 PathScale, Inc.  All Rights Reserved.
00003  */
00004 
00005 /*
00006 
00007   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00008 
00009   This program is free software; you can redistribute it and/or modify it
00010   under the terms of version 2 of the GNU General Public License as
00011   published by the Free Software Foundation.
00012 
00013   This program is distributed in the hope that it would be useful, but
00014   WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00016 
00017   Further, this software is distributed without any warranty that it is
00018   free of the rightful claim of any third person regarding infringement 
00019   or the like.  Any license provided herein, whether implied or 
00020   otherwise, applies only to this software file.  Patent licenses, if 
00021   any, provided herein do not apply to combinations of this program with 
00022   other software, or any other product whatsoever.  
00023 
00024   You should have received a copy of the GNU General Public License along
00025   with this program; if not, write the Free Software Foundation, Inc., 59
00026   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00027 
00028   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00029   Mountain View, CA 94043, or:
00030 
00031   http://www.sgi.com
00032 
00033   For further information regarding this notice, see:
00034 
00035   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00036 
00037 */
00038 
00039 
00040 #include "lnotarget.h"
00041 #include "w2op.h"
00042 
00043 TOP
00044 LNOTARGET_Whirl_To_Top (WN* wn)
00045 {
00046   OPCODE opcode = WN_opcode(wn);
00047   switch (opcode) {
00048   case OPC_F4ADD:
00049     return TOP_addss;
00050   case OPC_F8ADD:
00051     return TOP_addsd;
00052   case OPC_F4SUB:
00053     return TOP_subss;
00054   case OPC_F8SUB:
00055     return TOP_subsd;
00056   case OPC_F4MPY:
00057     return TOP_mulss;
00058   case OPC_F8MPY:
00059     return TOP_mulsd;
00060   case OPC_F4MADD:  // (src2 * src3) + src1
00061   case OPC_F4NMADD: // -((src2 * src3) + src1)
00062   case OPC_F4MSUB:  // (src2 * src3) - src1
00063   case OPC_F4NMSUB: // -((src2 * src3) - src1)
00064   case OPC_F8MADD:  // (src2 * src3) + src1
00065   case OPC_F8NMADD: // -((src2 * src3) + src1)
00066   case OPC_F8MSUB:  // (src2 * src3) - src1
00067   case OPC_F8NMSUB: // -((src2 * src3) - src1)
00068     FmtAssert( false, ("NYI") );
00069     break;
00070   case OPC_F4DIV:
00071     return TOP_divss;
00072   case OPC_F8DIV:
00073     return TOP_divsd;
00074   case OPC_F4RSQRT:
00075   case OPC_F4ATOMIC_RSQRT:
00076     return TOP_sqrtss;
00077   case OPC_F8RSQRT:
00078     return TOP_sqrtsd;
00079   case OPC_F4NEG:
00080     return TOP_xorps;
00081   case OPC_F8NEG:
00082     return TOP_xorpd;    
00083   case OPC_I4F8EQ:
00084   case OPC_I4F4EQ:
00085   case OPC_I4F8NE:
00086   case OPC_I4F4NE:
00087   case OPC_I4F8LT:
00088   case OPC_I4F4LT:
00089   case OPC_I4F8GT:
00090   case OPC_I4F4GT:
00091   case OPC_I4F8LE:
00092   case OPC_I4F4LE:
00093   case OPC_I4F8GE:
00094   case OPC_I4F4GE:
00095   case OPC_U4F8EQ:
00096   case OPC_U4F4EQ:
00097   case OPC_U4F8NE:
00098   case OPC_U4F4NE:
00099   case OPC_U4F8LT:
00100   case OPC_U4F4LT:
00101   case OPC_U4F8GT:
00102   case OPC_U4F4GT:
00103   case OPC_U4F8LE:
00104   case OPC_U4F4LE:
00105   case OPC_U4F8GE:
00106   case OPC_U4F4GE:
00107     // needs a ucomisd/ucomiss and some form of set
00108     return TOP_UNDEFINED;    
00109   case OPC_F4RECIP:
00110   case OPC_F8RECIP:
00111     // needs two ops - one to load constant 1; and one to divide
00112     return TOP_UNDEFINED;
00113   case OPC_F4ABS:
00114     // approximate because needs an op to load a special constant 
00115     return TOP_andps;
00116   case OPC_F8ABS:
00117     // approximate because needs an op to load a special constant 
00118     return TOP_andpd;
00119   case OPC_F4SELECT:
00120   case OPC_F8SELECT:
00121     // selects have no direct particular ops; and get expanded to multiple ops.
00122     return TOP_UNDEFINED;
00123   case OPC_F4F4FLOOR:
00124   case OPC_F8F8FLOOR:
00125     // expand into several ops
00126     return TOP_UNDEFINED;
00127   default:
00128     // bug 10320: handle TAS to avoid assertion failure
00129     if(OPCODE_operator(opcode) == OPR_TAS)
00130       break;
00131     else
00132       FmtAssert(FALSE, ("Handle this case"));
00133   }
00134   return WHIRL_To_TOP(wn);
00135 }
00136 
00137 void
00138 LNOTARGET_Loop_Inc_Test_Res (TI_RES_COUNT* resource_count)
00139 {
00140   // Can not be sure about the exact instructions; 
00141   // we could be using an lea inplace of add
00142   // and, we could be using a test instruction in place of cmp
00143   // Also, there are many flavors of branch.
00144   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_add32);
00145   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmp32);  
00146   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_je);
00147 }
00148 
00149 double
00150 LNOTARGET_Cvt_Res (TI_RES_COUNT* resource_count, OPCODE opcode)
00151 {
00152   TYPE_ID rtype, desc;
00153 
00154   switch(opcode) {
00155     // Is_CVT_Noop
00156   case OPC_I4U4CVT:
00157   case OPC_U4I4CVT:
00158   case OPC_I8U8CVT:
00159   case OPC_U8I8CVT:
00160     return 0.0;
00161 
00162     // TODO: need to look at parent load/store; 
00163     // but there is a long call chain that needs to be updated
00164     // to support that in model.cxx
00165   case OPC_I4U8CVT: rtype = MTYPE_I4; desc = MTYPE_U8; break;
00166   case OPC_I4I8CVT: rtype = MTYPE_I4; desc = MTYPE_I8; break;
00167   case OPC_U4U8CVT: rtype = MTYPE_U4; desc = MTYPE_U8; break;
00168   case OPC_U4I8CVT: rtype = MTYPE_U4; desc = MTYPE_I8; break;
00169 
00170     // Is_CVTL_Opcode
00171   case OPC_U8I4CVT: rtype = MTYPE_U8; desc = MTYPE_I4; break;
00172   case OPC_U8U4CVT: rtype = MTYPE_U8; desc = MTYPE_U4; break;
00173   case OPC_I8I4CVT: rtype = MTYPE_I8; desc = MTYPE_I4; break;
00174   case OPC_I8U4CVT: rtype = MTYPE_I8; desc = MTYPE_U4; break;
00175 
00176   case OPC_I8CVTL:
00177   case OPC_I4CVTL:
00178   case OPC_U8CVTL:
00179   case OPC_U4CVTL:
00180     FmtAssert(FALSE, ("NYI2.2"));
00181     break;
00182     
00183   case OPC_F8F4CVT:       
00184     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtss2sd);
00185     return 1.0;
00186   case OPC_F4F8CVT: 
00187     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtsd2ss);
00188     return 1.0;
00189 
00190   case OPC_F4I8CVT: 
00191     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtsi2ssq);
00192     return 1.0;    
00193   case OPC_F4I4CVT: 
00194     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtsi2ss);
00195     return 1.0;    
00196   case OPC_F4U8CVT: 
00197     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_shri64);
00198     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_andi32);
00199     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_or64);
00200     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtsi2ssq);
00201     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_addss);
00202     return 5.0;    
00203   case OPC_F4U4CVT: 
00204     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_mov32);
00205     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtsi2ssq);
00206     return 2.0;    
00207   case OPC_F8I8CVT: 
00208     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtsi2sdq);
00209     return 1.0;    
00210   case OPC_F8I4CVT: 
00211     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtsi2sd);
00212     return 1.0;    
00213   case OPC_F8U8CVT: 
00214     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_shri64);
00215     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_andi32);
00216     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_or64);
00217     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtsi2sdq);
00218     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_addsd);
00219     return 5.0;    
00220   case OPC_F8U4CVT: 
00221     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_mov32);
00222     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvtsi2sdq);
00223     return 2.0;    
00224 
00225   case OPC_I8F4TRUNC: 
00226   case OPC_I8F4RND: 
00227   case OPC_I8F4CEIL: 
00228   case OPC_I8F4FLOOR: 
00229   case OPC_I8F4CVT: 
00230   case OPC_U8F4CVT: 
00231   case OPC_U8F4TRUNC:
00232   case OPC_U8F4RND:
00233   case OPC_U8F4CEIL:
00234   case OPC_U8F4FLOOR:
00235     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvttss2siq);
00236     return 1.0;    
00237   case OPC_I4F4TRUNC: 
00238   case OPC_I4F4RND: 
00239   case OPC_I4F4CEIL: 
00240   case OPC_I4F4FLOOR: 
00241   case OPC_I4F4CVT: 
00242     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvttss2si);
00243     return 1.0;    
00244   case OPC_U4F4TRUNC: 
00245   case OPC_U4F4RND: 
00246   case OPC_U4F4CEIL: 
00247   case OPC_U4F4FLOOR: 
00248   case OPC_U4F4CVT: 
00249     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvttss2siq);
00250     return 1.0;        
00251   case OPC_I8F8TRUNC: 
00252   case OPC_U8F8TRUNC:
00253   case OPC_I8F8RND: 
00254   case OPC_U8F8RND:
00255   case OPC_I8F8CEIL:
00256   case OPC_U8F8CEIL:
00257   case OPC_I8F8FLOOR:
00258   case OPC_U8F8FLOOR:
00259   case OPC_I8F8CVT: 
00260   case OPC_U8F8CVT:
00261     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvttsd2siq);
00262     return 1.0;        
00263   case OPC_I4F8TRUNC:     
00264   case OPC_I4F8RND:     
00265   case OPC_I4F8CEIL:     
00266   case OPC_I4F8FLOOR:     
00267   case OPC_I4F8CVT:     
00268     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvttsd2si);
00269     return 1.0;        
00270   case OPC_U4F8TRUNC: 
00271   case OPC_U4F8RND: 
00272   case OPC_U4F8CEIL: 
00273   case OPC_U4F8FLOOR: 
00274   case OPC_U4F8CVT: 
00275     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cvttsd2siq);
00276     return 1.0;        
00277  
00278   case OPC_FQF8CVT:
00279   case OPC_FQF4CVT:
00280     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00281           opcode == OPC_F8FQCVT ? TOP_stsd : TOP_stss);
00282     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00283           opcode == OPC_F8FQCVT ? TOP_fldl : TOP_flds);
00284     return 2.0;        
00285   case OPC_F8FQCVT:
00286   case OPC_F4FQCVT:
00287     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00288           opcode == OPC_F8FQCVT ? TOP_fstpl:TOP_fstps);
00289     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00290           opcode == OPC_F8FQCVT ? TOP_ldsd : TOP_ldss);
00291     return 2.0;        
00292 
00293   case OPC_FQI4CVT:
00294   case OPC_FQI8CVT:
00295   case OPC_FQU4CVT:
00296   case OPC_FQU8CVT:
00297     // CG forms few basic blocks. Use a simple model here.
00298     return 4.0;
00299 
00300   case OPC_I4FQCVT:
00301   case OPC_I8FQCVT:
00302   case OPC_U4FQCVT:
00303   case OPC_U8FQCVT:
00304     {
00305       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_fnstcw);
00306       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_ld32);
00307       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_or32);    
00308       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_store16);
00309       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_fldcw);
00310       TOP top;
00311       switch (opcode) {
00312       case OPC_I4FQCVT:    top = TOP_fistpl;   break;
00313       case OPC_U4FQCVT:
00314       case OPC_U8FQCVT:
00315       case OPC_I8FQCVT:    top = TOP_fistpll;  break;
00316       default:
00317   // Follow CG
00318   FmtAssert( false, ("NYI") );
00319       }
00320       TI_RES_COUNT_Add_Op_Resources(resource_count, top);
00321       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_fldcw);
00322       if (opcode != OPC_U8FQCVT)
00323   return 7.0;
00324       else
00325   // and then few new basic blocks. Use a simple model here.
00326   return 11.0;
00327     }
00328 
00329   default:
00330     FmtAssert(FALSE, ("NYI2.1"));
00331     break;
00332   }
00333 
00334   switch (opcode) {
00335     // Is_CVTL_Opcode
00336   case OPC_U8I4CVT: 
00337   case OPC_U8U4CVT: 
00338   case OPC_I8I4CVT: 
00339   case OPC_I8U4CVT: 
00340   case OPC_I4I8CVT: 
00341   case OPC_I4U8CVT: 
00342   case OPC_U4U8CVT: 
00343   case OPC_U4I8CVT: 
00344     {
00345       const UINT64 val = 32;
00346       const BOOL is_64bit = MTYPE_is_size_double(rtype);
00347       const BOOL signed_extension = MTYPE_is_signed(desc) || 
00348   (MTYPE_bit_size(desc) > MTYPE_bit_size(rtype));
00349       TOP new_opcode;
00350 
00351       if ( is_64bit )
00352   new_opcode = signed_extension ? TOP_movslq: TOP_mov64;
00353       else if ( MTYPE_bit_size(rtype) == 32)
00354   new_opcode = TOP_mov32;
00355       TI_RES_COUNT_Add_Op_Resources(resource_count, new_opcode);
00356       return 1.0;
00357     }
00358     break;
00359   }
00360   return 0.0;
00361 }
00362 
00363 double
00364 LNOTARGET_FP_Madd_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00365 {
00366   const BOOL is_64bit = MTYPE_is_size_double(mtype);
00367   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00368         is_64bit ? TOP_mulsd: TOP_mulss);
00369   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00370         is_64bit ? TOP_addsd: TOP_addss);
00371   return 2.0;
00372 }
00373 
00374 double
00375 LNOTARGET_FP_Min_Max_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00376 {
00377   const BOOL is_64bit = MTYPE_is_size_double(mtype);
00378   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00379         is_64bit ? TOP_minsd: TOP_minss);
00380   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00381         is_64bit ? TOP_maxsd: TOP_maxss);
00382   return 2.0;
00383 }
00384 
00385 double
00386 LNOTARGET_FP_Div_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00387 {
00388   const BOOL is_64bit = MTYPE_is_size_double(mtype);
00389   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00390         is_64bit ? TOP_divsd: TOP_divss);
00391   return 1.0;
00392 }
00393 
00394 double
00395 LNOTARGET_FP_Recip_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00396 {
00397   const BOOL is_64bit = MTYPE_is_size_double(mtype);
00398   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00399         is_64bit ? TOP_ldc64: TOP_ldc32);
00400   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00401         is_64bit ? TOP_divsd: TOP_divss);
00402   return 2.0;
00403 }
00404 
00405 double
00406 LNOTARGET_FP_Rsqrt_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00407 {
00408   const BOOL is_64bit = MTYPE_is_size_double(mtype);
00409   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00410         is_64bit ? TOP_sqrtsd: TOP_sqrtss);
00411   return 1.0;
00412 }
00413 
00414 double
00415 LNOTARGET_FP_Sqrt_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00416 {
00417   const BOOL is_64bit = MTYPE_is_size_double(mtype);
00418   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00419         is_64bit ? TOP_sqrtsd: TOP_sqrtss);
00420   return 1.0;
00421 }
00422  
00423 double
00424 LNOTARGET_FP_Exp_Res (TI_RES_COUNT* resource_count, 
00425                       INTRINSIC intr,
00426                       INT num_multiplies)
00427 {
00428   return -1.0;
00429 }
00430 
00431 double
00432 LNOTARGET_FP_Floor_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00433 {
00434   if (mtype == MTYPE_F4) {
00435     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_andps);
00436     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_orps);
00437     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_addss);
00438     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_subss);
00439     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_subss);
00440     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmpss);
00441     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_andps);
00442     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_subss);
00443     return 8.0;
00444   } else if (mtype == MTYPE_F8) {
00445     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_andpd);
00446     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_andpd);
00447     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_orpd);
00448     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_addsd);
00449     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_subsd);
00450     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_subsd);
00451     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_subsd);
00452     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmpsd);
00453     return 8.0;
00454   }
00455   FmtAssert(FALSE, ("LNOTARGET_FP_Floor_Res: mtype not yet implemented"));
00456   return 0.0; // dummy
00457 }
00458 
00459 double
00460 LNOTARGET_Complex_Add_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00461 {
00462   const BOOL is_64bit = MTYPE_is_size_double(mtype);
00463   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00464         is_64bit ? TOP_addsd: TOP_addss);
00465   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00466         is_64bit ? TOP_addsd: TOP_addss);
00467   return 2.0;  
00468 }
00469 
00470 double
00471 LNOTARGET_Complex_Mult_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00472 {
00473   const BOOL is_64bit = MTYPE_is_size_double(mtype);
00474   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00475         is_64bit ? TOP_mulsd: TOP_mulss);
00476   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00477         is_64bit ? TOP_mulsd: TOP_mulss);
00478   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00479         is_64bit ? TOP_mulsd: TOP_mulss);
00480   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00481         is_64bit ? TOP_mulsd: TOP_mulss);
00482   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00483         is_64bit ? TOP_addsd: TOP_addss);
00484   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00485         is_64bit ? TOP_addsd: TOP_addss);
00486   return 6.0;  
00487 }
00488 
00489 double
00490 LNOTARGET_Complex_Neg_Res (TI_RES_COUNT* resource_count, TYPE_ID mtype)
00491 {
00492   const BOOL is_64bit = MTYPE_is_size_double(mtype);
00493   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00494         is_64bit ? TOP_ldsd: TOP_ldss);
00495   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00496         is_64bit ? TOP_ldsd: TOP_ldss);
00497   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00498         is_64bit ? TOP_xorpd: TOP_xorps);
00499   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00500         is_64bit ? TOP_xorpd: TOP_xorps);
00501   return 4.0;
00502 }
00503 
00504 double
00505 LNOTARGET_Fp_Select_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
00506 {  
00507   const BOOL is_64bit = MTYPE_is_size_double(rtype);
00508 
00509   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00510         is_64bit ? TOP_andpd: TOP_andps);
00511   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00512         is_64bit ? TOP_andnpd: TOP_andnps);
00513   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00514         is_64bit ? TOP_orpd: TOP_orps);
00515   
00516   return 3.0;
00517 }
00518 
00519 double
00520 LNOTARGET_Fp_Compare_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
00521 {  
00522   const BOOL is_64bit = MTYPE_is_size_double(rtype);
00523 
00524   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00525         is_64bit ? TOP_cmpsd: TOP_cmpss);
00526   
00527   return 1.0;
00528 }
00529 
00530 double
00531 LNOTARGET_Int_Select_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
00532 {  
00533   const BOOL is_64bit = MTYPE_is_size_double(rtype);
00534 
00535   // copes if dest_tn  == true_tn and dest == false_tn
00536   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00537         is_64bit ? TOP_mov64: TOP_mov32);
00538   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00539         is_64bit ? TOP_mov64: TOP_mov32);
00540   
00541   // assign true_tn to dest_tn
00542   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00543         is_64bit ? TOP_mov64: TOP_mov32);
00544   
00545   // test cond_tn
00546   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00547         is_64bit ? TOP_test64: TOP_test32);
00548 
00549   // move conditionally
00550   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmove);
00551 
00552   return 5.0;
00553 }
00554 
00555 double
00556 LNOTARGET_Int_Cvtl_Res (TI_RES_COUNT* resource_count, 
00557       TYPE_ID rtype, INT length)
00558 {
00559   const BOOL signed_extension = MTYPE_is_signed(rtype);
00560   const BOOL is_64bit = MTYPE_is_size_double(rtype);
00561   TOP new_opcode;
00562 
00563   if( length < 8 ){
00564     FmtAssert( !signed_extension, ("NYI") );
00565     new_opcode = TOP_andi32;
00566   } else if( length == 8 ){
00567     if( signed_extension ){
00568       new_opcode = is_64bit ? TOP_movsbq : TOP_movsbl;
00569     } else {
00570       new_opcode = is_64bit ? TOP_movzbq : TOP_movzbl;
00571     }
00572   } else if( length == 16 ){
00573     if( signed_extension ){
00574       new_opcode = is_64bit ? TOP_movswq : TOP_movswl;
00575     } else {
00576       new_opcode = is_64bit ? TOP_movzwq : TOP_movzwl;
00577     }
00578   } else if( length == 32 ){
00579     if( is_64bit )
00580       new_opcode = signed_extension ? TOP_movslq : TOP_mov64;
00581     else if( MTYPE_bit_size(rtype) == 32 )
00582       new_opcode = TOP_mov32;
00583   }
00584   TI_RES_COUNT_Add_Op_Resources(resource_count, new_opcode);
00585   return 1.0;
00586 }
00587 
00588 double
00589 LNOTARGET_Int_Neg_Res (TI_RES_COUNT* resource_count, BOOL eight_bytes)
00590 {
00591   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00592         eight_bytes ? TOP_neg64: TOP_neg32);
00593   return 1.0;
00594 }
00595 
00596 double
00597 LNOTARGET_Int_Abs_Res (TI_RES_COUNT* resource_count, BOOL eight_bytes)
00598 {
00599   // copy for src == dest
00600   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00601         eight_bytes ? TOP_mov64: TOP_mov32);
00602   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00603         eight_bytes ? TOP_neg64: TOP_neg32);  
00604   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmovs);
00605   return 3.0;
00606 }
00607 
00608 double
00609 LNOTARGET_Int_Bnot_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
00610 {
00611   const BOOL is_64bit = MTYPE_is_size_double(rtype);
00612   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00613         is_64bit? TOP_not64: TOP_not32);
00614   return 1.0;  
00615 }
00616 
00617 double
00618 LNOTARGET_Int_Lnot_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
00619 {
00620   const BOOL is_64bit = MTYPE_is_size_double(rtype);
00621   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00622         is_64bit? TOP_xori64: TOP_xori32);
00623   return 1.0;  
00624 }
00625 
00626 double
00627 LNOTARGET_Int_Mult_Res (TI_RES_COUNT* resource_count, BOOL eight_bytes)
00628 {
00629   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00630         eight_bytes?TOP_imul64:TOP_imul32);
00631   return 1.0;
00632 }
00633 
00634 /* return whether MPY will be translated into shifts and adds */
00635 /* NOTE:  this routine must stay in sync with cg's Expand_Multiply */
00636 static BOOL
00637 CGEXP_Can_Do_Fast_Multiply (TYPE_ID mtype, INT64 val)
00638 {
00639 #define MULTIPLICATION_LATENCY_32_BIT 2
00640 #define MULTIPLICATION_LATENCY_64_BIT 3 
00641 
00642   INT num_ops = 4; // Initialize more than limit
00643   BOOL neg = FALSE;
00644 
00645   if (OPT_Space) return FALSE;  // These may eat up a bunch of instructions
00646   
00647   // The following heuristic is based on Software Optimization guide for
00648   // Opteron. Section 8.2
00649   if (val == 0 || val == 1 || val == -1)
00650     return TRUE;
00651   else if (val < 0) {
00652     val = -val;
00653     neg = TRUE;
00654   } 
00655   switch (val) {
00656   case 3: num_ops = 2; break;
00657   case 5: num_ops = 2; break;
00658   case 6: num_ops = 3; break;
00659   case 7: num_ops = 2; break;
00660   case 9: num_ops = 2; break;
00661   case 10: num_ops = 3; break;
00662   case 11: num_ops = 3; break;
00663   case 12: num_ops = 3; break;
00664   case 13: num_ops = 3; break;
00665   case 14: num_ops = 3; break;
00666   case 15: num_ops = 2; break;
00667   case 17: num_ops = 2; break;
00668   case 18: num_ops = 3; break;
00669   case 19: num_ops = 3; break;
00670   case 20: num_ops = 3; break;
00671   case 21: num_ops = 3; break;
00672   case 23: num_ops = 3; break;
00673   case 24: num_ops = 3; break;
00674   case 25: num_ops = 3; break;
00675   case 27: num_ops = 3; break;
00676   case 28: num_ops = 3; break;
00677   case 29: num_ops = 3; break;
00678   case 30: num_ops = 3; break;
00679   case 31: num_ops = 2; break;
00680   }
00681   if (neg)
00682     num_ops ++;
00683   if ((mtype == MTYPE_I4 || mtype == MTYPE_U4) &&
00684       num_ops <= MULTIPLICATION_LATENCY_32_BIT)
00685     return TRUE;
00686   else if ((mtype == MTYPE_I8 || mtype == MTYPE_U8) &&
00687      num_ops <= MULTIPLICATION_LATENCY_64_BIT)
00688     return TRUE; 
00689   else
00690     return FALSE;
00691 }
00692 
00693 static double 
00694 CGEXP_Expand_Constant_Multiply (TI_RES_COUNT* resource_count, 
00695         TYPE_ID mtype, INT64 val)
00696 {
00697   BOOL eight_bytes = MTYPE_is_size_double(mtype);
00698   BOOL needs_sign_extension;
00699   double curr_instr = 0.0;
00700 
00701   // fast special cases
00702   if (val == 0) {
00703     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00704           eight_bytes?TOP_ldc64:TOP_ldc32);
00705     return 1.0;
00706   } else if (val == 1) {
00707     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00708           eight_bytes?TOP_mov64:TOP_mov32);
00709     return 1.0;
00710   } else if (val == -1) {
00711     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00712           eight_bytes?TOP_neg64:TOP_neg32);
00713     return 1.0;
00714   }
00715     
00716   needs_sign_extension = MTYPE_size_reg(mtype) != 64;
00717 
00718   if (val < 0) {
00719     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00720           eight_bytes?TOP_neg64:TOP_neg32);
00721     curr_instr = 1.0;
00722   }    
00723 
00724   TOP lea, add, sub, shift;
00725   if (eight_bytes) {
00726     lea = TOP_leax32;
00727     add = TOP_add32;
00728     sub = TOP_sub32;
00729     shift = TOP_shli32;
00730   } else {
00731     lea = TOP_leax64;
00732     add = TOP_add64;
00733     sub = TOP_sub64;
00734     shift = TOP_shli32;
00735   }
00736   switch (val) {
00737   case 3:
00738     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00739     curr_instr += 1.0;
00740     break;
00741   case 5:
00742     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00743     curr_instr += 1.0;
00744     break;
00745   case 6:
00746     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00747     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00748     curr_instr += 2.0;
00749     break;
00750   case 7:
00751     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00752     TI_RES_COUNT_Add_Op_Resources(resource_count, sub);
00753     curr_instr += 2.0;
00754     break;
00755   case 9:
00756     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00757     curr_instr += 1.0;
00758     break;
00759   case 10:
00760     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00761     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00762     curr_instr += 2.0;
00763     break;
00764   case 11:
00765     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00766     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00767     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00768     curr_instr += 3.0;
00769     break;
00770   case 12:
00771     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00772     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00773     curr_instr += 2.0;
00774     break;
00775   case 13:
00776     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00777     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00778     TI_RES_COUNT_Add_Op_Resources(resource_count, sub);
00779     curr_instr += 3.0;
00780     break;
00781   case 14:
00782     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00783     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00784     TI_RES_COUNT_Add_Op_Resources(resource_count, sub);
00785     curr_instr += 3.0;
00786     break;
00787   case 15:
00788     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00789     TI_RES_COUNT_Add_Op_Resources(resource_count, sub);
00790     curr_instr += 2.0;
00791     break;
00792   case 17:
00793     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00794     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00795     curr_instr += 2.0;
00796     break;
00797   case 18:
00798     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00799     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00800     curr_instr += 2.0;
00801     break;
00802   case 19:
00803     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00804     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00805     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00806     curr_instr += 3.0;
00807     break;
00808   case 20:
00809     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00810     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00811     curr_instr += 2.0;
00812     break;
00813   case 21:
00814     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00815     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00816     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00817     curr_instr += 3.0;
00818     break;
00819   case 23:
00820     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00821     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00822     TI_RES_COUNT_Add_Op_Resources(resource_count, sub);
00823     curr_instr += 3.0;
00824     break;
00825   case 24:
00826     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00827     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00828     curr_instr += 2.0;
00829     break;
00830   case 25:
00831     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00832     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00833     TI_RES_COUNT_Add_Op_Resources(resource_count, add);
00834     curr_instr += 3.0;
00835     break;
00836   case 27:
00837     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00838     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00839     TI_RES_COUNT_Add_Op_Resources(resource_count, sub);
00840     curr_instr += 3.0;
00841     break;
00842   case 29:
00843     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00844     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00845     TI_RES_COUNT_Add_Op_Resources(resource_count, sub);
00846     curr_instr += 3.0;
00847     break;
00848   case 30:
00849     TI_RES_COUNT_Add_Op_Resources(resource_count, lea);
00850     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00851     TI_RES_COUNT_Add_Op_Resources(resource_count, sub);
00852     curr_instr += 3.0;
00853     break;
00854   case 31:
00855     TI_RES_COUNT_Add_Op_Resources(resource_count, shift);
00856     TI_RES_COUNT_Add_Op_Resources(resource_count, sub);
00857     curr_instr += 2.0;
00858     break;
00859   default:
00860     curr_instr = -1.0;
00861     break;
00862   }
00863   return curr_instr;
00864 }
00865 
00866 double
00867 LNOTARGET_Int_Mult_Str_Red_Res (TI_RES_COUNT* resource_count, 
00868         TYPE_ID rtype, INT64 operand)
00869 {
00870   INT64 val = operand;
00871   const BOOL eight_bytes = MTYPE_is_size_double(rtype);
00872   double ret_val;
00873 
00874   if (val == 1) {
00875     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00876           eight_bytes?TOP_add64:TOP_add32);
00877     return 1.0;
00878   }
00879   if( val > 0 &&
00880       ( val & ( val - 1 ) ) == 0 ){
00881     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00882           eight_bytes?TOP_shli64:TOP_shli32);
00883     return 1.0;
00884   }
00885   else if (CGEXP_Can_Do_Fast_Multiply (rtype, val)) {
00886     ret_val = CGEXP_Expand_Constant_Multiply (resource_count, rtype, val);
00887     if (ret_val != -1.0)
00888       /* able to convert multiply into shifts/adds/subs */
00889       return ret_val;
00890   }      
00891 
00892   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00893         eight_bytes?TOP_ldc64:TOP_ldc32);
00894   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00895         eight_bytes?TOP_imul64:TOP_imul32);
00896   return 2.0;
00897 }
00898 
00899 double
00900 LNOTARGET_Int_Add_Res (TI_RES_COUNT* resource_count, BOOL eight_bytes)
00901 {
00902   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00903         eight_bytes?TOP_add64:TOP_add32);
00904   return 1.0;
00905 }
00906 
00907 double
00908 LNOTARGET_Int_Sub_Res (TI_RES_COUNT* resource_count, BOOL eight_bytes)
00909 { 
00910   TI_RES_COUNT_Add_Op_Resources(resource_count, 
00911         eight_bytes?TOP_sub64:TOP_sub32);
00912   return 1.0;
00913 }
00914 
00915 double
00916 LNOTARGET_Int_Div_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
00917 {
00918   TOP top;
00919   const BOOL is_signed = MTYPE_is_signed(rtype);
00920   const BOOL is_64bit = MTYPE_is_size_double(rtype);
00921 
00922   if (is_signed)
00923     TI_RES_COUNT_Add_Op_Resources(resource_count, 
00924           is_64bit ? TOP_sari64 : TOP_sari32); 
00925   else 
00926     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_ldc32);
00927   switch (rtype) {
00928   case MTYPE_I4: top = TOP_idiv32; break;
00929   case MTYPE_I8: top = TOP_idiv64; break;
00930   case MTYPE_U4: top = TOP_div32; break;
00931   case MTYPE_U8: top = TOP_div64; break;
00932   default: FmtAssert (FALSE, ("Handle this")); break;
00933   }
00934   TI_RES_COUNT_Add_Op_Resources(resource_count, top); 
00935   return (2.0);
00936 }
00937 
00938 /* return TRUE if the val is a power of 2 */
00939 #define IS_POWER_OF_2(val)  ((val != 0) && ((val & (val-1)) == 0))
00940 
00941 static BOOL Is_Power_Of_2(INT64 val, TYPE_ID mtype)
00942 {
00943   if (MTYPE_is_signed(mtype) && val < 0) val = -val;
00944 
00945   if (mtype == MTYPE_U4) val &= 0xffffffffull;
00946 
00947   return IS_POWER_OF_2(val);
00948 }
00949 
00950 /******************************************************************************
00951  *
00952  *   Function Name: determine_pseudo_inverse
00953  *
00954  *   Author: Bill Homer
00955  *
00956  *   Input Parameters: b              constant divisor
00957  *                     maxbits_in_a   size of dividend
00958  *
00959  *   Returns:          pseudo inverse
00960  *                     pn             smallest n, such that 2^n >= b
00961  *
00962  *   Description:
00963  *   Given an unsigned integer, calculate a "pseudo-inverse"
00964  *   (which is the return value) and the associated shift width
00965  *   (which is returned via the third parameter).
00966  *
00967  *   Usage:
00968  *    Let BPUL be the number of bits in an unsigned long.
00969  *    When b is a compile time constant, optimize an unsigned
00970  *    long integer division on T90,IEEE
00971  *                                    q = a/b
00972  *    by replacing it with:
00973  *
00974  *    Case 1) b == 2^n                q = b>>n
00975  *            Not done here.
00976  *
00977  *    Case 2) b >= 2^(BPUL-1)         q = (a >= b)
00978  *
00979  *    Case 3) a, b < 2^(BPUL/2)
00980  *            Not used; might be a good way to handle 32 bit ints.
00981  *            At compile time:        d = (~0UL)/b
00982  *            At run time:            q = int_mult_upper(d,a)
00983  *
00984  *    Case 4) Not used - general case; longer code than 5) & 6)
00985  *
00986  *    Case 5) a < 2^(BPUL-1)
00987  *            Used for 32 and 64 bit signed ints.
00988  *            At compile time:        d = determine_pseudo_inverse(b,BPUL-1,&n)
00989  *            At run time:            q = int_mult_upper(d,a) >> (n-1)
00990  *
00991  *    Case 6) default
00992  *            Used for unsigned 32 and 64 bit ints.
00993  *            At compile time:        d = determine_pseudo_inverse(b,BPUL,&n)
00994  *            At run time:            p = int_mult_upper(d,a)
00995  *                                    q = (p + ((a-p)>>1)) >> (n-1)
00996  *
00997  *****************************************************************************/
00998 
00999 static UINT64 determine_pseudo_inverse (
01000   UINT64      b,
01001   INT64       maxbits_a,
01002   INT64      *pn)
01003 {
01004   INT64  i, n;
01005   UINT64 m, q, b1;
01006 
01007   /*  Calculate the smallest n such that 2^n >= b,
01008    *  and the corresponding m = 2^n - 1
01009    *  (which satisfies m >= b - 1).
01010    */
01011   b1 = b - 1;
01012   n = 1;
01013   m = 1;
01014   while(m < b1) {
01015     n++;
01016     m = (m<<1) | 1;
01017   }
01018   *pn = n;
01019 
01020   /*  Calculate the "pseudo-inverse" of b, which is
01021    *  the ceiling of 2^(n+maxbits_a) divided by b, or
01022    *     d = 1 + (2^(n+maxbits_a) - 1) / b
01023    *  Because 2^n >=  b, d >= 2^maxbits_a, and
01024    *  because 2^n < 2*b, d <  2^(maxbits_a+1).
01025    *  Therefore d occupies (maxbits_a+1) bits,
01026    *  and its top bit is 1.
01027    *  Return value is:
01028    *     d         if maxbits_a  < BPUL (bits per unsigned long)
01029    *     d-2^BPUL  if maxbits_a == BPUL (i.e., all but top bit)
01030    */
01031   for(q=i=0; i<=maxbits_a; i++) {
01032     q <<= 1;
01033     if(m >= b) {
01034       m -= b;
01035       q |= 1;
01036     }
01037     m = (m<<1) | 1;
01038   }
01039   return 1+q;
01040 }
01041 
01042 static double 
01043 CGEXP_Expand_Integer_Divide_By_Constant (TI_RES_COUNT* resource_count, 
01044            TYPE_ID rtype, INT64 denom_val)
01045 {
01046   UINT64 b;       // b = |denom_val|
01047   UINT64 d;           // division scaling factor
01048   INT64  precision_required;
01049   INT64  n;
01050   BOOL is_odd;
01051   TOP opc;
01052   const BOOL is_double = MTYPE_is_size_double(rtype);
01053   const BOOL is_signed = MTYPE_is_signed(rtype);
01054   double curr_instr = 0.0;
01055 
01056   if (denom_val == 1) {
01057     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01058           is_double? TOP_mov64: TOP_mov32);     
01059     return 1.0;
01060   } else if (is_signed && denom_val == -1) {
01061     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01062           is_double? TOP_neg64: TOP_neg32);     
01063     return 1.0;
01064   }
01065 
01066   if( Is_Power_Of_2( denom_val, rtype)) {
01067     if (is_signed) {
01068       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01069             is_double? TOP_shri64: TOP_shri32);     
01070       return 1.0;
01071     } else {
01072       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01073             is_double? TOP_sari64: TOP_sari32);     
01074       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01075             is_double? TOP_ldc64: TOP_ldc32);          
01076       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01077             is_double? TOP_and64: TOP_and32);          
01078       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01079             is_double? TOP_add64: TOP_add32);
01080       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01081             is_double? TOP_sari64: TOP_sari32);
01082       curr_instr = 4.0;
01083       if (denom_val < 0) {
01084   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01085               is_double? TOP_neg64: TOP_neg32);
01086   curr_instr += 1.0;
01087       }
01088       return curr_instr;
01089     }
01090   }
01091 
01092   if (is_signed) {
01093 
01094     b = denom_val<0 ? -denom_val : denom_val;       // b = |denom_val|
01095     is_odd = (b&1);
01096 
01097     d = determine_pseudo_inverse (b, is_double?63:31, &n);
01098 
01099     if (n > (is_double ? 63 : 31)) {
01100       /* OOPS! The shift count can't be bigger than the word size! */
01101       return -1.0;
01102     }
01103 
01104     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01105           is_double? TOP_ldc64: TOP_ldc32);           
01106 
01107     /* Generate the absolute value of the numerator:
01108      */
01109     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01110           is_double? TOP_neg64: TOP_neg32);           
01111     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmovs);
01112  
01113     curr_instr += 3.0;
01114     
01115     /* Generate a multiply upper:
01116      */
01117     if (!is_double) {
01118       if (is_signed) {
01119   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_ldc64); 
01120   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_imul64);  
01121   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_shri64);  
01122   curr_instr += 3.0;
01123       } else {
01124   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_ldc64); 
01125   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_mul32); 
01126   curr_instr += 2.0;
01127       }
01128     } else {
01129       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_imul64);  
01130       curr_instr += 1.0;
01131     }
01132     
01133     /* Generate and attach the shift:
01134      */
01135     if (n > 0) {
01136       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01137             is_double? TOP_sari64: TOP_sari32);
01138       curr_instr += 1.0;
01139     }
01140     
01141     /* Select positive or negated result:
01142      */
01143     // for copy TNs. worst case
01144     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01145           is_double? TOP_mov64: TOP_mov32);           
01146     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01147           is_double? TOP_mov64: TOP_mov32);           
01148 
01149     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01150           is_double? TOP_test64: TOP_test32);
01151     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01152           is_double? TOP_neg64: TOP_neg32);           
01153     if (denom_val > 0)
01154       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmovge);
01155     else
01156       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmovl);
01157 
01158     curr_instr += 5.0;
01159   } /* end Signed */
01160 
01161   else { /* Unsigned */
01162 
01163     b = denom_val;
01164     is_odd = (b&1);
01165 
01166     /* Full precision calculation is required.
01167      */
01168     if (is_odd) {
01169       precision_required = is_double?64:32;
01170     } else {
01171       
01172       /* Pre-shift the numerator and denominator so that
01173    one less bit is required in the calculation. Then
01174    we can avoid the subtract-shift-add after the 
01175    multiply operation. */
01176       b >>= 1;
01177       precision_required = is_double?63:31;
01178   
01179       /* Pre-shift to simplify later calculations.
01180        */
01181       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01182             is_double ? TOP_sari64: TOP_sari32);
01183       curr_instr += 1.0;
01184     }
01185 
01186     d = determine_pseudo_inverse (b, precision_required, &n);
01187 
01188     if (n > precision_required) {
01189       /* OOPS! The shift count can't be bigger than the word size! */
01190       return -1.0;
01191     }
01192 
01193     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01194           is_double ? TOP_ldc64: TOP_ldc32);
01195 
01196     curr_instr += 1.0;
01197 
01198     /* Generate a multiply upper:
01199      */
01200     if (!is_double) {
01201       if (is_signed) {
01202   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_ldc64); 
01203   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_imul64);  
01204   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_shri64);  
01205   curr_instr += 3.0;
01206       } else {
01207   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_ldc64); 
01208   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_mul32); 
01209   curr_instr += 2.0;
01210       }
01211     } else {
01212       TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_imul64);  
01213       curr_instr += 1.0;
01214     }
01215 
01216     if (precision_required == 64 || precision_required == 32) {
01217 
01218       /* Odd divisors need full precision and, hence, extra instructions.
01219        */
01220       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01221             is_double ? TOP_sub64: TOP_sub32);
01222       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01223             is_double ? TOP_shri64: TOP_shri32);
01224       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01225             is_double ? TOP_add64: TOP_add32);
01226       curr_instr += 3.0;
01227     }
01228 
01229     /* Generate and attach the shift:
01230      */
01231     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01232           is_double ? TOP_shri64: TOP_shri32);
01233     curr_instr += 1.0;
01234   } /* end Unsigned */
01235 
01236   return curr_instr;
01237 }
01238 
01239 double
01240 LNOTARGET_Int_Div_Str_Red_Res (TI_RES_COUNT* resource_count, 
01241              TYPE_ID rtype, INT64 denom_val)
01242 {
01243   double curr_instr;
01244   TOP top;
01245   const BOOL is_double = MTYPE_is_signed(rtype);
01246 
01247   curr_instr = CGEXP_Expand_Integer_Divide_By_Constant (resource_count, 
01248               rtype, denom_val);
01249   if (curr_instr != -1.0)
01250     return curr_instr;
01251   
01252   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01253         is_double ? TOP_ldc64: TOP_ldc32);
01254   switch (rtype) {
01255   case MTYPE_I4: top = TOP_idiv32; break;
01256   case MTYPE_I8: top = TOP_idiv64; break;
01257   case MTYPE_U4: top = TOP_div32; break;
01258   case MTYPE_U8: top = TOP_div64; break;
01259   default: FmtAssert (FALSE, ("Handle this")); break;
01260   }
01261   TI_RES_COUNT_Add_Op_Resources(resource_count, top); 
01262   return 2.0;
01263 }
01264 
01265 double
01266 LNOTARGET_Int_Mod_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01267 {
01268   double val = LNOTARGET_Int_Rem_Res (resource_count, rtype);
01269   const BOOL is_double = MTYPE_is_size_double(rtype);
01270   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01271         is_double ? TOP_xor64: TOP_xor32);
01272   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01273         is_double ? TOP_test64: TOP_test32);
01274   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01275         is_double ? TOP_ldc64: TOP_ldc32);
01276   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmovl);
01277   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01278         is_double ? TOP_add64: TOP_add32);
01279   return (val + 5.0);
01280 }
01281 
01282 double
01283 LNOTARGET_Int_Mod_Str_Red_Res (TI_RES_COUNT* resource_count, 
01284              TYPE_ID rtype, INT64 denom_val)
01285 {
01286   const BOOL is_signed = MTYPE_is_signed(rtype);
01287   const BOOL is_double = MTYPE_is_size_double(rtype);
01288 
01289   if (Is_Power_Of_2(denom_val, rtype)) {
01290     if (is_signed && denom_val < 0) {
01291       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01292             is_double ? TOP_neg64: TOP_neg32);    
01293       if (denom_val == -1) 
01294   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01295               is_double ? TOP_mov64: TOP_mov32);    
01296       else if ( denom_val & 0xffffffff00000000ULL == 0 ) 
01297   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01298               is_double ? TOP_andi64: TOP_andi32);
01299       else {
01300   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01301               is_double ? TOP_mov64: TOP_mov32);
01302   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01303               is_double ? TOP_and64: TOP_and32);
01304   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01305               is_double ? TOP_neg64: TOP_neg32);
01306   return 4.0;
01307       }
01308       TI_RES_COUNT_Add_Op_Resources(resource_count, 
01309             is_double ? TOP_neg64: TOP_neg32);
01310       return 3.0;
01311     } else {
01312       if ( denom_val & 0xffffffff00000000ULL == 0 ) 
01313   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01314               is_double ? TOP_andi64: TOP_andi32);
01315       else {
01316   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01317               is_double ? TOP_mov64: TOP_mov32);
01318   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01319               is_double ? TOP_and64: TOP_and32);
01320   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01321               is_double ? TOP_neg64: TOP_neg32);
01322   return 3.0;
01323       }
01324       return 1.0;
01325     }
01326   }
01327 
01328   double val = LNOTARGET_Int_Rem_Res (resource_count, rtype);
01329   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01330         is_double ? TOP_xor64: TOP_xor32);
01331   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01332         is_double ? TOP_test64: TOP_test32);
01333   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01334         is_double ? TOP_ldc64: TOP_ldc32);
01335   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_cmovl);
01336   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01337         is_double ? TOP_add64: TOP_add32);
01338   return (val + 5.0);
01339 }
01340 
01341 double
01342 LNOTARGET_Int_Rem_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01343 {
01344   TOP top;
01345   const BOOL is_signed = MTYPE_is_signed(rtype);
01346   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01347 
01348   if (is_signed)
01349     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01350           is_64bit ? TOP_sari64 : TOP_sari32); 
01351   else 
01352     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_ldc32);
01353   switch (rtype) {
01354   case MTYPE_I4: top = TOP_idiv32; break;
01355   case MTYPE_I8: top = TOP_idiv64; break;
01356   case MTYPE_U4: top = TOP_div32; break;
01357   case MTYPE_U8: top = TOP_div64; break;
01358   default: FmtAssert (FALSE, ("Handle this")); break;
01359   }
01360   TI_RES_COUNT_Add_Op_Resources(resource_count, top); 
01361   return (2.0);
01362 }
01363 
01364 double
01365 LNOTARGET_Int_Rem_Str_Red_Res (TI_RES_COUNT* resource_count, 
01366              TYPE_ID rtype, INT64 denom_val)
01367 {
01368   double curr_instr;
01369   TOP top;
01370   BOOL is_double = MTYPE_is_size_double(rtype);
01371 
01372   curr_instr = CGEXP_Expand_Integer_Divide_By_Constant (resource_count, 
01373               rtype, denom_val);
01374   if (curr_instr != -1.0) {
01375     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01376           is_double ? TOP_imul64 : TOP_imul32);     
01377     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01378           is_double ? TOP_sub64 : TOP_sub32);    
01379     return curr_instr + 2.0;
01380   }
01381   
01382   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01383         is_double ? TOP_ldc64: TOP_ldc32);
01384   switch (rtype) {
01385   case MTYPE_I4: top = TOP_idiv32; break;
01386   case MTYPE_I8: top = TOP_idiv64; break;
01387   case MTYPE_U4: top = TOP_div32; break;
01388   case MTYPE_U8: top = TOP_div64; break;
01389   default: FmtAssert (FALSE, ("Handle this")); break;
01390   }
01391   TI_RES_COUNT_Add_Op_Resources(resource_count, top); 
01392   return 2.0;
01393 }
01394 
01395 double
01396 LNOTARGET_Int_DivRem_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01397 {
01398   TOP top;
01399   const BOOL is_signed = MTYPE_is_signed(rtype);
01400   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01401 
01402   if (is_signed)
01403     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01404           is_64bit ? TOP_sari64 : TOP_sari32); 
01405   else 
01406     TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_ldc32);
01407   switch (rtype) {
01408   case MTYPE_I4: top = TOP_idiv32; break;
01409   case MTYPE_I8: top = TOP_idiv64; break;
01410   case MTYPE_U4: top = TOP_div32; break;
01411   case MTYPE_U8: top = TOP_div64; break;
01412   default: FmtAssert (FALSE, ("Handle this")); break;
01413   }
01414   TI_RES_COUNT_Add_Op_Resources(resource_count, top); 
01415   return (2.0);
01416 }
01417 
01418 double
01419 LNOTARGET_Int_DivRem_Str_Red_Res (TI_RES_COUNT* resource_count, 
01420              TYPE_ID rtype, INT64 denom_val)
01421 {
01422   double curr_instr;
01423   TOP top;
01424   BOOL is_double = MTYPE_is_size_double(rtype);
01425 
01426   curr_instr = CGEXP_Expand_Integer_Divide_By_Constant (resource_count, 
01427               rtype, denom_val);
01428   if (curr_instr != -1.0) {
01429     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01430           is_double ? TOP_imul64 : TOP_imul32);     
01431     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01432           is_double ? TOP_sub64 : TOP_sub32);    
01433     return curr_instr + 2.0;
01434   }
01435   
01436   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01437         is_double ? TOP_ldc64: TOP_ldc32);
01438   switch (rtype) {
01439   case MTYPE_I4: top = TOP_idiv32; break;
01440   case MTYPE_I8: top = TOP_idiv64; break;
01441   case MTYPE_U4: top = TOP_div32; break;
01442   case MTYPE_U8: top = TOP_div64; break;
01443   default: FmtAssert (FALSE, ("Handle this")); break;
01444   }
01445   TI_RES_COUNT_Add_Op_Resources(resource_count, top); 
01446   return 2.0;
01447 }
01448 
01449 double
01450 LNOTARGET_Int_Min_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01451 {
01452   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01453   const BOOL is_signed = MTYPE_is_signed(rtype);
01454   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01455         is_64bit ? TOP_mov64 : TOP_mov32);
01456   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01457         is_64bit ? TOP_cmp64: TOP_cmp32);
01458   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01459         is_signed ? TOP_cmovle: TOP_cmovbe);
01460   return 3.0;
01461 }
01462   
01463 double
01464 LNOTARGET_Int_Max_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01465 {
01466   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01467   const BOOL is_signed = MTYPE_is_signed(rtype);
01468   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01469         is_64bit ? TOP_mov64 : TOP_mov32);
01470   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01471         is_64bit ? TOP_cmp64: TOP_cmp32);
01472   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01473         is_signed ? TOP_cmovge: TOP_cmovae);
01474   return 3.0;
01475 }
01476   
01477 double
01478 LNOTARGET_Int_Min_Max_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01479 {
01480   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01481   const BOOL is_signed = MTYPE_is_signed(rtype);
01482   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01483         is_64bit ? TOP_mov64 : TOP_mov32);
01484   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01485         is_64bit ? TOP_mov64 : TOP_mov32);
01486   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01487         is_64bit ? TOP_cmp64: TOP_cmp32);
01488   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01489         is_signed ? TOP_cmovl: TOP_cmovb);
01490   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01491         is_signed ? TOP_cmovl: TOP_cmovb);
01492   return 5.0;
01493 }
01494   
01495 double
01496 LNOTARGET_Int_Band_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01497 {
01498   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01499   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01500         is_64bit ? TOP_and64: TOP_and32);
01501   return 1.0;
01502 }
01503 
01504 double
01505 LNOTARGET_Int_Bior_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01506 {
01507   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01508   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01509         is_64bit ? TOP_or64: TOP_or32);
01510   return 1.0;
01511 }
01512 
01513 double
01514 LNOTARGET_Int_Bnor_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01515 {
01516   FmtAssert(FALSE, ("NYI30"));
01517   return 1.0;
01518 }
01519 
01520 double
01521 LNOTARGET_Int_Bxor_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01522 {
01523   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01524   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01525         is_64bit ? TOP_xor64: TOP_xor32);
01526   return 1.0;
01527 }
01528 
01529 double
01530 LNOTARGET_Int_Band_Str_Red_Res (TI_RES_COUNT* resource_count, 
01531         TYPE_ID rtype, INT64 val)
01532 {
01533   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01534 
01535   if (val == -1) {
01536     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01537           is_64bit ? TOP_mov64: TOP_mov32);    
01538     return 1.0;
01539   }
01540   else if ( val & 0xffffffff00000000ULL == 0 ) { // LC_simm32
01541     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01542           is_64bit ? TOP_andi64: TOP_andi32);    
01543     return 1.0;
01544   } else {
01545     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01546           is_64bit ? TOP_ldc64: TOP_ldc32);    
01547     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01548           is_64bit ? TOP_and64: TOP_and32);    
01549     return 2.0;
01550   }  
01551 }
01552 
01553 double
01554 LNOTARGET_Int_Bior_Str_Red_Res (TI_RES_COUNT* resource_count, 
01555         TYPE_ID rtype, INT64 val)
01556 {
01557   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01558 
01559   if (val == 0) {
01560     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01561           is_64bit ? TOP_mov64: TOP_mov32);    
01562     return 1.0;
01563   }
01564   else if ( val & 0xffffffff00000000ULL == 0 ) { // LC_simm32
01565     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01566           is_64bit ? TOP_ori64: TOP_ori32);    
01567     return 1.0;
01568   } else {
01569     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01570           is_64bit ? TOP_ldc64: TOP_ldc32);    
01571     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01572           is_64bit ? TOP_or64: TOP_or32);    
01573     return 2.0;
01574   }  
01575 }
01576 
01577 double
01578 LNOTARGET_Int_Bxor_Str_Red_Res (TI_RES_COUNT* resource_count, 
01579         TYPE_ID rtype, INT64 val)
01580 {
01581   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01582 
01583   if (val == 0) {
01584     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01585           is_64bit ? TOP_mov64: TOP_mov32);    
01586     return 1.0;
01587   }
01588   else if ( val & 0xffffffff00000000ULL == 0 ) { // LC_simm32
01589     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01590           is_64bit ? TOP_xori64: TOP_xori32);    
01591     return 1.0;
01592   } else {
01593     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01594           is_64bit ? TOP_ldc64: TOP_ldc32);    
01595     TI_RES_COUNT_Add_Op_Resources(resource_count, 
01596           is_64bit ? TOP_xor64: TOP_xor32);    
01597     return 2.0;
01598   }  
01599 }
01600 
01601 double
01602 LNOTARGET_Int_Land_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01603 {
01604   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01605   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01606         is_64bit ? TOP_and64: TOP_and32);    
01607   return 1.0;
01608 }
01609 
01610 double
01611 LNOTARGET_Int_Cand_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01612 {
01613   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01614   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01615         is_64bit ? TOP_and64: TOP_and32);    
01616   return 1.0;
01617 }
01618 
01619 double
01620 LNOTARGET_Int_Lior_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01621 {
01622   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01623   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01624         is_64bit ? TOP_or64: TOP_or32);    
01625   return 1.0;
01626 }
01627 
01628 double
01629 LNOTARGET_Int_Cior_Res (TI_RES_COUNT* resource_count, TYPE_ID rtype)
01630 {
01631   const BOOL is_64bit = MTYPE_is_size_double(rtype);
01632   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01633         is_64bit ? TOP_or64: TOP_or32);    
01634   return 1.0;
01635 }
01636 
01637 double
01638 LNOTARGET_Int_Shl_Res (TI_RES_COUNT* resource_count, BOOL eight_bytes)
01639 {
01640   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01641         eight_bytes ? TOP_shli64: TOP_shli32);
01642   return 1.0;
01643 }
01644 
01645 double
01646 LNOTARGET_Int_Ashr_Res (TI_RES_COUNT* resource_count, BOOL eight_bytes)
01647 {
01648   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01649         eight_bytes ? TOP_sari64: TOP_sari32);
01650   return 1.0;
01651 }
01652 
01653 double
01654 LNOTARGET_Int_Lshr_Res (TI_RES_COUNT* resource_count, BOOL eight_bytes)
01655 {
01656   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01657         eight_bytes ? TOP_shri64: TOP_shri32);
01658   return 1.0;
01659 }
01660 
01661 double
01662 LNOTARGET_Int_Eq_Res (TI_RES_COUNT* resource_count, TYPE_ID desc)
01663 {
01664   const BOOL is_64bit = MTYPE_is_size_double(desc);
01665   // We could end up using test32/test64/cmpi32/cmpi64 if it is a compare 
01666   // with imm.
01667   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01668         is_64bit ? TOP_cmp64: TOP_cmp32);
01669   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_sete);
01670   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01671         is_64bit ? TOP_movzbq: TOP_movzbl);
01672   return 3.0;
01673 }
01674 
01675 double
01676 LNOTARGET_Int_Ne_Res (TI_RES_COUNT* resource_count, TYPE_ID desc)
01677 {
01678   const BOOL is_64bit = MTYPE_is_size_double(desc);
01679   // We could end up using test32/test64/cmpi32/cmpi64 if it is a compare 
01680   // with imm.
01681   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01682         is_64bit ? TOP_cmp64: TOP_cmp32);
01683   TI_RES_COUNT_Add_Op_Resources(resource_count, TOP_setne);
01684   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01685         is_64bit ? TOP_movzbq: TOP_movzbl);
01686   return 3.0;
01687 }
01688 
01689 double
01690 LNOTARGET_Int_Gt_Res (TI_RES_COUNT* resource_count, TYPE_ID desc)
01691 {  
01692   const BOOL is_64bit = MTYPE_is_size_double(desc);
01693   const BOOL is_signed = MTYPE_is_signed(desc);
01694   // We could end up using test32/test64/cmpi32/cmpi64 if it is a compare 
01695   // with imm.
01696   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01697         is_64bit ? TOP_cmp64: TOP_cmp32);
01698   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01699         is_signed ? TOP_setg : TOP_seta);
01700   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01701         is_64bit ? TOP_movzbq: TOP_movzbl);
01702   return 3.0;
01703 }
01704 
01705 double
01706 LNOTARGET_Int_Ge_Res (TI_RES_COUNT* resource_count, TYPE_ID desc)
01707 {
01708   const BOOL is_64bit = MTYPE_is_size_double(desc);
01709   const BOOL is_signed = MTYPE_is_signed(desc);
01710   // We could end up using test32/test64/cmpi32/cmpi64 if it is a compare 
01711   // with imm.
01712   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01713         is_64bit ? TOP_cmp64: TOP_cmp32);
01714   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01715         is_signed ? TOP_setge : TOP_setae);
01716   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01717         is_64bit ? TOP_movzbq: TOP_movzbl);
01718   return 3.0;
01719 }
01720 
01721 double
01722 LNOTARGET_Int_Lt_Res (TI_RES_COUNT* resource_count, TYPE_ID desc)
01723 {
01724   const BOOL is_64bit = MTYPE_is_size_double(desc);
01725   const BOOL is_signed = MTYPE_is_signed(desc);
01726   // We could end up using test32/test64/cmpi32/cmpi64 if it is a compare 
01727   // with imm.
01728   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01729         is_64bit ? TOP_cmp64: TOP_cmp32);
01730   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01731         is_signed ? TOP_setl : TOP_setb);
01732   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01733         is_64bit ? TOP_movzbq: TOP_movzbl);
01734   return 3.0;
01735 }
01736 
01737 double
01738 LNOTARGET_Int_Le_Res (TI_RES_COUNT* resource_count, TYPE_ID desc)
01739 {
01740   const BOOL is_64bit = MTYPE_is_size_double(desc);
01741   const BOOL is_signed = MTYPE_is_signed(desc);
01742   // We could end up using test32/test64/cmpi32/cmpi64 if it is a compare 
01743   // with imm.
01744   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01745         is_64bit ? TOP_cmp64: TOP_cmp32);
01746   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01747         is_signed ? TOP_setle : TOP_setbe);
01748   TI_RES_COUNT_Add_Op_Resources(resource_count, 
01749         is_64bit ? TOP_movzbq: TOP_movzbl);
01750   return 3.0;
01751 }
01752 
01753 double
01754 LNOTARGET_Int_Lda_Res (TI_RES_COUNT* resource_count)
01755 {
01756   FmtAssert(FALSE, ("NYI44"));
01757   return 2.0;
01758 }
01759 
01760 INT
01761 LNOTARGET_Cvt_Lat (OPCODE opcode)
01762 {
01763   TYPE_ID rtype, desc;
01764 
01765   switch(opcode) {
01766     // Is_CVT_Noop
01767   case OPC_I4U4CVT:
01768   case OPC_U4I4CVT:
01769   case OPC_I8U8CVT:
01770   case OPC_U8I8CVT:
01771     return 0;
01772 
01773     // TODO: need to look at parent load/store; 
01774     // but there is a long call chain that needs to be updated
01775     // to support that in model.cxx
01776   case OPC_I4U8CVT: rtype = MTYPE_I4; desc = MTYPE_U8; break;
01777   case OPC_I4I8CVT: rtype = MTYPE_I4; desc = MTYPE_I8; break;
01778   case OPC_U4U8CVT: rtype = MTYPE_U4; desc = MTYPE_U8; break;
01779   case OPC_U4I8CVT: rtype = MTYPE_U4; desc = MTYPE_I8; break;
01780 
01781     // Is_CVTL_Opcode
01782   case OPC_U8I4CVT: rtype = MTYPE_U8; desc = MTYPE_I4; break;
01783   case OPC_U8U4CVT: rtype = MTYPE_U8; desc = MTYPE_U4; break;
01784   case OPC_I8I4CVT: rtype = MTYPE_I8; desc = MTYPE_I4; break;
01785   case OPC_I8U4CVT: rtype = MTYPE_I8; desc = MTYPE_U4; break;
01786   case OPC_I8CVTL:
01787   case OPC_I4CVTL:
01788   case OPC_U8CVTL:
01789   case OPC_U4CVTL:
01790     FmtAssert(FALSE, ("NYI2.2"));
01791     break;
01792     
01793   case OPC_F8F4CVT:       
01794     return LNOTARGET_Top_Latency(TOP_cvtss2sd);
01795   case OPC_F4F8CVT: 
01796     return LNOTARGET_Top_Latency(TOP_cvtsd2ss);
01797 
01798   case OPC_F4I8CVT: 
01799     return LNOTARGET_Top_Latency(TOP_cvtsi2ssq);
01800   case OPC_F4I4CVT: 
01801     return LNOTARGET_Top_Latency(TOP_cvtsi2ss);
01802   case OPC_F4U8CVT: 
01803     return LNOTARGET_Top_Latency(TOP_shri64) +
01804       LNOTARGET_Top_Latency(TOP_andi32) +
01805       LNOTARGET_Top_Latency(TOP_or64) +
01806       LNOTARGET_Top_Latency(TOP_cvtsi2ssq) +
01807       LNOTARGET_Top_Latency(TOP_addss);
01808   case OPC_F4U4CVT: 
01809     return LNOTARGET_Top_Latency(TOP_mov32) +
01810       LNOTARGET_Top_Latency(TOP_cvtsi2ssq);
01811   case OPC_F8I8CVT: 
01812     return LNOTARGET_Top_Latency(TOP_cvtsi2sdq);
01813   case OPC_F8I4CVT: 
01814     return LNOTARGET_Top_Latency(TOP_cvtsi2sd);
01815   case OPC_F8U8CVT: 
01816     return LNOTARGET_Top_Latency(TOP_shri64) +
01817       LNOTARGET_Top_Latency(TOP_andi32) +
01818       LNOTARGET_Top_Latency(TOP_or64) +
01819       LNOTARGET_Top_Latency(TOP_cvtsi2sdq) +
01820       LNOTARGET_Top_Latency(TOP_addsd);
01821   case OPC_F8U4CVT: 
01822     return LNOTARGET_Top_Latency(TOP_mov32) +
01823       LNOTARGET_Top_Latency(TOP_cvtsi2sdq);
01824 
01825   case OPC_I8F4TRUNC: 
01826   case OPC_I8F4RND: 
01827   case OPC_I8F4CEIL: 
01828   case OPC_I8F4FLOOR: 
01829   case OPC_I8F4CVT: 
01830   case OPC_U8F4CVT: 
01831   case OPC_U8F4TRUNC:
01832   case OPC_U8F4RND:
01833   case OPC_U8F4CEIL:
01834   case OPC_U8F4FLOOR:
01835     return LNOTARGET_Top_Latency(TOP_cvttss2siq);
01836   case OPC_I4F4TRUNC: 
01837   case OPC_I4F4RND: 
01838   case OPC_I4F4CEIL: 
01839   case OPC_I4F4FLOOR: 
01840   case OPC_I4F4CVT: 
01841     return LNOTARGET_Top_Latency(TOP_cvttss2si);
01842   case OPC_U4F4TRUNC: 
01843   case OPC_U4F4RND: 
01844   case OPC_U4F4CEIL: 
01845   case OPC_U4F4FLOOR: 
01846   case OPC_U4F4CVT: 
01847     return LNOTARGET_Top_Latency(TOP_cvttss2siq);
01848   case OPC_I8F8TRUNC: 
01849   case OPC_U8F8TRUNC:
01850   case OPC_I8F8RND: 
01851   case OPC_U8F8RND:
01852   case OPC_I8F8CEIL:
01853   case OPC_U8F8CEIL:
01854   case OPC_I8F8FLOOR:
01855   case OPC_U8F8FLOOR:
01856   case OPC_I8F8CVT: 
01857   case OPC_U8F8CVT:
01858     return LNOTARGET_Top_Latency(TOP_cvttsd2siq);
01859   case OPC_I4F8TRUNC:     
01860   case OPC_I4F8RND:     
01861   case OPC_I4F8CEIL:     
01862   case OPC_I4F8FLOOR:     
01863   case OPC_I4F8CVT:     
01864     return LNOTARGET_Top_Latency(TOP_cvttsd2si);
01865   case OPC_U4F8TRUNC: 
01866   case OPC_U4F8RND: 
01867   case OPC_U4F8CEIL: 
01868   case OPC_U4F8FLOOR: 
01869   case OPC_U4F8CVT: 
01870     return LNOTARGET_Top_Latency(TOP_cvttsd2siq);
01871  
01872   default:
01873     FmtAssert(FALSE, ("NYI2.1"));
01874     break;
01875   }
01876 
01877   switch (opcode) {
01878     // Is_CVTL_Opcode
01879   case OPC_U8I4CVT: 
01880   case OPC_U8U4CVT: 
01881   case OPC_I8I4CVT: 
01882   case OPC_I8U4CVT: 
01883   case OPC_I4I8CVT: 
01884   case OPC_I4U8CVT: 
01885   case OPC_U4U8CVT: 
01886   case OPC_U4I8CVT: 
01887     {
01888       const BOOL is_64bit = MTYPE_is_size_double(rtype);
01889       const BOOL signed_extension = MTYPE_is_signed(desc) || 
01890   (MTYPE_bit_size(desc) > MTYPE_bit_size(rtype));
01891       TOP new_opcode;
01892 
01893       if ( is_64bit )
01894   new_opcode = signed_extension ? TOP_movslq: TOP_mov64;
01895       else if ( MTYPE_bit_size(rtype) == 32)
01896   new_opcode = TOP_mov32;
01897       return LNOTARGET_Top_Latency(new_opcode);
01898     }
01899     break;
01900   }
01901   return 0;
01902 }
01903 
01904 INT
01905 LNOTARGET_FP_Madd_Add_Lat (TYPE_ID mtype)
01906 {
01907   TOP add = (mtype == MTYPE_F4 ? TOP_addss: TOP_addsd);
01908   return LNOTARGET_Top_Latency(add);
01909 }
01910 
01911 INT
01912 LNOTARGET_FP_Madd_Mult_Lat (TYPE_ID mtype)
01913 {
01914   TOP mpy = (mtype == MTYPE_F4 ? TOP_mulss: TOP_mulsd);
01915   return LNOTARGET_Top_Latency(mpy);
01916 }
01917 
01918 INT
01919 LNOTARGET_FP_Min_Max_Lat (TYPE_ID mtype)
01920 {
01921   TOP min = (mtype == MTYPE_F4 ? TOP_minss: TOP_minsd);
01922   TOP max = (mtype == MTYPE_F4 ? TOP_maxss: TOP_maxsd);
01923   return LNOTARGET_Top_Latency(min)+
01924     LNOTARGET_Top_Latency(max);
01925 }
01926 
01927 INT
01928 LNOTARGET_FP_Div_Lat (TYPE_ID mtype)
01929 {
01930   TOP div = (mtype == MTYPE_F4 ? TOP_divss: TOP_divsd);
01931   return LNOTARGET_Top_Latency(div);
01932 }
01933 
01934 INT
01935 LNOTARGET_FP_Recip_Lat (TYPE_ID mtype)
01936 {
01937   TOP div = (mtype == MTYPE_F4 ? TOP_divss: TOP_divsd);
01938   TOP recip = (mtype == MTYPE_F4 ? TOP_ldc32: TOP_ldc64);
01939   return LNOTARGET_Top_Latency(div) +
01940     LNOTARGET_Top_Latency(recip);
01941 }
01942 
01943 INT
01944 LNOTARGET_FP_Rsqrt_Lat (TYPE_ID mtype)
01945 {
01946   TOP rsqrt = (mtype == MTYPE_F4 ? TOP_sqrtss: TOP_sqrtsd);
01947   return LNOTARGET_Top_Latency(rsqrt);
01948 }
01949 
01950 INT
01951 LNOTARGET_FP_Sqrt_Lat (TYPE_ID mtype)
01952 {
01953   TOP sqrt = (mtype == MTYPE_F4 ? TOP_sqrtss: TOP_sqrtsd);
01954   return LNOTARGET_Top_Latency(sqrt);
01955 }
01956 
01957 INT
01958 LNOTARGET_FP_Exp_Lat (INTRINSIC intr, INT num_multiplies)
01959 {
01960   return -1;
01961 }
01962 
01963 INT
01964 LNOTARGET_FP_Floor_Lat (TYPE_ID mtype)
01965 {
01966   if (mtype == MTYPE_F4) {
01967     return LNOTARGET_Top_Latency(TOP_andps) * 2
01968      + LNOTARGET_Top_Latency(TOP_orps)
01969      + LNOTARGET_Top_Latency(TOP_addss)
01970      + LNOTARGET_Top_Latency(TOP_subss) * 3
01971      + LNOTARGET_Top_Latency(TOP_cmpss);
01972   } else if (mtype == MTYPE_F8) {
01973     return LNOTARGET_Top_Latency(TOP_andpd) * 2
01974      + LNOTARGET_Top_Latency(TOP_orpd)
01975      + LNOTARGET_Top_Latency(TOP_addsd)
01976      + LNOTARGET_Top_Latency(TOP_subsd) * 3
01977      + LNOTARGET_Top_Latency(TOP_cmpsd);
01978   }
01979   FmtAssert(FALSE, ("LNOTARGET_FP_Floor_Res: mtype not yet implemented"));
01980   return 0; // dummy
01981 }
01982 
01983 INT
01984 LNOTARGET_FP_Select_Lat (TYPE_ID mtype)
01985 {
01986   BOOL is_64bit = MTYPE_is_size_double(mtype);
01987   TOP andp = is_64bit ? TOP_andpd : TOP_andps;
01988   TOP andnp = is_64bit ? TOP_andnpd : TOP_andnps;
01989   TOP orp = is_64bit ? TOP_orpd : TOP_orps;
01990   return LNOTARGET_Top_Latency(andp) +
01991     LNOTARGET_Top_Latency(andnp) +
01992     LNOTARGET_Top_Latency(orp);
01993 }
01994 
01995 INT
01996 LNOTARGET_FP_Compare_Lat (TYPE_ID mtype)
01997 {
01998   TOP cmp = (mtype == MTYPE_F4 ? TOP_cmpss: TOP_cmpsd);
01999   return LNOTARGET_Top_Latency(cmp);
02000 }
02001 
02002 INT
02003 LNOTARGET_Complex_Add_Lat (TYPE_ID mtype)
02004 {
02005   TOP add = (mtype == MTYPE_C4 ? TOP_addss: TOP_addsd);
02006   return 2*LNOTARGET_Top_Latency(add);
02007 }
02008 
02009 INT
02010 LNOTARGET_Complex_Mult_Lat (TYPE_ID mtype)
02011 {
02012   TOP add = (mtype == MTYPE_C4 ? TOP_addss: TOP_addsd);
02013   TOP mpy = (mtype == MTYPE_C4 ? TOP_mulss: TOP_mulsd);
02014   return 2*LNOTARGET_Top_Latency(add) 
02015     + 4*LNOTARGET_Top_Latency(mpy);
02016 }
02017 
02018 INT
02019 LNOTARGET_Complex_Neg_Lat (TYPE_ID mtype)
02020 {
02021   TOP load = (mtype == MTYPE_C4 ? TOP_ldss: TOP_ldsd);
02022   TOP xori = (mtype == MTYPE_C4 ? TOP_xorps: TOP_xorpd);
02023   return 2*LNOTARGET_Top_Latency(load) 
02024     + 2*LNOTARGET_Top_Latency(xori);
02025 }