WebSVN - Open64 - Blame - Rev 2694 - /trunk/osprey/be/vho/vho

[/] [trunk/] [osprey/] [be/] [vho/] [vho_lower.cxx] - Blame information for rev 2694

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * Copyright (C) 2009 Advanced Micro Devices, Inc.  All Rights Reserved.
 */
/*
 * Copyright 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
 */
 
/*
 
  Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
 
  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.
 
  This program is distributed in the hope that it would be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
  Further, this software is distributed without any warranty that it is
  free of the rightful claim of any third person regarding infringement
  or the like.  Any license provided herein, whether implied or
  otherwise, applies only to this software file.  Patent licenses, if
  any, provided herein do not apply to combinations of this program with
  other software, or any other product whatsoever.
 
  You should have received a copy of the GNU General Public License along
  with this program; if not, write the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston MA 02111-1307, USA.
 
  Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
  Mountain View, CA 94043, or:
 
  http://www.sgi.com
 
  For further information regarding this notice, see:
 
  http://oss.sgi.com/projects/GenInfo/NoticeExplan
 
*/
 
 
//-*-c++-*-
 
#define __STDC_LIMIT_MACROS
#include <stdint.h>
 
#ifndef FRONT_END
 
#include "defs.h"
#include "config.h"
#include "config_opt.h"
#include "config_debug.h"
#include "mempool.h"
#include "wn.h"
#include "wn_util.h"
#include "opcode.h"
#include <stdlib.h>
#include "flags.h"
#include "pu_info.h"
#include "vho_lower.h"
#include "f90_lower.h"
#include "fb_whirl.h"
#include "wn_simp.h"
#include "topcode.h"
#include "callutil.h"
#include "targ_sim.h"
#include "cxx_template.h"
#include "prompf.h"
#include "wb_f90_lower.h"
#include "wn_lower.h"
#include "be_util.h"            // For Current_PU_Count
#include "glob.h"               // For Show_Progress
#ifdef KEY
#include "w2op.h"   // For OPCODE_Can_Be_Spculative
#endif
#include "config_clist.h"
 
typedef enum {
  ADDRESS_USED,
  ADDRESS_PASSED,
  ADDRESS_SAVED
} ADDRESS_INFO_TYPE;
 
#endif /* FRONT_END */
 
#include "tracing.h"
#include "ir_reader.h"
#include "config_vho.h"
#include "targ_const.h"
#include "erbe.h"
 
#define DO_VHO_LOWERING 1
#define IS_POWER_OF_2(x) (((x)!=0) && ((x) & ((x)-1))==0)
 
#define ST_addr_taken_passed(st)       ST_addr_passed(st)
#define Set_ST_addr_taken_passed(st)   Set_ST_addr_passed(st)
#define Reset_ST_addr_taken_passed(st) Reset_ST_addr_passed(st)
#define ST_addr_taken_saved(st)        ST_addr_saved(st)
#define Set_ST_addr_taken_saved(st)    Set_ST_addr_saved(st)
#define Reset_ST_addr_taken_saved(st)  Reset_ST_addr_saved(st)
 
#pragma set woff 1172
#ifdef KEY
static INT current_pu_id = -1;
static void Misc_Loop_Fusion ( WN * , WN * );
#endif
 
static BOOL
VHO_WN_is_zero ( WN * wn )
{
  return (    (    WN_operator(wn) == OPR_INTCONST
                && WN_const_val(wn) == 0 )
           || (    WN_operator(wn) == OPR_CONST
                && Targ_Is_Zero(STC_val(WN_st(wn))) ) );
} /* VHO_WN_is_zero */
 
 
static BOOL
VHO_WN_has_side_effects ( WN * wn )
{
  INT32    nkids;
  INT32    i;
  OPERATOR wn_operator;
  BOOL     has_side_effects;
 
  wn_operator = WN_operator(wn);
  nkids       = WN_kid_count(wn);
 
  switch ( wn_operator ) {
 
    case OPR_LDID:
 
      has_side_effects = TY_is_volatile(WN_ty(wn));
      break;
 
    case OPR_ILOAD:
 
      has_side_effects =    TY_is_volatile(WN_ty(wn))
                         || VHO_WN_has_side_effects ( WN_kid0(wn) );
      break;
 
    default:
 
      has_side_effects = FALSE;
 
      for ( i = 0; i < nkids; i++ ) {
 
        if ( VHO_WN_has_side_effects ( WN_kid(wn,i) ) ) {
 
          has_side_effects = TRUE;
          break;
        }
      }
      break;
  }
 
  return has_side_effects;
} /* VHO_WN_has_side_effects */
 
 
typedef struct bool_expr_info_t {
  OPCODE opcode;
  BOOL   used_true_label;
  BOOL   used_false_label;
  LABEL_IDX true_label;
  LABEL_IDX false_label;
} BOOL_INFO;
 
static WN * vho_lower ( WN * wn, WN * block );
static WN * vho_lower_stmt ( WN * stmt, WN * block );
static WN * vho_lower_block ( WN * wn );
static WN * vho_lower_expr ( WN * expr, WN * block, BOOL_INFO * bool_info, BOOL is_return=FALSE );
 
/* Table used to promote integers less than 4 bytes into their
 * 4 byte counterparts in order to get the right type for OPCODE_make_op
 */
 
TYPE_ID Promoted_Mtype [MTYPE_LAST + 1] = {
  MTYPE_UNKNOWN,  /* MTYPE_UNKNOWN */
  MTYPE_UNKNOWN,  /* MTYPE_B */
  MTYPE_I4,       /* MTYPE_I1 */
  MTYPE_I4,       /* MTYPE_I2 */
  MTYPE_I4,       /* MTYPE_I4 */
  MTYPE_I8,       /* MTYPE_I8 */
  MTYPE_U4,       /* MTYPE_U1 */
  MTYPE_U4,       /* MTYPE_U2 */
  MTYPE_U4,       /* MTYPE_U4 */
  MTYPE_U8,       /* MTYPE_U8 */
  MTYPE_F4,       /* MTYPE_F4 */
  MTYPE_F8,       /* MTYPE_F8 */
  MTYPE_F10,      /* MTYPE_F10 */
  MTYPE_UNKNOWN,  /* MTYPE_F16 */
  MTYPE_UNKNOWN,  /* MTYPE_STR */
  MTYPE_FQ,       /* MTYPE_FQ */
  MTYPE_M,        /* MTYPE_M */
  MTYPE_C4,       /* MTYPE_C4 */
  MTYPE_C8,       /* MTYPE_C8 */
  MTYPE_CQ,       /* MTYPE_CQ */
  MTYPE_V,         /* MTYPE_V */
#if defined(TARG_IA64)
  MTYPE_UNKNOWN,  /* MTYPE_BS */
  MTYPE_UNKNOWN,  /* MTYPE_A4 */
  MTYPE_UNKNOWN,  /* MTYPE_A8 */
  MTYPE_C10,      /* MTYPE_C10 */
#endif
};
 
#ifdef VHO_DEBUG
static BOOL      VHO_Switch_Debug = TRUE;
static BOOL      VHO_Struct_Debug = TRUE;
static char    * VHO_Switch_Format;
#endif /* VHO_DEBUG */
 
static SRCPOS    VHO_Srcpos;
static BOOL      VHO_SCL_Debug;             // Debug Structure Copy Lowering
static BOOL      VHO_M_Debug_Type_Mismatch;
 
/* Variables related to handling of switch statements */
 
INT32   VHO_Switch_Distance = 128;         /* max distance between values    */
INT32   VHO_Switch_Default_Label_Count = 16;
BOOL    VHO_Give_Preg_Names = FALSE;
 
static const char * vho_lower_mstore_name    = "__lower_mstore";
static const char * vho_lower_cand_cior_name = "__cand_cior";
static const char * vho_lower_cselect_name   = "__cselect";
static const char * vho_lower_rcomma_name    = "__rcomma";
static const char * vho_lower_comma_name     = "__comma";
 
static TY_IDX vho_u4a1_ty_idx = (TY_IDX) 0;
static TY_IDX vho_u8a1_ty_idx = (TY_IDX) 0;
 
typedef struct switch_case_table_entry_t {
  WN    * wn;
  INT32   count;
  FB_FREQ freq;
} VHO_SWITCH_ITEM;
 
static VHO_SWITCH_ITEM * VHO_Switch_Case_Table; /* table for switch cases    */
 
#define VHO_SWITCH_wn(i)    (VHO_Switch_Case_Table[i].wn)
#define VHO_SWITCH_count(i) (VHO_Switch_Case_Table[i].count)
#define VHO_SWITCH_freq(i)  (VHO_Switch_Case_Table[i].freq)
 
static BOOL      VHO_Switch_Signed;        /* signedness of switch index     */
static OPCODE    VHO_Switch_Int_Opcode;    /* opcode for Create_Int          */
static OPCODE    VHO_Switch_Sub_Opcode;    /* opcode for subtract            */
static OPCODE    VHO_Switch_EQ_Opcode;     /* opcode for == comparison       */
static OPCODE    VHO_Switch_LT_Opcode;     /* opcode for <  comparison       */
static OPCODE    VHO_Switch_GT_Opcode;     /* opcode for >  comparison       */
 
static LABEL_IDX VHO_Switch_Default_Label; /* default label in switch        */
static INT32     VHO_Switch_Last_Label;    /* last label in switch           */
static INT32   * VHO_Switch_Cluster_Table; /* table for switch clusters      */
static INT32     VHO_Switch_Ncases;        /* # of cases in switch           */
static INT32     VHO_Switch_Nclusters;     /* # of clusters in switch        */
static WN      * VHO_Switch_Index;         /* load of switch index           */
static WN      * VHO_Switch_Default_Goto;  /* goto switch default label      */
static WN      * VHO_Switch_Stmt;          /* switch statement               */
static FB_FREQ   VHO_Switch_Default_Freq;  /* goto switch default freq       */
 
#ifdef KEY
static BOOL VHO_In_MP_Region_Pragma = FALSE;
#endif // KEY
 
/* Variables related to struct lowering */
 
#if defined(TARG_X8664) || defined(TARG_IA64)
INT32  VHO_Struct_Limit = 8;               /* max # of fields/statements     */
#elif defined(TARG_NVISA)
INT32  VHO_Struct_Limit = 24;              /* max # of fields/statements     */
#else
INT32  VHO_Struct_Limit = 4;               /* max # of fields/statements     */
#endif
 
// static INT32  VHO_Struct_Alignment;      /* Alignment of struct           */
static BOOL   VHO_Struct_Can_Be_Lowered;    /* FALSE if cannot be lowered    */
static INT32  VHO_Struct_Nfields;           /* # of fields                   */
static TY_IDX VHO_Struct_Fld_Table [255]; /* table containing fields         */
static INT32 VHO_Struct_Offset_Table [255]; /* table containing fields offset */
// We want to use field_ids when possible,
// as that gives higher-level type info about the original struct
// (e.g. if want to know alignment of original struct).
// However, fields that are arrays have a single field id,
// but may span multiple elements, so use element types in that case.
static INT32 VHO_Struct_Field_Id_Table[255]; /* table containing field ids   */
static BOOL VHO_Struct_Field_Is_Array_Table[255]; /* field is array? */
static INT32  VHO_Struct_Last_Field_Offset; /* offset of last field          */
static INT32  VHO_Struct_Last_Field_Size;   /* size of last field            */
 
#define LESS    -1
#define EQUAL    0
#define GREATER  1
 
#define SWITCH_key(i)  (VHO_Switch_Signed ? WN_const_val(VHO_SWITCH_wn(i)) : (UINT64) WN_const_val(VHO_SWITCH_wn(i)))
 
INT32
VHO_Switch_Compare_Value ( const void *v_item1, const void *v_item2 )
{
  INT32   compare_code;
  WN    * case1;
  WN    * case2;
 
  case1 = (( VHO_SWITCH_ITEM * ) v_item1)->wn;
  case2 = (( VHO_SWITCH_ITEM * ) v_item2)->wn;
 
  if ( VHO_Switch_Signed ) {
 
    if ( WN_const_val(case1) < WN_const_val(case2) )
      compare_code = LESS;
 
    else
    if ( WN_const_val(case1) > WN_const_val(case2) )
      compare_code = GREATER;
 
    else
      compare_code = EQUAL;
  }
  else {
 
    if ( (UINT64) WN_const_val(case1) < (UINT64) WN_const_val(case2) )
      compare_code = LESS;
 
    else
    if ( (UINT64) WN_const_val(case1) > (UINT64) WN_const_val(case2) )
      compare_code = GREATER;
 
    else
      compare_code = EQUAL;
  }
 
  return ( compare_code );
} /* VHO_Switch_Compare_Value */
 
 
/* ============================================================================
 *
 * INT32
 * VHO_Switch_Compare_Frequency ( const void *v_item1, const void *v_item2 )
 *
 * Routine invoked by qsort to compare two case values frequencies specified
 * the switch statement.
 *
 * ============================================================================
 */
 
INT32
VHO_Switch_Compare_Frequency ( const void *v_item1, const void *v_item2 )
{
  INT32   compare_code;
  WN    * case1;
  WN    * case2;
  FB_FREQ freq1;
  FB_FREQ freq2;
 
  case1  = (( VHO_SWITCH_ITEM * ) v_item1)->wn;
  case2  = (( VHO_SWITCH_ITEM * ) v_item2)->wn;
  freq1  = (( VHO_SWITCH_ITEM * ) v_item1)->freq;
  freq2  = (( VHO_SWITCH_ITEM * ) v_item2)->freq;
 
  if ( freq1 != freq2 ) {
 
    // Order of _decreasing_ frequencies
 
    if ( freq1 > freq2 )
      compare_code = LESS;
 
    else // freq1 < freq2
      compare_code = GREATER;
 
  } else
  if ( VHO_Switch_Signed ) {
 
    if ( WN_const_val(case1) < WN_const_val(case2) )
      compare_code = LESS;
 
    else
    if ( WN_const_val(case1) > WN_const_val(case2) )
      compare_code = GREATER;
 
    else
      compare_code = EQUAL;
  }
 
  else {
 
    if ( (UINT64) WN_const_val(case1) < (UINT64) WN_const_val(case2) )
      compare_code = LESS;
 
    else
    if ( (UINT64) WN_const_val(case1) > (UINT64) WN_const_val(case2) )
      compare_code = GREATER;
 
    else
      compare_code = EQUAL;
  }
 
  return ( compare_code );
} /* VHO_Switch_Compare_Frequency */
 
#ifdef KEY
/* ============================================================================
 *
 * static WN *
 * VHO_Switch_Generate_If_Else_Reduce_Branch ( SRCPOS srcpos )
 *
 * Generate if-else sequence for the switch statement by grouping consecutive
 * cases together and using a single branch for each group.
 *
 * ============================================================================
 */
static WN *
VHO_Switch_Generate_If_Else_Reduce_Branch (SRCPOS srcpos)
{
  WN *block, *case_goto, *wn;
  INT32 i, j;
  INT32 switch_first_label;
  INT32 highest_label_num, lowest_label_num;
  WN **labels_map;
 
  block = WN_CreateBlock();
  WN_Set_Linenum(block, srcpos);
 
  // Find the highest and lowest case label numbers.
  highest_label_num = 0;
  lowest_label_num = INT32_MAX;
  for (i = 0; i < VHO_Switch_Ncases; i++) {
    case_goto = VHO_SWITCH_wn(i);
    INT64 value = WN_label_number(case_goto);
    if (value > highest_label_num)
      highest_label_num = value;
    if (value < lowest_label_num)
      lowest_label_num = value;
  }
 
  // Create case labels map.
  INT32 size = (highest_label_num - lowest_label_num + 1) * sizeof(WN *);
  labels_map = (WN **) alloca(size);
  memset(labels_map, 0, size);
 
  // Map each case label to the first label in the case code.  A case code will
  // have multiple labels if it is shared by different case values.
  WN *first_label_in_group = (WN *) NULL;
  for (wn = WN_next(VHO_Switch_Stmt); ; wn = WN_next(wn)) {
    if (WN_operator(wn) == OPR_LABEL) {
      if (first_label_in_group == NULL)
  first_label_in_group = wn;
      // Map only the labels in the switch stmt.
      if (WN_label_number(wn) >= lowest_label_num &&
    WN_label_number(wn) <= highest_label_num) {
  labels_map[WN_label_number(wn)] = first_label_in_group;
      }
      if (WN_label_number(wn) == VHO_Switch_Last_Label)
  break;
    } else {
      // Real code terminates the labels group.
      first_label_in_group = NULL;
    }
  }
 
  // Sort the case values.
  qsort(VHO_Switch_Case_Table, VHO_Switch_Ncases,
  sizeof(VHO_SWITCH_ITEM), VHO_Switch_Compare_Value);
 
  for (i = 0; i < VHO_Switch_Ncases; i++) {
    WN *test, *sub, *tas;
    case_goto = VHO_SWITCH_wn(i);
    INT64 first_value = WN_const_val(case_goto);
    INT64 last_value = first_value;
 
    // Detect consecutive case values sharing common case code.
    for (j = i + 1; j < VHO_Switch_Ncases; j++) {
      WN *next_case_goto = VHO_SWITCH_wn(j);
      INT64 next_value = WN_const_val(next_case_goto);
      if (next_value != last_value + 1 ||
    (labels_map[WN_label_number(next_case_goto)] !=
     labels_map[WN_label_number(case_goto)]))
  break;
      last_value = next_value;
    }
 
    if (first_value == last_value) {
      // No consecutive case values.
      test = WN_CreateExp2(VHO_Switch_EQ_Opcode,
         WN_COPY_Tree(VHO_Switch_Index),
         WN_CreateIntconst(VHO_Switch_Int_Opcode,
               first_value));
      wn = WN_CreateTruebr(WN_label_number(case_goto), test);
      WN_Set_Linenum(wn, srcpos);
    } else {
      // Consecutive case values sharing common case code.  Translate:
      //
      //   case k:
      //   case k+1:
      //    ...
      //   case k+n:  goto label
      //
      // into:
      //
      //   if ((unsigned int)(index - k) <= n)
      //     goto label
      //
      // If index is less than k, then (unsigned int)(index - k) will be
      // a large unsigned int larger than n.
 
      WN *upper =
  WN_CreateIntconst(VHO_Switch_Int_Opcode, last_value - first_value);
      TYPE_ID mtype = WN_rtype(VHO_Switch_Index);
      sub = WN_CreateExp2(VHO_Switch_Sub_Opcode,
        WN_COPY_Tree(VHO_Switch_Index),
        WN_CreateIntconst(VHO_Switch_Int_Opcode,
              first_value));
      tas = WN_Tas(MTYPE_U4, MTYPE_To_TY(MTYPE_U4), sub);
      test = WN_CreateExp2(OPCODE_make_op(OPR_LE, MTYPE_U4, MTYPE_U4),
         tas, upper);
      wn = WN_CreateTruebr(WN_label_number(case_goto), test);
      WN_Set_Linenum(wn, srcpos);
      i = j - 1;    // Skip to the next case value.
    }
    WN_INSERT_BlockAfter(block, WN_last(block), wn);
  }
 
  WN_INSERT_BlockAfter(block, WN_last(block),
                       WN_COPY_Tree(VHO_Switch_Default_Goto));
  return block;
}
#endif
 
/* ============================================================================
 *
 * static WN *
 * VHO_Switch_Generate_If_Else ( SRCPOS srcpos )
 *
 * Generate if-else sequence for the switch statement.
 *
 * ============================================================================
 */
 
static WN *
VHO_Switch_Generate_If_Else ( SRCPOS srcpos )
{
  WN     * block;
  WN     * value;
  WN     * test;
  WN     * case_goto;
  WN     * wn;
  INT32    i;
  FB_FREQ  freq_rest;
 
  block = WN_CreateBlock();
  WN_Set_Linenum ( block, srcpos );
 
  if ( Cur_PU_Feedback ) {
 
    qsort ( VHO_Switch_Case_Table, VHO_Switch_Ncases,
            sizeof(VHO_SWITCH_ITEM), VHO_Switch_Compare_Frequency );
 
    freq_rest = VHO_Switch_Default_Freq;
    for ( i = 0; i < VHO_Switch_Ncases; i++ ) {
      freq_rest += VHO_SWITCH_freq(i);
    }
 
  }
 
  for ( i = 0; i < VHO_Switch_Ncases; i++ ) {
 
    case_goto = VHO_SWITCH_wn(i);
    value     = WN_CreateIntconst ( VHO_Switch_Int_Opcode,
                                    WN_const_val(case_goto) );
    test      = WN_CreateExp2 ( VHO_Switch_EQ_Opcode,
                                WN_COPY_Tree ( VHO_Switch_Index ), value );
    wn        = WN_CreateTruebr ( WN_label_number(case_goto), test );
    WN_Set_Linenum ( wn, srcpos );
 
    if ( Cur_PU_Feedback ) {
      freq_rest -= VHO_SWITCH_freq(i);
      Cur_PU_Feedback->Annot( wn, FB_EDGE_BRANCH_TAKEN, VHO_SWITCH_freq(i) );
      Cur_PU_Feedback->Annot( wn, FB_EDGE_BRANCH_NOT_TAKEN, freq_rest );
    }
 
    WN_INSERT_BlockAfter ( block, WN_last(block), wn );
  }
  if ( Cur_PU_Feedback && (VHO_Switch_Ncases > 0))
    Cur_PU_Feedback->Annot( wn, FB_EDGE_BRANCH_NOT_TAKEN,
          VHO_Switch_Default_Freq );
 
  WN_INSERT_BlockAfter ( block, WN_last(block),
                         WN_COPY_Tree ( VHO_Switch_Default_Goto ) );
 
  return ( block );
} /* VHO_Switch_Generate_If_Else */
/* ============================================================================
 *
 * static WN *
 * VHO_Switch_Opt_Case_Hoist ( SRCPOS srcpos )
 *
 * Generate if-else sequence for the highly biased cases.
 * ============================================================================
 */
static WN *
VHO_Switch_Opt_Case_Hoist( SRCPOS srcpos )
{
  WN     * block;
  WN     * value;
  WN     * test;
  WN     * case_goto;
  WN     * wn;
  INT32    i;
  FB_FREQ  freq_total, freq_rest, freq_top;
  FB_FREQ  freq_tops; // record only top 30 cases of frequencies
  INT32    num_hoist=0;
 
  if (!Cur_PU_Feedback ) return NULL;  // no switch optimization if no feedback
 
#ifdef KEY
  freq_tops = freq_total = 0.0;
#else
  freq_tops = freq_total = 0;
#endif
 
  block = WN_CreateBlock();
  WN_Set_Linenum ( block, srcpos );
 
  if ( Cur_PU_Feedback ) {
    qsort ( VHO_Switch_Case_Table, VHO_Switch_Ncases,
            sizeof(VHO_SWITCH_ITEM), VHO_Switch_Compare_Frequency );
 
    freq_total = VHO_Switch_Default_Freq;
    for ( i = 0; i < VHO_Switch_Ncases; i++ ) {
      freq_total += VHO_SWITCH_freq(i);
 
      if (i < VHO_Switch_Ncases * 0.3) // top 30 % of cases
          freq_tops += VHO_SWITCH_freq(i);
    }
  }
  /* If lower than 70%, don't do switch optimization */
  if (freq_total.Value()<=0 || freq_tops.Value()/freq_total.Value() < 0.70)
      return NULL;
 
 
  freq_rest = freq_total;
 
  for ( i = 0; i < VHO_Switch_Ncases; i++ ) {
 
    if ( Cur_PU_Feedback &&  VHO_SWITCH_freq(i).Value()/freq_total.Value()
                              < (float) VHO_Switch_Opt_Threshold/100)
                break;
#ifdef VHO_DEBUG
    if ( VHO_Switch_Debug )
      fprintf ( TFile, "SWITCH_OPT_CASE_HOIST: %d (case %d of freq %f)\n", (INT32) srcpos, i, VHO_SWITCH_freq(i).Value() );
#endif /* VHO_DEBUG */
 
//    printf("WARNING: SWITCH_OPT_CASE_HOIST: %d (case %d of freq %f total:%f)\n",(INT32) srcpos, i, VHO_SWITCH_freq(i).Value(), freq_total.Value());
 
    num_hoist++;
    case_goto = VHO_SWITCH_wn(i);
    value     = WN_CreateIntconst ( VHO_Switch_Int_Opcode,
                                    WN_const_val(case_goto) );
    test      = WN_CreateExp2 ( VHO_Switch_EQ_Opcode,
                                WN_COPY_Tree ( VHO_Switch_Index ), value );
    wn = WN_CreateTruebr ( WN_label_number(case_goto), test );
 
    WN_Set_Linenum ( wn, srcpos );
 
 
    if ( Cur_PU_Feedback ) {
      freq_rest -= VHO_SWITCH_freq(i);
      Cur_PU_Feedback->Annot_branch( wn, FB_Info_Branch( VHO_SWITCH_freq(i),
                        freq_rest, WN_operator( wn ) ) );
      Cur_PU_Feedback->FB_hoist_case(VHO_Switch_Stmt, i);
#ifdef KEY
      VHO_SWITCH_freq(i) = 0.0;
#else
      VHO_SWITCH_freq(i) = 0;
#endif
     }
 
    WN_INSERT_BlockAfter ( block, WN_last(block), wn );
  }
 
  /* Remove all the cases that are hoisted */
  for ( i = 0; i < VHO_Switch_Ncases; i++ ) {
        VHO_SWITCH_wn(i) = VHO_SWITCH_wn(i + num_hoist);
        VHO_SWITCH_freq(i) = VHO_SWITCH_freq(i + num_hoist);
        VHO_SWITCH_count(i) = VHO_SWITCH_count(i+num_hoist);
 
  }
  VHO_Switch_Ncases = VHO_Switch_Ncases - num_hoist;
  VHO_SWITCH_wn(VHO_Switch_Ncases) = VHO_SWITCH_wn(VHO_Switch_Ncases - 1);
 
  return ( block );
 
} /* VHO_Switch_Opt_Case_Hoist */
 
 
/* ============================================================================
 *
 * static WN *
 * VHO_Switch_Generate_Compgoto ( SRCPOS srcpos )
 *
 * Generate a COMPGOTO for the switch statement.
 *
 * ============================================================================
 */
 
