Open64: osprey/be/whirl2c/wn_attr.cxx Source File

00001 /*
00002  * Copyright 2003, 2004, 2005, 2006 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 /* ====================================================================
00041  * ====================================================================
00042  *
00043  * Module: wn_attr.c
00044  * $Revision: 1.12 $
00045  * $Date: 05/12/05 08:59:32-08:00 $
00046  * $Author: bos@eng-24.pathscale.com $
00047  * $Source: /scratch/mee/2.4-65/kpro64-pending/be/whirl2c/SCCS/s.wn_attr.cxx $
00048  *
00049  * Revision history:
00050  *  07-Mar-95 - Original Version
00051  *
00052  * Description:
00053  *
00054  *   Get WN tree attributes, beyond those provided through 
00055  *   common/com/wn_core.h.
00056  *
00057  * ====================================================================
00058  * ====================================================================
00059  */
00060 
00061 #ifdef _KEEP_RCS_ID
00062 static char *rcs_id = "$Source: /scratch/mee/2.4-65/kpro64-pending/be/whirl2c/SCCS/s.wn_attr.cxx $ $Revision: 1.12 $";
00063 #endif /* _KEEP_RCS_ID */
00064 
00065 
00066 #include "common_include.h"
00067 #include "wn_util.h"
00068 #include "intrn_info.h"
00069 #include "wutil.h"
00070 
00071 /* INTRN_c_name() is only implemented when !defined(BUILD_SKIP_WHIRL2C), while
00072  * we must use INTRN_specific_name() when !defined(BUILD_SKIP_WHIRL2F).  To 
00073  * abstract away from this, we define the macro INTRN_high_level_name.
00074  * NOT TRUE anymore, but keep this cause I'm not sure which they really want.
00075  */
00076 #if !defined(BUILD_SKIP_WHIRL2C)
00077 #define INTRN_high_level_name INTRN_c_name
00078 #else /*BUILD_WHIRL2F*/
00079 #define INTRN_high_level_name INTRN_specific_name
00080 #endif
00081 
00082 
00083 /*--------- Hidden utility to get type info about a cvtl node ---------*
00084  *---------------------------------------------------------------------*/
00085 
00086 static const MTYPE WN_Cvtl_Mtype[2/*is_signed*/][9/*byte-size*/] =
00087 {/* unsigned */
00088  {MTYPE_UNKNOWN,      /* 0 bytes */
00089   MTYPE_U1,           /* 1 byte  */
00090   MTYPE_U2,           /* 2 bytes */
00091   MTYPE_UNKNOWN,      /* 3 bytes */
00092   MTYPE_U4,           /* 4 bytes */
00093   MTYPE_UNKNOWN,      /* 5 bytes */
00094   MTYPE_UNKNOWN,      /* 6 bytes */
00095   MTYPE_UNKNOWN,      /* 7 bytes */
00096   MTYPE_U8},          /* 8 bytes */
00097  /* signed */
00098  {MTYPE_UNKNOWN,      /* 0 bytes */
00099   MTYPE_I1,           /* 1 byte  */
00100   MTYPE_I2,           /* 2 bytes */
00101   MTYPE_UNKNOWN,      /* 3 bytes */
00102   MTYPE_I4,           /* 4 bytes */
00103   MTYPE_UNKNOWN,      /* 5 bytes */
00104   MTYPE_UNKNOWN,      /* 6 bytes */
00105   MTYPE_UNKNOWN,      /* 7 bytes */
00106   MTYPE_I8}           /* 8 bytes */
00107 }; /* WN_Cvtl_Mtype */
00108 
00109 static TY_IDX
00110 WN_Cvtl_Ty(const WN *wn)
00111 {
00112    /* The type of a CVTL node is the return type scaled down to the
00113     * given bitsize.
00114     */ 
00115    const INT   cvtl_bytes = WN_cvtl_bits(wn)>>3;
00116    const MTYPE dest_mtype = WN_opc_rtype(wn);
00117    const BOOL  is_signed = MTYPE_signed(dest_mtype);
00118    const MTYPE cvtl_mtype = WN_Cvtl_Mtype[is_signed? 1 : 0][cvtl_bytes];
00119 
00120    return Stab_Mtype_To_Ty(cvtl_mtype);
00121 } /* WN_Cvtl_Ty */
00122 
00123 TY_IDX Get_Field_Type(TY_IDX base, int field_id) {
00124 
00125   Is_True(TY_Is_Structured(base), ("CALLING GET_FIELD_TYPE with a non struct type"));
00126 
00127   UINT cur_fld_id = 0;
00128   FLD_HANDLE fh = FLD_get_to_field(base, field_id, cur_fld_id);
00129   return FLD_type(fh);
00130 }
00131 
00132 
00133 /*------------------------ Exported functions -------------------------
00134  *---------------------------------------------------------------------*/
00135 
00136 
00137 UINT
00138 WN_num_var_refs(WN *wn, const ST *st, STAB_OFFSET st_ofst)
00139 {
00140    /* Count the number of nodes that references the object or address
00141     * denoted by the given ST.  Only count LDID, STID or LDA references.
00142     */
00143    UINT      counter = 0;
00144    WN_ITER  *wn_iter;
00145    const WN *subtree;
00146 
00147    for (wn_iter = WN_WALK_TreeIter(wn); 
00148   wn_iter != NULL;
00149   wn_iter = WN_WALK_TreeNext(wn_iter))
00150    {
00151       subtree = WN_ITER_wn(wn_iter);
00152       if (subtree != NULL)
00153    switch (WN_opc_operator(subtree))
00154    {
00155    case OPR_LDID:
00156    case OPR_STID:
00157    case OPR_LDA:
00158       if (WN_st(subtree) == st && WN_offset(subtree) == st_ofst)
00159          counter += 1;
00160       break;
00161       
00162    default:
00163       break;
00164    }
00165    } /*loop*/
00166    return counter;
00167 } /* WN_num_var_refs */
00168 
00169 
00170 const char *
00171 WN_intrinsic_name(INTRINSIC intr_opc)
00172 {
00173    const char *name;
00174    
00175    Is_True(INTRINSIC_FIRST<=intr_opc && intr_opc<=INTRINSIC_LAST,
00176      ("Intrinsic Opcode (%d) out of range", intr_opc)); 
00177    if (INTRN_high_level_name(intr_opc) != NULL)
00178       name = INTRN_high_level_name(intr_opc);
00179 #if !defined(BUILD_SKIP_WHIRL2F)
00180    else
00181    {
00182       ASSERT_WARN(FALSE, 
00183       (DIAG_A_STRING,
00184        Concat2_Strings("Missing intrinsic name ", 
00185            INTRINSIC_name(intr_opc))));
00186       name = INTRINSIC_name(intr_opc);
00187    }
00188 #else /* BUILD_SKIP_WHIRL2C*/
00189    else if (INTRN_rt_name(intr_opc) != NULL)
00190       name = INTRN_rt_name(intr_opc);
00191    else
00192    {
00193       Is_True(FALSE, 
00194         ("Expected \"high_level\" or \"rt\" name in WN_intrinsic_name()"));
00195       name =
00196    Concat3_Strings("<INTR: ", Number_as_String(intr_opc, "%lld"), ">");
00197    }
00198 #endif /*BUILD_WHIRL2F*/
00199 
00200    return name;
00201 } /* WN_intrinsic_name */
00202 
00203 
00204 TY_IDX
00205 WN_intrinsic_return_ty(OPCODE wn_opc, INTRINSIC intr_opc, const WN *call)
00206 {
00207    TY_IDX ret_ty;
00208    
00209    Is_True(INTRINSIC_FIRST<=intr_opc && intr_opc<=INTRINSIC_LAST,
00210      ("Intrinsic Opcode (%d) out of range", intr_opc)); 
00211    switch (INTRN_return_kind(intr_opc))
00212    {
00213    case IRETURN_UNKNOWN:
00214       /* Use the opcode to get the type */
00215       ret_ty = Stab_Mtype_To_Ty(OPCODE_rtype(wn_opc));
00216       break;
00217    case IRETURN_V:
00218       ret_ty = Stab_Mtype_To_Ty(MTYPE_V);
00219       break;
00220    case IRETURN_I1:
00221       ret_ty = Stab_Mtype_To_Ty(MTYPE_I1);
00222       break;
00223    case IRETURN_I2:
00224       ret_ty = Stab_Mtype_To_Ty(MTYPE_I2);
00225       break;
00226    case IRETURN_I4:
00227       ret_ty = Stab_Mtype_To_Ty(MTYPE_I4);
00228       break;
00229    case IRETURN_I8:
00230       ret_ty = Stab_Mtype_To_Ty(MTYPE_I8);
00231       break;
00232    case IRETURN_U1:
00233       ret_ty = Stab_Mtype_To_Ty(MTYPE_U1);
00234       break;
00235    case IRETURN_U2:
00236       ret_ty = Stab_Mtype_To_Ty(MTYPE_U2);
00237       break;
00238    case IRETURN_U4:
00239       ret_ty = Stab_Mtype_To_Ty(MTYPE_U4);
00240       break;
00241    case IRETURN_U8:
00242       ret_ty = Stab_Mtype_To_Ty(MTYPE_U8);
00243       break;
00244    case IRETURN_F4:
00245       ret_ty = Stab_Mtype_To_Ty(MTYPE_F4);
00246       break;
00247    case IRETURN_F8:
00248       ret_ty = Stab_Mtype_To_Ty(MTYPE_F8);
00249       break;
00250    case IRETURN_FQ:
00251       ret_ty = Stab_Mtype_To_Ty(MTYPE_FQ);
00252       break;
00253    case IRETURN_C4:
00254       ret_ty = Stab_Mtype_To_Ty(MTYPE_C4);
00255       break;
00256    case IRETURN_C8:
00257       ret_ty = Stab_Mtype_To_Ty(MTYPE_C8);
00258       break;
00259    case IRETURN_CQ:
00260       ret_ty = Stab_Mtype_To_Ty(MTYPE_CQ);
00261       break;
00262    case IRETURN_PV:
00263       ret_ty = Stab_Pointer_To(Stab_Mtype_To_Ty(MTYPE_V));
00264       break;
00265    case IRETURN_PU1:
00266       ret_ty = Stab_Pointer_To(Stab_Mtype_To_Ty(MTYPE_U1));
00267       break;
00268    case IRETURN_DA1:
00269       ret_ty = WN_Tree_Type(WN_kid0(call));
00270       break;
00271 #ifdef KEY
00272    case IRETURN_PC:
00273       ret_ty = Stab_Pointer_To(Stab_Mtype_To_Ty(MTYPE_V));
00274       break;
00275    case IRETURN_SZT:
00276       ret_ty = Stab_Mtype_To_Ty(MTYPE_I4);
00277       break;
00278 #ifdef TARG_X8664
00279    case IRETURN_V16C8:
00280      ret_ty = Stab_Mtype_To_Ty(MTYPE_V16C8);
00281      break;
00282    case IRETURN_V16I1:
00283      ret_ty = Stab_Mtype_To_Ty(MTYPE_V16I1);
00284      break;
00285    case IRETURN_V16I2:
00286      ret_ty = Stab_Mtype_To_Ty(MTYPE_V16I2);
00287      break;     
00288    case IRETURN_V16I4:
00289      ret_ty = Stab_Mtype_To_Ty(MTYPE_V16I4);
00290      break;     
00291    case IRETURN_V16I8:
00292      ret_ty = Stab_Mtype_To_Ty(MTYPE_V16I8);
00293      break;
00294    case IRETURN_V16F8:
00295      ret_ty = Stab_Mtype_To_Ty(MTYPE_V16F8);
00296      break;
00297    case IRETURN_V16F4:
00298      ret_ty = Stab_Mtype_To_Ty(MTYPE_V16F4);
00299      break;     
00300    case IRETURN_M8I1:
00301      ret_ty = Stab_Mtype_To_Ty(MTYPE_M8I1);
00302      break;
00303    case IRETURN_M8I2:
00304      ret_ty = Stab_Mtype_To_Ty(MTYPE_M8I2);
00305      break;     
00306    case IRETURN_M8I4:
00307      ret_ty = Stab_Mtype_To_Ty(MTYPE_M8I4);
00308      break;     
00309 #endif
00310 #endif
00311    case IRETURN_PPU2:
00312      ret_ty = Stab_Pointer_To(Stab_Pointer_To(Stab_Mtype_To_Ty(MTYPE_U2)));
00313      break;
00314    case IRETURN_PPI4:
00315      ret_ty = Stab_Pointer_To(Stab_Pointer_To(Stab_Mtype_To_Ty(MTYPE_I4)));
00316      break;
00317    default:
00318       Is_True(FALSE, 
00319         ("Unexpected INTRN_RETKIND in WN_intrinsic_return_ty()"));
00320       ret_ty = Stab_Mtype_To_Ty(MTYPE_V);
00321       break;
00322    }
00323    
00324    return ret_ty;
00325 } /* WN_intrinsic_return_ty */
00326 
00327 
00328 BOOL 
00329 WN_intrinsic_return_to_param(TY_IDX return_ty)
00330 {
00331    /* We assume there is only one case when the return value
00332     * cannot be passed through registers, namely for a quad
00333     * precision complex number.
00334     */
00335    return (TY_mtype(return_ty) == MTYPE_CQ);
00336 
00337 } /* WN_intrinsic_return_to_param */
00338 
00339 
00340 WN *
00341 WN_Get_PtrAdd_Intconst(WN    *wn0, 
00342            WN    *wn1, 
00343            TY_IDX pointed_ty)
00344 {
00345    /* We make an attempt at retaining pointer types for ptr
00346     * additions, where we expect the ptr expression to be of
00347     * one of the following forms:
00348     *
00349     *    1)  ptr + expr
00350     *    2)  ptr + expr*const
00351     *    3)  ptr + const
00352     *
00353     * where const must be a multiple of the size of the pointed_ty
00354     * and only abscent when the size is 1. If this pattern is not 
00355     * found, then return NULL; otherwise return the const expression,
00356     * if one is found, or the integral expression when size==1.
00357     */
00358    WN *intconst = NULL;
00359    
00360    /* Identify the integral expression */
00361    if (!TY_Is_Pointer(WN_Tree_Type(wn0)))
00362       intconst = wn0;
00363    else if (!TY_Is_Pointer(WN_Tree_Type(wn1)))
00364       intconst = wn1;
00365 
00366    /* Get the constant expression */
00367    if (intconst != NULL && TY_size(pointed_ty) > 1)
00368    {
00369       /* Identify the integral constant expression */
00370       if (WN_opc_operator(intconst) == OPR_MPY)
00371       {
00372    if (WN_opc_operator(WN_kid0(intconst)) == OPR_INTCONST)
00373       intconst = WN_kid0(intconst);
00374    else if (WN_opc_operator(WN_kid1(intconst)) == OPR_INTCONST)
00375       intconst = WN_kid1(intconst);
00376    else
00377       intconst = NULL;
00378       }
00379       else if (WN_opc_operator(intconst) != OPR_INTCONST)
00380    intconst = NULL;
00381    }
00382    
00383    /* Make sure the constant expression is a multiple of the size of type
00384     * pointed to.
00385     */
00386    if (TY_size(pointed_ty) == 0 ||    /* incomplete type */
00387        TY_kind(pointed_ty) == KIND_ARRAY || /* for arrays, we always need a cast to the pointer type */
00388        (intconst != NULL && 
00389   WN_opc_operator(intconst) == OPR_INTCONST &&
00390   WN_const_val(intconst)%TY_size(pointed_ty) != 0LL))
00391    {
00392       intconst = NULL;
00393    }
00394    return intconst;
00395 } /* WN_Get_PtrAdd_Intconst */
00396 
00397 TY_IDX
00398 WN_Tree_Type(const WN *wn)
00399 {
00400    /* Return a TY that as closely as possible represents the type of the
00401     * given subexpression (wn).
00402     *
00403     * TY_is_logical() will only hold true when the TY is resolved from
00404     * a WN_ty or ST_ty attribute, not when it is resolved from an MTYPE.
00405     *
00406     * Pointer types may be created as a result of a call to this routine.
00407     */
00408    TY_IDX ty = Stab_Mtype_To_Ty(MTYPE_V); /* return value, default = void */
00409    
00410    if (OPCODE_is_expression(WN_opcode(wn)))
00411    {
00412       switch (WN_opc_operator(wn))
00413       {
00414       case OPR_ILOADX:
00415   ty = WN_ty(wn);
00416   break;
00417       case OPR_ILOAD:
00418       case OPR_LDID:
00419    ty = WN_ty(wn);
00420    if (WN_field_id(wn) > 0) {
00421      ty = Get_Field_Type(ty, WN_field_id(wn));
00422    }
00423    break;
00424 
00425       case OPR_LDA_LABEL: 
00426          ty = TY_pointed(WN_ty(wn));
00427          break;
00428 
00429       case OPR_LDA:
00430    ty = WN_ty(wn);
00431    //bug 606: LDAs may also have field ids (e.g., arrays in a struct, with array lowering disabled)
00432    if (WN_field_id(wn) > 0) {
00433      TY_IDX pointed = TY_pointed(ty);
00434      if (TY_kind(pointed) ==  KIND_STRUCT) {
00435        pointed = Get_Field_Type(pointed, WN_field_id(wn));
00436        if(TY_kind(pointed) == KIND_ARRAY) {
00437          ty = Make_Pointer_Type(Get_Inner_Array_Type(pointed));
00438        } else 
00439          ty = Make_Pointer_Type(pointed);
00440      }
00441    } 
00442    else if (TY_kind(TY_pointed(ty)) == KIND_ARRAY && WN_load_offset(wn) == 0) {
00443      //fix bug445.
00444      //When taking the address of an array, 
00445      //the LDAs generated by the front-end / backend does not distinguish between
00446      //the two cases(same address but different type): &arr (pointer to the array) and arr (pointer to the elements)
00447      //We assume the type is always the latter, and use explicit casts to take care of the former case
00448      //(there will be a type mismatch)
00449      // Should we go for the inner array type here or for the element type?
00450      ty = Make_Pointer_Type(Get_Inner_Array_Type(TY_pointed(ty)));
00451    }
00452          break; 
00453       case OPR_MLOAD:
00454    /* There is not much we can do about this case */
00455    if (WN_opc_operator(WN_kid1(wn)) == OPR_INTCONST &&
00456        TY_Is_Structured(TY_pointed(WN_ty(wn))))
00457    {
00458      /* WEI: for field accesses, get the type of the field */
00459      if (WN_field_id(wn) != 0) {
00460        ty = Get_Field_Type(TY_pointed(WN_ty(wn)), WN_field_id(wn));
00461      } else {
00462       ty = Stab_Get_Mload_Ty(TY_pointed(WN_ty(wn)), 
00463            WN_load_offset(wn), 
00464            WN_const_val(WN_kid1(wn)));
00465      }
00466    }
00467    else
00468    {
00469       ty = TY_pointed(WN_ty(wn));
00470    }
00471    break;
00472    
00473       case OPR_ARRAY:
00474    /* Get the address type denoted by the base offset by the
00475     * given indexing expression. Note that we do handle
00476     * pointers as arrays when there is no ambiguity, and
00477     * we rely on the flag TY_ptr_as_array() to handle indexing
00478     * of an array of arrays.  The following should access the
00479     * fifth element, each element consisting of 17 ints:
00480     *
00481     *    int (*a)[17]; .... a[5] ....
00482     *
00483     * This will be represented as (OPR_ARRAY (OPR_LDID a) ...),
00484     * but, since the type of kid0 is ptr-to-arrayOfInts, we need
00485     * the flag TY_ptr_as_array or else the type of the ARRAY
00486     * node would be considered a ptr-to-ints (see also 
00487     * WN2C_array()).
00488     */
00489    ty = WN_Tree_Type(WN_kid0(wn));
00490    if (!TY_Is_Pointer(ty))
00491    {
00492       /* Create a pointer to be treated as an array when also used
00493        * as the base-type of this OPC_ARRAY.  This must be handled
00494        * very carefully in WN2C_array().
00495        */
00496       ty = Stab_Pointer_To(Stab_Array_Of(Stab_Mtype_To_Ty(MTYPE_U1),
00497                  WN_element_size(wn)));
00498    }
00499          else if (!TY_ptr_as_array(Ty_Table[ty]) && TY_Is_Array(TY_pointed(ty)))
00500    {
00501       ty = Stab_Pointer_To(TY_AR_etype(TY_pointed(ty)));
00502    }
00503    break;
00504 
00505       case OPR_TAS:
00506    ty = WN_ty(wn);
00507    break;
00508    
00509       case OPR_SELECT:
00510    /* We make an attempt at retaining pointer types for ptr
00511     * arithmetics.
00512     */
00513    if (WN_opc_rtype(wn) == Pointer_Mtype)
00514    {
00515       ty = WN_Tree_Type(WN_kid0(wn));
00516       if (!TY_Is_Pointer(ty))
00517       {
00518          ty = WN_Tree_Type(WN_kid1(wn));
00519          if (!TY_Is_Pointer(ty))
00520       ty = Stab_Mtype_To_Ty(WN_opc_rtype(wn));
00521       }
00522    }
00523    else
00524       ty = Stab_Mtype_To_Ty(WN_opc_rtype(wn));
00525    break;     
00526 
00527       case OPR_CVTL:
00528    ty = WN_Cvtl_Ty(wn);
00529    break;
00530    
00531       case OPR_PAREN:
00532    ty = WN_Tree_Type(WN_kid0(wn));
00533    break;
00534 
00535       case OPR_ADD:
00536    /* We make an attempt at retaining pointer types for ptr
00537     * arithmetics.  If either one of the operands is a pointer,
00538     * then return this as the type of the expression, otherwise
00539     * return the type indicated by the opc_rtype.
00540     */
00541    if (WN_opc_rtype(wn) == Pointer_Mtype)
00542    {
00543       ty = WN_Tree_Type(WN_kid0(wn));
00544       if (!TY_Is_Pointer(ty))
00545       {
00546          ty = WN_Tree_Type(WN_kid1(wn));
00547          if (!TY_Is_Pointer(ty))
00548       ty = Stab_Mtype_To_Ty(WN_opc_rtype(wn));
00549       }
00550       
00551       /* For pointer of the form &a[exp] where a is an array,
00552          we want its type to be a pointer to a[exp],
00553          instead of a pointer to the array itself
00554          see bug376.
00555       */
00556       if (TY_Is_Pointer(ty) && TY_kind(TY_pointed(ty)) == KIND_ARRAY) {
00557         if (WN_operator(WN_kid0(wn)) == OPR_LDA ||
00558       WN_operator(WN_kid1(wn)) == OPR_LDA) {
00559     TY_IDX base_ty = TY_etype(TY_pointed(ty));
00560     if (TY_kind(base_ty) != KIND_ARRAY) {
00561       ty = Make_Pointer_Type(base_ty);
00562     }
00563         }
00564       }
00565 #if !defined(BUILD_SKIP_WHIRL2C)
00566       /* Also check that the constant expression can be reduced */
00567       if (TY_Is_Pointer(ty) && 
00568     WN_Get_PtrAdd_Intconst(WN_kid0(wn), 
00569                WN_kid1(wn),
00570                TY_pointed(ty)) == NULL)
00571       {
00572          ty = Stab_Mtype_To_Ty(WN_opc_rtype(wn));
00573       }
00574 #endif /* BUILD_WHIRL2C */
00575    }
00576    else
00577       ty = Stab_Mtype_To_Ty(WN_opc_rtype(wn));
00578    break;
00579 
00580       case OPR_INTRINSIC_OP:
00581    if (INTR_is_adrtmp(WN_intrinsic(wn)))
00582    {
00583       if (WN_opcode(WN_kid0(wn)) == OPC_VCALL ||
00584     WN_opcode(WN_kid0(wn)) == OPC_VINTRINSIC_CALL)
00585       {
00586          ty = WN_Tree_Type(WN_kid0(WN_kid0(wn)));
00587       }
00588       else
00589       {
00590          ty = Stab_Pointer_To(WN_Tree_Type(WN_kid0(wn)));
00591       }
00592    }
00593    else if (INTR_is_valtmp(WN_intrinsic(wn)))
00594    {
00595       if (WN_opcode(WN_kid0(wn)) == OPC_VCALL ||
00596     WN_opcode(WN_kid0(wn)) == OPC_VINTRINSIC_CALL)
00597       {
00598          ty = TY_pointed(WN_Tree_Type(WN_kid0(WN_kid0(wn))));
00599       }
00600       else
00601       {
00602          ty = WN_Tree_Type(WN_kid0(wn));
00603       }
00604    }
00605    else
00606    {
00607       ty = WN_intrinsic_return_ty(WN_opcode(wn),
00608                                         (INTRINSIC)WN_intrinsic(wn), wn);
00609    }
00610    break;
00611    
00612       case OPR_CVT:
00613       case OPR_NEG:
00614       case OPR_ABS:
00615       case OPR_SQRT:
00616       case OPR_REALPART:
00617       case OPR_IMAGPART:
00618       case OPR_RND:
00619       case OPR_TRUNC:
00620       case OPR_CEIL:
00621       case OPR_FLOOR:
00622       case OPR_BNOT:
00623       case OPR_LNOT:
00624       case OPR_SUB:
00625       case OPR_MPY:
00626       case OPR_DIV:
00627       case OPR_MOD:
00628       case OPR_REM:
00629       case OPR_MAX:
00630       case OPR_MIN:
00631       case OPR_BAND:
00632       case OPR_BIOR:
00633       case OPR_BXOR:
00634       case OPR_BNOR:
00635       case OPR_LAND:
00636       case OPR_LIOR:
00637       case OPR_CAND:
00638       case OPR_CIOR:
00639       case OPR_SHL:
00640       case OPR_ASHR:
00641       case OPR_LSHR:
00642       case OPR_COMPLEX:
00643       case OPR_RECIP:
00644       case OPR_RSQRT:
00645       case OPR_EQ:
00646       case OPR_NE:
00647       case OPR_GT:
00648       case OPR_GE:
00649       case OPR_LT:
00650       case OPR_LE:
00651       case OPR_CONST:
00652       case OPR_INTCONST:
00653       case OPR_DIVREM:
00654       case OPR_HIGHPART:
00655       case OPR_LOWPART:
00656       case OPR_HIGHMPY:
00657    ty = Stab_Mtype_To_Ty(WN_opc_rtype(wn));
00658    break;
00659 
00660       case OPR_PARM:
00661    ty = WN_Tree_Type(WN_kid0(wn));
00662    break;
00663    
00664       case OPR_COMMA:
00665          ty = WN_Tree_Type(WN_kid1(wn));
00666          break;
00667 
00668       case OPR_RCOMMA:
00669          ty = WN_Tree_Type(WN_kid0(wn));
00670          break;
00671 
00672       case OPR_ALLOCA:
00673          ty = WN_ty(wn);
00674          break;
00675 
00676 #ifdef TARG_X8664
00677       case OPR_REPLICATE:
00678       case OPR_REDUCE_ADD:
00679       case OPR_REDUCE_MPY:
00680       case OPR_REDUCE_MAX:
00681       case OPR_REDUCE_MIN:
00682       case OPR_SHUFFLE:
00683   ty = Stab_Mtype_To_Ty(WN_opc_rtype(wn));
00684   break;
00685 
00686       case OPR_COMPOSE_BITS:
00687   ty = WN_Tree_Type(WN_kid0(wn));
00688   break;
00689 
00690       case OPR_EXTRACT_BITS:
00691   ty = WN_Tree_Type(WN_kid0(wn));
00692   break;
00693 
00694 #endif /* TARG_X8664 */
00695       default:
00696    /* Only the above forms of expression nodes are handled here */
00697    FmtAssert(FALSE, ("unexpected operator %s", OPERATOR_name(WN_operator(wn))));
00698       } /* switch */
00699    } /* else */
00700    
00701    return ty;
00702 } /* WN_Tree_Type */
00703 
00704 
00705 void
00706 Remove_Skips(WN             *ablock,
00707              W2CF_SKIP_ITEM *skip_info,
00708              INT            *next_info_idx,
00709              INT             max_info_idx,
00710              BOOL            clist)
00711 {
00712    /* See also the code in prp_wn_mngr.cxx
00713     */
00714    WN             *parent;
00715    WN             *stmt;
00716    WN_ITER        *iter;
00717    W2CF_SKIP_ITEM *skip;
00718 
00719    Is_True(WN_opcode(ablock) == OPC_BLOCK,
00720      ("expected OPC_BLOCK in Remove_Skips()"));
00721 
00722    for (iter = WN_WALK_StmtIter(ablock);
00723         iter != NULL;
00724         iter = WN_WALK_StmtNext(iter))
00725    {
00726       parent = WN_ITER_wn(iter);
00727       if (WN_opcode(parent) == OPC_BLOCK)
00728       {
00729          /* Remove any statement sequence enclosed by pragmas indicating
00730           * that we should skip the statements in w2c or w2f translation.
00731           */
00732          stmt = WN_first(parent);
00733          while (stmt != NULL)
00734          {
00735             if (WN_opc_operator(stmt) == OPR_PRAGMA &&
00736                 (clist?
00737                  WN_pragma(stmt) == WN_PRAGMA_CLIST_SKIP_BEGIN:
00738                  WN_pragma(stmt) == WN_PRAGMA_FLIST_SKIP_BEGIN))
00739             {
00740                Is_True(*next_info_idx <= max_info_idx,
00741                        ("exceeded max number of skip sequences"));
00742 
00743                /* Get a skipped item info record.
00744                 */
00745                skip = &skip_info[*next_info_idx];
00746                *next_info_idx += 1;
00747 
00748                /* Record this skipped item.
00749                 */
00750                skip->parent = parent;
00751                skip->first = stmt;
00752                while (clist?
00753                       WN_pragma(stmt) != WN_PRAGMA_CLIST_SKIP_END:
00754                       WN_pragma(stmt) != WN_PRAGMA_FLIST_SKIP_END)
00755                {
00756                   stmt = WN_next(stmt);
00757                }
00758                skip->last = stmt;
00759 
00760                /* Remove this skipped sequence of statements
00761                 */
00762                if (WN_prev(skip->first) == NULL)
00763                   WN_first(parent) = WN_next(skip->last);
00764                else
00765                   WN_next(WN_prev(skip->first)) = WN_next(skip->last);
00766 
00767                if (WN_last(parent) == skip->last)
00768                   WN_last(parent) = WN_prev(skip->first);
00769                else
00770                   WN_prev(WN_next(skip->last)) = WN_prev(skip->first);
00771             }
00772             stmt = WN_next(stmt);
00773          } /* if a skip sequence is found */
00774       } /*if a block is found */
00775    } /* for each statement */
00776 } /* Remove_Skips */
00777 
00778 
00779 void
00780 Restore_Skips(const W2CF_SKIP_ITEM *skip_info,
00781               INT                   number_of_items,
00782               BOOL                  clist)
00783 {
00784    WN                   *parent, *prev, *next;
00785    const W2CF_SKIP_ITEM *skipped;
00786 
00787    while (number_of_items > 0)
00788    {
00789       number_of_items--;
00790       skipped = &skip_info[number_of_items];
00791       parent = skipped->parent;
00792 
00793       /* Purple might insert instrumentation between the prev and next
00794        * nodes that used to surround the removed code segment.  We step
00795        * by any such inserted code, thus re-inserting the temporarily
00796        * removed code after the instrumentation.
00797        */
00798       prev = WN_prev(skipped->first);
00799       next = WN_next(skipped->last);
00800       if (prev == NULL && WN_prev(next) != NULL)
00801    prev = WN_first(parent); /* Code inserted at beginning of block */
00802       while (prev != NULL && WN_next(prev) != NULL && prev != WN_prev(next))
00803    prev = WN_next(prev);
00804 
00805       /* Reinsert the temporarily removed code (after instrumentations)
00806        */
00807       if (prev == NULL)
00808          WN_first(parent) = skipped->first;
00809       else
00810          WN_next(prev) = skipped->first;
00811 
00812       if (next == NULL)
00813          WN_last(parent) = skipped->last;
00814       else
00815          WN_prev(next) = skipped->last;
00816    }
00817 } /* Restore_Skips */
00818 
00819 TY_IDX Get_Inner_Array_Type( TY_IDX idx)
00820 {
00821   Is_True(TY_kind(idx) == KIND_ARRAY,("Get_Inner_Array_Type not an array?"));
00822   TY_IDX eidx = TY_etype(idx);
00823   while (TY_kind(eidx) == KIND_ARRAY)
00824     eidx = TY_etype(eidx);
00825 
00826   return eidx;
00827 }
00828