Open64: osprey/be/com/wn_retype_expr.cxx Source File

00001 /*
00002  * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00003  *
00004  * This program is free software; you can redistribute it and/or modify it
00005  * under the terms of version 2 of the GNU General Public License as
00006  * published by the Free Software Foundation.
00007  *
00008  * This program is distributed in the hope that it would be useful, but
00009  * WITHOUT ANY WARRANTY; without even the implied warranty of
00010  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00011  *
00012  * Further, this software is distributed without any warranty that it is
00013  * free of the rightful claim of any third person regarding infringement 
00014  * or the like.  Any license provided herein, whether implied or 
00015  * otherwise, applies only to this software file.  Patent licenses, if 
00016  * any, provided herein do not apply to combinations of this program with 
00017  * other software, or any other product whatsoever.  
00018  *
00019  * You should have received a copy of the GNU General Public License along
00020  * with this program; if not, write the Free Software Foundation, Inc., 59
00021  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
00022  */
00023 
00024 #ifdef USE_PCH
00025 #include "be_com_pch.h"
00026 #endif /* USE_PCH */
00027 #pragma hdrstop
00028 
00029 #include "defs.h"
00030 #include "config.h"
00031 #include "errors.h"
00032 #include "erglob.h"
00033 #include "tracing.h"
00034 #include "glob.h"
00035 #include "timing.h"
00036 #include "wn.h"
00037 #include "wn_util.h"
00038 #include "wn_lower.h"
00039 
00040 static WN * RETYPE_EXPR_expr(WN *tree, BOOL can_be_32bit, BOOL addr_expr);
00041 
00042 // taken from wn_mp.cxx
00043 static const char * const dope_str_prefix = ".dope." ;
00044 static const INT dope_str_prefix_len = 6;
00045 
00046 static BOOL
00047 ST_Has_Dope_Vector(ST *st) {
00048   if (ST_class(st) != CLASS_VAR)
00049     return FALSE;
00050 
00051   if ( TY_is_f90_pointer(ST_type(st)) )
00052     return TRUE;
00053 
00054   TY_IDX ty = ST_type(st);
00055   while (TY_kind(ty) == KIND_POINTER)
00056     ty = TY_pointed(ty);
00057 
00058   if (TY_kind(ty) == KIND_STRUCT &&
00059       strncmp(TY_name(ty), dope_str_prefix, dope_str_prefix_len) == 0)
00060     return TRUE;
00061 
00062   return FALSE;
00063 }
00064 
00065 /* ====================================================================
00066  * walk down the tree and change the types of appropriate nodes to 32-bit
00067  * ==================================================================== */
00068 static WN *Change_types_to_32bit(WN *tree)
00069 {
00070   OPERATOR opr = WN_operator(tree);
00071   TYPE_ID rtype = WN_rtype(tree);
00072   TYPE_ID desc = WN_desc(tree);
00073 
00074   Is_True(MTYPE_is_integral(rtype),("unexpected mtype"));
00075 
00076   switch (opr) {
00077   // leaves
00078   case OPR_LDID: 
00079   case OPR_LDBITS: 
00080   case OPR_INTCONST: 
00081     WN_set_rtype(tree, Mtype_TransferSize(MTYPE_U4, rtype));
00082     if (MTYPE_byte_size(desc) == 8) {
00083       WN_set_desc(tree, Mtype_TransferSize(MTYPE_U4, desc));
00084       WN_set_ty(tree, MTYPE_To_TY(WN_desc(tree)));
00085     }
00086     break;
00087 
00088   case OPR_LDA: 
00089   case OPR_LDA_LABEL: 
00090     break;
00091 
00092   // unary
00093   case OPR_ILOAD: 
00094   case OPR_ILDBITS: 
00095     WN_set_rtype(tree, Mtype_TransferSize(MTYPE_U4, rtype));
00096     break;
00097 
00098   case OPR_EXTRACT_BITS: 
00099   case OPR_LNOT: 
00100     WN_set_rtype(tree, Mtype_TransferSize(MTYPE_U4, rtype));
00101     break;
00102 
00103   case OPR_SQRT: case OPR_RSQRT: case OPR_RECIP:
00104   case OPR_REALPART: case OPR_IMAGPART:
00105   case OPR_HIGHPART: case OPR_LOWPART:
00106   case OPR_ALLOCA:
00107   case OPR_PARM:
00108   case OPR_RND: case OPR_TRUNC: case OPR_CEIL: case OPR_FLOOR:
00109   case OPR_BNOT:
00110   case OPR_TAS: 
00111 #ifdef TARG_X8664
00112   case OPR_ATOMIC_RSQRT:
00113 #endif
00114     break;
00115 
00116   case OPR_PAREN:
00117   case OPR_NEG:
00118   case OPR_ABS:
00119   case OPR_MINPART: case OPR_MAXPART:
00120     WN_set_rtype(tree, Mtype_TransferSize(MTYPE_U4, rtype));
00121     WN_kid0(tree) = Change_types_to_32bit(WN_kid0(tree));
00122     break;
00123 
00124   case OPR_CVTL:
00125     WN_set_rtype(tree, Mtype_TransferSize(MTYPE_U4, rtype));
00126     WN_set_desc(tree, WN_rtype(tree));
00127     if (WN_cvtl_bits(tree) > 32) 
00128       WN_kid0(tree) = Change_types_to_32bit(WN_kid0(tree));
00129     break;
00130 
00131   case OPR_CVT:
00132     if (MTYPE_byte_size(rtype) <= 4)
00133       return tree;
00134     else if (MTYPE_byte_size(desc) == 8) 
00135       return Change_types_to_32bit(WN_kid0(tree)); // delete the CVT
00136     else return WN_kid0(tree); // delete the CVT
00137     break;
00138 
00139   // binary
00140   case OPR_MPY:
00141   case OPR_DIV: 
00142   case OPR_MOD: case OPR_REM:
00143   case OPR_DIVREM: 
00144     Is_True(MTYPE_byte_size(rtype) <= 4,("unexpected mtype size"));
00145     break;
00146 
00147   case OPR_ADD: case OPR_SUB:
00148   case OPR_MAX: case OPR_MIN: 
00149   case OPR_MINMAX:
00150     if (MTYPE_byte_size(rtype) == 8) {
00151       WN_set_rtype(tree, Mtype_TransferSize(MTYPE_U4, rtype));
00152       WN_kid0(tree) = Change_types_to_32bit(WN_kid0(tree));
00153       WN_kid1(tree) = Change_types_to_32bit(WN_kid1(tree));
00154     }
00155     break;
00156 
00157   case OPR_BAND: case OPR_BIOR: case OPR_BNOR: case OPR_BXOR:
00158   case OPR_ASHR: case OPR_LSHR:
00159   case OPR_SHL: 
00160   case OPR_COMPOSE_BITS:
00161     Is_True(MTYPE_byte_size(rtype) <= 4,("unexpected mtype size"));
00162     break;
00163 
00164   case OPR_EQ: case OPR_NE: 
00165   case OPR_GE: case OPR_GT: case OPR_LE: case OPR_LT: 
00166   case OPR_LAND: case OPR_LIOR:
00167     WN_set_rtype(tree, Mtype_TransferSize(MTYPE_U4, rtype));
00168     break;
00169 
00170   // ternary
00171   case OPR_SELECT:
00172     if (MTYPE_byte_size(rtype) == 8) {
00173       WN_set_rtype(tree, Mtype_TransferSize(MTYPE_U4, rtype));
00174       WN_kid0(tree) = Change_types_to_32bit(WN_kid0(tree));
00175       WN_kid1(tree) = Change_types_to_32bit(WN_kid1(tree));
00176     }
00177     break;
00178 
00179   case OPR_INTRINSIC_OP: 
00180     Is_True(MTYPE_byte_size(rtype) <= 4,("unexpected mtype size"));
00181     break;
00182 
00183   default: Is_True(FALSE,("unexpected operator"));
00184   }
00185   return tree;
00186 }
00187 
00188 /* ====================================================================
00189  * check if there is only 32-bit operands for the given operation; it assumes
00190  * RETYPE_EXPR_expr has already been called for the given tree.
00191  * ==================================================================== */
00192 BOOL Only_32bit_opnds(WN *tree)
00193 {
00194   OPERATOR opr = WN_operator(tree);
00195   TYPE_ID rtype = WN_rtype(tree);
00196   TYPE_ID desc = WN_desc(tree);
00197 
00198   if (!MTYPE_is_integral(rtype))
00199     return FALSE;
00200 
00201   switch (opr) {
00202   // leaves
00203   case OPR_LDID: 
00204     return MTYPE_byte_size(desc) <= 4 ||
00205            rtype == MTYPE_I8 && ST_Has_Dope_Vector(WN_st(tree));
00206 
00207   case OPR_LDBITS: return WN_bit_size(tree) <= 32;
00208 
00209   case OPR_INTCONST: return WN_const_val(tree) >= (INT32)0x80000000 &&
00210             WN_const_val(tree) <= 0x7fffffff;
00211 
00212   case OPR_CONST: 
00213   case OPR_LDA: 
00214   case OPR_LDA_LABEL: return FALSE;
00215 
00216   // unary
00217   case OPR_ILOAD: return MTYPE_byte_size(desc) <= 4;
00218 
00219   case OPR_ILDBITS: 
00220   case OPR_EXTRACT_BITS: return WN_bit_size(tree) <= 32;
00221 
00222   case OPR_LNOT: return TRUE;
00223 
00224   case OPR_SQRT: case OPR_RSQRT: case OPR_RECIP:
00225   case OPR_REALPART: case OPR_IMAGPART:
00226   case OPR_HIGHPART: case OPR_LOWPART:
00227   case OPR_ALLOCA:
00228   case OPR_PARM:
00229   case OPR_RND: case OPR_TRUNC: case OPR_CEIL: case OPR_FLOOR:
00230   case OPR_BNOT:
00231   case OPR_TAS: 
00232 #ifdef TARG_X8664
00233   case OPR_ATOMIC_RSQRT:
00234 #endif
00235     return MTYPE_byte_size(rtype) <= 4;
00236 
00237   case OPR_PAREN:
00238   case OPR_NEG:
00239   case OPR_ABS:
00240   case OPR_MINPART: case OPR_MAXPART:
00241     return Only_32bit_opnds(WN_kid0(tree)); 
00242 
00243   case OPR_CVTL: return WN_cvtl_bits(tree) <= 32 || 
00244         Only_32bit_opnds(WN_kid0(tree));
00245 
00246   case OPR_CVT: return MTYPE_byte_size(rtype) <= 4 ||
00247            MTYPE_is_integral(desc) && 
00248              (MTYPE_byte_size(desc) <= 4 || 
00249             Only_32bit_opnds(WN_kid0(tree)));
00250 
00251   // binary
00252   case OPR_MLOAD: return FALSE;
00253 
00254   case OPR_MPY:
00255   case OPR_DIV: 
00256   case OPR_MOD: case OPR_REM:
00257   case OPR_DIVREM: return MTYPE_byte_size(rtype) <= 4;
00258 
00259   case OPR_ADD: case OPR_SUB:
00260   case OPR_MAX: case OPR_MIN: 
00261   case OPR_MINMAX:
00262     return MTYPE_byte_size(rtype) <= 4 ||
00263            Only_32bit_opnds(WN_kid0(tree)) && Only_32bit_opnds(WN_kid1(tree));
00264 
00265   case OPR_BAND: case OPR_BIOR: case OPR_BNOR: case OPR_BXOR:
00266   case OPR_ASHR: case OPR_LSHR:
00267   case OPR_SHL: 
00268   case OPR_COMPOSE_BITS:
00269     return MTYPE_byte_size(rtype) <= 4;
00270 
00271   case OPR_EQ: case OPR_NE: 
00272   case OPR_GE: case OPR_GT: case OPR_LE: case OPR_LT: 
00273   case OPR_LAND: case OPR_LIOR:
00274     return TRUE;
00275 
00276   // ternary
00277   case OPR_SELECT:
00278     return MTYPE_byte_size(rtype) <= 4 ||
00279            Only_32bit_opnds(WN_kid1(tree)) && Only_32bit_opnds(WN_kid2(tree));
00280 
00281   // n-ary
00282   case OPR_INTRINSIC_OP: 
00283     return MTYPE_byte_size(rtype) <= 4;
00284 
00285   default: Is_True(FALSE,("unexpected operator"));
00286   }
00287 
00288   return FALSE;
00289 }
00290 
00291 /* ====================================================================
00292  * Only 32-bit or less of the value computed by the tree is needed, so
00293  * shrink the type of the computation to 32-bit if it will not affect the
00294  * correctness, which in turn depends on the size of the operands.
00295  * ==================================================================== */
00296 static WN *
00297 Shrink_to_32bit(WN *tree)
00298 {
00299   OPERATOR opr = WN_operator(tree);
00300   TYPE_ID rtype = WN_rtype(tree);
00301   TYPE_ID desc = WN_desc(tree);
00302   TYPE_ID orig_kid0_rtype, orig_kid1_rtype;
00303 
00304   if (MTYPE_byte_size(rtype) == 8) {
00305     switch (opr) {
00306     case OPR_MPY:
00307     case OPR_DIV: 
00308     case OPR_MOD: case OPR_REM:
00309     case OPR_DIVREM:
00310       orig_kid0_rtype = WN_rtype(WN_kid0(tree));
00311       orig_kid1_rtype = WN_rtype(WN_kid1(tree));
00312       WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), TRUE, FALSE);
00313       WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), TRUE, FALSE);
00314       if (Only_32bit_opnds(WN_kid0(tree)) && Only_32bit_opnds(WN_kid1(tree)) &&
00315     (opr != OPR_MPY || (WN_operator(WN_kid0(tree)) != OPR_INTCONST &&
00316               WN_operator(WN_kid1(tree)) != OPR_INTCONST))) {
00317   // not doing for mult with const so as not to disable lea optimization
00318   WN_kid0(tree) = Change_types_to_32bit(WN_kid0(tree));
00319   WN_kid1(tree) = Change_types_to_32bit(WN_kid1(tree));
00320   WN_set_rtype(tree, MTYPE_I4);
00321       }
00322       else {
00323   TYPE_ID kid0_rtype = WN_rtype(WN_kid(tree, 0));
00324   if (orig_kid0_rtype != kid0_rtype &&
00325       MTYPE_byte_size(WN_rtype(WN_kid(tree, 0))) < 8) { // insert CVT
00326     WN_kid(tree, 0) = WN_Cvt(kid0_rtype, 
00327            Mtype_TransferSize(MTYPE_I8, kid0_rtype), 
00328            WN_kid(tree, 0));
00329   }
00330   TYPE_ID kid1_rtype = WN_rtype(WN_kid(tree, 1));
00331   if (orig_kid1_rtype != kid1_rtype &&
00332       MTYPE_byte_size(WN_rtype(WN_kid(tree, 1))) < 8) { // insert CVT
00333     WN_kid(tree, 1) = WN_Cvt(kid1_rtype, 
00334            Mtype_TransferSize(MTYPE_I8, kid1_rtype), 
00335            WN_kid(tree, 1));
00336   }
00337       }
00338       return tree;
00339   
00340     default: ;
00341     }
00342   }
00343   return RETYPE_EXPR_expr(tree, TRUE, FALSE);
00344 }
00345 
00346 /* ====================================================================
00347  * Traverse the given expr wn and find 64-bit expressions that can be retyped to
00348  * 32-bit without affecting the results; can_be_32bit gives whether the current
00349  * expr can be converted to 32-bit if all the operands are 32-bit; addr_expr 
00350  * gives whether we are in an expression that performs address computation;
00351  * if addr_expr is true, any 64-bit integer mul/div/mod/rem can be converted 
00352  * to 32-bit if all the operands are 32-bit.
00353  * ==================================================================== */
00354 static WN *
00355 RETYPE_EXPR_expr(WN *tree, BOOL can_be_32bit, BOOL addr_expr)
00356 {
00357   INT i;
00358   OPERATOR opr = WN_operator(tree);
00359   TYPE_ID rtype = WN_rtype(tree);
00360   TYPE_ID desc = WN_desc(tree);
00361 
00362   switch (opr) {
00363   // leaves
00364   case OPR_LDID: 
00365   case OPR_LDBITS:
00366   case OPR_INTCONST:
00367   case OPR_CONST:
00368   case OPR_LDA:
00369   case OPR_LDA_LABEL:
00370     return tree;
00371 
00372   // unary
00373   case OPR_ILOAD:
00374   case OPR_ILDBITS:
00375     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, TRUE);
00376     return tree;
00377 
00378   case OPR_SQRT: case OPR_RSQRT: case OPR_RECIP:
00379   case OPR_PAREN:
00380   case OPR_REALPART: case OPR_IMAGPART:
00381   case OPR_HIGHPART: case OPR_LOWPART:
00382   case OPR_ALLOCA:
00383   case OPR_LNOT:
00384   case OPR_EXTRACT_BITS:
00385   case OPR_BNOT:
00386   case OPR_PARM:
00387   case OPR_TAS:
00388   case OPR_RND: case OPR_TRUNC: case OPR_CEIL: case OPR_FLOOR:
00389 #ifdef TARG_X8664
00390   case OPR_REPLICATE:
00391   case OPR_REDUCE_ADD: case OPR_REDUCE_MPY: 
00392   case OPR_REDUCE_MAX: case OPR_REDUCE_MIN:
00393   case OPR_SHUFFLE:
00394   case OPR_ATOMIC_RSQRT:
00395 #endif // TARG_X8664
00396     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00397     return tree;
00398 
00399   case OPR_NEG:
00400   case OPR_ABS:
00401   case OPR_MINPART: case OPR_MAXPART:
00402     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), can_be_32bit, addr_expr);
00403     return tree;
00404 
00405   case OPR_CVTL:
00406     if (WN_cvtl_bits(tree) > 32)
00407       WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00408     else WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), TRUE, FALSE);
00409     return tree;
00410 
00411   case OPR_CVT:
00412     if (! MTYPE_is_integral(rtype) || 
00413         ! MTYPE_is_integral(desc) || 
00414   MTYPE_byte_size(rtype) == 8)
00415       WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00416     else {
00417       WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), TRUE, FALSE);
00418       if (can_be_32bit && MTYPE_byte_size(WN_rtype(WN_kid0(tree))) <= 8)
00419   return WN_kid0(tree); // can skip the CVT
00420     }
00421     return tree;
00422 
00423   // binary
00424   case OPR_MLOAD:
00425     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, TRUE);
00426     WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), FALSE, FALSE);
00427     return tree;
00428 
00429   case OPR_MPY:
00430   case OPR_DIV: 
00431   case OPR_MOD: case OPR_REM:
00432   case OPR_DIVREM:
00433     if (MTYPE_byte_size(rtype) == 8 && (can_be_32bit || addr_expr)) {
00434       tree = Shrink_to_32bit(tree);
00435       if (MTYPE_byte_size(WN_rtype(tree)) < 8 && !can_be_32bit) { // insert CVT
00436   return WN_Cvt(WN_rtype(tree), rtype, tree);
00437       } 
00438       return tree;
00439     }
00440     // fall thru
00441 
00442   case OPR_ADD: case OPR_SUB:
00443   case OPR_MAX: case OPR_MIN: 
00444   case OPR_MINMAX:
00445     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), can_be_32bit, addr_expr);
00446     if (MTYPE_byte_size(rtype) == 8 &&
00447         MTYPE_byte_size(WN_rtype(WN_kid0(tree))) != 8)
00448       WN_kid0(tree) = WN_Cvt(WN_rtype(WN_kid0(tree)), rtype, WN_kid0(tree));
00449     WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), can_be_32bit, addr_expr);
00450     if (MTYPE_byte_size(rtype) == 8 &&
00451         MTYPE_byte_size(WN_rtype(WN_kid1(tree))) != 8)
00452       WN_kid1(tree) = WN_Cvt(WN_rtype(WN_kid1(tree)), rtype, WN_kid1(tree));
00453     return tree;
00454 
00455   case OPR_BAND: case OPR_BIOR: case OPR_BNOR: case OPR_BXOR:
00456   case OPR_ASHR: case OPR_LSHR:
00457   case OPR_SHL: 
00458   case OPR_EQ: case OPR_NE: 
00459   case OPR_GE: case OPR_GT: case OPR_LE: case OPR_LT:
00460   case OPR_LAND: case OPR_LIOR:
00461   case OPR_COMPLEX:
00462     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00463     WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), FALSE, FALSE);
00464     return tree;
00465 
00466   case OPR_COMPOSE_BITS:
00467     if (WN_bit_size(tree) <= 32)
00468       WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), TRUE, FALSE);
00469     else WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00470     WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), FALSE, FALSE);
00471     return tree;
00472 
00473   // ternary
00474   case OPR_SELECT:
00475     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00476     WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), can_be_32bit, addr_expr);
00477     WN_kid2(tree) = RETYPE_EXPR_expr(WN_kid2(tree), can_be_32bit, addr_expr);
00478     return tree;
00479 
00480   // n-ary
00481   case OPR_INTRINSIC_OP: 
00482     for (i = 0; i < WN_kid_count(tree); i++)  // kids must be PARMs
00483       RETYPE_EXPR_expr(WN_kid(tree,i), FALSE, FALSE); 
00484     return tree;
00485 
00486   default: Is_True(FALSE,("unexpected operator"));
00487   }
00488 
00489   return NULL;
00490 }
00491 
00492 /* ====================================================================
00493  * In the given stmt wn, find 64-bit expressions that can be retyped to
00494  * 32-bit without affecting the results and call RETYPE_EXPR_expr to perform 
00495  * the retyping
00496  * ==================================================================== */
00497 static void
00498 RETYPE_EXPR_stmt(WN *tree)
00499 {
00500   OPERATOR opr = WN_operator(tree);
00501   INT i;
00502 
00503   switch (opr) {
00504 
00505   // operators with no expression as kid
00506   case OPR_GOTO:
00507   case OPR_GOTO_OUTER_BLOCK:
00508   case OPR_RETURN:
00509   case OPR_COMMENT:
00510   case OPR_TRAP :
00511   case OPR_FORWARD_BARRIER:
00512   case OPR_BACKWARD_BARRIER:
00513   case OPR_ALTENTRY:
00514   case OPR_PRAGMA:
00515   case OPR_LABEL:
00516   case OPR_REGION:
00517   case OPR_REGION_EXIT:
00518     return;
00519 
00520   case OPR_DEALLOCA:  
00521   case OPR_PREFETCH:
00522   case OPR_AGOTO:
00523     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, TRUE);
00524     return;
00525 
00526   case OPR_EVAL: 
00527   case OPR_TRUEBR:
00528   case OPR_FALSEBR:
00529   case OPR_ASSERT:
00530   case OPR_RETURN_VAL:
00531   case OPR_COMPGOTO:
00532   case OPR_XGOTO:
00533   case OPR_XPRAGMA:
00534     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00535     return;
00536 
00537   case OPR_ISTORE:
00538     WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), FALSE, TRUE);
00539   // fall through
00540 
00541   case OPR_STID:
00542     if (MTYPE_byte_size(WN_desc(tree)) != 8)
00543       WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), TRUE, FALSE);
00544     else WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00545     return;
00546 
00547   case OPR_ISTBITS:
00548     WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), FALSE, TRUE);
00549   // fall through
00550 
00551   case OPR_STBITS:
00552     if (WN_bit_size(tree) <= 32)
00553       WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), TRUE, FALSE);
00554     else WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00555     return;
00556 
00557   case OPR_CALL:          
00558   case OPR_ICALL:
00559   case OPR_INTRINSIC_CALL:
00560     for (i = 0; i < WN_kid_count(tree); i++) 
00561       WN_kid(tree,i) = RETYPE_EXPR_expr(WN_kid(tree,i), FALSE, FALSE);
00562     return;
00563 
00564   case OPR_PICCALL:
00565     for (i = 0; i < (WN_kid_count(tree)-1); i++) 
00566       WN_kid(tree,i) = RETYPE_EXPR_expr(WN_kid(tree,i), FALSE, FALSE);
00567     return;
00568 
00569   case OPR_ASM_STMT:
00570     for (i = 2; i < WN_kid_count(tree); i++) {
00571       WN_kid0(WN_kid(tree,i)) = RETYPE_EXPR_expr(WN_kid0(WN_kid(tree,i)), FALSE, FALSE);
00572     }
00573     return;
00574 
00575   case OPR_MSTORE:
00576     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00577     WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), FALSE, TRUE);
00578     WN_kid2(tree) = RETYPE_EXPR_expr(WN_kid2(tree), FALSE, FALSE);
00579     return;
00580 
00581   case OPR_LOOP_INFO:
00582     if (WN_kid1(tree) != NULL) {
00583       WN_kid1(tree) = RETYPE_EXPR_expr(WN_kid1(tree), FALSE, FALSE);
00584     }
00585     return;
00586 
00587   // structured control flow statements
00588 
00589   case OPR_BLOCK: {
00590     WN *stmt;
00591     for (stmt = WN_first(tree); stmt; stmt = WN_next(stmt)) {
00592       Is_True(OPERATOR_is_stmt(WN_operator(stmt)) || OPERATOR_is_scf(WN_operator(stmt)),
00593         ("statement operator expected"));
00594       RETYPE_EXPR_stmt(stmt);
00595     }
00596     return;
00597     }
00598 
00599   case OPR_DO_LOOP:
00600     RETYPE_EXPR_stmt(WN_kid(tree, 1)); // the initialization statement
00601     WN_kid2(tree) = RETYPE_EXPR_expr(WN_kid2(tree), FALSE, FALSE);
00602     RETYPE_EXPR_stmt(WN_kid(tree, 3)); // the increment statement
00603     RETYPE_EXPR_stmt(WN_kid(tree, 4)); // the block
00604     if (WN_kid_count(tree) == 6)
00605       RETYPE_EXPR_stmt(WN_kid(tree, 5)); // LOOP_INFO
00606     return;
00607 
00608   case OPR_DO_WHILE:
00609   case OPR_WHILE_DO:
00610     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00611     RETYPE_EXPR_stmt(WN_kid(tree, 1));
00612     return;
00613 
00614   case OPR_IF:
00615     WN_kid0(tree) = RETYPE_EXPR_expr(WN_kid0(tree), FALSE, FALSE);
00616     RETYPE_EXPR_stmt(WN_kid(tree, 1));
00617     RETYPE_EXPR_stmt(WN_kid(tree, 2));
00618     return;
00619 
00620   default:  
00621     Is_True(FALSE,("unexpected operator"));
00622   }
00623 
00624   return;  
00625 }
00626 
00627 /* ====================================================================
00628  * Top level routine for finding 64-bit expressions that can be retyped to
00629  * 32-bit without affecting the results
00630  * ==================================================================== */
00631 void
00632 WN_retype_expr(WN *tree)
00633 {
00634   Start_Timer(T_Lower_CU);
00635   Set_Error_Phase("WN_retype_expr");
00636 
00637   if (WN_operator(tree) == OPR_FUNC_ENTRY) 
00638     RETYPE_EXPR_stmt(WN_func_body(tree));
00639   else if (WN_operator(tree) == OPR_REGION) 
00640     RETYPE_EXPR_stmt(WN_region_body(tree));
00641   else if (OPERATOR_is_stmt(WN_operator(tree)) || OPERATOR_is_scf(WN_operator(tree)))
00642     RETYPE_EXPR_stmt(tree);
00643   else Is_True(FALSE, ("unexpected WHIRL operator"));
00644 
00645   Stop_Timer(T_Lower_CU);
00646 
00647   WN_Lower_Checkdump("After wn_retype_expr", tree, 0);   
00648 
00649   WN_verifier(tree);
00650 
00651   return;
00652 }