static WN *
VHO_Switch_Generate_Compgoto ( SRCPOS srcpos )
{
  WN      * block;
  WN      * test;
  WN      * value;
  WN      * wn;
  WN      * case_goto;
  INT32     i;
  INT32     j;
  INT32     n;
  INT64     case_value;
  INT64     curr_value;
  FB_FREQ * freq_new = NULL;
 
  block = WN_CreateBlock ();
  WN_Set_Linenum ( block, srcpos );
 
  case_goto  = VHO_SWITCH_wn(0);
  case_value = WN_const_val(case_goto);
  curr_value = 0;
  test       = WN_COPY_Tree ( VHO_Switch_Index );
 
  /* Check to see whether we can avoid generating a subtract. */
 
  if (     case_value
       && (UINT64)case_value > VHO_Switch_Compgoto_Limit ) {
 
    value      = WN_CreateIntconst ( VHO_Switch_Int_Opcode,
                                     WN_const_val(case_goto) );
    test       = WN_CreateExp2 ( VHO_Switch_Sub_Opcode, test, value );
    curr_value = case_value;
  }
 
  i = 0;
  n =   WN_const_val(VHO_SWITCH_wn(VHO_Switch_Ncases - 1))
      - curr_value + 1;
 
  if ( Cur_PU_Feedback )
    freq_new = TYPE_MEM_POOL_ALLOC_N( FB_FREQ, MEM_local_pool_ptr, n );
 
  for ( j = 0; j < n; j++ ) {
 
    if ( curr_value != case_value ) {
      wn = WN_COPY_Tree ( VHO_Switch_Default_Goto );
      if ( Cur_PU_Feedback )
//      freq_new[j] = FB_FREQ_UNKNOWN;
        freq_new[j] = FB_FREQ(FB_FREQ_TYPE_GUESS);  //INLINING_TUNINING
 
    } else {
 
      wn = WN_CreateGoto ( (ST_IDX) NULL, WN_label_number(case_goto) );
      if ( Cur_PU_Feedback )
  freq_new[j] = VHO_SWITCH_freq(i);
      i++;
      case_goto   = VHO_SWITCH_wn(i);
      case_value  = WN_const_val(case_goto);
    }
 
    WN_Set_Linenum ( wn, srcpos );
 
    WN_INSERT_BlockAfter ( block, WN_last(block), wn );
    curr_value++;
  }
 
  wn = WN_CreateCompgoto ( n, test, block, VHO_Switch_Default_Goto,
                           VHO_Switch_Last_Label );
 
  if ( Cur_PU_Feedback ) {
 
    FB_Info_Switch info_switch( n );
    info_switch[ FB_EDGE_SWITCH_INDEX( FB_EDGE_SWITCH_DEFAULT ) ]
//      = FB_FREQ_UNKNOWN; // not VHO_Switch_Default_Freq
        = FB_FREQ(VHO_Switch_Default_Freq.Value(), FALSE);//INLINING_TUNINING
    for ( j = 0; j < n; j++ )
      info_switch[ FB_EDGE_SWITCH_INDEX( FB_EDGE_SWITCH( j ) ) ] = freq_new[j];
    Cur_PU_Feedback->Annot_switch( wn, info_switch );
 
    MEM_POOL_FREE( MEM_local_pool_ptr, freq_new );
  }
 
  return wn;
} /* VHO_Switch_Generate_Compgoto */
 
 
/* ============================================================================
 *
 * static void
 * VHO_Switch_Generate_Binary_Search ( INT32 left, INT32 right, WN * block )
 *
 * Implement the switch statement as a binary search.
 * left and right give the indices in VHO_Switch_Case_Table which
 * contain the values to be compared with.
 * block contains the WHIRL block node to which statements are to be added.
 *
 * ============================================================================
 */
 
static void
VHO_Switch_Generate_Binary_Search ( INT32 left, INT32 right, WN * block )
{
  INT32    mid;
  INT64    value;
  WN     * test;
  WN     * wn;
  SRCPOS   srcpos;
 
  LABEL_IDX lt_label;
  LABEL_IDX gt_label;
 
  srcpos = WN_Get_Linenum(block);
 
  mid   = ( left + right + 1 ) >> 1;
  value = WN_const_val(VHO_SWITCH_wn(mid));
 
 
  if (mid > left)
    LABEL_Init (New_LABEL (CURRENT_SYMTAB, lt_label), 0, LKIND_DEFAULT);
  else
    lt_label = VHO_Switch_Default_Label;
 
  if (mid < right)
    LABEL_Init (New_LABEL (CURRENT_SYMTAB, gt_label), 0, LKIND_DEFAULT);
  else
    gt_label = VHO_Switch_Default_Label;
 
  if ( lt_label == gt_label ) {
 
    test = WN_CreateExp2 ( VHO_Switch_EQ_Opcode,
                           WN_COPY_Tree ( VHO_Switch_Index ),
                           WN_CreateIntconst ( VHO_Switch_Int_Opcode,
                                               value ) );
    wn = WN_CreateFalsebr ( lt_label, test );
    WN_Set_Linenum ( wn, srcpos );
    if ( Cur_PU_Feedback ) {
      Cur_PU_Feedback->Annot( wn, FB_EDGE_BRANCH_TAKEN, FB_FREQ_UNKNOWN );
      Cur_PU_Feedback->Annot( wn, FB_EDGE_BRANCH_NOT_TAKEN,
            VHO_SWITCH_freq( mid ) );
    }
 
    WN_INSERT_BlockAfter ( block, WN_last(block), wn );
  }
 
  else {
 
    test = WN_CreateExp2 ( VHO_Switch_LT_Opcode,
                           WN_COPY_Tree ( VHO_Switch_Index ),
                           WN_CreateIntconst ( VHO_Switch_Int_Opcode,
                                               value ) );
    wn = WN_CreateTruebr ( lt_label, test );
    WN_Set_Linenum ( wn, srcpos );
    if ( Cur_PU_Feedback ) {
      Cur_PU_Feedback->Annot( wn, FB_EDGE_BRANCH_TAKEN, FB_FREQ_UNKNOWN );
      Cur_PU_Feedback->Annot( wn, FB_EDGE_BRANCH_NOT_TAKEN,
            FB_FREQ_UNKNOWN );
    }
 
    WN_INSERT_BlockAfter ( block, WN_last(block), wn );
 
    test = WN_CreateExp2 ( VHO_Switch_GT_Opcode,
                           WN_COPY_Tree ( VHO_Switch_Index ),
                           WN_CreateIntconst ( VHO_Switch_Int_Opcode,
                                               value ) );
    wn = WN_CreateTruebr ( gt_label, test );
    WN_Set_Linenum ( wn, srcpos );
    if ( Cur_PU_Feedback ) {
      Cur_PU_Feedback->Annot( wn, FB_EDGE_BRANCH_TAKEN, FB_FREQ_UNKNOWN );
      Cur_PU_Feedback->Annot( wn, FB_EDGE_BRANCH_NOT_TAKEN,
            VHO_SWITCH_freq( mid ) );
    }
 
    WN_INSERT_BlockAfter ( block, WN_last(block), wn );
  }
 
  wn = WN_CreateGoto ( (ST_IDX) NULL, WN_label_number(VHO_SWITCH_wn(mid)) );
  WN_Set_Linenum ( wn, srcpos );
  if ( Cur_PU_Feedback )
    Cur_PU_Feedback->Annot( wn, FB_EDGE_OUTGOING, VHO_SWITCH_freq( mid ) );
 
  WN_INSERT_BlockAfter ( block, WN_last(block), wn );
 
  if ( mid > left ) {
 
    wn = WN_CreateLabel ( (ST_IDX) 0, lt_label, 0, NULL );
    WN_Set_Linenum ( wn, srcpos );
 
    WN_INSERT_BlockAfter ( block, WN_last(block), wn );
    VHO_Switch_Generate_Binary_Search ( left, mid - 1, block );
  }
 
  if ( mid < right ) {
 
    wn = WN_CreateLabel ( (ST_IDX) 0, gt_label, 0, NULL );
    WN_Set_Linenum ( wn, srcpos );
 
    WN_INSERT_BlockAfter ( block, WN_last(block), wn );
    VHO_Switch_Generate_Binary_Search ( mid + 1, right, block );
  }
} /* VHO_Switch_Generate_Binary_Search */
 
/* ============================================================================
 *
 * static void
 * VHO_Switch_Find_Clusters ( void )
 *
 * Group the switch values into clusters.
 * For each cluster a COMPGOTO cna be generated.
 *
 * ============================================================================
 */
 
static void
VHO_Switch_Find_Clusters ( void )
{
  INT32   i;
  INT32   j;
  INT32   k;
  INT32   n;
 
  qsort ( VHO_Switch_Case_Table, VHO_Switch_Ncases,
          sizeof(VHO_SWITCH_ITEM), VHO_Switch_Compare_Value );
 
#ifdef VHO_DEBUG
  if ( VHO_Switch_Debug ) {
 
    fprintf ( TFile, "SWITCH TABLE after sorting\n" );
 
    for ( i = 0; i < VHO_Switch_Ncases; i++ ) {
 
      case_goto = VHO_SWITCH_wn(i);
      fprintf ( TFile, VHO_Switch_Format, i,
                WN_const_val(case_goto), WN_label_number(case_goto) );
    }
  }
#endif /* VHO_DEBUG */
 
  j = 0;
  VHO_Switch_Cluster_Table [0] = 0;
 
  for ( i = 1; i < VHO_Switch_Ncases; i++ ) {
 
    if (    ( i - VHO_Switch_Cluster_Table [j] ) * VHO_Switch_Density
         >= SWITCH_key(i) - SWITCH_key(VHO_Switch_Cluster_Table[j]) ) {
 
      if (j > 0) {
 
        if (    ( i - VHO_Switch_Cluster_Table [j-1] ) * VHO_Switch_Density
             >= SWITCH_key(i) - SWITCH_key(VHO_Switch_Cluster_Table[j-1]) )
          j--;
      }
    }
 
    else
      VHO_Switch_Cluster_Table [++j] = i;
  }
 
  VHO_Switch_Cluster_Table [++j] = VHO_Switch_Ncases;
 
  VHO_Switch_Nclusters = 0;
 
  for ( i = 0; i < j; i++ ) {
 
    if (   VHO_Switch_Cluster_Table [i+1] - VHO_Switch_Cluster_Table [i]
         > VHO_Switch_If_Else_Limit )
      VHO_Switch_Nclusters++;
 
    else
      VHO_Switch_Nclusters +=
        VHO_Switch_Cluster_Table [i+1] - VHO_Switch_Cluster_Table [i];
  }
 
  if ( VHO_Switch_Nclusters > j ) {
 
    i = VHO_Switch_Nclusters;
 
    while ( j > 0 ) {
 
      n = VHO_Switch_Cluster_Table [j] - VHO_Switch_Cluster_Table [j-1];
 
      if ( n > VHO_Switch_If_Else_Limit )
        VHO_Switch_Cluster_Table [i--] = VHO_Switch_Cluster_Table [j];
 
      else {
 
        for ( k = 0; k < n; k++ )
          VHO_Switch_Cluster_Table [i--] = VHO_Switch_Cluster_Table [j] - k;
 
        if ( i < j )
          break;
      }
 
      --j;
    }
  }
 
#ifdef VHO_DEBUG
  if ( VHO_Switch_Debug ) {
 
    fprintf (TFile, "  VHO_Switch_Nclusters = %d\n", VHO_Switch_Nclusters);
 
    for ( i = 0; i <= VHO_Switch_Nclusters; i++ )
      fprintf (TFile, "  VHO_Switch_Cluster_Table [%2d] = %2d\n",
               i, VHO_Switch_Cluster_Table [i]);
  }
#endif /* VHO_DEBUG */
} /* VHO_Switch_Find_Clusters */
 
/* ============================================================================
 *
 * static WN *
 * VHO_Lower_Switch ( WN * wn )
 *
 * Lower a switch statement into a combination of
 *
 *   if-else
 *   COMPGOTO
 *   binary search.
 *
 * ============================================================================
 */
 
static WN *
VHO_Lower_Switch ( WN * wn )
{
  WN       * block;
  WN       * case_goto;
  TYPE_ID    mtype;
  INT32      i;
  INT32      j;
  SRCPOS     srcpos;
  INT32      count;
  WN       * conv_wn = NULL;
 
  LABEL_IDX  last_label;
 
  srcpos = WN_Get_Linenum(wn);
  block  = WN_kid1(wn);
 
  VHO_Switch_Stmt         = wn;
  VHO_Switch_Index        = WN_kid0(wn);
  VHO_Switch_Default_Goto = ( WN_kid_count(wn) == 3 ) ? WN_kid2(wn) : NULL;
  VHO_Switch_Last_Label   = WN_last_label(wn);
 
  mtype = WN_rtype (VHO_Switch_Index);
 
  VHO_Switch_Int_Opcode = OPCODE_make_op ( OPR_INTCONST,
                                           Promoted_Mtype [mtype],
                                           MTYPE_V );
  VHO_Switch_Sub_Opcode = OPCODE_make_op ( OPR_SUB,
                                           Promoted_Mtype [mtype],
                                           MTYPE_V );
  VHO_Switch_EQ_Opcode  = OPCODE_make_op ( OPR_EQ,
                                           MTYPE_I4,
                                           Promoted_Mtype [mtype] );
  VHO_Switch_LT_Opcode  = OPCODE_make_op ( OPR_LT,
                                           MTYPE_I4,
                                           Promoted_Mtype [mtype] );
  VHO_Switch_GT_Opcode  = OPCODE_make_op ( OPR_GT,
                                           MTYPE_I4,
                                           Promoted_Mtype [mtype] );
 
#ifdef VHO_DEBUG
  if ( VHO_Switch_Debug )
    fprintf ( TFile, "SWITCH TABLE before sorting\n" );
#endif /* VHO_DEBUG */
 
  switch ( mtype ) {
 
  case MTYPE_I1:
  case MTYPE_I2:
  case MTYPE_I4:
  case MTYPE_I8:
 
#ifdef VHO_DEBUG
    VHO_Switch_Format = "  [%2d] value = %lld, label = %d\n";
#endif /* VHO_DEBUG */
 
    VHO_Switch_Signed = TRUE;
    break;
 
  case MTYPE_U1:
  case MTYPE_U2:
  case MTYPE_U4:
  case MTYPE_U8:
 
#ifdef VHO_DEBUG
    VHO_Switch_Format = "  [%2d] value = %llu, label = %d\n";
#endif /* VHO_DEBUG */
 
    VHO_Switch_Signed = FALSE;
    break;
  }
 
  for ( VHO_Switch_Ncases = 0, case_goto = WN_first(block);
        case_goto;
        VHO_Switch_Ncases++, case_goto = WN_next(case_goto) ) {
 
#ifdef VHO_DEBUG
    if ( VHO_Switch_Debug )
      fprintf ( TFile, VHO_Switch_Format, VHO_Switch_Ncases,
    WN_const_val(case_goto), WN_label_number(case_goto) );
#endif /* VHO_DEBUG */
 
  }
 
  if ( Cur_PU_Feedback ) {
    VHO_Switch_Default_Freq
      = ( VHO_Switch_Default_Goto
    ? Cur_PU_Feedback->Query( wn, FB_EDGE_SWITCH_DEFAULT )
    : FB_FREQ_ZERO );
  }
 
  VHO_Switch_Case_Table =
    TYPE_MEM_POOL_ALLOC_N(VHO_SWITCH_ITEM,
                          MEM_local_pool_ptr, (VHO_Switch_Ncases+1));
  VHO_Switch_Cluster_Table =
    TYPE_MEM_POOL_ALLOC_N(INT32, MEM_local_pool_ptr, (VHO_Switch_Ncases+1));
 
  last_label = INT32_MIN;
 
  for ( i = 0, case_goto = WN_first(block);
        i < VHO_Switch_Ncases;
        i++, case_goto = WN_next(case_goto) ) {
 
    VHO_SWITCH_wn(i) = case_goto;
    if ( Cur_PU_Feedback )
      VHO_SWITCH_freq(i) = Cur_PU_Feedback->Query( wn, FB_EDGE_SWITCH( i ) );
 
    if ( WN_label_number(case_goto) == last_label )
      count++;
 
    else {
 
      for ( j = i - 1; j >= 0; --j ) {
 
        if ( last_label == WN_label_number(VHO_SWITCH_wn(j)) )
          VHO_SWITCH_count(j) = count;
 
        else
          break;
      }
 
      count = 1;
      last_label = WN_label_number(case_goto);
    }
  }
 
  for ( j = i - 1; j >= 0; --j ) {
 
    if ( last_label == WN_label_number(VHO_SWITCH_wn(j)) )
      VHO_SWITCH_count(j) = count;
 
    else
      break;
  }
 
  VHO_SWITCH_wn(VHO_Switch_Ncases) = VHO_SWITCH_wn(VHO_Switch_Ncases - 1);
 
  for ( i = 0; i < VHO_Switch_Ncases; i++ ) {
 
    case_goto = VHO_SWITCH_wn(i);
  }
 
  if ( VHO_Switch_Ncases <= VHO_Switch_If_Else_Limit ) {
 
#ifdef VHO_DEBUG
    if ( VHO_Switch_Debug )
      fprintf ( TFile, "SWITCH_If_Else %d\n", (INT32) srcpos );
#endif /* VHO_DEBUG */
 
#ifdef KEY
    if ( !Cur_PU_Feedback &&
         VHO_Switch_Reduce_Branch) {
      wn = VHO_Switch_Generate_If_Else_Reduce_Branch(srcpos);
    } else
#endif
    wn = VHO_Switch_Generate_If_Else ( srcpos );
  }
 
  else {
   if (VHO_Switch_Opt)
       conv_wn = VHO_Switch_Opt_Case_Hoist ( srcpos );
 
#ifdef VHO_DEBUG
   if ( VHO_Switch_Debug )
       fprintf ( TFile, "SWITCH_OPT %d\n", (INT32) srcpos );
#endif /* VHO_DEBUG */
 
    VHO_Switch_Find_Clusters ();
 
    if ( VHO_Switch_Nclusters == 1 ) {
 
#ifdef VHO_DEBUG
      if ( VHO_Switch_Debug )
        fprintf ( TFile, "SWITCH_Compgoto %d\n", (INT32) srcpos );
#endif /* VHO_DEBUG */
 
      wn = VHO_Switch_Generate_Compgoto ( srcpos );
    }
 
    else {
 
#ifdef VHO_DEBUG
      if ( VHO_Switch_Debug )
        fprintf ( TFile, "SWITCH_binary %d\n", (INT32) srcpos );
#endif /* VHO_DEBUG */
 
      wn = WN_CreateBlock ();
      WN_Set_Linenum ( wn, srcpos );
 
      if (VHO_Switch_Default_Goto)
        VHO_Switch_Default_Label = WN_label_number(VHO_Switch_Default_Goto);
      else
      LABEL_Init (New_LABEL (CURRENT_SYMTAB, VHO_Switch_Default_Label),
    0, LKIND_DEFAULT);
 
      VHO_Switch_Generate_Binary_Search ( 0, VHO_Switch_Ncases-1, wn );
    }
  }
 
  MEM_POOL_FREE ( MEM_local_pool_ptr, VHO_Switch_Case_Table );
  MEM_POOL_FREE ( MEM_local_pool_ptr, VHO_Switch_Cluster_Table );
  if (conv_wn == NULL)
        return wn;
  else {
     WN_INSERT_BlockAfter (conv_wn, WN_last(conv_wn),  wn);
     return conv_wn;
  }
 
  return wn;
} /* VHO_Lower_Switch */
 
/* ============================================================================
 *
 * static WN *
 * VHO_Lower_Compgoto ( WN * wn )
 *
 * ============================================================================
 */
 
static WN *
VHO_Lower_Compgoto ( WN * wn )
{
  return wn;
} /* VHO_Lower_Compgoto */
 
 
/* ============================================================================
 *
 * static UINT
 * VHO_Get_Field_List ( WN_OFFSET offset, TY_IDX sty_idx )
 *
 * Flatten a struct/union 'sty' starting as 'offset' into non overlapping
 * fields and place them in the array VHO_Struct_Fld_Table.
 * Update VHO_Struct_Nfields, VHO_Struct_Last_Field_Offset
 * VHO_Struct_Last_Field_Size.
 *
 * If the structure contains misaligned data, holes or fields which
 * are out of order, then lowering is not done.
 * This is done by setting VHO_Struct_Can_Be_Lowered to FALSE.
 *
 * ============================================================================
 */
 
