Open64: osprey/common/com/const.cxx Source File

00001 /*
00002  *  Copyright (C) 2007 QLogic Corporation.  All Rights Reserved.
00003  */
00004 
00005 /*
00006  * Copyright 2003, 2004, 2005, 2006 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  * ====================================================================
00046  *
00047  * Module: const.c
00048  *
00049  * Revision history:
00050  *  12-Jun-91 - Integrated from Josie
00051  *  30-Apr-93 - Added constant table manipulation from stab.c
00052  *
00053  * Description:
00054  *
00055  * Routines for manipulating constants.
00056  *
00057  * ====================================================================
00058  * ====================================================================
00059  */
00060 #ifdef USE_PCH
00061 #include "common_com_pch.h"
00062 #endif /* USE_PCH */
00063 #pragma hdrstop
00064 
00065 
00066 #include "defs.h"
00067 #include "symtab.h"
00068 #include "wn.h"
00069 #include "config_targ.h"
00070 #include <ext/hash_map>
00071 #include <math.h>
00072 using __gnu_cxx::hash_map;
00073 
00074 namespace {
00075     // unnamed namespace for function objects used for removing duplicated
00076     // constant STs
00077     struct eq_tcon {
00078   bool operator () (TCON_IDX t1_idx, TCON_IDX t2_idx) const {
00079       if (t1_idx == t2_idx)
00080     return TRUE;
00081       const TCON& t1 = Tcon_Table[t1_idx];
00082       const TCON& t2 = Tcon_Table[t2_idx];
00083 
00084       if (TCON_ty (t1) != TCON_ty (t2))
00085     return FALSE;
00086       if (t1.flags != t2.flags)
00087     return FALSE;
00088 
00089       switch (TCON_ty (t1)) {
00090 
00091       case MTYPE_I1:
00092       case MTYPE_I2:
00093       case MTYPE_I4:
00094       case MTYPE_I8:
00095       case MTYPE_U1:
00096       case MTYPE_U2:
00097       case MTYPE_U4:
00098       case MTYPE_U8:
00099     return TCON_i0 (t1) == TCON_i0 (t2);
00100 
00101       case MTYPE_F4:
00102     // Need to use integer inequality because need to match exact bit pattern
00103     return TCON_ival (t1) == TCON_ival (t2);
00104 
00105       case MTYPE_F8:
00106     // Need to use integer inequality because need to match exact bit pattern
00107     return TCON_k0 (t1) == TCON_k0 (t2);
00108       
00109       case MTYPE_STR:
00110     return (TCON_str_idx (t1) == TCON_str_idx (t2) &&
00111       TCON_str_len (t1) == TCON_str_len (t2));
00112 
00113       default:
00114     return memcmp (&t1, &t2, sizeof(TCON)) == 0;
00115       }
00116   }
00117     };
00118 
00119     struct tcon_hash {
00120   size_t operator() (TCON_IDX tcon_idx) const {
00121       const TCON& tcon = Tcon_Table[tcon_idx];
00122       size_t val = TCON_ty (tcon);
00123       val ^= TCON_ival (tcon);
00124       return val;
00125   }
00126     };
00127 } // unnamed namespace
00128     
00129 
00130 typedef hash_map<TCON_IDX, ST *, tcon_hash, eq_tcon> TCON_MERGE;
00131 
00132 ST *
00133 New_Const_Sym (TCON_IDX tcon, TY_IDX ty)
00134 {
00135     static TCON_MERGE merge;
00136 
00137     TCON_MERGE::iterator iter = merge.find (tcon);
00138 
00139     ST* st;
00140     if (iter == merge.end ()) {
00141   // create new constant
00142   st = New_ST (GLOBAL_SYMTAB);
00143 
00144   ST_Init (st, 0, CLASS_CONST, SCLASS_FSTATIC, EXPORT_LOCAL, ty);
00145   Set_ST_tcon (st, tcon);
00146   Set_ST_is_initialized (st);
00147   merge[tcon] = st;
00148     } else {
00149   st = (*iter).second;
00150   Is_True (ST_class (st) == CLASS_CONST &&
00151      ST_sclass (st) == SCLASS_FSTATIC &&
00152      ST_export (st) == EXPORT_LOCAL &&
00153      ST_is_initialized (st), ("Mismatched const ST"));
00154     }
00155     return st;
00156   
00157 } // New_Const_Sym
00158 
00159 
00160 ST *
00161 Gen_String_Sym (TCON *val, TY_IDX ty, BOOL)
00162 {
00163     return New_Const_Sym (Enter_tcon (*val), ty);
00164 }
00165 
00166 
00167 /* ====================================================================
00168  *
00169  * Const_Val
00170  *
00171  * Return the value of a constant node.
00172  *
00173  * WARNING:  The node passed must be know to be one of those with a
00174  * ND_dec field pointing to a CLASS_CONST symbol.
00175  *
00176  * ====================================================================
00177  */
00178 
00179 TCON
00180 Const_Val ( WN *n )
00181 {
00182     return WN_val (n);
00183 }
00184 
00185 
00186 /* ====================================================================
00187  *
00188  * Make_Const
00189  *
00190  * Make a constant node of the given value.
00191  *
00192  * ====================================================================
00193  */
00194 
00195 WN *
00196 Make_Const ( TCON c )
00197 {
00198    WN *n;
00199    OPCODE opc;
00200    ST *csym;
00201   
00202 
00203 #ifdef Is_True_On
00204   Check_TCON(&c);
00205 #endif /* Is_True_On */
00206 
00207   switch(TCON_ty(c)) {
00208     case MTYPE_F4:
00209       opc = OPC_F4CONST;
00210       break;
00211     case MTYPE_F8:
00212       opc = OPC_F8CONST;
00213       break;
00214     case MTYPE_F10:
00215       opc = OPC_F10CONST;
00216       break;
00217     case MTYPE_FQ:
00218       opc = OPC_FQCONST;
00219       break;
00220     case MTYPE_C4:
00221       opc = OPC_C4CONST;
00222       break;
00223     case MTYPE_C8:
00224       opc = OPC_C8CONST;
00225       break;
00226 #ifdef TARG_IA64
00227     case MTYPE_C10:
00228       opc = OPC_C10CONST;
00229       break;
00230 #endif
00231     case MTYPE_CQ:
00232       opc = OPC_CQCONST;
00233       break;
00234 #ifdef TARG_X8664
00235     case MTYPE_V8I1:
00236       opc = OPC_V8I1CONST;
00237       break;
00238     case MTYPE_V8I2:
00239       opc = OPC_V8I2CONST;
00240       break;
00241     case MTYPE_V8I4:
00242       opc = OPC_V8I4CONST;
00243       break;
00244     case MTYPE_V16I1:
00245       opc = OPC_V16I1CONST;
00246       break;
00247     case MTYPE_V16I4:
00248       opc = OPC_V16I4CONST;
00249       break;
00250     case MTYPE_V16I8:
00251       opc = OPC_V16I8CONST;
00252       break;
00253     case MTYPE_V16F4:
00254       opc = OPC_V16F4CONST;
00255       break;
00256     case MTYPE_V16F8:
00257       opc = OPC_V16F8CONST;
00258       break;
00259     case MTYPE_M8I1:
00260       opc = OPC_M8I1CONST;
00261       break;
00262     case MTYPE_M8I2:
00263       opc = OPC_M8I2CONST;
00264       break;
00265     case MTYPE_M8I4:
00266       opc = OPC_M8I4CONST;
00267       break;
00268 #endif
00269     default:
00270       Is_True ( FALSE, ( "Make_Const can not handle %s",
00271        Mtype_Name(TCON_ty(c)) ) );
00272       return NULL;
00273   }
00274    
00275    csym = New_Const_Sym (Enter_tcon (c), Be_Type_Tbl(TCON_ty(c)));
00276    n = WN_CreateConst(opc, csym );
00277    return (n);
00278    
00279 }
00280 
00281 #ifndef MONGOOSE_BE
00282 /* ====================================================================
00283  *
00284  * Make_Zerocon
00285  *
00286  * Make a zero node of the given type.
00287  *
00288  * ====================================================================
00289  */
00290 
00291 WN *
00292 Make_Zerocon ( TYPE_ID ty )
00293 {
00294   return Make_Const ( Targ_Conv ( ty, Host_To_Targ ( MTYPE_I4, 0 ) ));
00295 }
00296 
00297 
00298 /* ====================================================================
00299  *
00300  * Make_Comparison_Result_Const
00301  *
00302  * Make a TRUE or FALSE node of the default comparison result type.
00303  *
00304  * ====================================================================
00305  */
00306 
00307 WN *
00308 Make_Comparison_Result_Const ( INT16 val )
00309 {
00310   return Make_Const ( Host_To_Targ ( Comparison_Result_Mtype, val ) );
00311 }
00312 
00313 
00314 /* ====================================================================
00315  *
00316  * Make_Integer_Const
00317  *
00318  * Make an integer constant node of the given type and value.
00319  *
00320  * ====================================================================
00321  */
00322 
00323 WN *
00324 Make_Integer_Const ( INT16 mtype, TARG_INT val )
00325 {
00326    /* Actually, in WHIRL there are no integer constants of the symbol table type */
00327    /*
00328     *  return Make_Const ( Host_To_Targ ( mtype, val ) );
00329     */
00330 
00331    /* NOTE: TARG_INT should be INT64 for this to work! */
00332    return (WN_CreateIntconst(OPCODE_make_op(OPR_INTCONST,mtype,MTYPE_V), val));
00333 
00334 }
00335 
00336 #endif /* MONGOOSE_BE */
00337 
00338 /******************************************************************************
00339  This routine makes a WHIRL node representing the reduction
00340  identity for a given WHIRL op. For example, the reduction identity 
00341  for + is 0, for * is 1.  The only tricky part is getting the value
00342  and constant types correct for each mtype (particularly partial-word
00343  integers.
00344 *******************************************************************************/
00345 
00346 WN * Make_Reduction_Identity ( INT32 opr, TYPE_ID mtype )
00347 {
00348    WN * r;
00349    TYPE_ID ntype;
00350 
00351    if ((mtype == MTYPE_I1) || (mtype == MTYPE_I2))
00352      ntype = MTYPE_I4;
00353    else if ((mtype == MTYPE_U1) || (mtype == MTYPE_U2))
00354      ntype = MTYPE_U4;
00355    else
00356      ntype = mtype;
00357 
00358    switch (opr) {
00359 
00360     case OPR_ADD:
00361     case OPR_SUB:
00362       switch (mtype) {
00363        case MTYPE_I1:
00364        case MTYPE_I2:
00365        case MTYPE_I4:
00366        case MTYPE_I8:
00367        case MTYPE_U1:
00368        case MTYPE_U2:
00369        case MTYPE_U4:
00370        case MTYPE_U8:
00371    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00372              MTYPE_V), 0 );
00373    break;
00374 
00375        case MTYPE_F4:
00376        case MTYPE_F8:
00377        case MTYPE_F10:
00378        case MTYPE_FQ:
00379        case MTYPE_C4:
00380        case MTYPE_C8:
00381        case MTYPE_C10:
00382        case MTYPE_CQ:
00383    r = Make_Const ( Host_To_Targ_Float ( ntype, 0.0 ) );
00384    break;
00385 
00386        default:
00387    Fail_FmtAssertion ( "No reduction identity for operator %d, type %d",
00388           opr, mtype);
00389       }
00390       break;
00391 
00392     case OPR_MPY:
00393     case OPR_DIV:
00394       switch (mtype) {
00395        case MTYPE_I1:
00396        case MTYPE_I2:
00397        case MTYPE_I4:
00398        case MTYPE_I8:
00399        case MTYPE_U1:
00400        case MTYPE_U2:
00401        case MTYPE_U4:
00402        case MTYPE_U8:
00403    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00404              MTYPE_V), 1 );
00405    break;
00406 
00407        case MTYPE_F4:
00408        case MTYPE_F8:
00409        case MTYPE_F10:
00410        case MTYPE_FQ:
00411        case MTYPE_C4:
00412        case MTYPE_C8:
00413        case MTYPE_C10:
00414        case MTYPE_CQ:
00415    r = Make_Const ( Host_To_Targ_Float ( ntype, 1.0 ) );
00416    break;
00417 
00418        default:
00419    Fail_FmtAssertion ( "No reduction identity for operator %d, type %d",
00420           opr, mtype);
00421       }
00422       break;
00423 
00424     case OPR_MAX:
00425       switch (mtype) {
00426        case MTYPE_I1:
00427    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00428              MTYPE_V), -128LL );
00429    break;
00430 
00431        case MTYPE_I2:
00432    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00433              MTYPE_V), -32768LL );
00434    break;
00435 
00436        case MTYPE_I4:
00437    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00438              MTYPE_V), -2147483648LL);
00439    break;
00440 
00441        case MTYPE_I8:
00442    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00443              MTYPE_V),
00444         0x8000000000000000LL );
00445    break;
00446 
00447        case MTYPE_U1:
00448        case MTYPE_U2:
00449        case MTYPE_U4:
00450        case MTYPE_U8:
00451    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00452              MTYPE_V), 0 );
00453    break;
00454 
00455        case MTYPE_F4:
00456        case MTYPE_F8:
00457        case MTYPE_F10:
00458        case MTYPE_FQ:
00459    r = Make_Const ( Host_To_Targ_Float ( ntype, -HUGE_VAL ) );
00460    break;
00461 
00462        default:
00463    Fail_FmtAssertion ( "No reduction identity for operator %d, type %d",
00464           opr, mtype);
00465       }
00466       break;
00467 
00468     case OPR_MIN:
00469       switch (mtype) {
00470        case MTYPE_I1:
00471    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00472              MTYPE_V), 0x7f );
00473    break;
00474 
00475        case MTYPE_I2:
00476    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00477              MTYPE_V), 0x7fff );
00478    break;
00479 
00480        case MTYPE_I4:
00481    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00482              MTYPE_V), 0x7fffffff );
00483    break;
00484 
00485        case MTYPE_I8:
00486    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00487              MTYPE_V),
00488         0x7fffffffffffffffLL );
00489    break;
00490 
00491        case MTYPE_U1:
00492    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00493              MTYPE_V), 0xff );
00494    break;
00495 
00496        case MTYPE_U2:
00497    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00498              MTYPE_V), 0xffff );
00499    break;
00500 
00501        case MTYPE_U4:
00502    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00503              MTYPE_V), 0xffffffff );
00504    break;
00505 
00506        case MTYPE_U8:
00507    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00508              MTYPE_V),
00509         0xffffffffffffffffLL );
00510    break;
00511 
00512        case MTYPE_F4:
00513        case MTYPE_F8:
00514        case MTYPE_F10:
00515        case MTYPE_FQ:
00516    r = Make_Const ( Host_To_Targ_Float ( ntype, HUGE_VAL ) );
00517    break;
00518 
00519        default:
00520    Fail_FmtAssertion ( "No reduction identity for operator %d, type %d",
00521           opr, mtype);
00522       }
00523       break;
00524 
00525     case OPR_BIOR:
00526     case OPR_BXOR:
00527       switch (mtype) {
00528        case MTYPE_I1:
00529        case MTYPE_I2:
00530        case MTYPE_I4:
00531        case MTYPE_I8:
00532        case MTYPE_U1:
00533        case MTYPE_U2:
00534        case MTYPE_U4:
00535        case MTYPE_U8:
00536    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00537              MTYPE_V), 0 );
00538    break;
00539 
00540        default:
00541    Fail_FmtAssertion ( "No reduction identity for operator %d, type %d",
00542           opr, mtype);
00543       }
00544       break;
00545 
00546     case OPR_BAND:
00547       switch (mtype) {
00548        case MTYPE_I1:
00549        case MTYPE_U1:
00550    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00551              MTYPE_V), 0xff );
00552    break;
00553 
00554        case MTYPE_I2:
00555        case MTYPE_U2:
00556    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00557              MTYPE_V), 0xffff );
00558    break;
00559 
00560        case MTYPE_I4:
00561        case MTYPE_U4:
00562    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00563              MTYPE_V), 0xffffffff );
00564    break;
00565 
00566        case MTYPE_I8:
00567        case MTYPE_U8:
00568    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00569              MTYPE_V),
00570         0xffffffffffffffffLL );
00571    break;
00572 
00573        default:
00574    Fail_FmtAssertion ( "No reduction identity for operator %d, type %d",
00575           opr, mtype);
00576       }
00577       break;
00578 
00579     case OPR_LIOR:
00580       r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype, MTYPE_V ),
00581            0 );
00582       break;
00583   
00584     case OPR_LAND:
00585       r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype, MTYPE_V ),
00586            1 );
00587       break;
00588   
00589     case OPR_EQ:    /* Fortran .EQV. operator on type LOGICAL */
00590     case OPR_NE:    /* Fortran .NEQV. operator on type LOGICAL */
00591     case OPR_CAND:  /* C/C++ short-circuit "&&" on integral or floating-
00592                        point type */
00593     case OPR_CIOR:  /* C/C++ short-circuit "||" on int/float */
00594       switch (mtype) {
00595        case MTYPE_I1:
00596        case MTYPE_I2:
00597        case MTYPE_I4:
00598        case MTYPE_I8:
00599        case MTYPE_U1:
00600        case MTYPE_U2:
00601        case MTYPE_U4:
00602        case MTYPE_U8:
00603    r = WN_CreateIntconst ( OPCODE_make_op ( OPR_INTCONST, ntype,
00604              MTYPE_V),
00605                                  (opr == OPR_EQ || opr == OPR_CAND) ? 1
00606                                                                     : 0 );
00607    break;
00608 
00609        case MTYPE_F4:
00610        case MTYPE_F8:
00611        case MTYPE_F10:
00612        case MTYPE_FQ:
00613         Is_True(opr == OPR_CAND || opr == OPR_CIOR,
00614           ("bad opr %d", (INT) opr));
00615         r = Make_Const(Host_To_Targ_Float(ntype,
00616                                           (opr == OPR_CAND) ? 1.0 : 0.0));
00617         break;
00618 
00619        default:
00620    Fail_FmtAssertion ( "No reduction identity for operator %d, type %d",
00621           opr, mtype);
00622       }
00623       break;
00624 
00625     default:
00626       Fail_FmtAssertion ( "No reduction identity for operator %d, type %d", opr,
00627        mtype);
00628       break;
00629    }
00630    return (r);
00631 }