static UINT
VHO_Get_Field_List ( WN_OFFSET offset, TY_IDX sty_idx, UINT field_id )
{
  TY_IDX      fty_idx;
  WN_OFFSET   field_offset;
 
  if ( TY_fld(Ty_Table [sty_idx]).Is_Null () ) {
    VHO_Struct_Can_Be_Lowered = FALSE;
    return field_id;
  }
 
  FLD_ITER fld_iter = Make_fld_iter (TY_fld (Ty_Table[sty_idx]));
 
  while (VHO_Struct_Can_Be_Lowered) {
    FLD_HANDLE fld (fld_iter);
    if ( FLD_is_bit_field(fld) ) {
      VHO_Struct_Can_Be_Lowered = FALSE;
      break;
    }
    fty_idx = FLD_type(fld);
    switch ( TY_kind(Ty_Table [fty_idx]) ) {
 
      case KIND_SCALAR:
      case KIND_POINTER:
        field_offset = offset + FLD_ofst(fld);
        // always increase the field_id for SCALAR and POINTER
        ++field_id;
        if ( VHO_Struct_Nfields ) {
          if ( field_offset >= VHO_Struct_Last_Field_Offset
                                 + VHO_Struct_Last_Field_Size ) {
            /* new field */
            VHO_Struct_Last_Field_Offset = field_offset;
            VHO_Struct_Last_Field_Size   = TY_size (Ty_Table [fty_idx]);
            VHO_Struct_Field_Is_Array_Table [VHO_Struct_Nfields] = FALSE;
            VHO_Struct_Field_Id_Table [VHO_Struct_Nfields] = field_id;
            VHO_Struct_Offset_Table [VHO_Struct_Nfields] = field_offset;
            VHO_Struct_Fld_Table [VHO_Struct_Nfields++] = fty_idx;
          }
          else
          if ( field_offset == VHO_Struct_Last_Field_Offset ) {
            /* overlapping field with same start offset */
            if ( TY_size (Ty_Table [fty_idx]) > VHO_Struct_Last_Field_Size ) {
              /* overlapping field with larger size */
              VHO_Struct_Last_Field_Offset = field_offset;
              VHO_Struct_Last_Field_Size   = TY_size (Ty_Table [fty_idx]);
              VHO_Struct_Field_Is_Array_Table [VHO_Struct_Nfields] = FALSE;
              VHO_Struct_Field_Id_Table [VHO_Struct_Nfields] = field_id;
              VHO_Struct_Fld_Table [VHO_Struct_Nfields-1] = fty_idx;
              VHO_Struct_Offset_Table [VHO_Struct_Nfields-1] = field_offset;
            }
          }
          else
          if ( field_offset + TY_size (Ty_Table [fty_idx])
                   > VHO_Struct_Last_Field_Offset + VHO_Struct_Last_Field_Size ) {
            VHO_Struct_Can_Be_Lowered = FALSE;
          }
        }
 
        else {
          /* new field */
          VHO_Struct_Last_Field_Offset = field_offset;
          VHO_Struct_Last_Field_Size   = TY_size (Ty_Table [fty_idx]);
          VHO_Struct_Field_Is_Array_Table [VHO_Struct_Nfields] = FALSE;
          VHO_Struct_Field_Id_Table [VHO_Struct_Nfields] = field_id;
          VHO_Struct_Offset_Table [VHO_Struct_Nfields] = field_offset;
          VHO_Struct_Fld_Table [VHO_Struct_Nfields++] = fty_idx;
        }
        break;
 
      case KIND_STRUCT:
 
        if ( TY_is_packed(Ty_Table[fty_idx] ))
          VHO_Struct_Can_Be_Lowered = FALSE;
        else {
          // Structs are their own field id,
          // then each field in them gets new id.
          // So increment field_id,
          // but don't want whole struct in table, just each subfield.
          ++field_id;
 
          // get new field id from sub-struct
          // so next field will have right value.
          field_id = VHO_Get_Field_List (offset + FLD_ofst (fld), fty_idx, field_id);
        }
        break;
 
      case KIND_ARRAY:
        INT32   array_elem_num;
  TY_IDX  ety_idx;
 
        ety_idx = Ty_Table [fty_idx].Etype();
#ifdef KEY // bug 5273: array element size can be zero
       if (TY_size(Ty_Table[ety_idx]) == 0)
         array_elem_num = 0;
       else {
#endif
         Is_True (TY_size(Ty_Table [fty_idx])%TY_size(Ty_Table [ety_idx]) == 0,
                       ("unexpected array type"));
         array_elem_num = TY_size(Ty_Table [fty_idx])/TY_size(Ty_Table [ety_idx]);
#ifdef KEY // bug 5273
       }
#endif
        // Is_True (VHO_Struct_Nfields + array_elem_num < 255,
        //            ("number of flattened fields exceeds limit");
        if (VHO_Struct_Nfields + array_elem_num >= 255) {
          VHO_Struct_Can_Be_Lowered = FALSE;
          break;
        }
  ++field_id; // keep same field_id for all array elements
        field_offset = offset + FLD_ofst(fld);
 
        if(VHO_Struct_Nfields) {
          if ( field_offset >=  VHO_Struct_Last_Field_Offset
                                  + VHO_Struct_Last_Field_Size ) {
            for(int i=0; i<array_elem_num; i++) {
              if (TY_kind(ety_idx) == KIND_STRUCT) {
                INT last_nfield = VHO_Struct_Nfields;
                // array of structs; open up each field of struct
                VHO_Get_Field_List (field_offset + i*TY_size(ety_idx),
                                    ety_idx, field_id);
                for (INT j=last_nfield; j < VHO_Struct_Nfields; ++j) {
                  VHO_Struct_Field_Is_Array_Table [j] = TRUE;
                  VHO_Struct_Field_Id_Table [j] = field_id;
                }
              }
              else {
                VHO_Struct_Field_Is_Array_Table [VHO_Struct_Nfields] = TRUE;
                VHO_Struct_Field_Id_Table [VHO_Struct_Nfields] = field_id;
                VHO_Struct_Offset_Table [VHO_Struct_Nfields] = field_offset + i*TY_size(Ty_Table [ety_idx]);
                VHO_Struct_Fld_Table [VHO_Struct_Nfields++] = ety_idx;
              }
            }
            VHO_Struct_Last_Field_Offset = field_offset;
            VHO_Struct_Last_Field_Size   = TY_size(Ty_Table [fty_idx]);
          } else if ( field_offset == VHO_Struct_Last_Field_Offset ) {
            if ( TY_size (Ty_Table [fty_idx]) > VHO_Struct_Last_Field_Size ) {
              VHO_Struct_Nfields--;
              for(int i=0; i<array_elem_num; i++) {
                if (TY_kind(ety_idx) == KIND_STRUCT) {
                  INT last_nfield = VHO_Struct_Nfields;
                  // array of structs; open up each field of struct
                  VHO_Get_Field_List (field_offset + i*TY_size(ety_idx),
                                      ety_idx, field_id);
                  for (INT j=last_nfield; j < VHO_Struct_Nfields; ++j) {
                    VHO_Struct_Field_Is_Array_Table [j] = TRUE;
                    VHO_Struct_Field_Id_Table [j] = field_id;
                  }
                }
                else {
                  VHO_Struct_Field_Is_Array_Table [VHO_Struct_Nfields] = TRUE;
                  VHO_Struct_Field_Id_Table [VHO_Struct_Nfields] = field_id;
                  VHO_Struct_Offset_Table [VHO_Struct_Nfields] = field_offset + i*TY_size(Ty_Table [ety_idx]);
                  VHO_Struct_Fld_Table [VHO_Struct_Nfields++] = ety_idx;
                }
              }
              VHO_Struct_Last_Field_Offset = field_offset;
              VHO_Struct_Last_Field_Size   = TY_size(Ty_Table [fty_idx]);
            }
          } else if ( field_offset + TY_size (Ty_Table [fty_idx])
                        > VHO_Struct_Last_Field_Offset + VHO_Struct_Last_Field_Size ) {
            VHO_Struct_Can_Be_Lowered = FALSE;
          }
        }
        else {
          for(int i=0; i<array_elem_num; i++) {
            if (TY_kind(ety_idx) == KIND_STRUCT) {
              INT last_nfield = VHO_Struct_Nfields;
              // array of structs; open up each field of struct
              VHO_Get_Field_List (field_offset + i*TY_size(ety_idx),
                                  ety_idx, field_id);
              for (INT j=last_nfield; j < VHO_Struct_Nfields; ++j) {
                VHO_Struct_Field_Is_Array_Table [j] = TRUE;
                VHO_Struct_Field_Id_Table [j] = field_id;
              }
            }
            else {
                VHO_Struct_Field_Is_Array_Table [VHO_Struct_Nfields] = TRUE;
                VHO_Struct_Field_Id_Table [VHO_Struct_Nfields] = field_id;
                VHO_Struct_Offset_Table [VHO_Struct_Nfields] = field_offset + i*TY_size(Ty_Table [ety_idx]);
                VHO_Struct_Fld_Table [VHO_Struct_Nfields++] = ety_idx;
            }
          }
          VHO_Struct_Last_Field_Offset = field_offset;
          VHO_Struct_Last_Field_Size   = TY_size(Ty_Table [fty_idx]);
        }
        break;
 
      default:
 
        VHO_Struct_Can_Be_Lowered = FALSE;
        break;
    }
 
    if (FLD_last_field (fld))
      break;
    else
      ++fld_iter;
  }
  return field_id;
 
} /* VHO_Get_Field_List */
 
#ifdef KEY
// If there is a single field that spans across the entire
// struct (i.e. any other field has size zero), return the field-id,
// else return 0.
static INT
single_field_in_struct (TY_IDX struct_type)
{
  Is_True (TY_kind(struct_type) == KIND_STRUCT,
           ("single_field_in_struct: expected struct type"));
 
  Is_True (TY_size(struct_type) == 4 || TY_size(struct_type) == 8,
           ("single_field_in_struct: sizes 4/8 only supported"));
  FLD_ITER fld_iter = Make_fld_iter (TY_fld (struct_type));
  INT fld_count = 0;
 
  do {
    FLD_HANDLE fld(fld_iter);
    fld_count++;
    if (! FLD_is_bit_field(fld) &&
        TY_size (FLD_type (fld)) == TY_size (struct_type))
      return fld_count;
    // Else if there is a field with non-zero size, then there must be
    // multiple non-zero-size fields.
    else if (TY_size (FLD_type (fld)))
      return 0;
  } while (!FLD_last_field(fld_iter++));
 
  return 0;
}
#endif
 
static TY_IDX
get_field_type (TY_IDX struct_type, UINT field_id)
{
  Is_True (TY_kind (struct_type) == KIND_STRUCT, ("expecting KIND_STRUCT"));
  UINT cur_field_id = 0;
  FLD_HANDLE fld = FLD_get_to_field (struct_type, field_id, cur_field_id);
  Is_True (! fld.Is_Null(), ("Invalid field id %d for type 0x%x",
                          field_id, struct_type));
  return FLD_type (fld);
}
 
/* ============================================================================
 *
 * WN *VHO_Lower_Mstore ( WN * wn )
 *
 * If the structure being copied is sufficiently small, then flatten out the
 * structure into a set of non overlapping fields and load/store the
 * individual fields, thereby replacing MSTORE/MLOAD by a sequence of
 * one or more (controlled by VHO_Struct_Limit) pairs of STID/ISTORE
 * over LDID/ILOAD.
 *
 * The following structures are not currently handled.
 *
 *   structures containing misaligned fields
 *   structures containing bit fields
 *   structures containing arrays
 *
 * ============================================================================
 */
 
WN *
VHO_Lower_Mstore ( WN * wn )
{
  WN_OFFSET   dst_offset;
  WN        * dst_address;
  TY_IDX      ptr_dst_ty_idx;
  TY_IDX      dst_ty_idx;
  ST        * dst_st = NULL;
  WN        * src_value;
  WN_OFFSET   src_offset;
  WN        * src_address;
  TY_IDX      ptr_src_ty_idx;
  TY_IDX      src_ty_idx;
  ST        * src_st;
  WN        * size;
  INT64       bytes;
  WN        * block;
  // WN_OFFSET   field_offset;
  INT32       i;
  SRCPOS      srcpos;
  WN        * temp;
  PREG_NUM    preg;
  ST        * preg_st;
  TY_IDX      preg_ty_idx;
  OPCODE      opc;
 
  src_value      = WN_kid0(wn);
  dst_address    = WN_kid1(wn);
  size           = WN_kid(wn,2);
  dst_offset     = WN_store_offset(wn);
  ptr_dst_ty_idx = WN_ty(wn);
  srcpos         = WN_Get_Linenum(wn);
 
  if ( VHO_Struct_Opt
       && WN_operator(size) == OPR_INTCONST
       && WN_opcode(src_value) == OPC_MLOAD ) {
       /* need to handle WN_opcode(src_value) == OPC_MMLDID,
          see VHO_Lower_Mstid function                        */
 
    bytes          = WN_const_val(size);
    src_address    = WN_kid0(src_value);
    ptr_src_ty_idx = WN_ty(src_value);
    src_ty_idx     = TY_pointed(Ty_Table[ptr_src_ty_idx]);
    if (WN_field_id(src_value) != 0) {
       src_ty_idx = get_field_type(src_ty_idx, WN_field_id(src_value));
    }
 
    dst_ty_idx     = TY_pointed(Ty_Table[ptr_dst_ty_idx]);
    if (WN_field_id(wn) != 0) {
       dst_ty_idx = get_field_type(dst_ty_idx, WN_field_id(wn));
    }
 
    // Used to check for matching struct alignment,
    // but we don't need alignment to match to copy fields
    // (may have been related to unused VHO_Struct_Alignment variable).
    // if (    TY_align(src_ty_idx) == TY_align(dst_ty_idx)
    if (TY_kind(src_ty_idx) == KIND_STRUCT
         && TY_is_packed(Ty_Table[src_ty_idx]) == FALSE
         && TY_is_packed(Ty_Table[dst_ty_idx]) == FALSE
         && bytes / TY_align(src_ty_idx) <= VHO_Struct_Limit ) {
 
      VHO_Struct_Nfields = 0;
      VHO_Struct_Can_Be_Lowered = TRUE;
//    VHO_Struct_Alignment = TY_align(dst_ty_idx);
 
      /* Flatten out the structure into non overlapping fields */
      VHO_Get_Field_List ( 0, src_ty_idx, WN_field_id(src_value) );
 
#ifdef VHO_DEBUG
      if ( VHO_Struct_Debug )
        fprintf ( TFile, "VHO_Lower_Mstore : %s %d\n",
                  VHO_Struct_Can_Be_Lowered ? "TRUE" : "FALSE",
                  (INT32) srcpos );
#endif /* VHO_DEBUG */
 
      if ( VHO_Struct_Can_Be_Lowered && VHO_Struct_Nfields ) {
 
        block = WN_CreateBlock ();
        WN_Set_Linenum ( block, srcpos );
 
        src_offset = WN_offset(src_value);
 
        if ( WN_operator(src_address) == OPR_LDA &&
          WN_field_id(src_value) != 0 ) {
 
          src_st      = WN_st(src_address);
          src_offset += WN_offset(src_address);
        } else  src_st = NULL;
/*
        if (    WN_operator(src_address) == OPR_ARRAY
             && WN_operator(WN_kid0(src_address)) == OPR_LDA )
          src_st = NULL;
 
        else {
 
          preg = Create_Preg (Pointer_Mtype, vho_lower_mstore_name);
 
          preg_st     = MTYPE_To_PREG ( Pointer_Mtype );
          preg_ty_idx = ptr_src_ty_idx;
 
          if ( src_offset == 0 ) {
 
            opc  = OPCODE_make_op ( OPR_STID, MTYPE_V, Pointer_Mtype );
            temp = WN_CreateStid ( opc, preg, preg_st, preg_ty_idx,
           src_address );
          } else {
            opc  = OPCODE_make_op ( OPR_INTCONST, Pointer_Mtype, MTYPE_V );
            temp = WN_CreateIntconst ( opc, src_offset );
            opc  = OPCODE_make_op ( OPR_ADD, Pointer_Mtype, MTYPE_V );
            temp = WN_CreateExp2 ( opc, src_address, temp );
            opc  = OPCODE_make_op ( OPR_STID, MTYPE_V, Pointer_Mtype );
            temp = WN_CreateStid ( opc, preg, preg_st, preg_ty_idx, temp );
          }
 
          WN_Set_Linenum(temp, srcpos);
 
          WN_INSERT_BlockAfter ( block, WN_last(block), temp );
 
          opc = OPCODE_make_op ( OPR_LDID, Pointer_Mtype, Pointer_Mtype );
          src_address = WN_CreateLdid ( opc, preg, preg_st, preg_ty_idx );
          src_st      = NULL;
          src_offset  = 0;
        }
*/
 
        dst_offset = WN_store_offset(wn);
 
        if ( WN_operator(dst_address) == OPR_LDA && WN_field_id(wn) == 0) {
 
          dst_st      = WN_st(dst_address);
          dst_offset += WN_offset(dst_address);
        }
        else  dst_st = NULL;
/*
        if (    WN_operator(dst_address) == OPR_ARRAY
             && WN_operator(WN_kid0(dst_address)) == OPR_LDA )
          dst_st = NULL;
 
        else {
 
          preg = Create_Preg (Pointer_Mtype, vho_lower_mstore_name);
 
          preg_st     = MTYPE_To_PREG ( Pointer_Mtype );
          preg_ty_idx = ptr_src_ty_idx;
 
          if ( dst_offset == 0 ) {
 
            opc  = OPCODE_make_op ( OPR_STID, MTYPE_V, Pointer_Mtype );
            temp = WN_CreateStid ( opc, preg, preg_st, preg_ty_idx,
           dst_address );
          }
 
          else {
 
            opc  = OPCODE_make_op ( OPR_INTCONST, Pointer_Mtype, MTYPE_V );
            temp = WN_CreateIntconst ( opc, dst_offset );
            opc  = OPCODE_make_op ( OPR_ADD, Pointer_Mtype, MTYPE_V );
            temp = WN_CreateExp2 ( opc, dst_address, temp );
            opc  = OPCODE_make_op ( OPR_STID, MTYPE_V, Pointer_Mtype );
            temp = WN_CreateStid ( opc, preg, preg_st, preg_ty_idx, temp );
          }
 
          WN_Set_Linenum(temp, srcpos);
 
          WN_INSERT_BlockAfter ( block, WN_last(block), temp );
 
          opc  = OPCODE_make_op ( OPR_LDID, Pointer_Mtype, Pointer_Mtype );
          dst_address = WN_CreateLdid ( opc, preg, preg_st, preg_ty_idx );
          dst_st      = NULL;
          dst_offset  = 0;
        }
*/
        // field_offset = 0;
 
        for ( i = 0; i < VHO_Struct_Nfields; i++ ) {
 
          TY_IDX   fty_idx;
          WN     * src;
          WN     * dst;
 
          fty_idx = VHO_Struct_Fld_Table [i];
          if ( src_st ) {
            opc = OPCODE_make_op ( OPR_LDID,
                                   Promoted_Mtype [TY_mtype(fty_idx)],
                                   TY_mtype(fty_idx) );
            src = WN_CreateLdid ( opc, src_offset + VHO_Struct_Offset_Table[i],
                                  src_st, fty_idx );
          }
          else {
            opc = OPCODE_make_op ( OPR_ILOAD,
                                   Promoted_Mtype [TY_mtype(fty_idx)],
                                   TY_mtype(fty_idx) );
            src = WN_CreateIload ( opc, src_offset + VHO_Struct_Offset_Table[i], fty_idx,
                                   Make_Pointer_Type ( fty_idx, FALSE ),
                                   WN_COPY_Tree ( src_address ) );
          }
          if ( dst_st ) {
            opc = OPCODE_make_op ( OPR_STID, MTYPE_V, TY_mtype(fty_idx) );
            dst = WN_CreateStid ( opc, dst_offset + VHO_Struct_Offset_Table[i],
                                  dst_st, fty_idx, src );
          }
          else {
            opc = OPCODE_make_op ( OPR_ISTORE, MTYPE_V, TY_mtype(fty_idx) );
            dst = WN_CreateIstore ( opc, dst_offset + VHO_Struct_Offset_Table[i],
                                    Make_Pointer_Type ( fty_idx, FALSE ),
                                    src,
                                    WN_COPY_Tree ( dst_address ) );
          }
          WN_Set_Linenum(dst, srcpos);
          WN_INSERT_BlockAfter ( block, WN_last(block), dst );
          // field_offset += TY_size(fty_idx);
        }
        wn = block;
      }
    }
 
    else {
#ifdef VHO_DEBUG
      if ( VHO_Struct_Debug )
        fprintf ( TFile, "VHO_Lower_Mstore : FALSE %d\n", (INT32) srcpos );
#endif /* VHO_DEBUG */
    }
  }
  return wn;
} /* VHO_Lower_Mstore */
 
inline BOOL Is_Ldid_Or_Lda (WN *tree)
{
  return (WN_operator(tree) == OPR_LDID || WN_operator(tree) == OPR_LDA);
}
// 64bit code can have cvt above the multiply
inline BOOL Is_Multiply_Or_Cvt_Multiply (WN *tree)
{
  return ((WN_operator(tree) == OPR_MPY)
    || (WN_operator(tree) == OPR_CVT && WN_operator(WN_kid0(tree)) == OPR_MPY));
}
 
// share code for finding LDID under a MMILOAD
static WN*
Find_Ldid_Under_Iload (WN *iload_kid)
{
    if (Is_Ldid_Or_Lda(iload_kid)) {
    return iload_kid;
    }
    else if (WN_operator(iload_kid) == OPR_ADD) {
      if (Is_Ldid_Or_Lda(WN_kid0(iload_kid))
        && Is_Multiply_Or_Cvt_Multiply(WN_kid1(iload_kid)) )
      {
      // array index
      return WN_kid0(iload_kid);
      }
      // check other kid
      else if (Is_Ldid_Or_Lda(WN_kid1(iload_kid))
        && Is_Multiply_Or_Cvt_Multiply(WN_kid0(iload_kid)) )
      {
      // array index
      return WN_kid1(iload_kid);
      }
    }
    else if (WN_operator(iload_kid) == OPR_ARRAY) {
      // recurse on array index variant
      return Find_Ldid_Under_Iload (WN_kid0(iload_kid));
    }
    return NULL;
}
 
static TY_IDX
Is_MM_load(WN *src, WN *dst)
{
  if (WN_opcode(src) == OPC_MMLDID) {
    if (ST_class(WN_st(dst)) != CLASS_PREG &&
       ST_class(WN_st(src)) != CLASS_PREG)
      return WN_ty(src);
    else
      return (TY_IDX)0;
  }
  if (WN_opcode(src) == OPC_MMILOAD) {
    if (OPCODE_is_load(WN_opcode(WN_kid0(src))))
      return WN_ty(WN_kid0(src));
  }
  return (TY_IDX)0;
}
 
/* ==============================================================================
 *
 * WN *VHO_Lower_Mstid(WN * wn)
 *
 * If the structure being copied is sufficiently small, then flatten out the
 * structure into a set of non overlapping fields and load/store the
 * individual fields, thereby replacing MMSTID/MLDID by a sequence of
 * one or more (controlled by VHO_Struct_Limit) pairs of STID/ISTORE
 * over LDID/ILOAD.
 *
 * The following structures are not currently handled.
 *
 * structures containing misaligned fields
 * structures containing bit fields
 * structures containing arrays
 *
 * ==============================================================================
 */
 
WN *
VHO_Lower_Mstid (WN * wn)
{
  WN_OFFSET   dst_offset;
  TY_IDX      dst_ty_idx;
  ST        * dst_st;
  WN        * src_value;
  WN        * src_iload_kid;
  WN        * src_ldid;
  WN_OFFSET   src_offset;
  TY_IDX      src_ty_idx;
  TY_IDX      orig_src_ty_idx;
  TY_IDX      src_ptr_ty_idx;
  ST        * src_st;
  WN        * size;
  INT64       bytes;
  WN        * block;
  // WN_OFFSET   field_offset;
  INT32       i;
  SRCPOS      srcpos;
  OPCODE      opc;
  BOOL        src_is_pointer = FALSE;
  BOOL        ty_mismatch;
  INT src_field_id = 0;
  INT dst_field_id = 0;
 
  if (VHO_SCL_Debug) {
      fprintf ( TFile, "\nVHO_Lower_Mstid  lowering:\n");
      fdump_tree(TFile, wn);
  }
 
  src_value   = WN_kid0(wn);
  dst_ty_idx  = WN_ty(wn);
  srcpos      = WN_Get_Linenum(wn);
 
  // field_ids complicate things, as they require generating
  // (struct-type, field_id) rather than a simple field type.
  // We can handle field_ids by getting fty
  // of struct subfields for appropriate mtype, but generating field_ids
  // of original struct for the actual ldid/stid.
  if (WN_field_id(wn) != 0) {
      dst_field_id = WN_field_id(wn);
      dst_ty_idx = get_field_type(dst_ty_idx, WN_field_id(wn));
  }
  if (WN_opcode(src_value) == OPC_MMLDID) {
      src_ldid = src_value;
      src_ty_idx = WN_ty(src_ldid);
  }
  else if (WN_opcode(src_value) == OPC_MMILOAD)
  {
      // will replace MSTID(MMILOAD) with STID<field1>(ILOAD<field1>),etc
      src_iload_kid = WN_kid0(src_value);
      // is indirect load, so will be pointer type
      src_is_pointer = TRUE;
      src_ptr_ty_idx =  WN_load_addr_ty(src_value);
 
      if (TY_kind(src_ptr_ty_idx) != KIND_POINTER) {
          return wn;      // doesn't fit pattern so ignore
      }
      src_ty_idx = TY_pointed(src_ptr_ty_idx);
      src_ldid = Find_Ldid_Under_Iload (src_iload_kid);
 
      if (src_ldid == NULL)
          return wn;  // don't handle any other cases
  }
  else
  {
      return wn;  // don't handle any other cases
  }
 
  // keep the original src_type
  orig_src_ty_idx = src_ty_idx;
  // we have a src_ty_idx type at src_field_id of orig_src_ty_idx
  if (WN_field_id(src_value) != 0) {
      src_field_id = WN_field_id(src_value);
      src_ty_idx = get_field_type(src_ty_idx, src_field_id);
  }
  // iload of preg is okay cause iload takes the field offset
  if ( ST_class(WN_st(wn)) == CLASS_PREG ||
       (ST_class(WN_st(src_ldid)) == CLASS_PREG && !src_is_pointer)) {
      /* screen out PREG for now, need to change them into extract sometime */
      return wn;
  }
 
  bytes = TY_size(dst_ty_idx);
 
#if defined(TARG_NVISA)
  if ((VHO_Struct_Opt && (bytes > 0))) {
#else
  if ((VHO_Struct_Opt && (bytes > 0)) && (Is_MM_load(src_value, wn) != (TY_IDX)0)) {
    /* screen out PREG for now, need to change them into extract sometime */
#endif
 
#ifdef KEY
    VHO_Struct_Nfields = 0;
    VHO_Struct_Can_Be_Lowered = TRUE;
#endif
 
          // Used to check for matching struct alignment,
          // but we don't need alignment to match to copy fields
          // (may have been related to unused VHO_Struct_Alignment variable).
          // if(   TY_align(src_ty_idx) == TY_align(dst_ty_idx)
    if (TY_kind(src_ty_idx) == KIND_STRUCT
       && TY_is_packed(Ty_Table[src_ty_idx]) == FALSE
       && TY_is_packed(Ty_Table[dst_ty_idx]) == FALSE
       && bytes / TY_align(src_ty_idx) <= VHO_Struct_Limit) {
 
#ifndef KEY
      VHO_Struct_Nfields = 0;
      VHO_Struct_Can_Be_Lowered = TRUE;
#endif
      //  VHO_Struct_Alignment = TY_align(dst_ty_idx);
 
      // Flatten out the structure into non overlapping fields
      // src_field_id is the starting point of type src_ty_idx
      // inside the outer structure of type orig_src_ty_idx
 
      VHO_Get_Field_List (0, src_ty_idx, src_field_id);
 
#ifdef VHO_DEBUG
      if ( VHO_Struct_Debug)
        fprintf ( TFile, "VHO_Lower_Mstid : %s %d \n",
                  VHO_Struct_Can_Be_Lowered ? "TRUE" : "FALSE",
                  (INT32) srcpos);
#endif /* VHO_DEBUG */
 
      if ( VHO_Struct_Can_Be_Lowered && VHO_Struct_Nfields) {
 
        block = WN_CreateBlock();
        WN_Set_Linenum (block, srcpos);
        src_st = WN_st(src_ldid);
        // preserve offset from original ldid/iload
        src_offset = WN_offset(src_value);
        dst_st = WN_st(wn);
        dst_offset = WN_store_offset(wn);
 
        // field_offset = 0;
 
        for (i = 0; i < VHO_Struct_Nfields; i++) {
 
          TY_IDX    fty_idx;
          WN      * src;
          WN      * dst;
 
          fty_idx = VHO_Struct_Fld_Table[i];
          if (src_is_pointer) {
              opc = OPCODE_make_op ( OPR_ILOAD,
                                     Promoted_Mtype [TY_mtype(fty_idx)],
                                     TY_mtype(fty_idx) );
              if (VHO_Struct_Field_Is_Array_Table[i]) {
                  src = WN_CreateIload ( opc,
                                         src_offset + VHO_Struct_Offset_Table[i],
                                         fty_idx,
                                         Make_Pointer_Type ( fty_idx),
                                         WN_COPY_Tree (src_iload_kid) );
              } else {
                  src = WN_CreateIload ( opc,
                                         src_offset + VHO_Struct_Offset_Table[i],
                                         orig_src_ty_idx, src_ptr_ty_idx,
                                         WN_COPY_Tree (src_iload_kid),
                                         VHO_Struct_Field_Id_Table[i]);
              }
          } else {
              opc = OPCODE_make_op ( OPR_LDID,
                                     Promoted_Mtype [TY_mtype(fty_idx)],
                                     TY_mtype(fty_idx) );
              if (VHO_Struct_Field_Is_Array_Table[i]) {
                  // each element uses same field_id,
                  // so rather than create array refs, just do element copies
                  src = WN_CreateLdid ( opc,
                                        src_offset + VHO_Struct_Offset_Table[i],
                                        src_st, fty_idx);
              } else {
                  src = WN_CreateLdid ( opc,
                                        src_offset + VHO_Struct_Offset_Table[i],
                                        src_st, WN_ty(src_ldid),
                                        VHO_Struct_Field_Id_Table[i]);
              }
          }
 
          // Note (1).  The source and dest. types must match otherwise, the
          // calculation to compute the field_id argument to WN_CreateStid()
          // will be incorrect.
          opc = OPCODE_make_op ( OPR_STID, MTYPE_V, TY_mtype(fty_idx) );
          ty_mismatch = TY_id(src_ty_idx) != TY_id(dst_ty_idx);
          if (VHO_Struct_Field_Is_Array_Table[i] || ty_mismatch || VHO_Disable_Copy_Field_Element) {
              // each element uses same field_id,
              // so rather than create array refs, just do element copies
              dst = WN_CreateStid ( opc,
                                    dst_offset + VHO_Struct_Offset_Table[i],
                                    dst_st, fty_idx, src);
              if (VHO_M_Debug_Type_Mismatch && ty_mismatch || VHO_SCL_Debug) {
                  fprintf(TFile, "VHO_Lower_Mstid: %stype mismatch, dst WN follows\n",
                        ty_mismatch ? "" : "no ");
                  fdump_tree(TFile, dst);
              }
          } else {
              dst = WN_CreateStid ( opc,
                                    dst_offset + VHO_Struct_Offset_Table[i],
                                    dst_st, WN_ty(wn), src,
                                    dst_field_id - src_field_id + VHO_Struct_Field_Id_Table[i]);
              if (VHO_SCL_Debug) {
                  fprintf(TFile, "dst_field_id=%d, src_field_id=%d, VHO_Struct_Field_Id_Table[%d]=%d, dst WN follows\n",
                          dst_field_id, src_field_id, i, VHO_Struct_Field_Id_Table[i]);
                  fdump_tree(TFile, dst);
              }
          }
          WN_Set_Linenum(dst, srcpos);
          WN_INSERT_BlockAfter (block, WN_last(block), dst);
          // field_offset += TY_size(fty_idx);
        } //end for
        wn = block;
      } // end if ( VHO_Struct_Can_Be_Lowered && VHO_Struct_Nfields) {
    } // end TY_kind(src_ty_idx) == KIND_STRUCT
#ifdef KEY
    if (VHO_Struct_Can_Be_Lowered && VHO_Struct_Nfields)
      ; // we already lowered the struct
#ifdef TARG_SL
    else if ((bytes == 4) &&  TY_size(src_ty_idx) == bytes) {
#else
    else if ((bytes == 4 || bytes == 8) && TY_size(src_ty_idx) == bytes) {
#endif
      // bug 7741: change MTYPE_M to MTYPE_U[48]
      TYPE_ID mtype = (bytes == 4) ? MTYPE_U4 : MTYPE_U8;
      WN_set_desc(wn, mtype);
      WN_set_rtype(src_value, mtype);
      WN_set_desc(src_value, mtype);
 
      // bugs 9989, 10139
      INT field_id;
      // We allow the field_id not zero, comment out the Is_True
      //Is_True (WN_field_id(src_value) == 0,("Expected field-id zero"));
      if ((TY_kind(src_ty_idx) == KIND_STRUCT) &&
          (field_id /* assign */ = single_field_in_struct (src_ty_idx)))
        WN_set_field_id (src_value, field_id);
 
      // We allow the field_id not zero, comment out the Is_True
      //Is_True (WN_field_id(wn) == 0,("Expected field-id zero"));
      if ((TY_kind(dst_ty_idx) == KIND_STRUCT) &&
          (field_id /* assign */ = single_field_in_struct (dst_ty_idx)))
        WN_set_field_id (wn, field_id);
    }
    else {
#endif
 
#ifdef VHO_DEBUG
    if ( VHO_Struct_Debug)
     fprintf (TFile, "VHO_Lower_Mstid: FALSE %d\n", (INT32) scrpos);
#endif /* VHO_DEBUG */
    }
  }
  return wn;
} /* VHO_Lower_Mstid */
 
/* ============================================================================
 *
 * WN *VHO_Lower_Mistore ( WN * wn )
 *
 * If the structure being copied is sufficiently small, then flatten out the
 * structure into a set of non overlapping fields and load/istore the
 * individual fields, thereby replacing MISTORE/MLDID by a sequence of
 * one or more (controlled by VHO_Struct_Limit) pairs of STID/ISTORE
 * over LDID/ILOAD.
 *
 * The following structures are not currently handled.
 *
 *   structures containing misaligned fields
 *   structures containing bit fields
 *   structures containing arrays
 *
 * ============================================================================
 */
 
WN *
VHO_Lower_Mistore ( WN * wn )
{
  WN_OFFSET   dst_offset;
  TY_IDX      dst_ty_idx;
  ST        * dst_st;
  WN        * src_value;
  WN_OFFSET   src_offset;
  TY_IDX      src_ty_idx;
  ST        * src_st;
  WN        * size;
  INT64       bytes;
  WN        * block;
  BOOL        ty_mismatch;
  // WN_OFFSET   field_offset;
  INT32       i;
  SRCPOS      srcpos;
  OPCODE      opc;
  INT src_field_id = 0;
  INT dst_field_id = 0;
  BOOL src_is_pointer = FALSE;
  TY_IDX src_ptr_ty_idx;
  WN *src_iload_kid;
  WN *src_ldid;
 
  if (VHO_SCL_Debug) {
      fprintf ( TFile, "\nVHO_Lower_Mistore lowering:\n");
      fdump_tree(TFile, wn);
  }
  src_value      = WN_kid0(wn);
  WN *dst_address= WN_kid1(wn);
  dst_offset     = WN_store_offset(wn);
  TY_IDX ptr_dst_ty_idx = WN_ty(wn);
  dst_ty_idx     = TY_pointed(Ty_Table[ptr_dst_ty_idx]);
  if (WN_field_id(wn) != 0) {
    dst_ty_idx = get_field_type(dst_ty_idx, WN_field_id(wn));
  }
  srcpos         = WN_Get_Linenum(wn);
  bytes          = TY_size(dst_ty_idx);
 
  if (WN_field_id(src_value) != 0) {
    /* otherwise, we need to get to the subfields, or generate ILOAD, later */
    return wn;
  }
  if ( VHO_Struct_Opt
    && bytes > 0) {
    if (WN_opcode(src_value) == OPC_MMLDID
    && ST_class(WN_st(src_value)) != CLASS_PREG ) {
      /* screen out PREG for now, need to change them into extract sometime */
      src_ty_idx     = WN_ty(src_value);
      src_ldid = src_value;
    }
    else if (WN_opcode(src_value) == OPC_MMILOAD) {
      // is indirect load, so will be pointer type
      src_is_pointer = TRUE;
      src_ptr_ty_idx =  WN_load_addr_ty(src_value);
      if (TY_kind(src_ptr_ty_idx) != KIND_POINTER) {
        return wn;      // doesn't fit pattern so ignore
      }
      src_ty_idx = TY_pointed(src_ptr_ty_idx);
      src_iload_kid = WN_kid0(src_value);
      src_ldid = Find_Ldid_Under_Iload (src_iload_kid);
      if (src_ldid == NULL)
        return wn;// don't handle other cases
    }
    else {
      return wn; // don't handle other cases
    }
 
    // Used to check for matching struct alignment,
    // but we don't need alignment to match to copy fields
    // (may have been related to unused VHO_Struct_Alignment variable).
    // if (    TY_align(src_ty_idx) == TY_align(dst_ty_idx)
    if (TY_kind(src_ty_idx) == KIND_STRUCT
          && TY_is_packed(Ty_Table[src_ty_idx]) == FALSE
          && TY_is_packed(Ty_Table[dst_ty_idx]) == FALSE
          && bytes / TY_align(src_ty_idx) <= VHO_Struct_Limit ) {
 
      VHO_Struct_Nfields = 0;
      VHO_Struct_Can_Be_Lowered = TRUE;
      //    VHO_Struct_Alignment = TY_align(dst_ty_idx);
      /* Flatten out the structure into non overlapping fields */
      VHO_Get_Field_List ( 0, src_ty_idx, WN_field_id(src_value) );
 
#ifdef VHO_DEBUG
      if ( VHO_Struct_Debug )
        fprintf ( TFile, "VHO_Lower_Mistore : %s %d\n",
                    VHO_Struct_Can_Be_Lowered ? "TRUE" : "FALSE",
                    (INT32) srcpos );
#endif /* VHO_DEBUG */
 
      if ( VHO_Struct_Can_Be_Lowered && VHO_Struct_Nfields ) {
 
        block = WN_CreateBlock ();
        WN_Set_Linenum ( block, srcpos );
        src_st     = WN_st(src_ldid);
 
        // preserve offset from original ldid/iload
        src_offset = WN_offset(src_value);
        // field_offset = 0;
        for ( i = 0; i < VHO_Struct_Nfields; i++ ) {
 
          TY_IDX   fty_idx;
          WN     * src;
          WN     * dst;
 
          fty_idx = VHO_Struct_Fld_Table [i];
 
          if (src_is_pointer) {
            opc = OPCODE_make_op ( OPR_ILOAD,
                                   Promoted_Mtype [TY_mtype(fty_idx)],
                                   TY_mtype(fty_idx) );
            if (VHO_Struct_Field_Is_Array_Table[i]) {
              src = WN_CreateIload ( opc,
                                     src_offset + VHO_Struct_Offset_Table[i],
                                     fty_idx,
                                     Make_Pointer_Type ( fty_idx),
                                     WN_COPY_Tree (src_iload_kid) );
            } else {
              src = WN_CreateIload ( opc,
                                     src_offset + VHO_Struct_Offset_Table[i],
                                     src_ty_idx, src_ptr_ty_idx,
                                     WN_COPY_Tree (src_iload_kid),
                                     VHO_Struct_Field_Id_Table[i]);
      }
          }
          else {
            opc = OPCODE_make_op ( OPR_LDID,
                                   Promoted_Mtype [TY_mtype(fty_idx)],
                                   TY_mtype(fty_idx) );
            if (VHO_Struct_Field_Is_Array_Table[i]) {
              // each element uses same field_id,
              // so rather than create array refs, just do element copies
              src = WN_CreateLdid ( opc,
                                    src_offset + VHO_Struct_Offset_Table[i],
                                    src_st, fty_idx );
            } else {
              src = WN_CreateLdid ( opc,
                                    src_offset + VHO_Struct_Offset_Table[i],
                                    src_st, src_ty_idx, VHO_Struct_Field_Id_Table[i]);
            }
          }
          opc = OPCODE_make_op ( OPR_ISTORE, MTYPE_V, TY_mtype(fty_idx));
          // See Note (1).
          ty_mismatch = TY_id(src_ty_idx) != TY_id(dst_ty_idx);
          if (VHO_Struct_Field_Is_Array_Table[i] || ty_mismatch || VHO_Disable_Copy_Field_Element) {
            dst = WN_CreateIstore ( opc,
                                    dst_offset + VHO_Struct_Offset_Table[i],
                                    Make_Pointer_Type( fty_idx),
                                    src, WN_COPY_Tree( dst_address ));
            if (VHO_M_Debug_Type_Mismatch && ty_mismatch || VHO_SCL_Debug) {
              fprintf(TFile, "VHO_Lower_Mistore: %stype mismatch, dst WN follows\n",
                      ty_mismatch ? "" : "no ");
              fdump_tree(TFile, dst);
            }
          } else {
            dst = WN_CreateIstore ( opc,
                                    dst_offset + VHO_Struct_Offset_Table[i],
                                    ptr_dst_ty_idx,
                                    src, WN_COPY_Tree( dst_address ),
                                    dst_field_id - src_field_id + VHO_Struct_Field_Id_Table[i]);
            if (VHO_SCL_Debug) {
              fprintf(TFile, "dst_field_id=%d, src_field_id=%d, VHO_Struct_Field_Id_Table[%d]=%d, dst WN follows\n",
                      dst_field_id, src_field_id, i, VHO_Struct_Field_Id_Table[i]);
              fdump_tree(TFile, dst);
            }
          }
          WN_Set_Linenum(dst, srcpos);
 
          WN_INSERT_BlockAfter ( block, WN_last(block), dst );
          // field_offset += TY_size(fty_idx);
        }
        wn = block;
      }
    }
    else {
#ifdef VHO_DEBUG
      if ( VHO_Struct_Debug )
        fprintf ( TFile, "VHO_Lower_Mstid : FALSE %d\n", (INT32) srcpos );
#endif /* VHO_DEBUG */
    }
  }
 
  return wn;
} /* VHO_Lower_Mistore */
 
static void
vho_lower_set_st_addr_info ( WN * wn, ADDRESS_INFO_TYPE code )
{
  OPCODE     opc;
  OPERATOR   wn_operator;
  ST       * st;
 
  opc = WN_opcode(wn);
  wn_operator = OPCODE_operator(opc);
 
  switch ( wn_operator ) {
 
    case OPR_LDA:
 
      st = WN_st(wn);
      if ( ST_class(st) == CLASS_VAR || ST_class(st) == CLASS_FUNC ) {
 
        if ( code == ADDRESS_PASSED ) {
 
          if ( WHIRL_Addr_Passed_On ) {
            Set_ST_addr_taken_passed(st);
 
            if ( WHIRL_Addr_Saved_For_Passed_On )
              Set_ST_addr_taken_saved(st);
          }
        }
 
        else
          Set_ST_addr_taken_saved(st);
      }
      break;
 
    case OPR_ARRAY:
 
      vho_lower_set_st_addr_info ( WN_kid0(wn), code );
      break;
 
    case OPR_LDID:
/*
      st = WN_st(wn);
      if ( ST_sclass(st) == SCLASS_FORMAL && (ST_class(st) == CLASS_VAR ||
                ST_class(st) == CLASS_FUNC ))
        if ( code == ADDRESS_PASSED )
          Set_ST_addr_taken_passed(st);
        else
          Set_ST_addr_taken_saved(st);
      break;
*/
    case OPR_CONST:
    case OPR_ILOAD:
    case OPR_MLOAD:
    case OPR_INTCONST:
    case OPR_INTRINSIC_OP:
    case OPR_CALL:
    case OPR_EQ:
    case OPR_NE:
    case OPR_GT:
    case OPR_GE:
    case OPR_LT:
    case OPR_LE:
      break;
 
    case OPR_EVAL:
    case OPR_TAS:
    case OPR_CVT:
    case OPR_CVTL:
    case OPR_NEG:
    case OPR_ABS:
    case OPR_SQRT:
    case OPR_REALPART:
    case OPR_IMAGPART:
    case OPR_PAREN:
    case OPR_RND:
    case OPR_TRUNC:
    case OPR_CEIL:
    case OPR_FLOOR:
    case OPR_BNOT:
    case OPR_LNOT:
    case OPR_DIVPART:
    case OPR_REMPART:
    case OPR_MINPART:
    case OPR_MAXPART:
    case OPR_RECIP:
    case OPR_RSQRT:
    case OPR_PARM:
 
      vho_lower_set_st_addr_info ( WN_kid0(wn), code );
      break;
 
    case OPR_SELECT:
    case OPR_CSELECT:
    case OPR_ADD:
    case OPR_SUB:
    case OPR_MPY:
    case OPR_DIV:
    case OPR_MOD:
    case OPR_REM:
    case OPR_DIVREM:
    case OPR_MAX:
    case OPR_MIN:
    case OPR_MINMAX:
    case OPR_BAND:
    case OPR_BIOR:
    case OPR_BXOR:
    case OPR_BNOR:
    case OPR_LAND:
    case OPR_LIOR:
    case OPR_SHL:
    case OPR_ASHR:
    case OPR_LSHR:
    case OPR_COMPLEX:
    case OPR_HIGHMPY:
#ifdef KEY
    case OPR_COMPOSE_BITS:
#endif
 
      vho_lower_set_st_addr_info ( WN_kid0(wn), code );
      vho_lower_set_st_addr_info ( WN_kid1(wn), code );
      break;
 
    case OPR_CAND:
    case OPR_CIOR:
 
      break;
 
    case OPR_COMMA:
 
      vho_lower_set_st_addr_info ( WN_kid1(wn), code );
      break;
 
    case OPR_RCOMMA:
 
      vho_lower_set_st_addr_info ( WN_kid0(wn), code );
      break;
 
    default:
 
      FmtAssert ( TRUE,
                  ("vho_lower_set_st_addr_info not implemented") );
  }
} /* vho_lower_set_st_addr_taken */
 
 
static void
vho_initialize_bool_info ( BOOL_INFO * bool_info )
{
  bool_info->opcode           = OPCODE_UNKNOWN;
  bool_info->used_true_label  = FALSE;
  bool_info->used_false_label = FALSE;
  bool_info->true_label       = 0;
  bool_info->false_label      = 0;
} /* vho_initialize_bool_info */
 
 
static WN *
vho_lower_comma ( WN * wn, WN *block, BOOL_INFO * bool_info, BOOL is_return=FALSE)
{
  WN       * comma_block;
  WN       * result_block;
  WN       * result;
  WN       * first;
  WN       * value;
  WN       * stmt;
  WN       * prev_call;
  PREG_NUM   preg;
  BOOL       call;
 
  result = WN_kid1 (wn);
  if( PU_cxx_lang (Get_Current_PU()) && WN_operator(WN_last(WN_kid0(wn))) == OPR_STID)
    prev_call = WN_kid0(WN_last(WN_kid0(wn)));
  else
    prev_call = NULL;
  call   =   WHIRL_Return_Val_On
          && WN_operator(result) == OPR_LDID
          && WN_st(result) == Return_Val_Preg;
 
  if ( PU_cxx_lang (Get_Current_PU())&&
       prev_call &&
       WN_operator(prev_call) == OPR_LDID &&
       (WN_st(prev_call) == Return_Val_Preg || is_return)&&
       WN_rtype(prev_call) == MTYPE_M &&
       WN_rtype(wn) == MTYPE_M){
    WN_Set_Linenum ( block, VHO_Srcpos );
    WN * next_wn;
 
    for ( wn = WN_first( WN_kid0(wn)); wn; wn = next_wn ) {
      next_wn = WN_next(wn);
      if (!next_wn) {
  result = vho_lower_expr (WN_kid0(wn), block, bool_info);
  break;
      }
      wn = vho_lower ( wn, block );
      if ( wn )
  WN_INSERT_BlockLast ( block, wn );
    }
    return result;
  }
 
  comma_block = vho_lower_block (WN_kid0(wn));
  WN_Set_Linenum ( comma_block, VHO_Srcpos );
  first = WN_first(comma_block);
 
  result_block = WN_CreateBlock ();
  result = vho_lower_expr (WN_kid1(wn), result_block, bool_info);
 
  if (    VHO_Call_Opt
       && first
       && WN_first(result_block) == NULL
       && WN_operator(first) == OPR_PRAGMA
       && WN_pragma(first) == WN_PRAGMA_INLINE_BODY_START ) {
/*
    fprintf ( stderr, "INLINE_BODY_START\n" );
    fdump_tree ( stderr, comma_block );
*/
    value = NULL;
    preg  = 0;
 
    stmt = WN_next(first);
 
    for (;;) {
/*
      fprintf ( stderr, "INLINE stmt\n" );
      fdump_tree ( stderr, stmt );
*/
      if (    WN_operator(stmt) == OPR_STID
           && ST_class(WN_st(stmt)) == CLASS_PREG ) {
 
        if ( value == NULL )
          value = WN_kid0(stmt);
 
        else
        if (    WN_operator(WN_kid0(stmt)) == OPR_LDID
             && ST_class(WN_st(WN_kid0(stmt))) == CLASS_PREG
             && WN_load_offset(WN_kid0(stmt)) == preg ) {
        }
 
        else
          break;
 
        preg = WN_store_offset(stmt);
/*
        fprintf ( stderr, "preg = %d\n", preg );
*/
      }
 
      else
      if (    WN_operator(stmt) == OPR_PRAGMA
           && WN_pragma(stmt) == WN_PRAGMA_INLINE_BODY_END ) {
 
        stmt = WN_next(stmt);
/*
        fprintf ( stderr, "INLINE_BODY_END\n" );
        fprintf ( stderr, "result\n" );
        fdump_tree ( stderr, result );
        fprintf ( stderr, "stmt\n" );
        fdump_tree ( stderr, stmt );
*/
        if (    stmt
             && WN_next(stmt) == NULL
             && WN_operator(stmt) == OPR_STID
             && ST_class(WN_st(stmt)) == CLASS_PREG ) {
 
          if ( value == NULL )
            value = WN_kid0(stmt);
 
          else
          if (    WN_operator(WN_kid0(stmt)) == OPR_LDID
               && ST_class(WN_st(WN_kid0(stmt))) == CLASS_PREG
               && WN_load_offset(WN_kid0(stmt)) == preg ) {
          }
 
          else
            break;
        }
 
        else
          break;
 
        preg = WN_store_offset(stmt);
/*
        fprintf ( stderr, "preg = %d\n", preg );
        fprintf ( stderr, "value\n" );
        fdump_tree ( stderr, value );
        fprintf ( stderr, "preg = %d\n", preg );
*/
        if (    value
             && WN_operator(result) == OPR_LDID
             && ST_class(WN_st(result)) == CLASS_PREG
             && WN_load_offset(result) == preg ) {
 
          comma_block = NULL;
          result = WN_Simplify_Tree ( value );
/*
          fprintf ( stderr, "vho_lower_comma: inline old\n" );
          fdump_tree ( stderr, wn );
          fprintf ( stderr, "vho_lower_comma: inline new\n" );
          fdump_tree ( stderr, result );
*/
        }
 
        break;
      }
 
      else
        break;
 
      stmt = WN_next(stmt);
    }
  }
 
  if ( comma_block ) {
 
    if (call) {
 
      TYPE_ID rtype  = WN_rtype (result);
      TYPE_ID desc   = WN_desc  (result);
      TY_IDX  ty_idx = WN_ty (result);
 
      if (desc == MTYPE_M) {
 
        ST* st = Gen_Temp_Symbol (ty_idx, ".call");
        wn = WN_CreateStid (OPC_MSTID, 0, st, ty_idx, result);
        WN_Set_Linenum ( wn, VHO_Srcpos );
        WN_INSERT_BlockLast (comma_block, wn);
        result = WN_CreateLdid (OPC_MMLDID, 0, st, ty_idx);
      }
#ifdef TARG_X8664
      else if (MTYPE_is_complex(desc) ||
               MTYPE_is_mmx_vector(desc)) {
        ST* st = Gen_Temp_Symbol (ty_idx, ".call");
        wn = WN_CreateStid (OPR_STID, MTYPE_V, desc, 0, st, ty_idx, result);
        WN_Set_Linenum ( wn, VHO_Srcpos );
        WN_INSERT_BlockLast (comma_block, wn);
        result = WN_CreateLdid (OPR_LDID, desc, desc, 0, st, ty_idx);
      }
#endif
 
      else {
 
#ifdef KEY
  if (VHO_In_MP_Region_Pragma)
  { // Use a temporary symbol instead of a preg
    ST * comma_st = Gen_Temp_Symbol (MTYPE_TO_TY_array[rtype], "_comma");
    wn = WN_Stid (rtype, 0, comma_st, ty_idx, result);
          WN_Set_Linenum ( wn, VHO_Srcpos );
          WN_INSERT_BlockLast (comma_block, wn);
    result = WN_Ldid (rtype, 0, comma_st, ty_idx);
  }
  else
#endif // KEY
  {
          PREG_NUM preg    = Create_Preg (rtype, vho_lower_comma_name);
          ST*      preg_st = MTYPE_To_PREG (rtype);
          OPCODE   opcode  = OPCODE_make_op (OPR_STID, MTYPE_V, rtype);
          wn = WN_CreateStid (opcode, preg, preg_st, ty_idx, result);
          WN_Set_Linenum ( wn, VHO_Srcpos );
          WN_INSERT_BlockLast (comma_block, wn);
          opcode = OPCODE_make_op (OPR_LDID, rtype, rtype);
          result = WN_CreateLdid (opcode, preg, preg_st, ty_idx);
  }
      }
    }
 
#ifdef KEY
    if (VHO_In_MP_Region_Pragma && WN_operator (result) == OPR_LDID &&
        ST_class (WN_st (result)) == CLASS_PREG)
    {
      // This can be caused by inlining of a call inside an xpragma, where
      // we need to use a temporary instead of a preg.
      TYPE_ID rtype = WN_rtype (result);
      ST * comma_st = Gen_Temp_Symbol (MTYPE_TO_TY_array[rtype], "_comma");
      WN * stid = WN_Stid (rtype, 0, comma_st, WN_ty (result), result);
      WN_Set_Linenum (stid, VHO_Srcpos);
      WN_INSERT_BlockLast (comma_block, stid);
      result = WN_Ldid (rtype, 0, comma_st, WN_ty (result));
    }
 
    // If this comma node is inside an atomic pragma, insert the lowered
    // comma block before the pragma node, since omp-lowerer expects the
    // atomic store to be the next stmt after the pragma
    WN * last = WN_last (block);
    if (last && WN_operator (last) == OPR_PRAGMA &&
        WN_pragma (last) == WN_PRAGMA_ATOMIC)
    {
      WN_INSERT_BlockBefore ( block, WN_last (block), comma_block );
    }
    else
#endif // KEY
      WN_INSERT_BlockLast ( block, comma_block );
  }
 
  if ( WN_first(result_block) ) {
 
    WN_INSERT_BlockLast ( block, result_block );
  }
 
  wn = result;
 
  return wn;
} /* vho_lower_comma */
 
 
static WN *
vho_lower_rcomma ( WN * wn, WN *block, BOOL_INFO * bool_info )
{
  WN       * rcomma_block;
  WN       * test;
  TYPE_ID    preg_mtype;
  PREG_NUM   preg;
  ST       * preg_st;
  TY_IDX     preg_ty_idx;
  OPCODE     opcode;
 
  preg_mtype = WN_rtype(wn);
  rcomma_block = WN_CreateBlock ();
  WN_Set_Linenum ( rcomma_block, VHO_Srcpos );
 
  test         = vho_lower_expr (WN_kid0(wn), rcomma_block, bool_info);
  if ( WN_first(rcomma_block) )
    WN_INSERT_BlockLast ( block, rcomma_block );
  rcomma_block = vho_lower_block ( WN_kid1(wn));
 
  preg = Create_Preg (preg_mtype, vho_lower_rcomma_name);
 
  preg_st      = MTYPE_To_PREG ( preg_mtype );
  preg_ty_idx  = Be_Type_Tbl(preg_mtype);
  opcode       = OPCODE_make_op ( OPR_STID, MTYPE_V, preg_mtype );
  wn           = WN_CreateStid ( opcode, preg, preg_st, preg_ty_idx, test );
  WN_Set_Linenum ( wn, VHO_Srcpos );
 
  WN_INSERT_BlockLast ( block, wn  );
  WN_INSERT_BlockLast ( block, rcomma_block );
  opcode     = OPCODE_make_op ( OPR_LDID, Promoted_Mtype [preg_mtype],
                                preg_mtype );
  wn = WN_CreateLdid ( opcode, preg, preg_st, preg_ty_idx );
 
  return wn;
} /* vho_lower_rcomma */
 
 
static WN *
vho_simplify_cand ( WN * wn, WN * l_wn, WN * r_wn )
{
  BOOL       simplified;
  OPCODE     l_opc;
  OPCODE     r_opc;
  OPERATOR   l_oper;
  OPERATOR   r_oper;
  OPERATOR   ll_oper;
  OPERATOR   lr_oper;
  OPERATOR   rl_oper;
  OPERATOR   rr_oper;
  OPERATOR   llr_oper;
  OPERATOR   rlr_oper;
 
  WN       * ll_wn;
  WN       * lr_wn;
  WN       * rl_wn;
  WN       * rr_wn;
  WN       * lll_wn;
  WN       * llr_wn;
  WN       * rll_wn;
  WN       * rlr_wn;
 
  simplified = FALSE;
 
  l_opc  = WN_opcode(l_wn);
  r_opc  = WN_opcode(r_wn);
  l_oper = OPCODE_operator(l_opc);
  r_oper = OPCODE_operator(r_opc);
 
  /* simplify
   *          ( e && e )
   * to
   *          ( e )
   */
 
  if ( WN_Simp_Compare_Trees ( l_wn, r_wn ) == 0 ) {
 
    wn = l_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *          ( e && TRUE )
   * to
   *          ( e )
   */
 
  else
  if (    r_oper == OPR_INTCONST
       && WN_const_val(r_wn) == 1 ) {
 
    wn = l_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *          ( e && FALSE )
   * to
   *          ( FALSE )
   */
 
  else
  if (    r_oper == OPR_INTCONST
       && WN_const_val(r_wn) == 0 ) {
 
    wn = r_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *          ( TRUE && e )
   * to
   *          ( e )
   */
 
  else
  if (    l_oper == OPR_INTCONST
       && WN_const_val(l_wn) == 1 ) {
 
    wn = r_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *          ( FALSE && e )
   * to
   *          ( FALSE )
   */
 
  else
  if (    l_oper == OPR_INTCONST
       && WN_const_val(l_wn) == 0 ) {
 
    wn = l_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *           ( ( e1 || e2 ) && ( e1 || e3 ) )
   * to
   *           ( e1 || ( e2 && e3 ) )
   */
 
  else
  if (    l_oper == OPR_CIOR
       && r_oper == OPR_CIOR ) {
 
    ll_wn   = WN_kid0(l_wn);
    lr_wn   = WN_kid1(l_wn);
    rl_wn   = WN_kid0(r_wn);
    rr_wn   = WN_kid1(r_wn);
 
    if ( WN_Simp_Compare_Trees ( ll_wn, rl_wn ) == 0 ) {
 
      WN *r_wn_new = WN_Create ( OPC_I4CAND, 2 );
      WN_kid0(r_wn_new) = lr_wn;
      WN_kid1(r_wn_new) = rr_wn;
      wn = WN_Create ( OPC_I4CIOR, 2 );
      WN_kid0(wn) = ll_wn;
      WN_kid1(wn) = r_wn_new;
      simplified = TRUE;
 
      if ( Cur_PU_Feedback )
  Cur_PU_Feedback->FB_factor_circuit( l_wn, r_wn, wn, r_wn_new );
    }
  }
 
  /* simplify
   *          ( ( ( e & c1 ) != 0 ) && ( ( e & c2 ) != 0 ) )
   * to
   *          ( ( e & ( c1 | c2 ) ) == ( c1 | c2 ) )
   */
 
  else
  if (    l_oper == OPR_NE
       && r_oper == OPR_NE
       && l_opc  == r_opc ) {
 
    ll_wn   = WN_kid0(l_wn);
    lr_wn   = WN_kid1(l_wn);
    rl_wn   = WN_kid0(r_wn);
    rr_wn   = WN_kid1(r_wn);
 
    ll_oper = WN_operator(ll_wn);
    lr_oper = WN_operator(lr_wn);
    rl_oper = WN_operator(rl_wn);
    rr_oper = WN_operator(rr_wn);
 
    if (    ll_oper == OPR_BAND
         && lr_oper == OPR_INTCONST
         && WN_const_val(lr_wn) == 0
         && rl_oper == OPR_BAND
         && rr_oper == OPR_INTCONST
         && WN_const_val(rr_wn) == 0 ) {
 
       lll_wn = WN_kid0(ll_wn);
       llr_wn = WN_kid1(ll_wn);
       rll_wn = WN_kid0(rl_wn);
       rlr_wn = WN_kid1(rl_wn);
 
       llr_oper = WN_operator(llr_wn);
       rlr_oper = WN_operator(rlr_wn);
 
       if (    llr_oper == OPR_INTCONST
            && rlr_oper == OPR_INTCONST
            && WN_Simp_Compare_Trees ( lll_wn, rll_wn ) == 0
            && IS_POWER_OF_2(WN_const_val(llr_wn))
            && IS_POWER_OF_2(WN_const_val(rlr_wn)) ) {
 
         r_wn = rlr_wn;
         WN_const_val(r_wn) |= WN_const_val(llr_wn);
         ll_wn = lll_wn;
         lr_wn = llr_wn;
         WN_const_val(lr_wn) = WN_const_val(r_wn);
         l_wn = WN_CreateExp2 ( WN_opcode(rl_wn), ll_wn, lr_wn );
#ifdef KEY
   if( MTYPE_is_size_double(WN_rtype(l_wn)) )
     wn = WN_CreateExp2 ( OPC_I4I8EQ, l_wn, r_wn );
   else
#endif
     wn = WN_CreateExp2 ( OPC_I4I4EQ, l_wn, r_wn );
         simplified = TRUE;
       }
    }
  }
 
  if ( ! simplified ) {
 
    if (    WN_kid0(wn) != l_wn
         || WN_kid1(wn) != r_wn ) {
 
      wn = WN_Create ( OPC_I4CAND, 2 );
      WN_kid0(wn) = l_wn;
      WN_kid1(wn) = r_wn;
    }
  }
 
  return wn;
} /* vho_simplify_cand */
 
static WN *
vho_simplify_cior ( WN * wn, WN * l_wn, WN * r_wn )
{
  BOOL       simplified;
  OPCODE     l_opc;
  OPCODE     r_opc;
  OPERATOR   l_oper;
  OPERATOR   r_oper;
  OPERATOR   ll_oper;
  OPERATOR   lr_oper;
  OPERATOR   rl_oper;
  OPERATOR   rr_oper;
  OPERATOR   llr_oper;
  OPERATOR   rlr_oper;
 
  WN       * ll_wn;
  WN       * lr_wn;
  WN       * rl_wn;
  WN       * rr_wn;
  WN       * lll_wn;
  WN       * llr_wn;
  WN       * rll_wn;
  WN       * rlr_wn;
 
  simplified = FALSE;
 
  l_opc  = WN_opcode(l_wn);
  r_opc  = WN_opcode(r_wn);
  l_oper = OPCODE_operator(l_opc);
  r_oper = OPCODE_operator(r_opc);
 
  if ( WN_Simp_Compare_Trees ( l_wn, r_wn ) == 0 ) {
 
    wn = l_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *          ( e || TRUE )
   * to
   *          ( TRUE )
   */
 
  else
  if (    r_oper == OPR_INTCONST
       && WN_const_val(r_wn) == 1 ) {
 
    wn = r_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *          ( e && FALSE )
   * to
   *          ( e )
   */
 
  else
  if (    r_oper == OPR_INTCONST
       && WN_const_val(r_wn) == 0 ) {
 
    wn = l_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *          ( TRUE || e )
   * to
   *          ( TRUE )
   */
 
  else
  if (    l_oper == OPR_INTCONST
       && WN_const_val(l_wn) == 1 ) {
 
    wn = l_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *          ( FALSE || e )
   * to
   *          ( e )
   */
 
  else
  if (    l_oper == OPR_INTCONST
       && WN_const_val(l_wn) == 0 ) {
 
    wn = r_wn;
    simplified = TRUE;
  }
 
  /* simplify
   *           ( ( e1 && e2 ) || ( e1 && e3 ) )
   * to
   *           ( e1 && ( e2 || e3 ) )
   */
 
  else
  if (    l_oper == OPR_CAND
       && r_oper == OPR_CAND ) {
 
    ll_wn   = WN_kid0(l_wn);
    lr_wn   = WN_kid1(l_wn);
    rl_wn   = WN_kid0(r_wn);
    rr_wn   = WN_kid1(r_wn);
 
    if ( WN_Simp_Compare_Trees ( ll_wn, rl_wn ) == 0 ) {
 
      WN *r_wn_new = WN_Create ( OPC_I4CIOR, 2 );
      WN_kid0(r_wn_new) = lr_wn;
      WN_kid1(r_wn_new) = rr_wn;
      wn = WN_Create ( OPC_I4CAND, 2 );
      WN_kid0(wn) = ll_wn;
      WN_kid1(wn) = r_wn_new;
      simplified = TRUE;
 
      if ( Cur_PU_Feedback )
  Cur_PU_Feedback->FB_factor_circuit( l_wn, r_wn, wn, r_wn_new );
    }
  }
 
  /* simplify
   *          ( ( ( e & c1 ) != 0 ) || ( ( e & c2 ) != 0 ) )
   * to
   *          ( e & ( c1 | c2 ) )
   */
 
  else
  if (    l_oper == OPR_NE
       && r_oper == OPR_NE
       && l_opc  == r_opc ) {
 
    ll_wn   = WN_kid0(l_wn);
    lr_wn   = WN_kid1(l_wn);
    rl_wn   = WN_kid0(r_wn);
    rr_wn   = WN_kid1(r_wn);
 
    ll_oper = WN_operator(ll_wn);
    lr_oper = WN_operator(lr_wn);
    rl_oper = WN_operator(rl_wn);
    rr_oper = WN_operator(rr_wn);
 
    if (    ll_oper == OPR_BAND
         && lr_oper == OPR_INTCONST
         && WN_const_val(lr_wn) == 0
         && rl_oper == OPR_BAND
         && rr_oper == OPR_INTCONST
         && WN_const_val(rr_wn) == 0 ) {
 
      lll_wn = WN_kid0(ll_wn);
      llr_wn = WN_kid1(ll_wn);
      rll_wn = WN_kid0(rl_wn);
      rlr_wn = WN_kid1(rl_wn);
 
      llr_oper = WN_operator(llr_wn);
      rlr_oper = WN_operator(rlr_wn);
 
      if (    llr_oper == OPR_INTCONST
           && rlr_oper == OPR_INTCONST
           && WN_Simp_Compare_Trees ( lll_wn, rll_wn ) == 0 ) {
 
        ll_wn = lll_wn;
        lr_wn = llr_wn;
        WN_const_val(lr_wn) |= WN_const_val(rlr_wn);
        l_wn = WN_CreateExp2 ( WN_opcode(rl_wn), ll_wn, lr_wn );
        r_wn = rr_wn;
        wn = WN_CreateExp2 ( l_opc, l_wn, r_wn );
        simplified = TRUE;
      }
    }
  }
 
  if ( ! simplified ) {
 
    if (    WN_kid0(wn) != l_wn
         || WN_kid1(wn) != r_wn ) {
 
      wn = WN_Create ( OPC_I4CIOR, 2 );
      WN_kid0(wn) = l_wn;
      WN_kid1(wn) = r_wn;
    }
  }
 
  return wn;
} /* vho_simplify_cior */
 
 
static WN *
vho_simplify_cand_cior ( WN * wn )
{
  WN * lwn;
  WN * rwn;
 
  switch ( WN_opcode(wn) ) {
 
// >> WHIRL 0.30: replaced OPC_CAND by OPC_B and OPC_I4 variants
// TODO WHIRL 0.30: get rid of OPC_I4 variant
    case OPC_BCAND:
    case OPC_I4CAND:
// << WHIRL 0.30: replaced OPC_CAND by OPC_B and OPC_I4 variants
 
      lwn = vho_simplify_cand_cior ( WN_kid0(wn) );
      rwn = vho_simplify_cand_cior ( WN_kid1(wn) );
      wn  = vho_simplify_cand ( wn, lwn, rwn );
      break;
 
// >> WHIRL 0.30: replaced OPC_CIOR by OPC_B and OPC_I4 variants
// TODO WHIRL 0.30: get rid of OPC_I4 variant
    case OPC_BCIOR:
    case OPC_I4CIOR:
// << WHIRL 0.30: replaced OPC_CIOR by OPC_B and OPC_I4 variants
 
      lwn = vho_simplify_cand_cior ( WN_kid0(wn) );
      rwn = vho_simplify_cand_cior ( WN_kid1(wn) );
      wn  = vho_simplify_cior ( wn, lwn, rwn );
      break;
  }
 
  return wn;
} /* vho_simplify_cand_cior */
 
 
static WN *
vho_lower_cand_cior ( WN *wn, WN *block, BOOL_INFO *bool_info )
{
  WN        * one;
  WN        * zero;
  WN        * cflow_block1;
  WN        * cflow_block2;
  BOOL_INFO   cflow_bool_info;
  BOOL_INFO   cflow_bool_info1;
  BOOL_INFO   cflow_bool_info2;
  OPCODE      opcode;
  LABEL_IDX   join_label;
  WN        * lwn;
  WN        * rwn;
  PREG_NUM    preg;
  ST        * preg_st;
  TY_IDX      preg_ty_idx;
 
  opcode = WN_opcode(wn);
 
  cflow_block1 = WN_CreateBlock ();
  cflow_block2 = WN_CreateBlock ();
 
  WN_Set_Linenum ( cflow_block1, VHO_Srcpos );
  WN_Set_Linenum ( cflow_block2, VHO_Srcpos );
 
  if ( ! bool_info ) {
 
    vho_initialize_bool_info (&cflow_bool_info);
    LABEL_Init (New_LABEL (CURRENT_SYMTAB, cflow_bool_info.true_label),
  0, LKIND_DEFAULT);
    LABEL_Init (New_LABEL (CURRENT_SYMTAB, cflow_bool_info.false_label),
  0, LKIND_DEFAULT);
    bool_info = &cflow_bool_info;
  }
 
  cflow_bool_info1 = *bool_info;
  cflow_bool_info1.opcode = opcode;
 
  if ( cflow_bool_info1.opcode != OPCODE_UNKNOWN )
    cflow_bool_info1.opcode = opcode;
 
  cflow_bool_info2 = cflow_bool_info1;
 
/*
  if (    bool_info->opcode != OPCODE_UNKNOWN
       && bool_info->opcode != opcode ) {
*/
 
  {
 
    if ( opcode == (OPC_I4CAND) ) {
 
      LABEL_Init (New_LABEL (CURRENT_SYMTAB, cflow_bool_info1.true_label),
  0, LKIND_DEFAULT);
      cflow_bool_info1.used_true_label  = FALSE;
    }
 
    else {
 
      LABEL_Init (New_LABEL (CURRENT_SYMTAB, cflow_bool_info1.false_label),
  0, LKIND_DEFAULT);
      cflow_bool_info1.used_false_label = FALSE;
    }
  }
 
  lwn = vho_lower_expr (WN_kid0(wn), cflow_block1, &cflow_bool_info1);
  rwn = vho_lower_expr (WN_kid1(wn), cflow_block2, &cflow_bool_info2);
  WN_kid0(wn) = lwn;
  WN_kid1(wn) = rwn;
 
  WN *wn_label, *wn_left_branch = NULL, *wn_right_branch = NULL;
 
  if ( WN_first(cflow_block1) )
    WN_INSERT_BlockLast ( block, cflow_block1 );
 
  if (    WN_first(cflow_block2)
       || cflow_bool_info1.used_true_label
       || cflow_bool_info1.used_false_label
       || cflow_bool_info2.used_true_label
       || cflow_bool_info2.used_false_label ) {
 
    if ( opcode == (OPC_I4CAND) ) {
 
      if ( lwn ) {
 
        wn_left_branch
    = WN_CreateFalsebr ( cflow_bool_info1.false_label, lwn );
        WN_Set_Linenum ( wn_left_branch, VHO_Srcpos );
        WN_INSERT_BlockLast ( block, wn_left_branch );
      }
/*
      else
      if ( cflow_bool_info1.used_true_label ) {
 
        WN *wn_goto = WN_CreateGoto ( (ST_IDX) NULL,
                                      cflow_bool_info1.false_label );
        WN_Set_Linenum ( wn_goto, VHO_Srcpos );
        WN_INSERT_BlockLast ( block, wn_goto );
      }
*/
      if ( cflow_bool_info1.used_true_label ) {
 
        wn_label = WN_CreateLabel ( (ST_IDX) 0, cflow_bool_info1.true_label,
            0, NULL );
        WN_Set_Linenum ( wn_label, VHO_Srcpos );
        WN_INSERT_BlockLast ( block, wn_label );
      }
 
      if ( WN_first(cflow_block2) )
        WN_INSERT_BlockLast ( block, cflow_block2 );
 
      if ( rwn ) {
 
        wn_right_branch
    = WN_CreateFalsebr ( cflow_bool_info2.false_label, rwn );
        WN_Set_Linenum ( wn_right_branch, VHO_Srcpos );
        WN_INSERT_BlockLast ( block, wn_right_branch );
 
        if ( bool_info->opcode ) {
 
          if ( opcode != bool_info->opcode ) {
 
            WN *wn_goto
        = WN_CreateGoto ( (ST_IDX) NULL, cflow_bool_info2.true_label );
            WN_Set_Linenum ( wn_goto, VHO_Srcpos );
            WN_INSERT_BlockLast ( block, wn_goto );
 
            cflow_bool_info2.used_true_label = TRUE;
          }
        }
      }
 
      bool_info->used_false_label = TRUE;
      bool_info->used_true_label |= cflow_bool_info2.used_true_label;
 
      if (Cur_PU_Feedback) {
  Cur_PU_Feedback->FB_lower_circuit( wn,
             wn_left_branch, wn_right_branch );
      }
    }
 
    else {
 
      if ( lwn ) {
 
        wn_left_branch = WN_CreateTruebr ( cflow_bool_info1.true_label, lwn );
        WN_Set_Linenum ( wn_left_branch, VHO_Srcpos );
        WN_INSERT_BlockLast ( block, wn_left_branch );
      }
 
      else
      if ( cflow_bool_info1.used_false_label ) {
 
        WN *wn_goto
    = WN_CreateGoto ( (ST_IDX) NULL, cflow_bool_info1.true_label );
        WN_Set_Linenum ( wn_goto, VHO_Srcpos );
        WN_INSERT_BlockLast ( block, wn_goto );
      }
 
      if ( cflow_bool_info1.used_false_label ) {
 
        wn_label
    = WN_CreateLabel ( (ST_IDX) 0, cflow_bool_info1.false_label, 0, NULL );
        WN_Set_Linenum ( wn_label, VHO_Srcpos );
        WN_INSERT_BlockLast ( block, wn_label );
      }
 
      if ( WN_first(cflow_block2) )
        WN_INSERT_BlockLast ( block, cflow_block2 );
 
      if ( rwn ) {
 
  wn_right_branch
    = WN_CreateFalsebr ( cflow_bool_info2.false_label, rwn );
  WN_Set_Linenum ( wn_right_branch, VHO_Srcpos );
  WN_INSERT_BlockLast ( block, wn_right_branch );
  cflow_bool_info2.used_false_label = TRUE;
 
        if ( bool_info->opcode != opcode
       && bool_info->opcode != OPCODE_UNKNOWN ) {
 
    WN *wn_goto
      = WN_CreateGoto ( (ST_IDX) NULL, cflow_bool_info2.true_label );
    WN_Set_Linenum ( wn_goto, VHO_Srcpos );
    WN_INSERT_BlockLast ( block, wn_goto );
        }
      }
/*
      else
      if (    bool_info->opcode != opcode
           && bool_info->opcode != OPCODE_UNKNOWN ) {
 
  WN *wn_goto
    = WN_CreateGoto ( (ST_IDX) NULL, cflow_bool_info2.false_label );
        WN_Set_Linenum ( wn_goto, VHO_Srcpos );
        WN_INSERT_BlockLast ( block, wn_goto );
        cflow_bool_info2.used_false_label = TRUE;
      }
*/
      bool_info->used_true_label   = TRUE;
      bool_info->used_false_label |= cflow_bool_info2.used_false_label;
 
      if (Cur_PU_Feedback)
  Cur_PU_Feedback->FB_lower_circuit( wn,
             wn_left_branch, wn_right_branch );
    }
 
    if ( bool_info == &cflow_bool_info ) {
 
      // TODO: Frequency data for the following
 
      LABEL_Init (New_LABEL (CURRENT_SYMTAB, join_label),
  0, LKIND_DEFAULT);
 
      preg = Create_Preg (MTYPE_I4, vho_lower_cand_cior_name);
 
      preg_st     = MTYPE_To_PREG ( MTYPE_I4 );
      preg_ty_idx = Be_Type_Tbl(MTYPE_I4);
 
      if ( bool_info->used_true_label ) {
 
        wn = WN_CreateLabel ( (ST_IDX) 0, bool_info->true_label, 0, NULL );
        WN_Set_Linenum ( wn, VHO_Srcpos );
        WN_INSERT_BlockLast ( block, wn );
      }
 
      one = WN_CreateIntconst ( OPC_I4INTCONST, 1 );
      wn  = WN_CreateStid ( OPC_I4STID, preg, preg_st, preg_ty_idx, one );
      WN_Set_Linenum ( wn, VHO_Srcpos );
      WN_INSERT_BlockLast ( block, wn );
 
      wn = WN_CreateGoto ( (ST_IDX) NULL, join_label );
      WN_Set_Linenum ( wn, VHO_Srcpos );
      WN_INSERT_BlockLast ( block, wn );
 
      wn = WN_CreateLabel ( (ST_IDX) 0, bool_info->false_label, 0, NULL );
      WN_Set_Linenum ( wn, VHO_Srcpos );
      WN_INSERT_BlockLast ( block, wn );
 
      zero    = WN_CreateIntconst ( OPC_I4INTCONST, 0 );
      wn      = WN_CreateStid ( OPC_I4STID, preg, preg_st, preg_ty_idx, zero );
      WN_Set_Linenum ( wn, VHO_Srcpos );
      WN_INSERT_BlockLast ( block, wn );
 
      wn = WN_CreateLabel ( (ST_IDX) 0, join_label, 0, NULL );
      WN_Set_Linenum ( wn, VHO_Srcpos );
      WN_INSERT_BlockLast ( block, wn );
 
      wn      = WN_CreateLdid ( OPC_I4I4LDID, preg, preg_st, preg_ty_idx );
    }
 
    else
 
      wn = NULL;
  }
 
  else {
 
    wn = vho_simplify_cand_cior ( wn );
  }
 
  return wn;
} /* vho_lower_cand_cior */
 
 
static WN *
vho_lower_cselect ( WN * wn_cselect, WN * block, BOOL_INFO * bool_info )
{
  WN        * wn = wn_cselect;
  WN        * cflow_block;
  WN        * cflow_block1;
  WN        * cflow_block2;
  BOOL_INFO   cflow_bool_info;
  WN        * test;
  WN        * lwn;
  WN        * rwn;
  TYPE_ID     preg_mtype;
  PREG_NUM    preg;
  ST        * preg_st;
  TY_IDX      preg_ty_idx;
  OPCODE      opcode;
  OPCODE      addopc;
  OPCODE      intopc;
  LABEL_IDX   join_label;
  BOOL        mcselect;
  BOOL        vcselect;
  TY_IDX      ty_idx;
  WN_OFFSET   offset;
  WN_OFFSET   lwn_offset;
  WN_OFFSET   rwn_offset;
  WN        * swn;
  BOOL        has_side_effects;
 
  vcselect     = FALSE;
  mcselect     = FALSE;
  cflow_block  = WN_CreateBlock ();
  cflow_block1 = WN_CreateBlock ();
  cflow_block2 = WN_CreateBlock ();
 
  WN_Set_Linenum ( cflow_block,  VHO_Srcpos );
  WN_Set_Linenum ( cflow_block1, VHO_Srcpos );
  WN_Set_Linenum ( cflow_block2, VHO_Srcpos );
 
  vho_initialize_bool_info (&cflow_bool_info);
 
  LABEL_Init (New_LABEL (CURRENT_SYMTAB, cflow_bool_info.true_label),
  0, LKIND_DEFAULT);
  LABEL_Init (New_LABEL (CURRENT_SYMTAB, cflow_bool_info.false_label),
  0, LKIND_DEFAULT);
 
  opcode = WN_opcode(wn_cselect);
  test   = vho_lower_expr ( WN_kid0(wn_cselect), cflow_block,
          &cflow_bool_info );
  lwn    = vho_lower_expr ( WN_kid1(wn_cselect), cflow_block1, NULL );
  rwn    = vho_lower_expr ( WN_kid2(wn_cselect), cflow_block2, NULL );
 
  if (    WHIRL_Mldid_Mstid_On && opcode == OPC_MCSELECT && test != NULL ) {
 
    // CSELECT                             IF
    //  <test>                              <test>
    //  <then_expr>                        THEN
    //  <else_expr>            ===>          <then_expr>
    //                                      STID <preg>
    //                                     ELSE
    //                                       <else_expr>
    //                                      STID <preg>
    //                                     END_IF
 
    ty_idx = WN_ty(lwn);
#ifdef KEY // bug 5179
    if (WN_field_id(lwn) != 0)
      ty_idx = get_field_type(ty_idx, WN_field_id(lwn));
#endif
    ST* temp = Gen_Temp_Symbol (ty_idx, ".mcselect");
 
    wn = WN_CreateStid (OPR_STID, MTYPE_V, MTYPE_M,
                        0, ST_st_idx (temp), ty_idx, lwn);
    WN_Set_Linenum (wn, VHO_Srcpos);
    WN_INSERT_BlockLast (cflow_block1, wn);
 
    wn = WN_CreateStid (OPR_STID, MTYPE_V, MTYPE_M,
                        0, ST_st_idx (temp), ty_idx, rwn);
    WN_Set_Linenum (wn, VHO_Srcpos);
    WN_INSERT_BlockLast (cflow_block2, wn);
 
    wn = WN_CreateIf (test, cflow_block1, cflow_block2);
    WN_Set_Linenum ( wn, VHO_Srcpos );
    if ( Cur_PU_Feedback ) {
      Cur_PU_Feedback->FB_lower_branch( wn_cselect, wn );
    }
 
    if (WN_first (cflow_block))
      WN_INSERT_BlockLast (block, cflow_block);
 
    WN_INSERT_BlockLast (block, wn);
 
    wn = WN_CreateLdid (OPR_LDID, MTYPE_M, MTYPE_M,
                        0, ST_st_idx (temp), ty_idx);
    return wn;
  }
 
  if (    VHO_Cselect_Opt
       && WN_first(cflow_block) == NULL
       && WN_first(cflow_block1) == NULL
       && WN_first(cflow_block2) == NULL
       && cflow_bool_info.used_true_label == FALSE
       && cflow_bool_info.used_false_label == FALSE ) {
 
    if ( opcode == OPC_VCSELECT ) {
 
    }
 
    else
    if ( opcode == OPC_MCSELECT ) {
 
    }
 
    else {
 
      has_side_effects =    VHO_WN_has_side_effects ( test )
                         || VHO_WN_has_side_effects ( lwn )
                         || VHO_WN_has_side_effects ( rwn );
 
      if ( has_side_effects == FALSE ) {
 
        /* kt != 0 ? kt : 0 => kt */
#ifdef KEY // bug 5363 and bug 5817
        if ( ( ! MTYPE_is_float(WN_desc(test)) || ! Force_IEEE_Comparisons) &&
       WN_operator(test) == OPR_NE &&
       VHO_WN_is_zero(WN_kid1(test)) &&
       WN_Simp_Compare_Trees ( WN_kid0(test), lwn ) == 0 &&
       VHO_WN_is_zero(rwn) )
          return lwn;
#endif
 
#ifdef KEY
  /* (a-b) >= 0 ? (a-b) : (b-a) => abs(a-b) */
        if( ( WN_operator(test) == OPR_GT ||
        WN_operator(test) == OPR_GE ) &&
      VHO_WN_is_zero(WN_kid1(test))   &&
      WN_Simp_Compare_Trees( WN_kid0(test), lwn ) == 0 ){
 
    if( WN_operator(rwn) == OPR_SUB          &&
        WN_operator(lwn) == WN_operator(rwn) &&
        WN_Simp_Compare_Trees( WN_kid0(rwn), WN_kid1(lwn) ) == 0 &&
        WN_Simp_Compare_Trees( WN_kid1(rwn), WN_kid0(lwn) ) == 0 ){
 
      opcode = OPCODE_make_op ( OPR_ABS,
              WN_rtype(wn),
              MTYPE_V );
      wn = WN_CreateExp1 ( opcode, lwn );
      return wn;
    }
  }
 
  /* Handle saturation arithmetic SUB operator by converting it
   * to an intrinsic
   * x =  (y >= 0x8000) ? y - 0x8000 : 0;
   */
#if defined(TARG_X8664)
  if ( WN_operator(test) == OPR_GT &&
       WN_rtype(test) == MTYPE_I4 &&
       WN_desc(test) == MTYPE_U4 &&
       WN_operator(WN_kid1(test)) == OPR_INTCONST &&
       WN_const_val(WN_kid1(test)) == 0x7fff &&
 
       WN_operator(WN_kid2(wn_cselect)) == OPR_INTCONST &&
       WN_const_val(WN_kid2(wn_cselect)) == 0 &&
 
       WN_operator(WN_kid1(wn_cselect)) == OPR_CVTL &&
       WN_cvtl_bits(WN_kid1(wn_cselect)) == 16 &&
       WN_operator(WN_kid0(WN_kid1(wn_cselect))) == OPR_SUB &&
       WN_operator(WN_kid1(WN_kid0(WN_kid1(wn_cselect)))) ==
       OPR_INTCONST &&
       WN_const_val(WN_kid1(WN_kid0(WN_kid1(wn_cselect)))) == 0x8000 &&
 
       WN_has_sym(WN_kid0(test)) &&
       WN_has_sym(WN_kid0(WN_kid0(WN_kid1(wn_cselect)))) &&
       WN_st(WN_kid0(test)) ==
       WN_st(WN_kid0(WN_kid0(WN_kid1(wn_cselect)))) ) {
    WN* kids[2];
    kids[0] = WN_kid0(test);
    kids[1] = WN_kid1(WN_kid0(WN_kid1(wn_cselect)));
    // Create parm nodes for intrinsic op
    kids[0] = WN_CreateParm (MTYPE_U4, kids[0],
           Be_Type_Tbl(MTYPE_U4),
             WN_PARM_BY_VALUE);
    kids[1] = WN_CreateParm (MTYPE_U4, kids[1],
           Be_Type_Tbl(MTYPE_U4),
             WN_PARM_BY_VALUE);
    wn = WN_Create_Intrinsic(OPCODE_make_op(OPR_INTRINSIC_OP,
              MTYPE_U4, MTYPE_V),
           INTRN_SUBSU2, 2, kids);
    return wn;
 
  }
#endif // TARG_X7664
#endif
 
        /* x > 0 ? x : -x => abs(x) */
 
        if (    (    WN_operator(test) == OPR_GT
                  || WN_operator(test) == OPR_GE )
             && VHO_WN_is_zero(WN_kid1(test))
             && WN_Simp_Compare_Trees ( WN_kid0(test), lwn ) == 0
             && WN_operator(rwn) == OPR_NEG
             && WN_Simp_Compare_Trees ( lwn, WN_kid0(rwn) ) == 0 ) {
 
          DevWarn ( "%s: %s %s\n",
                    OPCODE_name(WN_opcode(wn)),
                    MTYPE_name(WN_rtype(wn)),
                    MTYPE_name(WN_desc(wn)) );
 
          if ( MTYPE_signed(WN_rtype(wn)) ) {
 
            opcode = OPCODE_make_op ( OPR_ABS,
                                      WN_rtype(wn),
                                      MTYPE_V );
            wn = WN_CreateExp1 ( opcode, lwn );
/*
            fdump_tree ( stderr, wn );
*/
            return wn;
          }
        }
 
        /* x >= y ? x : y => max(x) */
 
        if (    (    WN_operator(test) == OPR_GT
                  || WN_operator(test) == OPR_GE )
             && WN_Simp_Compare_Trees ( WN_kid0(test), lwn ) == 0
             && WN_Simp_Compare_Trees ( WN_kid1(test), rwn ) == 0
#if defined(TARG_SL)
             && MTYPE_is_integral(WN_desc(test))
#endif
   ) {
 
          DevWarn ( "%s: %s %s\n",
                    OPCODE_name(WN_opcode(wn)),
                    MTYPE_name(WN_rtype(wn)),
                    MTYPE_name(WN_desc(wn)) );
 
          opcode = OPCODE_make_op ( OPR_MAX,
                                    WN_rtype(wn),
                                    MTYPE_V );
          wn = WN_CreateExp2 ( opcode, lwn, rwn );
/*
          fdump_tree ( stderr, wn );
*/
          return wn;
        }
 
        /* x <= y ? x : y => min(x) */
 
        if (    (    WN_operator(test) == OPR_LT
                  || WN_operator(test) == OPR_LE )
             && WN_Simp_Compare_Trees ( WN_kid0(test), lwn ) == 0
             && WN_Simp_Compare_Trees ( WN_kid1(test), rwn ) == 0
#if defined(TARG_SL)
             && MTYPE_is_integral(WN_desc(test))
#endif
   ) {
 
          DevWarn ( "%s: %s %s\n",
                    OPCODE_name(WN_opcode(wn)),
                    MTYPE_name(WN_rtype(wn)),
                    MTYPE_name(WN_desc(wn)) );
 
          opcode = OPCODE_make_op ( OPR_MIN,
                                    WN_rtype(wn),
                                    MTYPE_V );
          wn = WN_CreateExp2 ( opcode, lwn, rwn );
/*
          fdump_tree ( stderr, wn );
*/
          return wn;
        }
#ifdef TARG_NVISA
        // gcc converts x += (y == 0) into a cond of x+1 or x.
        // Would be more efficient for us if generated straight line code
        // of t = (y == 0); x += t;
        // Rather than try to change what gcc generates,
        // instead look for x and x+-1 in operands,
        // then transform that back to above 2-stmt sequence.
        if (WN_operator(rwn) == OPR_LDID
              && WN_operator(lwn) == OPR_ADD
              && WN_Simp_Compare_Trees ( WN_kid0(lwn), rwn ) == 0
              && WN_operator(WN_kid1(lwn)) == OPR_INTCONST
              && (WN_const_val(WN_kid1(lwn)) == 1
              // either adding or subtracting the condition result
              || WN_const_val(WN_kid1(lwn)) == -1))
        {
          DevWarn("transform cselect back to straightline code");
          ST *st = Gen_Temp_Symbol (MTYPE_To_TY(WN_rtype(test)), "_cond");
          wn = WN_Stid (WN_rtype(test), 0, st, ST_type(st),
                        test, 0);
          WN_Set_Linenum ( wn, VHO_Srcpos );
          WN_INSERT_BlockLast ( block, wn );
 
          WN *ldid = WN_Ldid (WN_rtype(test), 0, st, ST_type(st));
          if (WN_rtype(test) != WN_rtype(rwn))
            ldid = WN_Cvt(WN_rtype(test), WN_rtype(rwn), ldid);
          if (WN_const_val(WN_kid1(lwn)) == 1)
            wn = WN_Binary(OPR_ADD, WN_rtype(rwn), rwn, ldid);
          else
            wn = WN_Binary(OPR_SUB, WN_rtype(rwn), rwn, ldid);
           return wn;
         }
        // similar to above, but check for cond ? x|1 : x; which is just x|cond
        else if (WN_operator(rwn) == OPR_LDID
                   && WN_operator(lwn) == OPR_BIOR
                   && WN_Simp_Compare_Trees ( WN_kid0(lwn), rwn ) == 0
                   && WN_operator(WN_kid1(lwn)) == OPR_INTCONST
                   && WN_const_val(WN_kid1(lwn)) == 1)
        {
          DevWarn("transform cselect back to straightline code");
          ST *st = Gen_Temp_Symbol (MTYPE_To_TY(WN_rtype(test)), "_cond");
          wn = WN_Stid (WN_rtype(test), 0, st, ST_type(st),
                        test, 0);
          WN_Set_Linenum ( wn, VHO_Srcpos );
          WN_INSERT_BlockLast ( block, wn );
 
          WN *ldid = WN_Ldid (WN_rtype(test), 0, st, ST_type(st));
          if (WN_rtype(test) != WN_rtype(rwn))
            ldid = WN_Cvt(WN_rtype(test), WN_rtype(rwn), ldid);
          wn = WN_Binary(OPR_BIOR, WN_rtype(rwn), rwn, ldid);
          return wn;
        }
// could look for other patterns, but wait and see what shows up.
 #endif
      }
    }
  }
 
  if ( WN_first(cflow_block) )
    WN_INSERT_BlockLast ( block, cflow_block );
 
  if ( opcode == OPC_VCSELECT )
    vcselect = TRUE;
 
  else {
 
    if ( opcode == OPC_MCSELECT ) {
 
      FmtAssert ( (    WN_opcode(lwn) == OPC_MLOAD
                    && WN_opcode(rwn) == OPC_MLOAD ),
                  ("unimplemented case encountered in OPC_MCSELECT") );
 
      mcselect   = TRUE;
      preg_mtype = Pointer_Mtype;
      lwn_offset = WN_offset(lwn);
      rwn_offset = WN_offset(rwn);
      swn        = WN_kid1(lwn);
      ty_idx     = WN_ty(lwn);
      lwn        = WN_kid0(lwn);
      rwn        = WN_kid0(rwn);
 
      if ( lwn_offset == rwn_offset )
        offset = lwn_offset;
 
      else {
 
        offset = 0;
        addopc = OPCODE_make_op ( OPR_ADD, Pointer_Mtype, MTYPE_V );
        intopc = OPCODE_make_op ( OPR_INTCONST, Pointer_Mtype, MTYPE_V );
 
        if ( lwn_offset )
          lwn = WN_CreateExp2 ( addopc,
                                lwn,
                                WN_CreateIntconst ( intopc, lwn_offset ) );
 
        if ( rwn_offset )
          rwn = WN_CreateExp2 ( addopc,
                                rwn,
                                WN_CreateIntconst ( intopc, rwn_offset ) );
      }
    }
 
    else {
 
      preg_mtype = WN_rtype(wn);
    }
 
    vho_lower_set_st_addr_info ( lwn, ADDRESS_SAVED );
    vho_lower_set_st_addr_info ( rwn, ADDRESS_SAVED );
 
    preg = Create_Preg (preg_mtype, vho_lower_cselect_name);
 
    preg_st     = MTYPE_To_PREG ( preg_mtype );
    preg_ty_idx = Be_Type_Tbl(preg_mtype);
    opcode      = OPCODE_make_op ( OPR_STID, MTYPE_V, preg_mtype );
  }
 
  if (    cflow_bool_info.used_true_label
       || cflow_bool_info.used_false_label ) {
 
    LABEL_Init (New_LABEL (CURRENT_SYMTAB, join_label),
  0, LKIND_DEFAULT);
 
    if ( cflow_bool_info.used_true_label ) {
 
      wn = WN_CreateLabel ( (ST_IDX) 0, cflow_bool_info.true_label, 0, NULL );
      WN_Set_Linenum ( wn, VHO_Srcpos );
 
      WN_INSERT_BlockLast ( block, wn );
    }
 
    if ( WN_first(cflow_block1 ) )
      WN_INSERT_BlockLast ( block, cflow_block1 );
 
    if ( ! vcselect ) {
 
      lwn = WN_CreateStid ( opcode, preg, preg_st, preg_ty_idx, lwn );
      WN_Set_Linenum ( lwn, VHO_Srcpos );
 
      WN_INSERT_BlockLast ( block, lwn );
    }
 
    wn = WN_CreateGoto ( (ST_IDX) NULL, join_label );
    WN_Set_Linenum ( wn, VHO_Srcpos );
    if (Cur_PU_Feedback)
      Cur_PU_Feedback->Annot( wn, FB_EDGE_OUTGOING, FB_FREQ_UNKNOWN );
 
    WN_INSERT_BlockLast ( block, wn );
 
    wn = WN_CreateLabel ( (ST_IDX) 0, cflow_bool_info.false_label, 0, NULL );
    WN_Set_Linenum ( wn, VHO_Srcpos );
 
    WN_INSERT_BlockLast ( block, wn );
 
    if ( WN_first(cflow_block2 ) )
      WN_INSERT_BlockLast ( block, cflow_block2 );
 
    if ( ! vcselect ) {
 
      rwn = WN_CreateStid ( opcode, preg, preg_st, preg_ty_idx, rwn );
      WN_Set_Linenum ( rwn, VHO_Srcpos );
 
      WN_INSERT_BlockLast ( block, rwn );
    }
 
    wn = WN_CreateLabel ( (ST_IDX) 0, join_label, 0, NULL );
    WN_Set_Linenum ( wn, VHO_Srcpos );
 
    WN_INSERT_BlockLast ( block, wn );
  }
 
  else {
 
    if ( ! vcselect ) {
 
      // CSELECT                             IF
      //  <test>                              <test>
      //  <then_expr>                        THEN
      //  <else_expr>            ===>          <then_expr>
      //                                      STID <preg>
      //                                     ELSE
      //                                       <else_expr>
      //                                      STID <preg>
      //                                     END_IF
 
      lwn = WN_CreateStid ( opcode, preg, preg_st, preg_ty_idx, lwn );
      WN_Set_Linenum ( lwn, VHO_Srcpos );
 
      WN_INSERT_BlockLast ( cflow_block1, lwn );
 
      rwn = WN_CreateStid ( opcode, preg, preg_st, preg_ty_idx, rwn );
      WN_Set_Linenum ( rwn, VHO_Srcpos );
 
      WN_INSERT_BlockLast ( cflow_block2, rwn );
    }
 
    wn = WN_CreateIf ( test, cflow_block1, cflow_block2 );
    WN_Set_Linenum ( wn, VHO_Srcpos );
    if ( Cur_PU_Feedback ) {
      Cur_PU_Feedback->FB_lower_branch( wn_cselect, wn );
    }
 
    WN_INSERT_BlockLast ( block, wn );
  }
 
  if ( !vcselect ) {
 
    opcode = OPCODE_make_op ( OPR_LDID, Promoted_Mtype [preg_mtype],
                              preg_mtype );
    wn = WN_CreateLdid ( opcode, preg, preg_st, preg_ty_idx );
 
    if ( mcselect )
      wn = WN_CreateMload ( offset, ty_idx, wn, swn );
  }
 
  else
    wn = NULL;
 
  return wn;
} /* vho_lower_cselect */
 
 
#if VHO_DEBUG
#define record_combine_loads_failure(arg1,arg2) \
  fprintf (stderr, "[%d] combine_load_failure at %d of vho_lower.c\n", \
     arg1, arg2);
#else
#define record_combine_loads_failure(x,y)
#endif /* VHO_DEBUG */
 
WN *
vho_lower_combine_loads ( WN * wn )
{
  TYPE_ID    mtype;
  OPCODE     opcode;
  OPCODE     add_opc;
  OPCODE     or_opc;
  OPCODE     shift_opc;
  OPCODE     load_opcode;
  OPERATOR   wn_operator;
  OPERATOR   load_operator;
  INT32      bytes;
  INT32      size;
  INT32      item_size;
  INT32      last_item_size;
  INT32      shift_bits;
  INT32      shift_bytes;
  INT32      last_index;
  WN       * source;
  WN       * lwn;
  WN       * swn;
  WN       * twn;
  WN       * awn1;
  WN       * awn2;
  BOOL       combine;
 
  opcode = WN_opcode(wn);
 
  if ( opcode == OPC_U4ADD || opcode == OPC_U4BIOR ) {
    add_opc   = OPC_U4ADD;
    or_opc    = OPC_U4BIOR;
    shift_opc = OPC_U4SHL;
    size      = 4;
  }
  else if ( opcode == OPC_U8ADD || opcode == OPC_U8BIOR ) {
    add_opc   = OPC_U8ADD;
    or_opc    = OPC_U8BIOR;
    shift_opc = OPC_U8SHL;
    size      = 8;
  }
  else {
    record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
    return wn;
  }
 
  bytes   = 0;
  source  = NULL;
  combine = TRUE;
  lwn     = WN_kid0(wn);
  swn     = WN_kid1(wn);
 
  if ( WN_opcode(swn) != shift_opc ) {
    if ( WN_opcode(lwn) == shift_opc ) {
      swn = lwn;
      lwn = WN_kid1(wn);
    }
    else {
      combine = FALSE;
      record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
    }
  }
 
  mtype = WN_desc(lwn);
 
  if ( !MTYPE_is_unsigned(mtype) ) {
    combine = FALSE;
    record_combine_loads_failure ((INT32) VHO_Srcpos,  __LINE__);
  }
 
  load_opcode   = WN_opcode(lwn);
  load_operator = OPCODE_operator(load_opcode);
 
  if (    combine
       && WN_operator(WN_kid1(swn)) == OPR_INTCONST
       && ( load_operator == OPR_LDID || load_operator == OPR_ILOAD ) ) {
    bytes  = TY_size(WN_ty(lwn));
    source = lwn;
    last_item_size = bytes;
 
    if (    load_operator == OPR_ILOAD
         && WN_operator(WN_kid0(lwn)) == OPR_ARRAY )
      last_index = WN_kid_count(WN_kid0(lwn)) - 1;
 
    while ( swn ) {
      shift_bits = WN_const_val(WN_kid1(swn));
      if ( shift_bits == 0 || shift_bits % 8 ) {
        combine = FALSE;
        record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
        break;
      }
 
      shift_bytes = shift_bits >> 3;
 
      lwn         = WN_kid0(swn);
      opcode      = WN_opcode(lwn);
      wn_operator = OPCODE_operator(opcode);
 
      if ( wn_operator == OPR_LDID || wn_operator == OPR_ILOAD )
        swn = NULL;
      else if ( opcode == add_opc || opcode == or_opc ) {
        swn = WN_kid1(lwn);
        lwn = WN_kid0(lwn);
        if ( WN_opcode(swn) != shift_opc ) {
          if ( WN_opcode(lwn) == shift_opc ) {
            twn = lwn;
            lwn = swn;
            swn = twn;
          }
          else {
            combine = FALSE;
            record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
            break;
          }
        }
 
        if ( WN_operator(WN_kid1(swn)) != OPR_INTCONST ) {
          combine = FALSE;
          record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
          break;
        }
 
        wn_operator = WN_operator(lwn);
 
        if ( wn_operator != OPR_LDID && wn_operator != OPR_ILOAD ) {
          combine = FALSE;
          record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
          break;
        }
      }
      else {
        combine = FALSE;
        record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
        break;
      }
 
      item_size = TY_size(WN_ty(lwn));
 
      if ( item_size != shift_bytes ) {
        combine = FALSE;
        record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
        break;
      }
 
      bytes += item_size;
 
      if ( bytes > size ) {
        combine = FALSE;
        record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
        break;
      }
 
      opcode      = WN_opcode(lwn);
      wn_operator = OPCODE_operator(opcode);
 
      if ( wn_operator != load_operator ) {
        combine = FALSE;
        record_combine_loads_failure ((INT32) VHO_Srcpos,  __LINE__);
        break;
      }
 
      mtype = OPCODE_desc(opcode);
 
      if ( !MTYPE_is_unsigned(mtype) ) {
        combine = FALSE;
        record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
        break;
      }
 
      if ( load_operator == OPR_LDID ) {
        if (    WN_st(source) != WN_st(lwn)
             && WN_offset(source) != WN_offset(lwn) + last_item_size ) {
          combine = FALSE;
          record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
          break;
        }
      }
      else if ( load_operator == OPR_ILOAD ) {
        awn1 = WN_kid0(source);
        awn2 = WN_kid0(lwn);
        if ( WN_load_offset(source) == WN_load_offset(lwn) + last_item_size ) {
          if ( WN_Simp_Compare_Trees ( awn1, awn2 ) ) {
            combine = FALSE;
            record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
            break;
          }
        }
  else if ( WN_load_offset(source) == WN_load_offset(lwn) ) {
          if (    WN_operator(awn1) == OPR_ARRAY
               && WN_operator(WN_kid(awn1,last_index)) == OPR_INTCONST ) {
            WN_const_val(WN_kid(awn1,last_index)) -= 1;
 
            if ( WN_Simp_Compare_Trees ( awn1, awn2 ) ) {
              WN_const_val(WN_kid(awn1,last_index)) += 1;
              combine = FALSE;
              record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
              break;
            }
            else
              WN_const_val(WN_kid(awn1,last_index)) += 1;
          }
          else {
            combine = FALSE;
            record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
            break;
          }
        }
        else {
          combine = FALSE;
          record_combine_loads_failure ((INT32) VHO_Srcpos,  __LINE__);
          break;
        }
      }
      else {
        combine = FALSE;
        record_combine_loads_failure ((INT32) VHO_Srcpos, __LINE__);
        break;
      }
 
      source = lwn;
      last_item_size = item_size;
    }
  }
 
  if ( combine && bytes == size ) {
    TY_IDX aty_idx;
    TY_IDX uty_idx;
    TY_IDX pty_idx;
 
    if ( size == 4 ) {
      aty_idx = Be_Type_Tbl(MTYPE_U4);
      uty_idx = vho_u4a1_ty_idx;
 
      if ( uty_idx == (TY_IDX) 0 ) {
        uty_idx = aty_idx;
        Set_TY_align (uty_idx, 1);
        pty_idx = Make_Pointer_Type ( uty_idx, TRUE );
 
        vho_u4a1_ty_idx = uty_idx;
      }
      else
        pty_idx = TY_pointer(uty_idx);
    }
    else {
      aty_idx = Be_Type_Tbl(MTYPE_U8);
      uty_idx = vho_u8a1_ty_idx;
 
      if ( uty_idx == (TY_IDX) 0 ) {
        uty_idx = aty_idx;
        Set_TY_align (uty_idx, 1);
        pty_idx = Make_Pointer_Type ( uty_idx, TRUE );
 
        vho_u8a1_ty_idx = uty_idx;
      }
      else
        pty_idx = TY_pointer(uty_idx);
    }
 
    if ( load_operator == OPR_LDID ) {
      lwn = WN_COPY_Tree(lwn);
      WN_DELETE_Tree(wn);
      wn = lwn;
      opcode = size == 4 ? OPC_U4U4LDID : OPC_U8U8LDID;
      WN_set_opcode(wn,opcode);
      WN_set_ty(wn,uty_idx);
    }
    else {
      lwn = WN_COPY_Tree(lwn);
      WN_DELETE_Tree(wn);
      wn = lwn;
      opcode = size == 4 ? OPC_U4U4ILOAD : OPC_U8U8ILOAD;
      WN_set_opcode(wn,opcode);
      WN_set_ty(wn,aty_idx);
      WN_set_load_addr_ty(wn,pty_idx);
    }
  }
 
  return wn;
} /* vho_lower_combine_loads */
 
#ifdef KEY
// Utility function to traverse through an aggregate type and determine
// if any field/element is floating-point: bug 7770
// Called by vho_lower_mparm(), if there is any FP field, the mparm cannot
// be transformed.
// Return 1 if OK to transform, 0 if cannot be transformed.
static inline BOOL
traverse_struct (const TY_IDX ty)
{
  Is_True (TY_size(ty) <= 8, ("Type size cannot exceed 8"));
  if (TY_kind (ty) == KIND_STRUCT)
  {
    FLD_ITER fld_iter = Make_fld_iter(TY_fld(ty));
    do
    {
      FLD_HANDLE fld(fld_iter);
      if (TY_size(FLD_type(fld)) == 0)
        continue;
      if (!traverse_struct (FLD_type(fld))) return 0;
    } while (!FLD_last_field(fld_iter++));
  }
  else if (TY_kind (ty) == KIND_ARRAY)
    return traverse_struct (TY_etype (ty));
  else
    switch (TY_mtype (ty))
    {
      case MTYPE_F4:
      case MTYPE_F8:
      case MTYPE_C4: return 0;
      default: return 1;
    }
 
  return 1;
}
 
// If the struct under MPARM is of size 4 or 8, change LDID from M
// type to the appropriate type (U4/U8).
static inline WN *
vho_lower_mparm (WN * wn)
{
  WN * kid = WN_kid0 (wn);
  if (WN_opcode (kid) != OPC_MMLDID) return wn;
 
  TY_IDX ty = WN_ty (kid);
  INT64 bytes = TY_size (ty);
 
  if (VHO_Struct_Opt &&
      (bytes == 4 || bytes == 8) &&
      TY_size (WN_ty (wn)) == bytes &&
      ST_class (WN_st (kid)) != CLASS_PREG
#ifdef TARG_X8664
      && (Is_Target_32bit() ||
          traverse_struct (WN_ty (wn)))
#elif defined(TARG_MIPS) || defined(TARG_IA64)  // bug 12809
      && traverse_struct (WN_ty(wn))
#endif
#if defined(TARG_SL)
      && (bytes == 4)
#endif
      )
  {
    TYPE_ID mtype = (bytes == 4) ? MTYPE_U4 : MTYPE_U8;
    WN_set_rtype (wn, mtype);
    WN_set_rtype (kid, mtype);
    WN_set_desc (kid, mtype);
 
    // bugs 9989, 10139
    // bug fix for OSP_258
    INT field_id;
    Is_True (WN_field_id(kid) == 0,("vho_lower_mparm: Expected field-id zero"));
    if ((TY_kind(ty) == KIND_STRUCT) &&
        (field_id /* assign */ = single_field_in_struct (ty)))
      WN_set_field_id (kid, field_id);
  }
 
  return wn;
}
#endif
 
/* ============================================================================
 *
 * WN *vho_lower_expr ( WN * wn, WN * block, BOOL_INFO * bool_info )
 *
 * Given a tree, this routine traverses the tree performing lowering
 * actions for
 *
 *   SWITCH into a sequence of if-else, compgoto and/or binary search
 *   MSTORE into STID/ISTORE over LDID/ILOAD if the structure is
 *     sufficiently small.
 *
 * ============================================================================
 */
 
static WN *
vho_lower_expr ( WN * wn, WN * block, BOOL_INFO * bool_info, BOOL is_return )
{
  OPCODE     opcode;
  OPERATOR   wn_operator;
  mINT16     nkids;
  mINT16     i;
 
  opcode      = WN_opcode(wn);
  wn_operator = OPCODE_operator(opcode);
  nkids       = WN_kid_count(wn);
 
  switch ( wn_operator ) {
 
    case OPR_ILOAD:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
 
      if (    VHO_Iload_Opt
           && WN_operator(WN_kid0(wn)) == OPR_LDA ) {
 
        INT64 offset;
 
        offset = WN_load_offset(wn) + WN_lda_offset(WN_kid0(wn));
 
        if ( offset >= INT32_MIN && offset <= INT32_MAX ) {
 
          WN * wn1;
 
          wn1 = WN_CreateLdid ( OPCODE_make_op ( OPR_LDID,
                                                 OPCODE_rtype(opcode),
                                                 OPCODE_desc(opcode) ),
                                offset,
                                WN_st_idx(WN_kid0(wn)),
                                WN_ty(wn),
                                WN_field_id(wn) );
/*
          fprintf ( stderr, "ILOAD->LDID old\n" );
          fdump_tree ( stderr, wn );
          fprintf ( stderr, "ILOAD->LDID new\n" );
          fdump_tree ( stderr, wn1 );
*/
          wn = wn1;
        }
      }
 
      break;
 
    case OPR_ILOADX:
 
      FmtAssert ( TRUE, ("unexpected operator encountered in vho_lower") );
      break;
 
    case OPR_MLOAD:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      WN_kid1(wn) = vho_lower_expr (WN_kid1(wn), block, NULL);
      break;
 
    case OPR_ARRAY:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
 
      for ( i = (nkids + 1) >> 1; i < nkids; i++ )
        WN_kid(wn,i) = vho_lower_expr (WN_kid(wn,i), block, NULL);
      break;
 
    case OPR_INTRINSIC_OP:
 
#ifndef TARG_X8664
      for ( i = 0; i < nkids; i++ )
        WN_kid(wn,i) = vho_lower_expr (WN_kid(wn,i), block, NULL);
      break;
#else
      {
  // Fortran expression like a[i]**n can be vectorized if we expand
  // inline before LNO. However, we do this only for small values of n.
  // The math library (powd) may do a better job for large values of n.
  if ( WN_intrinsic(wn) == INTRN_F8I4EXPEXPR ||
       WN_intrinsic(wn) == INTRN_F4I4EXPEXPR ) {
    WN* parm1 = WN_kid1(wn);
    WN* exp = WN_kid0(parm1);
    if (WN_operator(exp) == OPR_INTCONST &&
        WN_const_val(exp) > 0 &&
        WN_const_val(exp) <= 5) {
      INT n = WN_const_val(exp);
      WN_kid0(WN_kid0(wn)) = vho_lower_expr(WN_kid0(WN_kid0(wn)),
              block, NULL); //bug 8576
      WN* opnd = WN_COPY_Tree ( WN_kid0(WN_kid0(wn)) );
      if ( n == 1 ) {
        wn = opnd; break;
      }
      wn = WN_Mpy(WN_rtype(wn), opnd, WN_COPY_Tree ( opnd )); n-= 2;
      for (;n > 0; n--)
        wn = WN_Mpy(WN_rtype(wn), wn, WN_COPY_Tree ( opnd ));
      break;
    }
  }
 
  for ( i = 0; i < nkids; i++ )
    WN_kid(wn,i) = vho_lower_expr (WN_kid(wn,i), block, NULL);
  break;
      }
#endif
 
    case OPR_TAS:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      break;
 
    case OPR_SELECT:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      WN_kid1(wn) = vho_lower_expr (WN_kid1(wn), block, NULL);
      WN_kid2(wn) = vho_lower_expr (WN_kid2(wn), block, NULL);
      break;
 
    case OPR_CSELECT:
 
      wn = vho_lower_cselect ( wn, block, bool_info);
      break;
 
    case OPR_CVT:
    case OPR_CVTL:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      break;
 
    case OPR_NEG:
    case OPR_ABS:
    case OPR_SQRT:
    case OPR_REALPART:
    case OPR_IMAGPART:
    case OPR_PAREN:
    case OPR_RND:
    case OPR_TRUNC:
    case OPR_CEIL:
    case OPR_FLOOR:
    case OPR_BNOT:
    case OPR_LNOT:
    case OPR_ALLOCA:
    case OPR_EXTRACT_BITS:  // bug fix for OSP_184
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      break;
 
    case OPR_ASM_INPUT:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      break;
 
    case OPR_ADD:
    case OPR_SUB:
    case OPR_MPY:
    case OPR_DIV:
    case OPR_MOD:
    case OPR_REM:
    case OPR_DIVREM:
#ifdef KEY
    case OPR_COMPOSE_BITS:
#endif
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      WN_kid1(wn) = vho_lower_expr (WN_kid1(wn), block, NULL);
 
      if ( VHO_Combine_Loads && wn_operator == OPR_ADD )
        wn = vho_lower_combine_loads ( wn );
      break;
 
    case OPR_LOWPART:
    case OPR_HIGHPART:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      break;
 
    case OPR_MAX:
    case OPR_MIN:
    case OPR_MINMAX:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      WN_kid1(wn) = vho_lower_expr (WN_kid1(wn), block, NULL);
      break;
 
    case OPR_MINPART:
    case OPR_MAXPART:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      break;
 
    case OPR_BAND:
    case OPR_BIOR:
    case OPR_BNOR:
    case OPR_BXOR:
    case OPR_LAND:
    case OPR_LIOR:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      WN_kid1(wn) = vho_lower_expr (WN_kid1(wn), block, NULL);
 
      if ( VHO_Combine_Loads && wn_operator == OPR_BIOR )
        wn = vho_lower_combine_loads ( wn );
      break;
 
    case OPR_CAND:
    case OPR_CIOR:
 
      wn = vho_lower_cand_cior ( wn, block, bool_info );
      break;
 
    case OPR_SHL:
    case OPR_ASHR:
    case OPR_LSHR:
    case OPR_COMPLEX:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      WN_kid1(wn) = vho_lower_expr (WN_kid1(wn), block, NULL);
      break;
 
    case OPR_RECIP:
    case OPR_RSQRT:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      break;
 
    case OPR_MADD:
    case OPR_MSUB:
    case OPR_NMADD:
    case OPR_NMSUB:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      WN_kid1(wn) = vho_lower_expr (WN_kid1(wn), block, NULL);
      WN_kid2(wn) = vho_lower_expr (WN_kid2(wn), block, NULL);
      break;
 
    case OPR_IO_ITEM:
 
      for ( i = 0; i < nkids; i++ )
        WN_kid(wn,i) = vho_lower_expr (WN_kid(wn,i), block, NULL);
      break;
 
    case OPR_EQ:
    case OPR_NE:
    case OPR_GT:
    case OPR_GE:
    case OPR_LT:
    case OPR_LE:
 
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      WN_kid1(wn) = vho_lower_expr (WN_kid1(wn), block, NULL);
      break;
 
    case OPR_LDID:
#ifdef TARG_NVISA
      // check for a load past the end of the struct
      if (ST_class(WN_st(wn)) == CLASS_VAR) {
        TY_IDX ty = ST_type(WN_st(wn));
        if (TY_kind(ty) == KIND_STRUCT && WN_offset(wn) >= TY_size(ty))
        {
          ErrMsgSrcpos(EC_Load_Past_Struct, VHO_Srcpos);
        }
      }
#endif
      break;
 
    case OPR_LDA:
    case OPR_CONST:
    case OPR_INTCONST:
    case OPR_IDNAME:
 
      /* No need to lower */
      break;
 
    case OPR_LOOP_INFO:
 
      FmtAssert ( TRUE, ("unexpected operator encountered in vho_lower") );
      break;
 
    case OPR_PARM:
 
#ifdef KEY // bug 7741
      wn = vho_lower_mparm (wn);
#endif
      WN_kid0(wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
      break;
 
    case OPR_TRIPLET:
    case OPR_ARRAYEXP:
    case OPR_ARRSECTION:
    case OPR_WHERE:
    case OPR_OPT_RESERVE2:
 
      FmtAssert ( TRUE, ("unexpected operator encountered in vho_lower") );
      break;
 
    case OPR_COMMA:
 
      wn = vho_lower_comma ( wn, block, bool_info, is_return );
/*
      comma_block = vho_lower_block (WN_kid0(wn));
      WN_INSERT_BlockLast ( block, comma_block );
      wn = vho_lower_expr (WN_kid1(wn), block, bool_info);
*/
      break;
 
    case OPR_RCOMMA:
 
      wn = vho_lower_rcomma ( wn, block, bool_info );
      break;
 
    case OPR_HIGHMPY:
    case OPR_XMPY:
 
      break;
 
    case OPR_RROTATE:
    {
#ifdef TARG_X8664
      // By default, generate rotate instruction only if it is C++ (bug 7932)
      // Can be crontrolled by internal flag -VHO:rotate
      if (!VHO_Generate_Rrotate_Set && PU_cxx_lang (Get_Current_PU()) &&
          (Is_Target_64bit() || MTYPE_byte_size(WN_desc(wn)) <= 4))
        VHO_Generate_Rrotate = TRUE;
 
      if (!VHO_Generate_Rrotate)
#endif
      {
        TYPE_ID  desc  = WN_desc(wn);
        TYPE_ID  rtype = WN_rtype(wn);
        INT32    size  = 8 * TY_size (Be_Type_Tbl (desc));
        WN      *wn0   = vho_lower_expr (WN_kid0(wn), block, NULL);
        WN      *wn1   = vho_lower_expr (WN_kid1(wn), block, NULL);
        TYPE_ID  shift_rtype = WN_rtype(wn1);
        WN      *rshift = WN_Lshr (rtype, WN_COPY_Tree (wn0), WN_COPY_Tree (wn1));
        WN      *lshift = WN_Shl  (rtype, wn0,
                                   WN_Binary (OPR_SUB, shift_rtype,
                                              WN_Intconst (shift_rtype, size),
                                              wn1));
#ifdef TARG_X8664 // bug 4552
        // This is now unused code, but keep the fix for the record.
        if (size < MTYPE_size_min(rtype))
    lshift = WN_CreateCvtl(OPR_CVTL, Mtype_TransferSign(MTYPE_U4, rtype),
          MTYPE_V, size, lshift);
#endif
        wn  = WN_Bior (rtype, lshift, rshift);
      }
#ifdef TARG_X8664
      else
      {
        WN_kid0 (wn) = vho_lower_expr (WN_kid0(wn), block, NULL);
        WN_kid1 (wn) = vho_lower_expr (WN_kid1(wn), block, NULL);
      }
#endif // TARG_X8664
      break;
    }
 
    default:
 
      FmtAssert ( TRUE, ("unknown operator encountered in vho_lower_expr") );
      break;
  }
 
  return wn;
} /* vho_lower_expr */
 
 
static WN *
vho_lower_compgoto ( WN * wn, WN * block )
{
  WN_kid0(wn) = vho_lower_expr ( WN_kid0(wn), block, NULL );
  WN_kid1(wn) = vho_lower_block ( WN_kid1(wn) );
  return wn;
} /* vho_lower_compgoto */
 
 
static WN *
vho_lower_switch ( WN * wn, WN * block )
{
  WN_kid0(wn) = vho_lower_expr ( WN_kid0(wn), block, NULL );
  wn = VHO_Lower_Switch ( wn );
  return wn;
} /* vho_lower_switch */
 
 
static WN *
vho_lower_casegoto ( WN * wn, WN * block )
{
  return wn;
} /* vho_lower_casegoto */
 
 
static WN *
vho_lower_truebr ( WN * wn, WN * block )
{
  WN        * test;
  WN        * test_block;
  BOOL_INFO   bool_info;
 
  test_block = WN_CreateBlock ();
  WN_Set_Linenum ( test_block, VHO_Srcpos );
 
  vho_initialize_bool_info (&bool_info);
  bool_info.true_label  = WN_label_number(wn);
 
  LABEL_Init (New_LABEL (CURRENT_SYMTAB, bool_info.false_label),
  0, LKIND_DEFAULT);
 
  test = vho_lower_expr ( WN_kid0(wn), test_block, &bool_info );
 
  if ( WN_first(test_block) ) {
    WN_INSERT_BlockLast ( block, test_block );
  }
 
  if ( test ) {
    WN_kid0(wn) = test;
  }
 
  else {
    // TRUEBR <test> <true_label>    ===>    <test>
    //                                       GOTO <true_label>
    //                                       LABEL <false_label>
 
    WN *wn_goto = WN_CreateGoto ( (ST_IDX) NULL, bool_info.true_label );
    WN_Set_Linenum ( wn_goto, VHO_Srcpos );
    WN_INSERT_BlockLast ( block, wn_goto );
 
    WN *wn_label
      = WN_CreateLabel ( (ST_IDX) 0, bool_info.false_label, 0, NULL );
    WN_Set_Linenum ( wn_label, VHO_Srcpos );
    WN_INSERT_BlockLast ( block, wn_label );
 
    // Don't update feedback; let propagation handle
 
    wn = NULL;
  }
 
  return wn;
} /* vho_lower_truebr */
 
 
static WN *
vho_lower_return ( WN * wn, WN * block )
{
  return wn;
} /* vho_lower_return */
 
static BOOL
vho_singleton_field (TY_IDX ty_idx)
{
  return FALSE;
} /* vho_singleton_field */
 
static WN *
vho_lower_return_val (WN* wn, WN* block)
{
  WN_kid0(wn) = vho_lower_expr ( WN_kid0(wn), block, NULL, WN_rtype(wn)==MTYPE_M );
  return wn;
} /* vho_lower_return_val */
 
static WN *
vho_lower_istore ( WN * wn, WN * block )
{
  WN_kid0(wn) = vho_lower_expr ( WN_kid0(wn), block, NULL );
  WN_kid1(wn) = vho_lower_expr ( WN_kid1(wn), block, NULL );
  return wn;
} /* vho_lower_istore */
 
 
static WN *
vho_lower_mstore ( WN * wn, WN * block )
{
  WN_kid0(wn) = vho_lower_expr ( WN_kid0(wn), block, NULL );
  WN_kid1(wn) = vho_lower_expr ( WN_kid1(wn), block, NULL );
  WN_kid(wn,2) = vho_lower_expr ( WN_kid(wn,2), block, NULL );
  wn = VHO_Lower_Mstore ( wn );
 
  return wn;
} /* vho_lower_mstore */
 
 
static WN *
vho_lower_stid ( WN * wn, WN * block )
{
  WN_kid0(wn) = vho_lower_expr ( WN_kid0(wn), block, NULL );
  if (WN_desc(wn) == MTYPE_M) {
    /* lower MSTID */
    wn = VHO_Lower_Mstid (wn);
  }
 
  return wn;
} /* vho_lower_stid */
 
 
static WN *
vho_lower_call ( WN * wn, WN * block )
{
  INT32 i;
#ifdef TARG_NVISA
  if ((!ST_is_export_local(WN_st(wn)) || ST_sclass(WN_st(wn)) == SCLASS_EXTERN)
        && !CLIST_enabled) // okay if producing C
  {
    // We only support calls to locally defined functions

Line No.	Rev	Author	Line
1	2	marcel	`/*`
2	2322	dcoakley	`* Copyright (C) 2009 Advanced Micro Devices, Inc. All Rights Reserved.`
3			`*/`
4			`/*`
5	749	hucheng	`* Copyright 2003, 2004, 2005, 2006 PathScale, Inc. All Rights Reserved.`
6			`*/`
7	71	marcel
8	749	hucheng	`/*`
9
10	2	marcel	`Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved.`
11
12			`This program is free software; you can redistribute it and/or modify it`
13			`under the terms of version 2 of the GNU General Public License as`
14			`published by the Free Software Foundation.`
15
16			`This program is distributed in the hope that it would be useful, but`
17			`WITHOUT ANY WARRANTY; without even the implied warranty of`
18			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.`
19
20			`Further, this software is distributed without any warranty that it is`
21			`free of the rightful claim of any third person regarding infringement`
22			`or the like. Any license provided herein, whether implied or`
23			`otherwise, applies only to this software file. Patent licenses, if`
24			`any, provided herein do not apply to combinations of this program with`
25			`other software, or any other product whatsoever.`
26
27			`You should have received a copy of the GNU General Public License along`
28			`with this program; if not, write the Free Software Foundation, Inc., 59`
29			`Temple Place - Suite 330, Boston MA 02111-1307, USA.`
30
31			`Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky,`
32			`Mountain View, CA 94043, or:`
33
34			`http://www.sgi.com`
35
36			`For further information regarding this notice, see:`
37
38			`http://oss.sgi.com/projects/GenInfo/NoticeExplan`
39
40			`*/`
41
42
43			`//--c++--`
44
45	71	marcel	`#define __STDC_LIMIT_MACROS`
46			`#include <stdint.h>`
47
48	2	marcel	`#ifndef FRONT_END`
49
50			`#include "defs.h"`
51			`#include "config.h"`
52			`#include "config_opt.h"`
53	2694	shenruifen	`#include "config_debug.h"`
54	2	marcel	`#include "mempool.h"`
55			`#include "wn.h"`
56			`#include "wn_util.h"`
57			`#include "opcode.h"`
58			`#include <stdlib.h>`
59			`#include "flags.h"`
60			`#include "pu_info.h"`
61			`#include "vho_lower.h"`
62			`#include "f90_lower.h"`
63			`#include "fb_whirl.h"`
64			`#include "wn_simp.h"`
65			`#include "topcode.h"`
66			`#include "callutil.h"`
67			`#include "targ_sim.h"`
68			`#include "cxx_template.h"`
69			`#include "prompf.h"`
70			`#include "wb_f90_lower.h"`
71			`#include "wn_lower.h"`
72	2113	laijx	`#include "be_util.h" // For Current_PU_Count`
73			`#include "glob.h" // For Show_Progress`
74	83	marcel	`#ifdef KEY`
75			`#include "w2op.h" // For OPCODE_Can_Be_Spculative`
76			`#endif`
77	1950	laijx	`#include "config_clist.h"`
78	2	marcel
79			`typedef enum {`
80			`ADDRESS_USED,`
81			`ADDRESS_PASSED,`
82			`ADDRESS_SAVED`
83			`} ADDRESS_INFO_TYPE;`
84
85			`#endif /* FRONT_END */`
86
87			`#include "tracing.h"`
88			`#include "ir_reader.h"`
89			`#include "config_vho.h"`
90			`#include "targ_const.h"`
91	1950	laijx	`#include "erbe.h"`
92	2	marcel
93			`#define DO_VHO_LOWERING 1`
94			`#define IS_POWER_OF_2(x) (((x)!=0) && ((x) & ((x)-1))==0)`
95
96			`#define ST_addr_taken_passed(st) ST_addr_passed(st)`
97			`#define Set_ST_addr_taken_passed(st) Set_ST_addr_passed(st)`
98			`#define Reset_ST_addr_taken_passed(st) Reset_ST_addr_passed(st)`
99			`#define ST_addr_taken_saved(st) ST_addr_saved(st)`
100			`#define Set_ST_addr_taken_saved(st) Set_ST_addr_saved(st)`
101			`#define Reset_ST_addr_taken_saved(st) Reset_ST_addr_saved(st)`
102
103			`#pragma set woff 1172`
104	135	marcel	`#ifdef KEY`
105			`static INT current_pu_id = -1;`
106	1411	laijx	`static void Misc_Loop_Fusion ( WN * , WN * );`
107	135	marcel	`#endif`
108	2	marcel
109			`static BOOL`
110			`VHO_WN_is_zero ( WN * wn )`
111			`{`
112			`return ( ( WN_operator(wn) == OPR_INTCONST`
113			`&& WN_const_val(wn) == 0 )`
114			`\|\| ( WN_operator(wn) == OPR_CONST`
115			`&& Targ_Is_Zero(STC_val(WN_st(wn))) ) );`
116			`} /* VHO_WN_is_zero */`
117
118
119			`static BOOL`
120			`VHO_WN_has_side_effects ( WN * wn )`
121			`{`
122			`INT32 nkids;`
123			`INT32 i;`
124			`OPERATOR wn_operator;`
125			`BOOL has_side_effects;`
126
127			`wn_operator = WN_operator(wn);`
128			`nkids = WN_kid_count(wn);`
129
130			`switch ( wn_operator ) {`
131
132			`case OPR_LDID:`
133
134			`has_side_effects = TY_is_volatile(WN_ty(wn));`
135			`break;`
136
137			`case OPR_ILOAD:`
138
139			`has_side_effects = TY_is_volatile(WN_ty(wn))`
140			`\|\| VHO_WN_has_side_effects ( WN_kid0(wn) );`
141			`break;`
142
143			`default:`
144
145			`has_side_effects = FALSE;`
146
147			`for ( i = 0; i < nkids; i++ ) {`
148
149			`if ( VHO_WN_has_side_effects ( WN_kid(wn,i) ) ) {`
150
151			`has_side_effects = TRUE;`
152			`break;`
153			`}`
154			`}`
155			`break;`
156			`}`
157
158			`return has_side_effects;`
159			`} /* VHO_WN_has_side_effects */`
160
161
162			`typedef struct bool_expr_info_t {`
163			`OPCODE opcode;`
164			`BOOL used_true_label;`
165			`BOOL used_false_label;`
166			`LABEL_IDX true_label;`
167			`LABEL_IDX false_label;`
168			`} BOOL_INFO;`
169
170			`static WN * vho_lower ( WN * wn, WN * block );`
171			`static WN * vho_lower_stmt ( WN * stmt, WN * block );`
172			`static WN * vho_lower_block ( WN * wn );`
173	1950	laijx	`static WN * vho_lower_expr ( WN * expr, WN * block, BOOL_INFO * bool_info, BOOL is_return=FALSE );`
174	2	marcel
175			`/* Table used to promote integers less than 4 bytes into their`
176			`* 4 byte counterparts in order to get the right type for OPCODE_make_op`
177			`*/`
178
179			`TYPE_ID Promoted_Mtype [MTYPE_LAST + 1] = {`
180			`MTYPE_UNKNOWN, /* MTYPE_UNKNOWN */`
181			`MTYPE_UNKNOWN, /* MTYPE_B */`
182			`MTYPE_I4, /* MTYPE_I1 */`
183			`MTYPE_I4, /* MTYPE_I2 */`
184			`MTYPE_I4, /* MTYPE_I4 */`
185			`MTYPE_I8, /* MTYPE_I8 */`
186			`MTYPE_U4, /* MTYPE_U1 */`
187			`MTYPE_U4, /* MTYPE_U2 */`
188			`MTYPE_U4, /* MTYPE_U4 */`
189			`MTYPE_U8, /* MTYPE_U8 */`
190			`MTYPE_F4, /* MTYPE_F4 */`
191			`MTYPE_F8, /* MTYPE_F8 */`
192	515	marcel	`MTYPE_F10, /* MTYPE_F10 */`
193	2	marcel	`MTYPE_UNKNOWN, /* MTYPE_F16 */`
194			`MTYPE_UNKNOWN, /* MTYPE_STR */`
195			`MTYPE_FQ, /* MTYPE_FQ */`
196			`MTYPE_M, /* MTYPE_M */`
197			`MTYPE_C4, /* MTYPE_C4 */`
198			`MTYPE_C8, /* MTYPE_C8 */`
199			`MTYPE_CQ, /* MTYPE_CQ */`
200	1950	laijx	`MTYPE_V, /* MTYPE_V */`
201			`#if defined(TARG_IA64)`
202	564	marcel	`MTYPE_UNKNOWN, /* MTYPE_BS */`
203			`MTYPE_UNKNOWN, /* MTYPE_A4 */`
204			`MTYPE_UNKNOWN, /* MTYPE_A8 */`
205			`MTYPE_C10, /* MTYPE_C10 */`
206	749	hucheng	`#endif`
207	2	marcel	`};`
208
209			`#ifdef VHO_DEBUG`
210			`static BOOL VHO_Switch_Debug = TRUE;`
211			`static BOOL VHO_Struct_Debug = TRUE;`
212			`static char * VHO_Switch_Format;`
213			`#endif /* VHO_DEBUG */`
214
215			`static SRCPOS VHO_Srcpos;`
216	2322	dcoakley	`static BOOL VHO_SCL_Debug; // Debug Structure Copy Lowering`
217			`static BOOL VHO_M_Debug_Type_Mismatch;`
218	2	marcel
219			`/* Variables related to handling of switch statements */`
220
221			`INT32 VHO_Switch_Distance = 128; /* max distance between values */`
222			`INT32 VHO_Switch_Default_Label_Count = 16;`
223			`BOOL VHO_Give_Preg_Names = FALSE;`
224
225			`static const char * vho_lower_mstore_name = "__lower_mstore";`
226			`static const char * vho_lower_cand_cior_name = "__cand_cior";`
227			`static const char * vho_lower_cselect_name = "__cselect";`
228			`static const char * vho_lower_rcomma_name = "__rcomma";`
229			`static const char * vho_lower_comma_name = "__comma";`
230
231			`static TY_IDX vho_u4a1_ty_idx = (TY_IDX) 0;`
232			`static TY_IDX vho_u8a1_ty_idx = (TY_IDX) 0;`
233
234			`typedef struct switch_case_table_entry_t {`
235			`WN * wn;`
236			`INT32 count;`
237			`FB_FREQ freq;`
238			`} VHO_SWITCH_ITEM;`
239
240			`static VHO_SWITCH_ITEM * VHO_Switch_Case_Table; /* table for switch cases */`
241
242			`#define VHO_SWITCH_wn(i) (VHO_Switch_Case_Table[i].wn)`
243			`#define VHO_SWITCH_count(i) (VHO_Switch_Case_Table[i].count)`
244			`#define VHO_SWITCH_freq(i) (VHO_Switch_Case_Table[i].freq)`
245
246			`static BOOL VHO_Switch_Signed; /* signedness of switch index */`
247			`static OPCODE VHO_Switch_Int_Opcode; /* opcode for Create_Int */`
248			`static OPCODE VHO_Switch_Sub_Opcode; /* opcode for subtract */`
249			`static OPCODE VHO_Switch_EQ_Opcode; /* opcode for == comparison */`
250			`static OPCODE VHO_Switch_LT_Opcode; /* opcode for < comparison */`
251			`static OPCODE VHO_Switch_GT_Opcode; /* opcode for > comparison */`
252
253			`static LABEL_IDX VHO_Switch_Default_Label; /* default label in switch */`
254			`static INT32 VHO_Switch_Last_Label; /* last label in switch */`
255			`static INT32 * VHO_Switch_Cluster_Table; /* table for switch clusters */`
256			`static INT32 VHO_Switch_Ncases; /* # of cases in switch */`
257			`static INT32 VHO_Switch_Nclusters; /* # of clusters in switch */`
258			`static WN * VHO_Switch_Index; /* load of switch index */`
259			`static WN * VHO_Switch_Default_Goto; /* goto switch default label */`
260	71	marcel	`static WN * VHO_Switch_Stmt; /* switch statement */`
261	2	marcel	`static FB_FREQ VHO_Switch_Default_Freq; /* goto switch default freq */`
262
263	135	marcel	`#ifdef KEY`
264			`static BOOL VHO_In_MP_Region_Pragma = FALSE;`
265			`#endif // KEY`
266
267	2	marcel	`/* Variables related to struct lowering */`
268
269	1470	dehao	`#if defined(TARG_X8664) \|\| defined(TARG_IA64)`
270	83	marcel	`INT32 VHO_Struct_Limit = 8; /* max # of fields/statements */`
271	1950	laijx	`#elif defined(TARG_NVISA)`
272			`INT32 VHO_Struct_Limit = 24; /* max # of fields/statements */`
273	83	marcel	`#else`
274	2	marcel	`INT32 VHO_Struct_Limit = 4; /* max # of fields/statements */`
275	83	marcel	`#endif`
276	2	marcel
277			`// static INT32 VHO_Struct_Alignment; /* Alignment of struct */`
278			`static BOOL VHO_Struct_Can_Be_Lowered; /* FALSE if cannot be lowered */`
279			`static INT32 VHO_Struct_Nfields; /* # of fields */`
280			`static TY_IDX VHO_Struct_Fld_Table [255]; /* table containing fields */`
281	71	marcel	`static INT32 VHO_Struct_Offset_Table [255]; /* table containing fields offset */`
282	1950	laijx	`// We want to use field_ids when possible,`
283			`// as that gives higher-level type info about the original struct`
284			`// (e.g. if want to know alignment of original struct).`
285			`// However, fields that are arrays have a single field id,`
286			`// but may span multiple elements, so use element types in that case.`
287			`static INT32 VHO_Struct_Field_Id_Table[255]; /* table containing field ids */`
288			`static BOOL VHO_Struct_Field_Is_Array_Table[255]; /* field is array? */`
289	2	marcel	`static INT32 VHO_Struct_Last_Field_Offset; /* offset of last field */`
290			`static INT32 VHO_Struct_Last_Field_Size; /* size of last field */`
291
292			`#define LESS -1`
293			`#define EQUAL 0`
294			`#define GREATER 1`
295
296	71	marcel	`#define SWITCH_key(i) (VHO_Switch_Signed ? WN_const_val(VHO_SWITCH_wn(i)) : (UINT64) WN_const_val(VHO_SWITCH_wn(i)))`
297	2	marcel
298			`INT32`
299			`VHO_Switch_Compare_Value ( const void v_item1, const void v_item2 )`
300			`{`
301			`INT32 compare_code;`
302			`WN * case1;`
303			`WN * case2;`
304
305			`case1 = (( VHO_SWITCH_ITEM * ) v_item1)->wn;`
306			`case2 = (( VHO_SWITCH_ITEM * ) v_item2)->wn;`
307
308			`if ( VHO_Switch_Signed ) {`
309
310			`if ( WN_const_val(case1) < WN_const_val(case2) )`
311			`compare_code = LESS;`
312
313			`else`
314			`if ( WN_const_val(case1) > WN_const_val(case2) )`
315			`compare_code = GREATER;`
316
317			`else`
318			`compare_code = EQUAL;`
319			`}`
320			`else {`
321
322			`if ( (UINT64) WN_const_val(case1) < (UINT64) WN_const_val(case2) )`
323			`compare_code = LESS;`
324
325			`else`
326			`if ( (UINT64) WN_const_val(case1) > (UINT64) WN_const_val(case2) )`
327			`compare_code = GREATER;`
328
329			`else`
330			`compare_code = EQUAL;`
331			`}`
332
333			`return ( compare_code );`
334			`} /* VHO_Switch_Compare_Value */`
335
336
337			`/* ============================================================================`
338			`*`
339			`* INT32`
340			`* VHO_Switch_Compare_Frequency ( const void v_item1, const void v_item2 )`
341			`*`
342			`* Routine invoked by qsort to compare two case values frequencies specified`
343			`* the switch statement.`
344			`*`
345			`* ============================================================================`
346			`*/`
347
348			`INT32`
349			`VHO_Switch_Compare_Frequency ( const void v_item1, const void v_item2 )`
350			`{`
351			`INT32 compare_code;`
352			`WN * case1;`
353			`WN * case2;`
354			`FB_FREQ freq1;`
355			`FB_FREQ freq2;`
356
357			`case1 = (( VHO_SWITCH_ITEM * ) v_item1)->wn;`
358			`case2 = (( VHO_SWITCH_ITEM * ) v_item2)->wn;`
359			`freq1 = (( VHO_SWITCH_ITEM * ) v_item1)->freq;`
360			`freq2 = (( VHO_SWITCH_ITEM * ) v_item2)->freq;`
361
362			`if ( freq1 != freq2 ) {`
363
364			`// Order of _decreasing_ frequencies`
365
366			`if ( freq1 > freq2 )`
367			`compare_code = LESS;`
368
369			`else // freq1 < freq2`
370			`compare_code = GREATER;`
371
372			`} else`
373			`if ( VHO_Switch_Signed ) {`
374
375			`if ( WN_const_val(case1) < WN_const_val(case2) )`
376			`compare_code = LESS;`
377
378			`else`
379			`if ( WN_const_val(case1) > WN_const_val(case2) )`
380			`compare_code = GREATER;`
381
382			`else`
383			`compare_code = EQUAL;`
384			`}`
385
386			`else {`
387
388			`if ( (UINT64) WN_const_val(case1) < (UINT64) WN_const_val(case2) )`
389			`compare_code = LESS;`
390
391			`else`
392			`if ( (UINT64) WN_const_val(case1) > (UINT64) WN_const_val(case2) )`
393			`compare_code = GREATER;`
394
395			`else`
396			`compare_code = EQUAL;`
397			`}`
398
399			`return ( compare_code );`
400			`} /* VHO_Switch_Compare_Frequency */`
401
402	1411	laijx	`#ifdef KEY`
403	2	marcel	`/* ============================================================================`
404			`*`
405			`* static WN *`
406	1411	laijx	`* VHO_Switch_Generate_If_Else_Reduce_Branch ( SRCPOS srcpos )`
407			`*`
408			`* Generate if-else sequence for the switch statement by grouping consecutive`
409			`* cases together and using a single branch for each group.`
410			`*`
411			`* ============================================================================`
412			`*/`
413			`static WN *`
414			`VHO_Switch_Generate_If_Else_Reduce_Branch (SRCPOS srcpos)`
415			`{`
416			`WN block, case_goto, *wn;`
417			`INT32 i, j;`
418			`INT32 switch_first_label;`
419			`INT32 highest_label_num, lowest_label_num;`
420			`WN **labels_map;`
421
422			`block = WN_CreateBlock();`
423			`WN_Set_Linenum(block, srcpos);`
424
425			`// Find the highest and lowest case label numbers.`
426			`highest_label_num = 0;`
427			`lowest_label_num = INT32_MAX;`
428			`for (i = 0; i < VHO_Switch_Ncases; i++) {`
429			`case_goto = VHO_SWITCH_wn(i);`
430			`INT64 value = WN_label_number(case_goto);`
431			`if (value > highest_label_num)`
432			`highest_label_num = value;`
433			`if (value < lowest_label_num)`
434			`lowest_label_num = value;`
435			`}`
436
437			`// Create case labels map.`
438			`INT32 size = (highest_label_num - lowest_label_num + 1) * sizeof(WN *);`
439			`labels_map = (WN **) alloca(size);`
440			`memset(labels_map, 0, size);`
441
442			`// Map each case label to the first label in the case code. A case code will`
443			`// have multiple labels if it is shared by different case values.`
444			`WN first_label_in_group = (WN ) NULL;`
445			`for (wn = WN_next(VHO_Switch_Stmt); ; wn = WN_next(wn)) {`
446			`if (WN_operator(wn) == OPR_LABEL) {`
447			`if (first_label_in_group == NULL)`
448			`first_label_in_group = wn;`
449			`// Map only the labels in the switch stmt.`
450			`if (WN_label_number(wn) >= lowest_label_num &&`
451			`WN_label_number(wn) <= highest_label_num) {`
452			`labels_map[WN_label_number(wn)] = first_label_in_group;`
453			`}`
454			`if (WN_label_number(wn) == VHO_Switch_Last_Label)`
455			`break;`
456			`} else {`
457			`// Real code terminates the labels group.`
458			`first_label_in_group = NULL;`
459			`}`
460			`}`
461
462			`// Sort the case values.`
463			`qsort(VHO_Switch_Case_Table, VHO_Switch_Ncases,`
464			`sizeof(VHO_SWITCH_ITEM), VHO_Switch_Compare_Value);`
465
466			`for (i = 0; i < VHO_Switch_Ncases; i++) {`
467			`WN test, sub, *tas;`
468			`case_goto = VHO_SWITCH_wn(i);`
469			`INT64 first_value = WN_const_val(case_goto);`
470			`INT64 last_value = first_value;`
471
472			`// Detect consecutive case values sharing common case code.`
473			`for (j = i + 1; j < VHO_Switch_Ncases; j++) {`
474			`WN *next_case_goto = VHO_SWITCH_wn(j);`
475			`INT64 next_value = WN_const_val(next_case_goto);`
476			`if (next_value != last_value + 1 \|\|`
477			`(labels_map[WN_label_number(next_case_goto)] !=`
478			`labels_map[WN_label_number(case_goto)]))`
479			`break;`
480			`last_value = next_value;`
481			`}`
482
483			`if (first_value == last_value) {`
484			`// No consecutive case values.`
485			`test = WN_CreateExp2(VHO_Switch_EQ_Opcode,`
486			`WN_COPY_Tree(VHO_Switch_Index),`
487			`WN_CreateIntconst(VHO_Switch_Int_Opcode,`
488			`first_value));`
489			`wn = WN_CreateTruebr(WN_label_number(case_goto), test);`
490			`WN_Set_Linenum(wn, srcpos);`
491			`} else {`
492			`// Consecutive case values sharing common case code. Translate:`
493			`//`
494			`// case k:`
495			`// case k+1:`
496			`// ...`
497			`// case k+n: goto label`
498			`//`
499			`// into:`
500			`//`

Subversion Repositories Open64

[/] [trunk/] [osprey/] [be/] [vho/] [vho_lower.cxx] - Blame information for rev 2694