<s> mask = ( d -> one_operand_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ; shift = d -> perm [ <NUM_LIT> ] ; if ( BYTES_BIG_ENDIAN && shift > nelt ) return false ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( d -> perm [ i ] != ( ( shift + i ) & mask ) ) return false ; if ( d -> testing_p ) return true ; hi = shift < nelt ? d -> op1 : d -> op0 ; lo = shift < nelt ? d -> op0 : d -> op1 ; shift %= nelt ; shift *= GET_MODE_UNIT_SIZE ( d -> vmode ) * BITS_PER_UNIT ; gcc_assert ( IN_RANGE ( shift , <NUM_LIT> , <NUM_LIT> ) ) ; if ( BYTES_BIG_ENDIAN ) shift = <NUM_LIT> - shift ;


<s> shift = d -> perm [ <NUM_LIT> ] ; if ( BYTES_BIG_ENDIAN && shift > nelt ) return false ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( d -> perm [ i ] != ( ( shift + i ) & mask ) ) return false ; if ( d -> testing_p ) return true ; hi = shift < nelt ? d -> op1 : d -> op0 ; lo = shift < nelt ? d -> op0 : d -> op1 ; shift %= nelt ; shift *= GET_MODE_UNIT_SIZE ( d -> vmode ) * BITS_PER_UNIT ; gcc_assert ( IN_RANGE ( shift , <NUM_LIT> , <NUM_LIT> ) ) ;

if ( BYTES_BIG_ENDIAN ) shift = <NUM_LIT> - shift ;


<s> mask = force_reg ( V4HImode , mask ) ; t0 = gen_reg_rtx ( V4HImode ) ; t1 = gen_reg_rtx ( V4HImode ) ; ok = expand_vselect ( t0 , d -> op0 , perm2 , <NUM_LIT> ) ; gcc_assert ( ok ) ; ok = expand_vselect ( t1 , d -> op1 , perm2 , <NUM_LIT> ) ; gcc_assert ( ok ) ; x = gen_rtx_AND ( V4HImode , mask , t0 ) ; emit_insn ( gen_rtx_SET ( t0 , x ) ) ;


<s> static bool expand_vselect ( rtx target , rtx op0 , const unsigned char * perm , unsigned nelt ) { rtx rperm [ MAX_VECT_LEN ] , x ; unsigned i ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) rperm [ i ] = GEN_INT ( perm [ i ] ) ; x = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec_v ( nelt , rperm ) ) ; x = gen_rtx_VEC_SELECT ( GET_MODE ( target ) , op0 , x ) ; x = gen_rtx_SET ( target , x ) ; rtx_insn * insn = emit_insn ( x ) ; if ( recog_memoized ( insn ) < <NUM_LIT> ) { remove_insn ( insn ) ; return false ; }


<s> machine_mode v2mode ; rtx x ; if ( ! GET_MODE_2XWIDER_MODE ( GET_MODE ( op0 ) ) . exists ( & v2mode ) ) return false ;


<s> return regno ; } if ( crtl -> is_leaf ) { for ( regno = GR_REG ( <NUM_LIT> ) ; regno <= GR_REG ( <NUM_LIT> ) ; regno ++ ) if ( ! df_regs_ever_live_p ( regno ) && call_used_or_fixed_reg_p ( regno ) && ! fixed_regs [ regno ] && ! global_regs [ regno ] && ( ( current_frame_info . gr_used_mask >> regno ) & <NUM_LIT> ) == <NUM_LIT> && ! is_emitted ( regno ) ) {


<s> for ( curr_state = allocated_bundle_states_chain ; curr_state != NULL ; curr_state = next_state ) { next_state = curr_state -> allocated_states_chain ; free ( curr_state -> dfa_state ) ; free ( curr_state ) ; }


<s> static void finish_spill_pointers ( void ) { current_frame_info . gr_used_mask = spill_fill_data . save_gr_used_mask ;


<s> i = strlen ( const_str ) ; str = ( char * ) alloca ( i + <NUM_LIT> ) ; memcpy ( str , const_str , i + <NUM_LIT> ) ; while ( <NUM_LIT> ) { dash = strchr ( str , '-' ) ; if ( ! dash ) { warning ( <NUM_LIT> , <STR_LIT> ) ; return ; } * dash = '\0' ; comma = strchr ( dash + <NUM_LIT> , ',' ) ; if ( comma ) * comma = '\0' ; first = decode_reg_name ( str ) ; if ( first < <NUM_LIT> ) { warning ( <NUM_LIT> , <STR_LIT> , str ) ; return ; } last = decode_reg_name ( dash + <NUM_LIT> ) ; if ( last < <NUM_LIT> ) { warning ( <NUM_LIT> , <STR_LIT> , dash + <NUM_LIT> ) ; return ; }


<s> comma = strchr ( dash + <NUM_LIT> , ',' ) ; if ( comma ) * comma = '\0' ; first = decode_reg_name ( str ) ; if ( first < <NUM_LIT> ) { warning ( <NUM_LIT> , <STR_LIT> , str ) ; return ; } last = decode_reg_name ( dash + <NUM_LIT> ) ; if ( last < <NUM_LIT> ) { warning ( <NUM_LIT> , <STR_LIT> , dash + <NUM_LIT> ) ; return ; } * dash = '-' ; if ( first > last ) { warning ( <NUM_LIT> , <STR_LIT> , str , dash + <NUM_LIT> ) ; return ; }

for ( i = first ; i <= last ; ++ i ) fixed_regs [ i ] = <NUM_LIT> ;


<s> if ( BB_HEAD ( bb ) == insn ) BB_HEAD ( bb ) = b ; if ( BB_END ( bb ) == insn ) BB_END ( bb ) = a ; } if ( insn == BB_END ( bb ) ) break ;


<s> c = ia64_safe_itanium_class ( next ) ; if ( ( c == ITANIUM_CLASS_ST || c == ITANIUM_CLASS_STF ) && ia64_st_address_bypass_p ( insn , next ) ) { has_mem_op_consumer_p = true ; break ; } else if ( ( c == ITANIUM_CLASS_LD || c == ITANIUM_CLASS_FLD || c == ITANIUM_CLASS_FLDP ) && ia64_ld_address_bypass_p ( insn , next ) ) { has_mem_op_consumer_p = true ; break ; }


<s> state -> next = free_bundle_state_chain ; free_bundle_state_chain = state ;


<s> static rtx gen_fr_restore_x ( rtx dest , rtx src , rtx offset ATTRIBUTE_UNUSED ) {


<s> return gen_fr_spill ( dest , src ) ;


<s> static rtx gen_mcount_func_rtx ( void ) {

if ( ! mcount_func_rtx ) mcount_func_rtx = init_one_libfunc ( <STR_LIT> ) ;


<s> if ( ! gen_tls_tga ) gen_tls_tga = init_one_libfunc ( <STR_LIT> ) ; return gen_tls_tga ;


<s> const char * get_bundle_name ( int b ) {


<s> free_bundle_state_chain = result -> next ; } else { result = XNEW ( struct bundle_state ) ;

result -> dfa_state = xmalloc ( dfa_state_size ) ;


<s> static struct bundle_state * get_free_bundle_state ( void ) { struct bundle_state * result ; if ( free_bundle_state_chain != NULL ) { result = free_bundle_state_chain ; free_bundle_state_chain = result -> next ; } else { result = XNEW ( struct bundle_state ) ; result -> dfa_state = xmalloc ( dfa_state_size ) ;

result -> allocated_states_chain = allocated_bundle_states_chain ;


<s> pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == COND_EXEC ) pat = COND_EXEC_CODE ( pat ) ; if ( GET_CODE ( pat ) != SET ) return - <NUM_LIT> ; reg = SET_DEST ( pat ) ; if ( ! REG_P ( reg ) ) return - <NUM_LIT> ; mem = SET_SRC ( pat ) ;

if ( GET_CODE ( mem ) == ZERO_EXTEND ) mem = XEXP ( mem , <NUM_LIT> ) ;


<s> else if ( cpu_unit_reservation_p ( state , pos_5 ) ) return <NUM_LIT> ; else if ( cpu_unit_reservation_p ( state , pos_4 ) ) return <NUM_LIT> ; else if ( cpu_unit_reservation_p ( state , pos_3 ) ) return <NUM_LIT> ; else if ( cpu_unit_reservation_p ( state , pos_2 ) ) return <NUM_LIT> ; else if ( cpu_unit_reservation_p ( state , pos_1 ) ) return <NUM_LIT> ; else return <NUM_LIT> ;


<s> mem = recog_data . operand [ <NUM_LIT> ] ; if ( get_attr_speculable1 ( insn ) == SPECULABLE1_YES ) { if ( ! reload_completed ) { if ( ! REG_P ( reg ) || AR_REGNO_P ( REGNO ( reg ) ) ) return - <NUM_LIT> ; if ( ! MEM_P ( mem ) ) return - <NUM_LIT> ; { rtx mem_reg = XEXP ( mem , <NUM_LIT> ) ; if ( ! REG_P ( mem_reg ) ) return - <NUM_LIT> ; } mode_rtx = mem ; } else if ( get_attr_speculable2 ( insn ) == SPECULABLE2_YES ) { gcc_assert ( REG_P ( reg ) && MEM_P ( mem ) ) ; mode_rtx = mem ; } else return - <NUM_LIT> ; } else if ( get_attr_data_speculative ( insn ) == DATA_SPECULATIVE_YES || get_attr_control_speculative ( insn ) == CONTROL_SPECULATIVE_YES || get_attr_check_load ( insn ) == CHECK_LOAD_YES ) { gcc_assert ( REG_P ( reg ) && MEM_P ( mem ) ) ; mode_rtx = mem ; } else { enum attr_itanium_class attr_class = get_attr_itanium_class ( insn ) ; if ( attr_class == ITANIUM_CLASS_CHK_A || attr_class == ITANIUM_CLASS_CHK_S_I || attr_class == ITANIUM_CLASS_CHK_S_F ) mode_rtx = reg ; else return - <NUM_LIT> ; }


<s> for ( ; insn && insn != tail ; insn = NEXT_INSN ( insn ) ) if ( important_for_bundling_p ( insn ) ) return insn ; return NULL ;


<s> return current_frame_info . r [ r ] ;


<s> static int get_reg ( enum ia64_frame_regs r ) {


<s> gen_speculation_check_bi , gen_speculation_check_qi , gen_speculation_check_hi , gen_speculation_check_si , gen_speculation_check_di , gen_speculation_check_sf , gen_speculation_check_df , gen_speculation_check_xf , gen_speculation_check_ti , gen_speculation_check_di , gen_speculation_check_di , gen_speculation_check_di , } ; gen_func_t * gen_check ; if ( ts & BEGIN_DATA ) { if ( simple_check_p ) { gcc_assert ( mflag_sched_spec_ldc ) ; if ( clearing_check_p ) gen_check = gen_ld_c_clr ; else gen_check = gen_ld_c_nc ; } else { if ( clearing_check_p ) gen_check = gen_chk_a_clr ; else gen_check = gen_chk_a_nc ; } } else if ( ts & BEGIN_CONTROL ) { if ( simple_check_p ) { gcc_assert ( ! ia64_needs_block_p ( ts ) ) ; if ( clearing_check_p ) gen_check = gen_ld_c_clr ; else gen_check = gen_ld_c_nc ; } else { gen_check = gen_chk_s ; } } else gcc_unreachable ( ) ; gcc_assert ( mode_no >= <NUM_LIT> ) ;


<s> if ( ts & BEGIN_DATA ) { if ( ts & BEGIN_CONTROL ) gen_ld = gen_ld_sa ; else gen_ld = gen_ld_a ; } else if ( ts & BEGIN_CONTROL ) { if ( ( spec_info -> flags & SEL_SCHED_SPEC_DONT_CHECK_CONTROL ) || ia64_needs_block_p ( ts ) ) gen_ld = gen_ld_s ; else gen_ld = gen_ld_s_a ; } else if ( ts == <NUM_LIT> ) gen_ld = gen_ld_ ; else gcc_unreachable ( ) ;


<s> code = XINT ( x , <NUM_LIT> ) ; switch ( code ) { case UNSPEC_LDA : case UNSPEC_LDS : case UNSPEC_LDS_A : case UNSPEC_LDSA : return code ; default : return - <NUM_LIT> ;


<s> switch ( code ) { case UNSPEC_LDA : case UNSPEC_LDS : case UNSPEC_LDS_A : case UNSPEC_LDSA : return code ; default : return - <NUM_LIT> ; }


<s> else if ( cpu_unit_reservation_p ( state , _1mib_ ) ) return <NUM_LIT> ; else if ( cpu_unit_reservation_p ( state , _1mbb_ ) ) return <NUM_LIT> ; else if ( cpu_unit_reservation_p ( state , _1bbb_ ) ) return <NUM_LIT> ; else if ( _1mmf_ >= <NUM_LIT> && cpu_unit_reservation_p ( state , _1mmf_ ) ) return <NUM_LIT> ; else if ( cpu_unit_reservation_p ( state , _1mfi_ ) ) return <NUM_LIT> ; else if ( cpu_unit_reservation_p ( state , _1mfb_ ) ) return <NUM_LIT> ; else if ( cpu_unit_reservation_p ( state , _1mlx_ ) ) return <NUM_LIT> ; else gcc_unreachable ( ) ; default :


<s> if ( ( pat = prev_active_insn ( insn ) ) && CALL_P ( pat ) ) { need_barrier = <NUM_LIT> ; break ; } need_barrier = rtx_needs_barrier ( PATTERN ( insn ) , flags , <NUM_LIT> ) ; break ; case JUMP_INSN : if ( ! ia64_spec_check_p ( insn ) ) flags . is_branch = <NUM_LIT> ; if ( ( pat = prev_active_insn ( insn ) ) && CALL_P ( pat ) ) { need_barrier = <NUM_LIT> ; break ; } case INSN : if ( GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER ) break ; pat = PATTERN ( insn ) ; switch ( recog_memoized ( insn ) ) { case CODE_FOR_epilogue_deallocate_stack : case CODE_FOR_prologue_allocate_stack : pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; break ; case CODE_FOR_doloop_end_internal : pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; break ; case CODE_FOR_pred_rel_mutex : case CODE_FOR_prologue_use : return <NUM_LIT> ; default : break ;


<s> memset ( rws_insn , <NUM_LIT> , sizeof ( rws_insn ) ) ; return <NUM_LIT> ; case CALL_INSN : flags . is_branch = <NUM_LIT> ; flags . is_sibcall = SIBLING_CALL_P ( insn ) ; memset ( rws_insn , <NUM_LIT> , sizeof ( rws_insn ) ) ; if ( ( pat = prev_active_insn ( insn ) ) && CALL_P ( pat ) ) { need_barrier = <NUM_LIT> ; break ; } need_barrier = rtx_needs_barrier ( PATTERN ( insn ) , flags , <NUM_LIT> ) ; break ; case JUMP_INSN : if ( ! ia64_spec_check_p ( insn ) ) flags . is_branch = <NUM_LIT> ; if ( ( pat = prev_active_insn ( insn ) ) && CALL_P ( pat ) ) { need_barrier = <NUM_LIT> ; break ; } case INSN : if ( GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER ) break ; pat = PATTERN ( insn ) ;


<s> inline hashval_t bundle_state_hasher :: hash ( const bundle_state * state ) { unsigned result , i ;

for ( result = i = <NUM_LIT> ; i < dfa_state_size ; i ++ ) result += ( ( ( unsigned char * ) state -> dfa_state ) [ i ] << ( ( i % CHAR_BIT ) * <NUM_LIT> + CHAR_BIT ) ) ;


<s> case LANG_TYPE : case FUNCTION_TYPE : return VOIDmode ; case COMPLEX_TYPE : if ( GET_MODE_CLASS ( TYPE_MODE ( type ) ) == MODE_COMPLEX_FLOAT && TYPE_MODE ( type ) != TCmode ) return GET_MODE_INNER ( TYPE_MODE ( type ) ) ; else return VOIDmode ; case REAL_TYPE : if ( nested && TYPE_MODE ( type ) != TFmode ) return TYPE_MODE ( type ) ; else return VOIDmode ; case ARRAY_TYPE : return hfa_element_mode ( TREE_TYPE ( type ) , <NUM_LIT> ) ; case RECORD_TYPE : case UNION_TYPE : case QUAL_UNION_TYPE : for ( t = TYPE_FIELDS ( type ) ; t ; t = DECL_CHAIN ( t ) ) { if ( TREE_CODE ( t ) != FIELD_DECL || DECL_FIELD_ABI_IGNORED ( t ) ) continue ; mode = hfa_element_mode ( TREE_TYPE ( t ) , <NUM_LIT> ) ; if ( know_element_mode ) { if ( mode != element_mode ) return VOIDmode ; } else if ( GET_MODE_CLASS ( mode ) != MODE_FLOAT ) return VOIDmode ; else { know_element_mode = <NUM_LIT> ; element_mode = mode ; } } return element_mode ; default : return VOIDmode ;


<s> rtx note = NULL_RTX ; insn = PREV_INSN ( insn ) ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { do insn = next_active_insn ( insn ) ; while ( NONJUMP_INSN_P ( insn ) && get_attr_empty ( insn ) == EMPTY_YES ) ; if ( CALL_P ( insn ) ) note = find_reg_note ( insn , REG_EH_REGION , NULL_RTX ) ; else if ( note ) { int code ; gcc_assert ( ( code = recog_memoized ( insn ) ) == CODE_FOR_nop || code == CODE_FOR_nop_b ) ; if ( find_reg_note ( insn , REG_EH_REGION , NULL_RTX ) ) note = NULL_RTX ; else add_reg_note ( insn , REG_EH_REGION , XEXP ( note , <NUM_LIT> ) ) ; } }


<s> int words = ia64_function_arg_words ( arg . type , arg . mode ) ; int offset = ia64_function_arg_offset ( cum , arg . type , words ) ; if ( cum -> words + offset >= MAX_ARGUMENT_SLOTS ) return <NUM_LIT> ;

if ( words + cum -> words + offset <= MAX_ARGUMENT_SLOTS ) return <NUM_LIT> ;


<s> if ( cum -> words + offset >= MAX_ARGUMENT_SLOTS ) return <NUM_LIT> ; if ( words + cum -> words + offset <= MAX_ARGUMENT_SLOTS ) return <NUM_LIT> ; return ( MAX_ARGUMENT_SLOTS - cum -> words - offset ) * UNITS_PER_WORD ;


<s> switch ( mode ) { case E_SFmode : return FS ; case E_DFmode :


<s> output_addr_const ( asm_out_file , personality ) ;


<s> fputs ( <STR_LIT> , asm_out_file ) ;

output_addr_const ( asm_out_file , personality ) ;


<s> static void ia64_asm_init_sections ( void ) { exception_section = get_unnamed_section ( <NUM_LIT> , output_section_asm_op , <STR_LIT> ) ;


<s> if ( ( TARGET_HPUX_LD || ! TARGET_GNU_AS ) && TREE_CODE ( decl ) == FUNCTION_DECL ) ( * targetm . asm_out . globalize_decl_name ) ( file , decl ) ; else if ( need_visibility && ! TARGET_GNU_AS ) ( * targetm . asm_out . globalize_label ) ( file , name ) ;


<s> if ( NOTE_P ( insn ) || ! RTX_FRAME_RELATED_P ( insn ) ) return ; if ( INSN_CODE ( insn ) == CODE_FOR_alloc ) { rtx dest = SET_DEST ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) ; int dest_regno = REGNO ( dest ) ; if ( dest_regno == current_frame_info . r [ reg_save_ar_pfs ] ) { if ( unwind ) fprintf ( out_file , <STR_LIT> , ia64_dbx_register_number ( dest_regno ) ) ; } else { if ( current_frame_info . total_size == <NUM_LIT> && ! frame_pointer_needed ) process_epilogue ( out_file , insn , unwind , frame ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> ) ; } return ; } handled_one = false ; for ( note = REG_NOTES ( insn ) ; note ; note = XEXP ( note , <NUM_LIT> ) ) switch ( REG_NOTE_KIND ( note ) ) { case REG_CFA_ADJUST_CFA : pat = XEXP ( note , <NUM_LIT> ) ; if ( pat == NULL ) pat = PATTERN ( insn ) ; process_cfa_adjust_cfa ( out_file , pat , insn , unwind , frame ) ; handled_one = true ; break ; case REG_CFA_OFFSET : pat = XEXP ( note , <NUM_LIT> ) ;


<s> if ( NOTE_INSN_BASIC_BLOCK_P ( insn ) ) { last_block = NOTE_BASIC_BLOCK ( insn ) -> next_bb == EXIT_BLOCK_PTR_FOR_FN ( cfun ) ; if ( need_copy_state ) { if ( unwind ) { fprintf ( out_file , <STR_LIT> ) ; fprintf ( out_file , <STR_LIT> , cfun -> machine -> state_num ) ; } need_copy_state = false ; } } if ( NOTE_P ( insn ) || ! RTX_FRAME_RELATED_P ( insn ) ) return ; if ( INSN_CODE ( insn ) == CODE_FOR_alloc ) { rtx dest = SET_DEST ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) ; int dest_regno = REGNO ( dest ) ; if ( dest_regno == current_frame_info . r [ reg_save_ar_pfs ] ) { if ( unwind ) fprintf ( out_file , <STR_LIT> , ia64_dbx_register_number ( dest_regno ) ) ; } else { if ( current_frame_info . total_size == <NUM_LIT> && ! frame_pointer_needed ) process_epilogue ( out_file , insn , unwind , frame ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> ) ; } return ; } handled_one = false ; for ( note = REG_NOTES ( insn ) ; note ; note = XEXP ( note , <NUM_LIT> ) ) switch ( REG_NOTE_KIND ( note ) ) { case REG_CFA_ADJUST_CFA : pat = XEXP ( note , <NUM_LIT> ) ; if ( pat == NULL ) pat = PATTERN ( insn ) ; process_cfa_adjust_cfa ( out_file , pat , insn , unwind , frame ) ; handled_one = true ; break ; case REG_CFA_OFFSET : pat = XEXP ( note , <NUM_LIT> ) ; if ( pat == NULL ) pat = PATTERN ( insn ) ; process_cfa_offset ( out_file , pat , unwind ) ; handled_one = true ; break ; case REG_CFA_REGISTER : pat = XEXP ( note , <NUM_LIT> ) ; if ( pat == NULL ) pat = PATTERN ( insn ) ; process_cfa_register ( out_file , pat , unwind ) ; handled_one = true ;


<s> if ( size == POINTER_SIZE / BITS_PER_UNIT && ! ( TARGET_NO_PIC || TARGET_AUTO_PIC ) && GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P ( x ) ) { static const char * const directive [ <NUM_LIT> ] [ <NUM_LIT> ] = { { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } } ; fputs ( directive [ ( aligned_p != <NUM_LIT> ) ] [ POINTER_SIZE == <NUM_LIT> ] , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputs ( <STR_LIT> , asm_out_file ) ;


<s> static bool ia64_attribute_takes_identifier_p ( const_tree attr_id ) { if ( is_attribute_p ( <STR_LIT> , attr_id ) ) return true ;


<s> static tree ia64_builtin_decl ( unsigned code , bool initialize_p ATTRIBUTE_UNUSED ) { if ( code >= IA64_BUILTIN_max ) return error_mark_node ;


<s> static bool ia64_cannot_force_const_mem ( machine_mode mode , rtx x ) { if ( mode == RFmode ) return true ; return tls_symbolic_operand_type ( x ) != <NUM_LIT> ;


<s> if ( SCALAR_FLOAT_MODE_P ( from ) != SCALAR_FLOAT_MODE_P ( to ) ) return ! reg_classes_intersect_p ( rclass , FR_REGS ) ; return true ;


<s> static bool ia64_can_change_mode_class ( machine_mode from , machine_mode to , reg_class_t rclass ) { if ( reg_classes_intersect_p ( rclass , BR_REGS ) ) return from == to ; if ( SCALAR_FLOAT_MODE_P ( from ) != SCALAR_FLOAT_MODE_P ( to ) ) return ! reg_classes_intersect_p ( rclass , FR_REGS ) ;


<s> bool ia64_can_eliminate ( const int from ATTRIBUTE_UNUSED , const int to ) {

return ( to == BR_REG ( <NUM_LIT> ) ? crtl -> is_leaf : true ) ;


<s> free ( sc -> prev_cycle_state ) ; sc -> prev_cycle_state = NULL ;


<s> ia64_sched_context_t sc = ( ia64_sched_context_t ) _sc ; free ( sc -> prev_cycle_state ) ; sc -> prev_cycle_state = NULL ;


<s> if ( suffix == 'q' ) return TFmode ; if ( suffix == 'w' ) return XFmode ; return VOIDmode ;


<s> if ( suffix == 'q' ) return TFmode ;


<s> if ( IN_REGNO_P ( regno ) ) return <NUM_LIT> + regno - IN_REG ( <NUM_LIT> ) ;

else if ( LOC_REGNO_P ( regno ) ) return <NUM_LIT> + current_frame_info . n_input_regs + regno - LOC_REG ( <NUM_LIT> ) ;


<s> else if ( LOC_REGNO_P ( regno ) ) return <NUM_LIT> + current_frame_info . n_input_regs + regno - LOC_REG ( <NUM_LIT> ) ; else if ( OUT_REGNO_P ( regno ) ) return ( <NUM_LIT> + current_frame_info . n_input_regs + current_frame_info . n_local_regs + regno - OUT_REG ( <NUM_LIT> ) ) ; else return regno ;


<s> ia64_dconst_0_375_rtx = const_double_from_real_value ( rv , DFmode ) ; }


<s> REAL_VALUE_TYPE rv ; real_from_string ( & rv , <STR_LIT> ) ; ia64_dconst_0_5_rtx = const_double_from_real_value ( rv , DFmode ) ; }


<s> if ( ! ia64_dconst_0_5_rtx ) { REAL_VALUE_TYPE rv ; real_from_string ( & rv , <STR_LIT> ) ;

ia64_dconst_0_5_rtx = const_double_from_real_value ( rv , DFmode ) ;


<s> static enum unwind_info_type ia64_debug_unwind_info ( void ) {


<s> for ( insn = head ; insn != next_tail ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) ) insn -> call = <NUM_LIT> ; for ( insn = head ; insn != next_tail ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) && ia64_safe_itanium_class ( insn ) == ITANIUM_CLASS_IALU ) { sd_iterator_def sd_it ;


<s> dep_t dep ; bool has_mem_op_consumer_p = false ; FOR_EACH_DEP ( insn , SD_LIST_FORW , sd_it , dep ) { enum attr_itanium_class c ; if ( DEP_TYPE ( dep ) != REG_DEP_TRUE ) continue ; next = DEP_CON ( dep ) ; c = ia64_safe_itanium_class ( next ) ; if ( ( c == ITANIUM_CLASS_ST || c == ITANIUM_CLASS_STF ) && ia64_st_address_bypass_p ( insn , next ) ) { has_mem_op_consumer_p = true ; break ; } else if ( ( c == ITANIUM_CLASS_LD || c == ITANIUM_CLASS_FLD || c == ITANIUM_CLASS_FLDP ) && ia64_ld_address_bypass_p ( insn , next ) ) { has_mem_op_consumer_p = true ; break ; } } insn -> call = has_mem_op_consumer_p ; }


<s> unsigned HOST_WIDE_INT op = INTVAL ( rop ) ; unsigned HOST_WIDE_INT shift = INTVAL ( rshift ) ; op >>= shift ; return exact_log2 ( op + <NUM_LIT> ) ;


<s> int ia64_depz_field_mask ( rtx rop , rtx rshift ) { unsigned HOST_WIDE_INT op = INTVAL ( rop ) ; unsigned HOST_WIDE_INT shift = INTVAL ( rshift ) ; op >>= shift ;


<s> if ( TARGET_EARLY_STOP_BITS ) * sort_p = ( last_scheduled_insn == NULL_RTX || ! CALL_P ( last_scheduled_insn ) ) ; else * sort_p = <NUM_LIT> ; return <NUM_LIT> ; } if ( last_scheduled_insn ) { if ( unknown_for_bundling_p ( last_scheduled_insn ) ) state_reset ( curr_state ) ; else { memcpy ( curr_state , prev_cycle_state , dfa_state_size ) ; state_transition ( curr_state , dfa_stop_insn ) ; state_transition ( curr_state , dfa_pre_cycle_insn ) ; state_transition ( curr_state , NULL ) ;


<s> else if ( n_ready > <NUM_LIT> ) return <NUM_LIT> ; } if ( ia64_final_schedule ) { int deleted = <NUM_LIT> ; int nr_need_stop = <NUM_LIT> ; for ( insnp = ready ; insnp < e_ready ; insnp ++ ) if ( safe_group_barrier_needed ( * insnp ) ) nr_need_stop ++ ; if ( reorder_type == <NUM_LIT> && n_ready == nr_need_stop ) return <NUM_LIT> ; if ( reorder_type == <NUM_LIT> ) return <NUM_LIT> ; insnp = e_ready ; while ( insnp -- > ready + deleted ) while ( insnp >= ready + deleted ) { rtx_insn * insn = * insnp ; if ( ! safe_group_barrier_needed ( insn ) ) break ; memmove ( ready + <NUM_LIT> , ready , ( insnp - ready ) * sizeof ( rtx ) ) ; * ready = insn ; deleted ++ ; } n_ready -= deleted ; ready += deleted ; } current_cycle = clock_var ; if ( reload_completed && mem_ops_in_group [ clock_var % <NUM_LIT> ] >= ia64_max_memory_insns ) { int moved = <NUM_LIT> ; insnp = e_ready ; while ( insnp -- > ready + moved ) while ( insnp >= ready + moved ) { rtx_insn * insn = * insnp ; if ( ! is_load_p ( insn ) ) break ; memmove ( ready + <NUM_LIT> , ready , ( insnp - ready ) * sizeof ( rtx ) ) ; * ready = insn ; moved ++ ; } n_ready -= moved ; ready += moved ;


<s> insnp = e_ready ; while ( insnp -- > ready + deleted ) while ( insnp >= ready + deleted ) { rtx_insn * insn = * insnp ; if ( ! safe_group_barrier_needed ( insn ) ) break ; memmove ( ready + <NUM_LIT> , ready , ( insnp - ready ) * sizeof ( rtx ) ) ; * ready = insn ; deleted ++ ; } n_ready -= deleted ; ready += deleted ; } current_cycle = clock_var ; if ( reload_completed && mem_ops_in_group [ clock_var % <NUM_LIT> ] >= ia64_max_memory_insns ) { int moved = <NUM_LIT> ; insnp = e_ready ; while ( insnp -- > ready + moved ) while ( insnp >= ready + moved ) { rtx_insn * insn = * insnp ; if ( ! is_load_p ( insn ) ) break ;


<s> if ( reload_completed && ! frame_pointer_needed ) { ia64_compute_frame_size ( get_frame_size ( ) ) ; return ( current_frame_info . total_size == <NUM_LIT> && current_frame_info . n_spilled == <NUM_LIT> && current_frame_info . r [ reg_save_b0 ] == <NUM_LIT> && current_frame_info . r [ reg_save_pr ] == <NUM_LIT> && current_frame_info . r [ reg_save_ar_pfs ] == <NUM_LIT> && current_frame_info . r [ reg_save_ar_unat ] == <NUM_LIT> && current_frame_info . r [ reg_save_ar_lc ] == <NUM_LIT> ) ; } return <NUM_LIT> ;


<s> int ia64_direct_return ( void ) { if ( reload_completed && ! frame_pointer_needed ) { ia64_compute_frame_size ( get_frame_size ( ) ) ; return ( current_frame_info . total_size == <NUM_LIT> && current_frame_info . n_spilled == <NUM_LIT> && current_frame_info . r [ reg_save_b0 ] == <NUM_LIT> && current_frame_info . r [ reg_save_pr ] == <NUM_LIT> && current_frame_info . r [ reg_save_ar_pfs ] == <NUM_LIT> && current_frame_info . r [ reg_save_ar_unat ] == <NUM_LIT> && current_frame_info . r [ reg_save_ar_lc ] == <NUM_LIT> ) ;


<s> if ( ! reload_completed ) return <NUM_LIT> ; if ( regno == <NUM_LIT> ) return <NUM_LIT> ; for ( r = reg_save_b0 ; r <= reg_save_ar_lc ; r ++ ) if ( regno == current_frame_info . r [ r ] || regno == emitted_frame_related_regs [ r ] ) return <NUM_LIT> ; return <NUM_LIT> ;


for ( insn = get_last_insn ( ) ; insn != first ; insn = PREV_INSN ( insn ) ) if ( INSN_P ( insn ) ) PATTERN ( insn ) = gen_rtx_COND_EXEC ( VOIDmode , copy_rtx ( cond ) , PATTERN ( insn ) ) ;


<s> for ( insn = get_last_insn ( ) ; insn != first ; insn = PREV_INSN ( insn ) ) if ( INSN_P ( insn ) ) PATTERN ( insn ) = gen_rtx_COND_EXEC ( VOIDmode , copy_rtx ( cond ) , PATTERN ( insn ) ) ;


<s> emit_insn_before ( insn , before ) ;


<s> static void ia64_emit_insn_before ( rtx insn , rtx_insn * before ) {


<s> static void ia64_emit_probe_stack_range ( HOST_WIDE_INT first , HOST_WIDE_INT size , int bs_size ) { rtx r2 = gen_rtx_REG ( Pmode , GR_REG ( <NUM_LIT> ) ) ; rtx r3 = gen_rtx_REG ( Pmode , GR_REG ( <NUM_LIT> ) ) ; rtx p6 = gen_rtx_REG ( BImode , PR_REG ( <NUM_LIT> ) ) ; emit_insn ( gen_bsp_value ( r3 ) ) ; emit_move_insn ( r2 , GEN_INT ( - ( first + size ) ) ) ; emit_insn ( gen_rtx_SET ( p6 , gen_rtx_fmt_ee ( LTU , BImode , r3 , stack_pointer_rtx ) ) ) ; emit_insn ( gen_rtx_SET ( r3 , plus_constant ( Pmode , r3 , <NUM_LIT> ) ) ) ; emit_insn ( gen_rtx_SET ( r2 , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , r2 ) ) ) ; emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_fmt_ee ( NE , VOIDmode , p6 , const0_rtx ) , gen_rtx_SET ( p6 , gen_rtx_fmt_ee ( GEU , BImode , r3 , r2 ) ) ) ) ; emit_insn ( gen_rtx_SET ( gen_rtx_ZERO_EXTRACT ( DImode , r3 , GEN_INT ( <NUM_LIT> ) , const0_rtx ) , const0_rtx ) ) ; emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_fmt_ee ( NE , VOIDmode , p6 , const0_rtx ) , gen_rtx_TRAP_IF ( VOIDmode , const1_rtx , GEN_INT ( <NUM_LIT> ) ) ) ) ; if ( bs_size > <NUM_LIT> ) emit_stack_probe ( r3 ) ; if ( size == <NUM_LIT> ) ; else if ( size <= PROBE_INTERVAL ) emit_stack_probe ( r2 ) ; else if ( size <= <NUM_LIT> * PROBE_INTERVAL ) {


<s> static void ia64_encode_section_info ( tree decl , rtx rtl , int first ) { default_encode_section_info ( decl , rtl , first ) ; if ( TREE_CODE ( decl ) == VAR_DECL && GET_CODE ( DECL_RTL ( decl ) ) == MEM && GET_CODE ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) ) == SYMBOL_REF && ( TREE_STATIC ( decl ) || DECL_EXTERNAL ( decl ) ) ) ia64_encode_addr_area ( decl , XEXP ( rtl , <NUM_LIT> ) ) ;


<s> if ( mode == SImode ) icode = CODE_FOR_fetchadd_rel_si ; else icode = CODE_FOR_fetchadd_rel_di ; break ; default : gcc_unreachable ( ) ; } emit_insn ( GEN_FCN ( icode ) ( old_dst , mem , val ) ) ; if ( new_dst ) { new_reg = expand_simple_binop ( mode , PLUS , old_dst , val , new_dst , true , OPTAB_WIDEN ) ; if ( new_reg != new_dst ) emit_move_insn ( new_dst , new_reg ) ; } return ; } gcc_assert ( is_mm_relaxed ( model ) || is_mm_release ( model ) || MEM_VOLATILE_P ( mem ) ) ; old_reg = gen_reg_rtx ( DImode ) ; cmp_reg = gen_reg_rtx ( DImode ) ; label = gen_label_rtx ( ) ; if ( mode != DImode ) { val = simplify_gen_subreg ( DImode , val , mode , <NUM_LIT> ) ; emit_insn ( gen_extend_insn ( cmp_reg , mem , DImode , mode , <NUM_LIT> ) ) ; } else emit_move_insn ( cmp_reg , mem ) ; emit_label ( label ) ; ar_ccv = gen_rtx_REG ( DImode , AR_CCV_REGNUM ) ; emit_move_insn ( old_reg , cmp_reg ) ; emit_move_insn ( ar_ccv , cmp_reg ) ; if ( old_dst ) emit_move_insn ( old_dst , gen_lowpart ( mode , cmp_reg ) ) ; new_reg = cmp_reg ; if ( code == NOT ) {

new_reg = expand_simple_binop ( DImode , AND , new_reg , val , NULL_RTX , true , OPTAB_DIRECT ) ;


<s> tree fndecl = TREE_OPERAND ( CALL_EXPR_FN ( exp ) , <NUM_LIT> ) ; unsigned int fcode = DECL_MD_FUNCTION_CODE ( fndecl ) ; switch ( fcode ) { case IA64_BUILTIN_BSP : if ( ! target || ! register_operand ( target , DImode ) ) target = gen_reg_rtx ( DImode ) ; emit_insn ( gen_bsp_value ( target ) ) ; target = convert_memory_address ( ptr_mode , target ) ; return target ; case IA64_BUILTIN_FLUSHRS : emit_insn ( gen_flushrs ( ) ) ;


<s> else insn = gen_call_value_nogp ( retval , addr , b0 ) ; insn = emit_call_insn ( insn ) ; } else { if ( sibcall_p ) insn = gen_sibcall_gp ( addr ) ; else if ( ! retval ) insn = gen_call_gp ( addr , b0 ) ; else insn = gen_call_value_gp ( retval , addr , b0 ) ;


<s> else if ( local_symbolic_operand64 ( src , VOIDmode ) ) { emit_insn ( gen_load_gprel64 ( dest , src ) ) ; } else { HOST_WIDE_INT addend = <NUM_LIT> ; rtx tmp ; if ( GET_CODE ( src ) == CONST ) { HOST_WIDE_INT hi , lo ; hi = INTVAL ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ) ; lo = ( ( hi & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; hi = hi - lo ; if ( lo != <NUM_LIT> ) { addend = lo ;

src = plus_constant ( Pmode , XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) , hi ) ;


<s> if ( any_offset_symbol_operand ( sym , mode ) ) addend = <NUM_LIT> ; else if ( aligned_offset_symbol_operand ( sym , mode ) ) { HOST_WIDE_INT addend_lo , addend_hi ; addend_lo = ( ( addend & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; addend_hi = addend - addend_lo ; if ( addend_lo != <NUM_LIT> ) { op1 = plus_constant ( mode , sym , addend_hi ) ; addend = addend_lo ; } else addend = <NUM_LIT> ; } else op1 = sym ; if ( reload_completed ) { gcc_assert ( addend == <NUM_LIT> ) ; if ( ia64_expand_load_address ( op0 , op1 ) ) return NULL_RTX ; } if ( addend ) { rtx subtarget = ! can_create_pseudo_p ( ) ? op0 : gen_reg_rtx ( mode ) ;

emit_insn ( gen_rtx_SET ( subtarget , op1 ) ) ;


<s> } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_DOUBLE ) { emit_move_insn ( gen_rtx_REG ( DImode , REGNO ( op0 ) ) , operand_subword ( operands [ <NUM_LIT> ] , WORDS_BIG_ENDIAN , <NUM_LIT> , mode ) ) ; emit_move_insn ( gen_rtx_REG ( DImode , REGNO ( op0 ) + <NUM_LIT> ) , operand_subword ( operands [ <NUM_LIT> ] , ! WORDS_BIG_ENDIAN , <NUM_LIT> , mode ) ) ; return true ; } if ( register_operand ( operands [ <NUM_LIT> ] , mode ) ) operands [ <NUM_LIT> ] = spill_xfmode_rfmode_operand ( operands [ <NUM_LIT> ] , <NUM_LIT> , mode ) ; gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) ; out [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( op0 ) ) ; out [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( op0 ) + <NUM_LIT> ) ; emit_move_insn ( out [ <NUM_LIT> ] , adjust_address ( operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ) ; emit_move_insn ( out [ <NUM_LIT> ] , adjust_address ( operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ) ; return true ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG && GR_REGNO_P ( REGNO ( operands [ <NUM_LIT> ] ) ) ) { gcc_assert ( can_create_pseudo_p ( ) ) ; if ( register_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx op1 = gen_rtx_REG ( TImode , REGNO ( operands [ <NUM_LIT> ] ) ) ; op1 = gen_rtx_SUBREG ( mode , op1 , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = spill_xfmode_rfmode_operand ( op1 , <NUM_LIT> , mode ) ; } else { rtx in [ <NUM_LIT> ] ; gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) ; in [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( operands [ <NUM_LIT> ] ) ) ;

in [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ;


<s> rtx_insn * insns ; rtx orig_op0 = op0 ; HOST_WIDE_INT addend_lo , addend_hi ; switch ( tls_kind ) { case TLS_MODEL_GLOBAL_DYNAMIC : start_sequence ( ) ; tga_op1 = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_load_dtpmod ( tga_op1 , op1 ) ) ; tga_op2 = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_load_dtprel ( tga_op2 , op1 ) ) ; tga_ret = emit_library_call_value ( gen_tls_get_addr ( ) , NULL_RTX , LCT_CONST , Pmode , tga_op1 , Pmode , tga_op2 , Pmode ) ; insns = get_insns ( ) ; end_sequence ( ) ; if ( GET_MODE ( op0 ) != Pmode ) op0 = tga_ret ; emit_libcall_block ( insns , op0 , tga_ret , op1 ) ; break ; case TLS_MODEL_LOCAL_DYNAMIC : start_sequence ( ) ; tga_op1 = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_load_dtpmod ( tga_op1 , op1 ) ) ; tga_op2 = const0_rtx ; tga_ret = emit_library_call_value ( gen_tls_get_addr ( ) , NULL_RTX , LCT_CONST , Pmode , tga_op1 , Pmode , tga_op2 , Pmode ) ; insns = get_insns ( ) ; end_sequence ( ) ; tga_eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_LD_BASE ) ;


<s> if ( of == CONST0_RTX ( mode ) ) { emit_move_insn ( operands [ <NUM_LIT> ] , ot ) ; return ; } x = gen_rtx_NOT ( mode , cmp ) ; x = gen_rtx_AND ( mode , x , of ) ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , x ) ) ; } else if ( of == CONST0_RTX ( mode ) ) { x = gen_rtx_AND ( mode , cmp , ot ) ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , x ) ) ;


<s> x = gen_rtx_AND ( mode , cmp , operands [ <NUM_LIT> + negate ] ) ; emit_insn ( gen_rtx_SET ( t , x ) ) ; f = gen_reg_rtx ( mode ) ; x = gen_rtx_NOT ( mode , cmp ) ; x = gen_rtx_AND ( mode , x , operands [ <NUM_LIT> - negate ] ) ; emit_insn ( gen_rtx_SET ( f , x ) ) ; x = gen_rtx_IOR ( mode , t , f ) ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , x ) ) ; }


<s> emit_insn ( gen_subv2si3 ( t1 , op0 , mask ) ) ; t2 = gen_reg_rtx ( mode ) ; emit_insn ( gen_subv2si3 ( t2 , op1 , mask ) ) ; op0 = t1 ; op1 = t2 ; code = GT ; } break ; case E_V8QImode : case E_V4HImode : x = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( x , gen_rtx_US_MINUS ( mode , op0 , op1 ) ) ) ; code = EQ ; op0 = x ; op1 = CONST0_RTX ( mode ) ; negate = ! negate ; break ; default : gcc_unreachable ( ) ; }


<s> bool ia64_expand_vecint_minmax ( enum rtx_code code , machine_mode mode , rtx operands [ ] ) { rtx xops [ <NUM_LIT> ] ; if ( mode == V8QImode && ( code == UMIN || code == UMAX ) ) return false ; if ( mode == V4HImode && ( code == SMIN || code == SMAX ) ) return false ; if ( mode == V4HImode && code == UMAX ) { rtx x , tmp = gen_reg_rtx ( mode ) ; x = gen_rtx_US_MINUS ( mode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_SET ( tmp , x ) ) ; emit_insn ( gen_addv4hi3 ( operands [ <NUM_LIT> ] , tmp , operands [ <NUM_LIT> ] ) ) ;


<s> if ( expand_vec_perm_broadcast ( d ) ) return true ; if ( expand_vec_perm_interleave_2 ( d ) ) return true ; if ( expand_vec_perm_v4hi_5 ( d ) ) return true ; return false ;


<s> d . op1 = op1 ; d . vmode = vmode ; d . nelt = nelt ; d . one_operand_p = false ; d . testing_p = false ;

for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d . perm [ i ] = i * <NUM_LIT> + odd ;


<s> d . vmode = V2SFmode ; d . nelt = <NUM_LIT> ; d . one_operand_p = false ; d . testing_p = false ; which = INTVAL ( operands [ <NUM_LIT> ] ) ; gcc_assert ( which <= <NUM_LIT> ) ;

d . perm [ <NUM_LIT> ] = <NUM_LIT> - which ;


<s> d . perm [ <NUM_LIT> ] = which + <NUM_LIT> ; emit_insn ( gen_fpack ( d . op1 , operands [ <NUM_LIT> ] , CONST0_RTX ( SFmode ) ) ) ; ok = ia64_expand_vec_perm_const_1 ( & d ) ;


<s> rtx l , h , t , sign ; sign = ia64_unpack_sign ( operands [ <NUM_LIT> ] , unsignedp ) ; wmode = GET_MODE ( operands [ <NUM_LIT> ] ) ; l = gen_reg_rtx ( wmode ) ; h = gen_reg_rtx ( wmode ) ; ia64_unpack_assemble ( l , operands [ <NUM_LIT> ] , sign , false ) ; ia64_unpack_assemble ( h , operands [ <NUM_LIT> ] , sign , true ) ; t = expand_binop ( wmode , add_optab , l , operands [ <NUM_LIT> ] , NULL , <NUM_LIT> , OPTAB_DIRECT ) ; t = expand_binop ( wmode , add_optab , h , t , operands [ <NUM_LIT> ] , <NUM_LIT> , OPTAB_DIRECT ) ; if ( t != operands [ <NUM_LIT> ] ) emit_move_insn ( operands [ <NUM_LIT> ] , t ) ;


<s> sign = ia64_unpack_sign ( operands [ <NUM_LIT> ] , unsignedp ) ; wmode = GET_MODE ( operands [ <NUM_LIT> ] ) ; l = gen_reg_rtx ( wmode ) ; h = gen_reg_rtx ( wmode ) ;

ia64_unpack_assemble ( l , operands [ <NUM_LIT> ] , sign , false ) ;


<s> return ( reload_completed ? <NUM_LIT> : <NUM_LIT> ) ;


<s> if ( pending_data_specs >= <NUM_LIT> && ( TODO_SPEC ( insn ) & BEGIN_DATA ) ) return ready_index == <NUM_LIT> ? - <NUM_LIT> : <NUM_LIT> ; if ( ready_index == <NUM_LIT> ) return <NUM_LIT> ;

if ( ( ! reload_completed || ! safe_group_barrier_needed ( insn ) ) && ( ! mflag_sched_mem_insns_hard_limit || ! is_load_p ( insn ) || mem_ops_in_group [ current_cycle % <NUM_LIT> ] < ia64_max_memory_insns ) ) return <NUM_LIT> ;


<s> if ( ( ! reload_completed || ! safe_group_barrier_needed ( insn ) ) && ( ! mflag_sched_mem_insns_hard_limit || ! is_load_p ( insn ) || mem_ops_in_group [ current_cycle % <NUM_LIT> ] < ia64_max_memory_insns ) ) return <NUM_LIT> ;


<s> const char * str = c_getstr ( * args ) ; int quiet = fn_code == IA64_BUILTIN_NANQ ; REAL_VALUE_TYPE real ; if ( str && real_nan ( & real , str , quiet , TYPE_MODE ( type ) ) ) return build_real ( type , real ) ; return NULL_TREE ; } default :


<s> static void ia64_free_sched_context ( void * _sc ) { gcc_assert ( _sc != NULL ) ; free ( _sc ) ;


<s> static rtx ia64_function_arg ( cumulative_args_t cum , const function_arg_info & arg ) {

return ia64_function_arg_1 ( cum , arg , false ) ;


<s> else if ( gr_size > UNITS_PER_WORD ) int_regs += gr_size / UNITS_PER_WORD ; } return gen_rtx_PARALLEL ( arg . mode , gen_rtvec_v ( i , loc ) ) ; } else if ( arg . mode == TFmode || arg . mode == TCmode || ! FLOAT_MODE_P ( arg . mode ) || cum -> fp_regs == MAX_ARGUMENT_SLOTS ) { int byte_size = arg . promoted_size_in_bytes ( ) ; if ( BYTES_BIG_ENDIAN && ( arg . mode == BLKmode || arg . aggregate_type_p ( ) ) && byte_size < UNITS_PER_WORD && byte_size > <NUM_LIT> ) { rtx gr_reg = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( DImode , ( basereg + cum -> words + offset ) ) , const0_rtx ) ; return gen_rtx_PARALLEL ( arg . mode , gen_rtvec ( <NUM_LIT> , gr_reg ) ) ; } else return gen_rtx_REG ( arg . mode , basereg + cum -> words + offset ) ; } else if ( cum -> prototype ) { if ( arg . named ) return gen_rtx_REG ( arg . mode , FR_ARG_FIRST + cum -> fp_regs ) ; else if ( BYTES_BIG_ENDIAN && arg . mode == SFmode ) return gen_rtx_PARALLEL ( arg . mode , gen_rtvec ( <NUM_LIT> , gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( DImode , basereg + cum -> words + offset ) , const0_rtx ) ) ) ; else return gen_rtx_REG ( arg . mode , basereg + cum -> words + offset ) ; } else { machine_mode inner_mode = ( BYTES_BIG_ENDIAN && arg . mode == SFmode ) ? DImode : arg . mode ; rtx fp_reg = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( arg . mode , ( FR_ARG_FIRST + cum -> fp_regs ) ) , const0_rtx ) ;

rtx gr_reg = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( inner_mode , ( basereg + cum -> words + offset ) ) , const0_rtx ) ;


<s> if ( TARGET_ABI_OPEN_VMS && arg . end_marker_p ( ) ) { unsigned HOST_WIDE_INT regval = cum -> words ; int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) regval |= ( ( int ) cum -> atypes [ i ] ) << ( i * <NUM_LIT> + <NUM_LIT> ) ; emit_move_insn ( gen_rtx_REG ( DImode , GR_REG ( <NUM_LIT> ) ) , GEN_INT ( regval ) ) ; } if ( cum -> words + offset >= MAX_ARGUMENT_SLOTS ) return <NUM_LIT> ; if ( TARGET_ABI_OPEN_VMS ) { if ( FLOAT_MODE_P ( arg . mode ) ) return gen_rtx_REG ( arg . mode , FR_ARG_FIRST + cum -> words ) ; else return gen_rtx_REG ( arg . mode , basereg + cum -> words ) ; } if ( arg . type ) hfa_mode = hfa_element_mode ( arg . type , <NUM_LIT> ) ; if ( hfa_mode != VOIDmode && ( ! cum -> prototype || arg . named ) ) { rtx loc [ <NUM_LIT> ] ; int i = <NUM_LIT> ; int fp_regs = cum -> fp_regs ; int int_regs = cum -> words + offset ; int hfa_size = GET_MODE_SIZE ( hfa_mode ) ; int byte_size ; int args_byte_size ; byte_size = arg . promoted_size_in_bytes ( ) ; args_byte_size = int_regs * UNITS_PER_WORD ; offset = <NUM_LIT> ;

for ( ; ( offset < byte_size && fp_regs < MAX_ARGUMENT_SLOTS && args_byte_size < ( MAX_ARGUMENT_SLOTS * UNITS_PER_WORD ) ) ; i ++ ) {


<s> static void ia64_function_arg_advance ( cumulative_args_t cum_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int words = ia64_function_arg_words ( arg . type , arg . mode ) ; int offset = ia64_function_arg_offset ( cum , arg . type , words ) ; machine_mode hfa_mode = VOIDmode ; if ( cum -> words >= MAX_ARGUMENT_SLOTS ) { cum -> words += words + offset ; return ; } cum -> atypes [ cum -> words ] = ia64_arg_type ( arg . mode ) ; cum -> words += words + offset ; if ( TARGET_ABI_OPEN_VMS ) { cum -> int_regs = cum -> words ; cum -> fp_regs = cum -> words ; return ; } if ( arg . type ) hfa_mode = hfa_element_mode ( arg . type , <NUM_LIT> ) ; if ( hfa_mode != VOIDmode && ( ! cum -> prototype || arg . named ) ) { int fp_regs = cum -> fp_regs ; int int_regs = cum -> words - words ; int hfa_size = GET_MODE_SIZE ( hfa_mode ) ; int byte_size ; int args_byte_size ; byte_size = arg . promoted_size_in_bytes ( ) ; args_byte_size = int_regs * UNITS_PER_WORD ; offset = <NUM_LIT> ; for ( ; ( offset < byte_size && fp_regs < MAX_ARGUMENT_SLOTS && args_byte_size < ( MAX_ARGUMENT_SLOTS * UNITS_PER_WORD ) ) ; ) { offset += hfa_size ; args_byte_size += hfa_size ; fp_regs ++ ; } cum -> fp_regs = fp_regs ; } else if ( arg . mode == TFmode || arg . mode == TCmode || ! FLOAT_MODE_P ( arg . mode ) || cum -> fp_regs == MAX_ARGUMENT_SLOTS ) cum -> int_regs = cum -> words ; else if ( cum -> prototype ) { if ( ! arg . named ) cum -> int_regs = cum -> words ; else cum -> fp_regs += ( GET_MODE_CLASS ( arg . mode ) == MODE_COMPLEX_FLOAT ? <NUM_LIT> : <NUM_LIT> ) ;


<s> static int ia64_function_arg_offset ( const CUMULATIVE_ARGS * cum , const_tree type , int words ) { if ( TARGET_ABI_OPEN_VMS || ( cum -> words & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ;

if ( type && TREE_CODE ( type ) != INTEGER_TYPE && TREE_CODE ( type ) != REAL_TYPE ) return TYPE_ALIGN ( type ) > <NUM_LIT> * BITS_PER_UNIT ;


<s> static pad_direction ia64_function_arg_padding ( machine_mode mode , const_tree type ) {

if ( TARGET_HPUX && type && AGGREGATE_TYPE_P ( type ) && int_size_in_bytes ( type ) < UNITS_PER_WORD ) return PAD_UPWARD ;


<s> if ( mode == BLKmode ) words = int_size_in_bytes ( type ) ; else words = GET_MODE_SIZE ( mode ) ;

return ( words + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ;


<s> return ia64_function_arg_1 ( cum , arg , true ) ;


<s> if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ) ) return false ;

return ( decl && ( * targetm . binds_local_p ) ( decl ) ) || TARGET_CONST_GP ;


<s> machine_mode hfa_mode ; int unsignedp ; const_tree func = fn_decl_or_type ; if ( fn_decl_or_type && ! DECL_P ( fn_decl_or_type ) ) func = NULL ; mode = TYPE_MODE ( valtype ) ; hfa_mode = hfa_element_mode ( valtype , <NUM_LIT> ) ; if ( hfa_mode != VOIDmode ) { rtx loc [ <NUM_LIT> ] ; int i ; int hfa_size ; int byte_size ; int offset ; hfa_size = GET_MODE_SIZE ( hfa_mode ) ; byte_size = ( ( mode == BLKmode ) ? int_size_in_bytes ( valtype ) : GET_MODE_SIZE ( mode ) ) ; offset = <NUM_LIT> ; for ( i = <NUM_LIT> ; offset < byte_size ; i ++ ) { loc [ i ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( hfa_mode , FR_ARG_FIRST + i ) , GEN_INT ( offset ) ) ; offset += hfa_size ; } return gen_rtx_PARALLEL ( mode , gen_rtvec_v ( i , loc ) ) ; } else if ( FLOAT_TYPE_P ( valtype ) && mode != TFmode && mode != TCmode ) return gen_rtx_REG ( mode , FR_ARG_FIRST ) ;


<s> } gen_check = get_spec_check_gen_function ( ds , mode_no , label == NULL_RTX , true ) ; check_pat = gen_check ( copy_rtx ( recog_data . operand [ <NUM_LIT> ] ) , op1 ) ; pat = PATTERN ( insn ) ;

if ( GET_CODE ( pat ) == COND_EXEC ) check_pat = gen_rtx_COND_EXEC ( VOIDmode , copy_rtx ( COND_EXEC_TEST ( pat ) ) , check_pat ) ;


<s> rtx pat , new_pat ; gen_func_t gen_load ; gen_load = get_spec_load_gen_function ( ts , mode_no ) ; new_pat = gen_load ( copy_rtx ( recog_data . operand [ <NUM_LIT> ] ) , copy_rtx ( recog_data . operand [ <NUM_LIT> ] ) ) ; pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == COND_EXEC ) new_pat = gen_rtx_COND_EXEC ( VOIDmode , copy_rtx ( COND_EXEC_TEST ( pat ) ) , new_pat ) ;


<s> pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == COND_EXEC ) new_pat = gen_rtx_COND_EXEC ( VOIDmode , copy_rtx ( COND_EXEC_TEST ( pat ) ) , new_pat ) ;


<s> id = TREE_VALUE ( TREE_VALUE ( model_attr ) ) ;

if ( id == small_ident1 || id == small_ident2 ) return ADDR_AREA_SMALL ;


<s> init_idents ( ) ; id = TREE_VALUE ( TREE_VALUE ( model_attr ) ) ; if ( id == small_ident1 || id == small_ident2 ) return ADDR_AREA_SMALL ; }


<s> return BEGIN_CONTROL ; case UNSPEC_LDS_A : case UNSPEC_LDSA : return BEGIN_DATA | BEGIN_CONTROL ; default : return <NUM_LIT> ;


<s> case UNSPEC_LDS : return BEGIN_CONTROL ; case UNSPEC_LDS_A : case UNSPEC_LDSA :


<s> static fixed_size_mode ia64_get_reg_raw_mode ( int regno ) { if ( FR_REGNO_P ( regno ) ) return XFmode ; return default_get_reg_raw_mode ( regno ) ;


<s> return build_va_arg_indirect_ref ( addr ) ; } if ( ( TREE_CODE ( type ) == REAL_TYPE || TREE_CODE ( type ) == INTEGER_TYPE ) ? int_size_in_bytes ( type ) > <NUM_LIT> : TYPE_ALIGN ( type ) > <NUM_LIT> * BITS_PER_UNIT ) {

tree t = fold_build_pointer_plus_hwi ( valist , <NUM_LIT> * UNITS_PER_WORD - <NUM_LIT> ) ;


<s> if ( ( TREE_CODE ( type ) == REAL_TYPE || TREE_CODE ( type ) == INTEGER_TYPE ) ? int_size_in_bytes ( type ) > <NUM_LIT> : TYPE_ALIGN ( type ) > <NUM_LIT> * BITS_PER_UNIT ) { tree t = fold_build_pointer_plus_hwi ( valist , <NUM_LIT> * UNITS_PER_WORD - <NUM_LIT> ) ; t = build2 ( BIT_AND_EXPR , TREE_TYPE ( t ) , t , build_int_cst ( TREE_TYPE ( t ) , - <NUM_LIT> * UNITS_PER_WORD ) ) ;

gimplify_assign ( unshare_expr ( valist ) , t , pre_p ) ;


<s> const char * name = XSTR ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; tree version_attr = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ; if ( version_attr ) { tree v = TREE_VALUE ( TREE_VALUE ( version_attr ) ) ; const char * p = TREE_STRING_POINTER ( v ) ; fprintf ( stream , <STR_LIT> , name , name , p ) ; }

targetm . asm_out . globalize_label ( stream , name ) ;


<s> if ( GR_REGNO_P ( regno ) ) return mode != XFmode && mode != XCmode && mode != RFmode ; if ( AR_REGNO_P ( regno ) ) return mode == DImode ; if ( BR_REGNO_P ( regno ) ) return mode == DImode ;


<s> if ( regno == PR_REG ( <NUM_LIT> ) && mode == DImode ) return <NUM_LIT> ; if ( PR_REGNO_P ( regno ) && ( mode ) == BImode ) return <NUM_LIT> ; if ( ( PR_REGNO_P ( regno ) || GR_REGNO_P ( regno ) ) && mode == CCImode ) return <NUM_LIT> ; if ( FR_REGNO_P ( regno ) && mode == XFmode ) return <NUM_LIT> ; if ( FR_REGNO_P ( regno ) && mode == RFmode ) return <NUM_LIT> ;

if ( FR_REGNO_P ( regno ) && mode == XCmode ) return <NUM_LIT> ;


<s> if ( PR_REGNO_P ( regno ) && ( mode ) == BImode ) return <NUM_LIT> ; if ( ( PR_REGNO_P ( regno ) || GR_REGNO_P ( regno ) ) && mode == CCImode ) return <NUM_LIT> ;

if ( FR_REGNO_P ( regno ) && mode == XFmode ) return <NUM_LIT> ;


<s> if ( OUT_REGNO_P ( to ) && to >= OUT_REG ( current_frame_info . n_output_regs ) ) return <NUM_LIT> ; if ( PR_REGNO_P ( from ) && PR_REGNO_P ( to ) ) return ( from & <NUM_LIT> ) == ( to & <NUM_LIT> ) ; return <NUM_LIT> ;


<s> ATTRIBUTE_UNUSED static section * ia64_hpux_function_section ( tree decl ATTRIBUTE_UNUSED , enum node_frequency freq ATTRIBUTE_UNUSED , bool startup ATTRIBUTE_UNUSED , bool exit ATTRIBUTE_UNUSED ) {


set_optab_libfunc ( le_optab , TFmode , <NUM_LIT> ) ;


set_optab_libfunc ( ne_optab , TFmode , <NUM_LIT> ) ;


<s> stops_p = ( char * ) xrecalloc ( stops_p , new_clocks_length , clocks_length , <NUM_LIT> ) ; clocks_length = new_clocks_length ;


<s> if ( stops_p != NULL ) { int new_clocks_length = get_max_uid ( ) * <NUM_LIT> / <NUM_LIT> ; stops_p = ( char * ) xrecalloc ( stops_p , new_clocks_length , clocks_length , <NUM_LIT> ) ;


<s> gcc_unreachable ( ) ; } break ; case ARG_POINTER_REGNUM : switch ( to ) { case HARD_FRAME_POINTER_REGNUM : offset = <NUM_LIT> - crtl -> args . pretend_args_size ; break ; case STACK_POINTER_REGNUM : offset = ( current_frame_info . total_size + <NUM_LIT> - crtl -> args . pretend_args_size ) ;


<s> break ; default : gcc_unreachable ( ) ; } break ; case ARG_POINTER_REGNUM : switch ( to ) { case HARD_FRAME_POINTER_REGNUM : offset = <NUM_LIT> - crtl -> args . pretend_args_size ; break ; case STACK_POINTER_REGNUM : offset = ( current_frame_info . total_size + <NUM_LIT> - crtl -> args . pretend_args_size ) ; break ; default : gcc_unreachable ( ) ; } break ; default : gcc_unreachable ( ) ; }


<s> TYPE_PRECISION ( fpreg_type ) = <NUM_LIT> ; layout_type ( fpreg_type ) ; ( * lang_hooks . types . register_builtin_type ) ( fpreg_type , <STR_LIT> ) ; if ( float64x_type_node != NULL_TREE && TYPE_MODE ( float64x_type_node ) == XFmode ) float80_type = float64x_type_node ; else { float80_type = make_node ( REAL_TYPE ) ; TYPE_PRECISION ( float80_type ) = <NUM_LIT> ; layout_type ( float80_type ) ; } ( * lang_hooks . types . register_builtin_type ) ( float80_type , <STR_LIT> ) ; if ( ! TARGET_HPUX ) { tree ftype ; tree const_string_type = build_pointer_type ( build_qualified_type ( char_type_node , TYPE_QUAL_CONST ) ) ; ( * lang_hooks . types . register_builtin_type ) ( float128_type_node , <STR_LIT> ) ; ftype = build_function_type_list ( float128_type_node , NULL_TREE ) ; decl = add_builtin_function ( <STR_LIT> , ftype , IA64_BUILTIN_INFQ , BUILT_IN_MD , NULL , NULL_TREE ) ; ia64_builtins [ IA64_BUILTIN_INFQ ] = decl ;

decl = add_builtin_function ( <STR_LIT> , ftype , IA64_BUILTIN_HUGE_VALQ , BUILT_IN_MD , NULL , NULL_TREE ) ;


<s> dfa_state_size = state_size ( ) ; temp_dfa_state = xmalloc ( dfa_state_size ) ; prev_cycle_state = xmalloc ( dfa_state_size ) ; }

dfa_pre_cycle_insn = make_insn_raw ( gen_pre_cycle ( ) ) ;


<s> memset ( & emitted_frame_related_regs , <NUM_LIT> , sizeof ( emitted_frame_related_regs ) ) ;


<s> set_conv_libfunc ( trunc_optab , XFmode , TFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , SImode , TFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , DImode , TFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , TImode , TFmode , <STR_LIT> ) ; set_conv_libfunc ( ufix_optab , SImode , TFmode , <STR_LIT> ) ; set_conv_libfunc ( ufix_optab , DImode , TFmode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , TFmode , SImode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , TFmode , DImode , <STR_LIT> ) ;

set_conv_libfunc ( sfloat_optab , TFmode , TImode , <STR_LIT> ) ;


<s> set_optab_libfunc ( sdiv_optab , TFmode , <STR_LIT> ) ; set_optab_libfunc ( neg_optab , TFmode , <STR_LIT> ) ; set_conv_libfunc ( sext_optab , TFmode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sext_optab , TFmode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sext_optab , TFmode , XFmode , <STR_LIT> ) ; set_conv_libfunc ( trunc_optab , SFmode , TFmode , <STR_LIT> ) ; set_conv_libfunc ( trunc_optab , DFmode , TFmode , <STR_LIT> ) ; set_conv_libfunc ( trunc_optab , XFmode , TFmode , <STR_LIT> ) ;

set_conv_libfunc ( sfix_optab , SImode , TFmode , <STR_LIT> ) ;


<s> static struct machine_function * ia64_init_machine_status ( void ) {

return ggc_cleared_alloc < machine_function > ( ) ;


<s> memset ( sc -> rws_insn , <NUM_LIT> , sizeof ( rws_insn ) ) ; sc -> first_instruction = <NUM_LIT> ; sc -> pending_data_specs = <NUM_LIT> ; sc -> current_cycle = <NUM_LIT> ; memset ( sc -> mem_ops_in_group , <NUM_LIT> , sizeof ( mem_ops_in_group ) ) ; } else { memcpy ( sc -> prev_cycle_state , prev_cycle_state , dfa_state_size ) ; sc -> last_scheduled_insn = last_scheduled_insn ; memcpy ( sc -> rws_sum , rws_sum , sizeof ( rws_sum ) ) ; memcpy ( sc -> rws_insn , rws_insn , sizeof ( rws_insn ) ) ;

sc -> first_instruction = first_instruction ;


<s> memset ( sc -> rws_insn , <NUM_LIT> , sizeof ( rws_insn ) ) ; sc -> first_instruction = <NUM_LIT> ; sc -> pending_data_specs = <NUM_LIT> ; sc -> current_cycle = <NUM_LIT> ; memset ( sc -> mem_ops_in_group , <NUM_LIT> , sizeof ( mem_ops_in_group ) ) ; } else { memcpy ( sc -> prev_cycle_state , prev_cycle_state , dfa_state_size ) ; sc -> last_scheduled_insn = last_scheduled_insn ; memcpy ( sc -> rws_sum , rws_sum , sizeof ( rws_sum ) ) ; memcpy ( sc -> rws_insn , rws_insn , sizeof ( rws_insn ) ) ; sc -> first_instruction = first_instruction ;

sc -> pending_data_specs = pending_data_specs ;


<s> static const char * ia64_invalid_binary_op ( int op ATTRIBUTE_UNUSED , const_tree type1 , const_tree type2 ) {

if ( TYPE_MODE ( type1 ) == RFmode || TYPE_MODE ( type2 ) == RFmode ) return N_ ( <STR_LIT> ) ;


<s> if ( TYPE_MODE ( fromtype ) == RFmode && TYPE_MODE ( totype ) != RFmode && TYPE_MODE ( totype ) != VOIDmode ) return N_ ( <STR_LIT> ) ; if ( TYPE_MODE ( totype ) == RFmode && TYPE_MODE ( fromtype ) != RFmode ) return N_ ( <STR_LIT> ) ;


<s> static const char * ia64_invalid_unary_op ( int op , const_tree type ) { if ( TYPE_MODE ( type ) == RFmode && op != CONVERT_EXPR && op != ADDR_EXPR ) return N_ ( <STR_LIT> ) ; return NULL ;


<s> if ( TREE_CODE ( exp ) == STRING_CST ) return false ; if ( TREE_CODE ( exp ) == FUNCTION_DECL ) return false ; if ( TREE_CODE ( exp ) == VAR_DECL && DECL_SECTION_NAME ( exp ) ) { const char * section = DECL_SECTION_NAME ( exp ) ; if ( strcmp ( section , <STR_LIT> ) == <NUM_LIT> || startswith ( section , <STR_LIT> ) || startswith ( section , <STR_LIT> ) || strcmp ( section , <STR_LIT> ) == <NUM_LIT> || startswith ( section , <STR_LIT> ) || startswith ( section , <STR_LIT> ) ) return true ; } else {

HOST_WIDE_INT size = int_size_in_bytes ( TREE_TYPE ( exp ) ) ;


<s> gcc_assert ( producer && consumer ) ; dest = ia64_single_set ( producer ) ; gcc_assert ( dest ) ; reg = SET_DEST ( dest ) ; gcc_assert ( reg ) ; if ( GET_CODE ( reg ) == SUBREG ) reg = SUBREG_REG ( reg ) ; gcc_assert ( GET_CODE ( reg ) == REG ) ; src = ia64_single_set ( consumer ) ; gcc_assert ( src ) ; mem = SET_SRC ( src ) ; gcc_assert ( mem ) ; if ( GET_CODE ( mem ) == UNSPEC && XVECLEN ( mem , <NUM_LIT> ) > <NUM_LIT> ) mem = XVECEXP ( mem , <NUM_LIT> , <NUM_LIT> ) ; else if ( GET_CODE ( mem ) == IF_THEN_ELSE ) { gcc_assert ( XINT ( XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_LDCCLR ) ; mem = XEXP ( mem , <NUM_LIT> ) ; } while ( GET_CODE ( mem ) == SUBREG || GET_CODE ( mem ) == ZERO_EXTEND ) mem = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( mem ) == UNSPEC ) { int c = XINT ( mem , <NUM_LIT> ) ; gcc_assert ( c == UNSPEC_LDA || c == UNSPEC_LDS || c == UNSPEC_LDS_A || c == UNSPEC_LDSA ) ; mem = XVECEXP ( mem , <NUM_LIT> , <NUM_LIT> ) ; }

gcc_assert ( GET_CODE ( mem ) == LO_SUM || GET_CODE ( mem ) == MEM ) ;


<s> gcc_assert ( producer && consumer ) ; dest = ia64_single_set ( producer ) ; gcc_assert ( dest ) ; reg = SET_DEST ( dest ) ; gcc_assert ( reg ) ; if ( GET_CODE ( reg ) == SUBREG ) reg = SUBREG_REG ( reg ) ; gcc_assert ( GET_CODE ( reg ) == REG ) ; src = ia64_single_set ( consumer ) ; gcc_assert ( src ) ; mem = SET_SRC ( src ) ; gcc_assert ( mem ) ;

if ( GET_CODE ( mem ) == UNSPEC && XVECLEN ( mem , <NUM_LIT> ) > <NUM_LIT> ) mem = XVECEXP ( mem , <NUM_LIT> , <NUM_LIT> ) ;


<s> static bool ia64_legitimate_address_disp ( const_rtx reg , const_rtx disp , bool strict ) { if ( GET_CODE ( disp ) == PLUS && rtx_equal_p ( reg , XEXP ( disp , <NUM_LIT> ) ) && ( ia64_legitimate_address_reg ( XEXP ( disp , <NUM_LIT> ) , strict ) || ( CONST_INT_P ( XEXP ( disp , <NUM_LIT> ) ) && IN_RANGE ( INTVAL ( XEXP ( disp , <NUM_LIT> ) ) , - <NUM_LIT> , <NUM_LIT> ) ) ) ) return true ;


<s> else if ( GET_CODE ( x ) == POST_MODIFY && ia64_legitimate_address_reg ( XEXP ( x , <NUM_LIT> ) , strict ) && XEXP ( x , <NUM_LIT> ) != arg_pointer_rtx && ia64_legitimate_address_disp ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , strict ) ) return true ;


<s> else if ( GET_CODE ( x ) == POST_MODIFY && ia64_legitimate_address_reg ( XEXP ( x , <NUM_LIT> ) , strict ) && XEXP ( x , <NUM_LIT> ) != arg_pointer_rtx && ia64_legitimate_address_disp ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , strict ) ) return true ; else return false ;


<s> static bool ia64_legitimate_address_reg ( const_rtx reg , bool strict ) {

if ( ( REG_P ( reg ) && ia64_reg_ok_for_base_p ( reg , strict ) ) || ( GET_CODE ( reg ) == SUBREG && REG_P ( XEXP ( reg , <NUM_LIT> ) ) && ia64_reg_ok_for_base_p ( XEXP ( reg , <NUM_LIT> ) , strict ) ) ) return true ;


<s> if ( tls_symbolic_operand_type ( x ) == <NUM_LIT> ) { HOST_WIDE_INT addend = <NUM_LIT> ; rtx op = x ; if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) { addend = INTVAL ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; op = XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ; } if ( any_offset_symbol_operand ( op , mode ) || function_operand ( op , mode ) ) return true ; if ( aligned_offset_symbol_operand ( op , mode ) ) return ( addend & <NUM_LIT> ) == <NUM_LIT> ; return false ; } return false ; case CONST_VECTOR :

if ( mode == V2SFmode ) return satisfies_constraint_Y ( x ) ;


<s> case CONST : case SYMBOL_REF : if ( tls_symbolic_operand_type ( x ) == <NUM_LIT> ) { HOST_WIDE_INT addend = <NUM_LIT> ; rtx op = x ; if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) { addend = INTVAL ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; op = XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ; } if ( any_offset_symbol_operand ( op , mode ) || function_operand ( op , mode ) ) return true ; if ( aligned_offset_symbol_operand ( op , mode ) ) return ( addend & <NUM_LIT> ) == <NUM_LIT> ; return false ; } return false ;


<s> static rtx ia64_libcall_value ( machine_mode mode , const_rtx fun ATTRIBUTE_UNUSED ) {

return gen_rtx_REG ( mode , ( ( ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) && ( mode ) != TFmode ) ? FR_RET_FIRST : GR_RET_FIRST ) ) ;


<s> if ( GET_CODE ( dst ) != REG || ! ( FP_REGNO_P ( REGNO ( dst ) ) && FP_REGNO_P ( REGNO ( dst ) + <NUM_LIT> ) ) ) return <NUM_LIT> ; if ( GET_CODE ( src ) != MEM || MEM_VOLATILE_P ( src ) ) return <NUM_LIT> ; switch ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) ) { case REG : case POST_INC : break ; case POST_DEC : return <NUM_LIT> ; case POST_MODIFY : { rtx adjust = XEXP ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ;

if ( GET_CODE ( adjust ) != CONST_INT || INTVAL ( adjust ) != GET_MODE_SIZE ( GET_MODE ( src ) ) ) return <NUM_LIT> ;


<s> int ia64_load_pair_ok ( rtx dst , rtx src ) { if ( GET_CODE ( dst ) != REG || ! ( FP_REGNO_P ( REGNO ( dst ) ) && FP_REGNO_P ( REGNO ( dst ) + <NUM_LIT> ) ) ) return <NUM_LIT> ; if ( GET_CODE ( src ) != MEM || MEM_VOLATILE_P ( src ) ) return <NUM_LIT> ; switch ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) ) { case REG : case POST_INC : break ; case POST_DEC : return <NUM_LIT> ; case POST_MODIFY : { rtx adjust = XEXP ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( adjust ) != CONST_INT || INTVAL ( adjust ) != GET_MODE_SIZE ( GET_MODE ( src ) ) ) return <NUM_LIT> ;


if ( TREE_CODE ( type ) != VOID_TYPE && TREE_CODE ( type ) != BOOLEAN_TYPE && TREE_CODE ( type ) != INTEGER_TYPE && TREE_CODE ( type ) != REAL_TYPE ) return NULL ;


<s> if ( ! TARGET_HPUX && TYPE_MODE ( type ) == TFmode ) return <STR_LIT> ;

if ( TYPE_MODE ( type ) == XFmode ) return TARGET_HPUX ? <STR_LIT> : <STR_LIT> ;


<s> bool ia64_member_type_forces_blk ( const_tree , machine_mode mode ) {


<s> return TARGET_HPUX && mode == TFmode ;


<s> static bool ia64_modes_tieable_p ( machine_mode mode1 , machine_mode mode2 ) { return ( GET_MODE_CLASS ( mode1 ) == GET_MODE_CLASS ( mode2 ) && ( ( mode1 == XFmode || mode1 == XCmode || mode1 == RFmode ) == ( mode2 == XFmode || mode2 == XCmode || mode2 == RFmode ) ) && ( mode1 == BImode ) == ( mode2 == BImode ) ) ;


<s> case E_HImode : return <NUM_LIT> ; case E_SImode : return <NUM_LIT> ; case E_DImode : return <NUM_LIT> ; case E_SFmode : return <NUM_LIT> ; case E_DFmode : return <NUM_LIT> ; case E_XFmode : return <NUM_LIT> ;


<s> case E_SFmode : return <NUM_LIT> ; case E_DFmode : return <NUM_LIT> ; case E_XFmode : return <NUM_LIT> ; case E_TImode : return SPEC_MODE_INVALID ; default : return SPEC_MODE_INVALID ; }


<s> if ( GET_CODE ( src ) == MEM ) return <NUM_LIT> ; if ( register_operand ( src , VOIDmode ) ) return <NUM_LIT> ; if ( INTEGRAL_MODE_P ( GET_MODE ( dst ) ) ) return src == const0_rtx ; else return satisfies_constraint_G ( src ) ;


<s> int ia64_move_ok ( rtx dst , rtx src ) { if ( GET_CODE ( dst ) != MEM ) return <NUM_LIT> ;

if ( GET_CODE ( src ) == MEM ) return <NUM_LIT> ;


<s> static bool ia64_needs_block_p ( ds_t ts ) { if ( ts & BEGIN_DATA ) return ! mflag_sched_spec_ldc ; gcc_assert ( ( ts & BEGIN_CONTROL ) != <NUM_LIT> ) ; return ! ( mflag_sched_spec_control_ldc && mflag_sched_spec_ldc ) ;


<s> static bool ia64_needs_block_p ( ds_t ts ) { if ( ts & BEGIN_DATA ) return ! mflag_sched_spec_ldc ;

gcc_assert ( ( ts & BEGIN_CONTROL ) != <NUM_LIT> ) ;


<s> switch ( opt -> opt_index ) { case OPT_mfixed_range_ : fix_range ( opt -> arg ) ; break ; default : gcc_unreachable ( ) ; } } if ( TARGET_AUTO_PIC ) target_flags |= MASK_CONST_GP ; if ( optimize >= <NUM_LIT> ) flag_ira_loop_pressure = <NUM_LIT> ; ia64_section_threshold = ( OPTION_SET_P ( g_switch_value ) ? g_switch_value : IA64_DEFAULT_GVALUE ) ; init_machine_status = ia64_init_machine_status ; if ( flag_align_functions && ! str_align_functions ) str_align_functions = <STR_LIT> ; if ( flag_align_loops && ! str_align_loops ) str_align_loops = <STR_LIT> ; if ( TARGET_ABI_OPEN_VMS ) flag_no_common = <NUM_LIT> ; ia64_override_options_after_change ( ) ;


<s> else fputs ( <STR_LIT> , file ) ; output_addr_const ( file , x ) ; fputs ( <STR_LIT> , file ) ;


<s> if ( ia64_except_unwind_info ( & global_options ) != UI_TARGET ) return ; fputs ( <STR_LIT> , file ) ;


<s> for ( i = <NUM_LIT> ; i < current_frame_info . n_local_regs ; i ++ ) reg_names [ LOC_REG ( i ) ] = ia64_local_reg_names [ i ] ;

for ( i = <NUM_LIT> ; i < current_frame_info . n_output_regs ; i ++ ) reg_names [ OUT_REG ( i ) ] = ia64_output_reg_names [ i ] ;


<s> reg_names [ current_frame_info . r [ reg_fp ] ] = tmp ; reg_emitted ( reg_fp ) ; } if ( ! TARGET_REG_NAMES ) { for ( i = <NUM_LIT> ; i < current_frame_info . n_input_regs ; i ++ ) reg_names [ IN_REG ( i ) ] = ia64_input_reg_names [ i ] ; for ( i = <NUM_LIT> ; i < current_frame_info . n_local_regs ; i ++ ) reg_names [ LOC_REG ( i ) ] = ia64_local_reg_names [ i ] ; for ( i = <NUM_LIT> ; i < current_frame_info . n_output_regs ; i ++ ) reg_names [ OUT_REG ( i ) ] = ia64_output_reg_names [ i ] ; } current_frame_info . initialized = <NUM_LIT> ;


<s> gcc_assert ( STATIC_CHAIN_REGNUM == <NUM_LIT> ) ; indirect_call = true ; } else indirect_call = false ; if ( TARGET_GNU_AS ) fputs ( <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; if ( NO_PROFILE_COUNTERS ) fputs ( <STR_LIT> , file ) ; else { char buf [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( buf , <STR_LIT> , labelno ) ; if ( TARGET_AUTO_PIC ) fputs ( <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; assemble_name ( file , buf ) ; if ( TARGET_AUTO_PIC ) fputs ( <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; } if ( indirect_call ) fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; if ( indirect_call ) fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; if ( indirect_call ) { fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ;


<s> if ( grsave_prev == <NUM_LIT> ) grsave = current_frame_info . r [ reg_save_ar_pfs ] ; grsave_prev = current_frame_info . r [ reg_save_ar_pfs ] ; } if ( current_frame_info . r [ reg_fp ] != <NUM_LIT> && ( grsave_prev == <NUM_LIT> || current_frame_info . r [ reg_fp ] == grsave_prev + <NUM_LIT> ) ) { mask |= <NUM_LIT> ; if ( grsave_prev == <NUM_LIT> ) grsave = HARD_FRAME_POINTER_REGNUM ; grsave_prev = current_frame_info . r [ reg_fp ] ; } if ( current_frame_info . r [ reg_save_pr ] != <NUM_LIT> && ( grsave_prev == <NUM_LIT> || current_frame_info . r [ reg_save_pr ] == grsave_prev + <NUM_LIT> ) ) { mask |= <NUM_LIT> ; if ( grsave_prev == <NUM_LIT> ) grsave = current_frame_info . r [ reg_save_pr ] ; } if ( mask && TARGET_GNU_AS ) fprintf ( file , <STR_LIT> , mask , ia64_dbx_register_number ( grsave ) ) ; else fputs ( <STR_LIT> , file ) ; if ( current_frame_info . spill_cfa_off != - <NUM_LIT> ) fprintf ( file , <STR_LIT> , ( long ) ( current_frame_info . spill_cfa_off + current_frame_info . spill_size ) ) ;


<s> if ( current_frame_info . r [ reg_fp ] != <NUM_LIT> && ( grsave_prev == <NUM_LIT> || current_frame_info . r [ reg_fp ] == grsave_prev + <NUM_LIT> ) ) { mask |= <NUM_LIT> ; if ( grsave_prev == <NUM_LIT> ) grsave = HARD_FRAME_POINTER_REGNUM ; grsave_prev = current_frame_info . r [ reg_fp ] ; } if ( current_frame_info . r [ reg_save_pr ] != <NUM_LIT> && ( grsave_prev == <NUM_LIT> || current_frame_info . r [ reg_save_pr ] == grsave_prev + <NUM_LIT> ) ) { mask |= <NUM_LIT> ; if ( grsave_prev == <NUM_LIT> ) grsave = current_frame_info . r [ reg_save_pr ] ; }

if ( mask && TARGET_GNU_AS ) fprintf ( file , <STR_LIT> , mask , ia64_dbx_register_number ( grsave ) ) ;


<s> static void ia64_output_mi_thunk ( FILE * file , tree thunk ATTRIBUTE_UNUSED , HOST_WIDE_INT delta , HOST_WIDE_INT vcall_offset , tree function ) { const char * fnname = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( thunk ) ) ; rtx this_rtx , funexp ; rtx_insn * insn ; unsigned int this_parmno ; unsigned int this_regno ; rtx delta_rtx ; reload_completed = <NUM_LIT> ; epilogue_completed = <NUM_LIT> ; last_scratch_gr_reg = <NUM_LIT> ; memset ( & current_frame_info , <NUM_LIT> , sizeof ( current_frame_info ) ) ; current_frame_info . spill_cfa_off = - <NUM_LIT> ; current_frame_info . n_input_regs = <NUM_LIT> ; current_frame_info . need_regstk = ( TARGET_REG_NAMES != <NUM_LIT> ) ; emit_note ( NOTE_INSN_PROLOGUE_END ) ; this_parmno = ( ia64_struct_retval_addr_is_first_parm_p ( TREE_TYPE ( thunk ) ) ? <NUM_LIT> : <NUM_LIT> ) ; this_regno = IN_REG ( this_parmno ) ; if ( ! TARGET_REG_NAMES ) reg_names [ this_regno ] = ia64_reg_numbers [ this_parmno ] ; this_rtx = gen_rtx_REG ( Pmode , this_regno ) ; delta_rtx = GEN_INT ( delta ) ; if ( TARGET_ILP32 ) { rtx tmp = gen_rtx_REG ( ptr_mode , this_regno ) ; REG_POINTER ( tmp ) = <NUM_LIT> ; if ( delta && satisfies_constraint_I ( delta_rtx ) ) { emit_insn ( gen_ptr_extend_plus_imm ( this_rtx , tmp , delta_rtx ) ) ; delta = <NUM_LIT> ; } else emit_insn ( gen_ptr_extend ( this_rtx , tmp ) ) ; } if ( delta ) { if ( ! satisfies_constraint_I ( delta_rtx ) ) { rtx tmp = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; emit_move_insn ( tmp , delta_rtx ) ; delta_rtx = tmp ; } emit_insn ( gen_adddi3 ( this_rtx , this_rtx , delta_rtx ) ) ; } if ( vcall_offset ) { rtx vcall_offset_rtx = GEN_INT ( vcall_offset ) ; rtx tmp = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; if ( TARGET_ILP32 ) { rtx t = gen_rtx_REG ( ptr_mode , <NUM_LIT> ) ; REG_POINTER ( t ) = <NUM_LIT> ; emit_move_insn ( t , gen_rtx_MEM ( ptr_mode , this_rtx ) ) ; if ( satisfies_constraint_I ( vcall_offset_rtx ) ) { emit_insn ( gen_ptr_extend_plus_imm ( tmp , t , vcall_offset_rtx ) ) ; vcall_offset = <NUM_LIT> ; } else emit_insn ( gen_ptr_extend ( tmp , t ) ) ; } else emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , this_rtx ) ) ;


if ( flag_sel_sched_pipelining && flag_auto_inc_dec ) {


<s> if ( INTVAL ( x ) & <NUM_LIT> ) { fprintf ( file , <STR_LIT> ) ; prefix = <STR_LIT> ; } fprintf ( file , <STR_LIT> , prefix , ( int ) INTVAL ( x ) & <NUM_LIT> ) ; return ; } break ; case 'X' : { unsigned int regno = REGNO ( x ) ; fprintf ( file , <STR_LIT> , reg_names [ regno ] , reg_names [ regno + <NUM_LIT> ] ) ; } return ; case 'r' : if ( GET_CODE ( x ) == REG ) fputs ( reg_names [ REGNO ( x ) ] , file ) ; else if ( x == CONST0_RTX ( GET_MODE ( x ) ) ) fputs ( <STR_LIT> , file ) ; else if ( GET_CODE ( x ) == CONST_INT ) output_addr_const ( file , x ) ; else output_operand_lossage ( <STR_LIT> ) ; return ; case 'v' : gcc_assert ( GET_CODE ( x ) == CONST_VECTOR ) ; x = simplify_subreg ( DImode , x , GET_MODE ( x ) , <NUM_LIT> ) ; break ; case '+' : { const char * which ; x = find_reg_note ( current_output_insn , REG_BR_PROB , <NUM_LIT> ) ; if ( x ) { int pred_val = profile_probability :: from_reg_br_prob_note ( XINT ( x , <NUM_LIT> ) ) . to_reg_br_prob_base ( ) ; if ( pred_val < REG_BR_PROB_BASE / <NUM_LIT> && br_prob_note_reliable_p ( x ) ) which = <STR_LIT> ; else if ( pred_val < REG_BR_PROB_BASE / <NUM_LIT> ) which = <STR_LIT> ; else if ( pred_val < REG_BR_PROB_BASE / <NUM_LIT> * <NUM_LIT> || ! br_prob_note_reliable_p ( x ) ) which = <STR_LIT> ; else which = <STR_LIT> ; } else if ( CALL_P ( current_output_insn ) ) which = <STR_LIT> ; else which = <STR_LIT> ; fputs ( which , file ) ; return ; } case ',' : x = current_insn_predicate ; if ( x ) { unsigned int regno = REGNO ( XEXP ( x , <NUM_LIT> ) ) ; if ( GET_CODE ( x ) == EQ ) regno += <NUM_LIT> ; fprintf ( file , <STR_LIT> , reg_names [ regno ] ) ; } return ; default : output_operand_lossage ( <STR_LIT> ) ; return ; } switch ( GET_CODE ( x ) ) { case POST_INC : case POST_DEC : case POST_MODIFY : x = XEXP ( x , <NUM_LIT> ) ; case REG : fputs ( reg_names [ REGNO ( x ) ] , file ) ; break ;


<s> static bool ia64_print_operand_punct_valid_p ( unsigned char code ) { return ( code == '+' || code == ',' ) ;


<s> int ia64_produce_address_p ( rtx insn ) { return insn -> call ;


<s> void ia64_profile_hook ( int labelno ) { rtx label , ip ; if ( NO_PROFILE_COUNTERS ) label = const0_rtx ; else { char buf [ <NUM_LIT> ] ; const char * label_name ; ASM_GENERATE_INTERNAL_LABEL ( buf , <STR_LIT> , labelno ) ; label_name = ggc_strdup ( ( * targetm . strip_name_encoding ) ( buf ) ) ; label = gen_rtx_SYMBOL_REF ( Pmode , label_name ) ; SYMBOL_REF_FLAGS ( label ) = SYMBOL_FLAG_LOCAL ; } ip = gen_reg_rtx ( Pmode ) ;


<s> if ( from != GR_REGS ) return memory_move_cost ( mode , to , false ) ; break ; case BR_REGS : if ( from != GR_REGS && from != GR_AND_BR_REGS ) return memory_move_cost ( mode , to , false ) ; break ; case AR_I_REGS : case AR_M_REGS : if ( from != GR_REGS ) return memory_move_cost ( mode , to , false ) ;


<s> static inline bool ia64_reg_ok_for_base_p ( const_rtx reg , bool strict ) { if ( strict && REGNO_OK_FOR_BASE_P ( REGNO ( reg ) ) ) return true ; else if ( ! strict && ( GENERAL_REGNO_P ( REGNO ( reg ) ) || ! HARD_REGISTER_P ( reg ) ) ) return true ;


<s> tmp = hard_frame_pointer_rtx ; offset = - offset ; } else { tmp = stack_pointer_rtx ; offset = current_frame_info . total_size - offset ; } offset_r = GEN_INT ( offset ) ; if ( satisfies_constraint_I ( offset_r ) ) emit_insn ( gen_adddi3 ( pic_offset_table_rtx , tmp , offset_r ) ) ; else { emit_move_insn ( pic_offset_table_rtx , offset_r ) ; emit_insn ( gen_adddi3 ( pic_offset_table_rtx , pic_offset_table_rtx , tmp ) ) ; } tmp = gen_rtx_MEM ( DImode , pic_offset_table_rtx ) ; }

emit_move_insn ( pic_offset_table_rtx , tmp ) ;


<s> static int ia64_reloc_rw_mask ( void ) {


<s> return gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_RET_ADDR ) ;


<s> byte_size = GET_MODE_SIZE ( mode ) ; if ( mode == BLKmode ) { byte_size = int_size_in_bytes ( valtype ) ; if ( byte_size < <NUM_LIT> ) return true ; } hfa_mode = hfa_element_mode ( valtype , <NUM_LIT> ) ;


<s> case PLUS : if ( satisfies_constraint_I ( x ) ) * total = <NUM_LIT> ; else if ( satisfies_constraint_J ( x ) ) * total = <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; default : if ( satisfies_constraint_K ( x ) || satisfies_constraint_L ( x ) ) * total = <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } case CONST_DOUBLE : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case CONST : case SYMBOL_REF : case LABEL_REF : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case FMA : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : if ( FLOAT_MODE_P ( mode ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_MODE_SIZE ( mode ) > <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case PLUS : case MINUS : if ( FLOAT_MODE_P ( mode ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } case ASHIFT : case ASHIFTRT : case LSHIFTRT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ;


<s> static enum attr_itanium_class ia64_safe_itanium_class ( rtx_insn * insn ) { if ( recog_memoized ( insn ) >= <NUM_LIT> ) return get_attr_itanium_class ( insn ) ;

else if ( DEBUG_INSN_P ( insn ) ) return ITANIUM_CLASS_IGNORE ;


<s> if ( recog_memoized ( insn ) >= <NUM_LIT> ) return get_attr_type ( insn ) ;


<s> case E_HImode : case E_SImode : case E_DImode : case E_TImode : return true ; case E_SFmode : case E_DFmode : case E_XFmode : case E_RFmode : return true ; case E_TFmode : return true ; default :


<s> if ( sched_verbose ) fprintf ( dump , <STR_LIT> ) ; if ( ! reload_completed ) return ; if ( reload_completed ) { final_emit_insn_group_barriers ( dump ) ; bundling ( dump , sched_verbose , current_sched_info -> prev_head , current_sched_info -> next_tail ) ; if ( sched_verbose && dump ) fprintf ( dump , <STR_LIT> , INSN_UID ( NEXT_INSN ( current_sched_info -> prev_head ) ) , INSN_UID ( PREV_INSN ( current_sched_info -> next_tail ) ) ) ; return ;


<s> final_emit_insn_group_barriers ( dump ) ; bundling ( dump , sched_verbose , current_sched_info -> prev_head , current_sched_info -> next_tail ) ;

if ( sched_verbose && dump ) fprintf ( dump , <STR_LIT> , INSN_UID ( NEXT_INSN ( current_sched_info -> prev_head ) ) , INSN_UID ( PREV_INSN ( current_sched_info -> next_tail ) ) ) ;


<s> return ia64_dfa_sched_reorder ( dump , sched_verbose , ready , pn_ready , clock_var , <NUM_LIT> ) ;


<s> case FP_REGS : if ( regno >= <NUM_LIT> && ! ( FR_REGNO_P ( regno ) || GENERAL_REGNO_P ( regno ) ) ) return GR_REGS ; if ( GET_CODE ( x ) == MEM && ( GET_MODE ( x ) == SImode || GET_MODE ( x ) == HImode || GET_MODE ( x ) == QImode ) ) return GR_REGS ; if ( GET_CODE ( x ) == CONST_INT ) return GR_REGS ;

if ( GET_CODE ( x ) == PLUS ) return GR_REGS ;


<s> if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || startswith ( name , <STR_LIT> ) || startswith ( name , <STR_LIT> ) || startswith ( name , <STR_LIT> ) || startswith ( name , <STR_LIT> ) || strcmp ( name , <STR_LIT> ) == <NUM_LIT> || startswith ( name , <STR_LIT> ) || startswith ( name , <STR_LIT> ) ) flags = SECTION_SMALL ;

flags |= default_section_type_flags ( decl , name , reloc ) ;


<s> if ( GET_MODE_SIZE ( mode ) > <NUM_LIT> && GET_MODE_SIZE ( mode ) <= ia64_section_threshold && ! TARGET_NO_SDATA ) return sdata_section ; else return default_elf_select_rtx_section ( mode , x , align ) ;


<s> static section * ia64_select_rtx_section ( machine_mode mode , rtx x , unsigned HOST_WIDE_INT align ) {

if ( GET_MODE_SIZE ( mode ) > <NUM_LIT> && GET_MODE_SIZE ( mode ) <= ia64_section_threshold && ! TARGET_NO_SDATA ) return sdata_section ;


<s> int n = MAX_ARGUMENT_SLOTS - next_cum . words ; * pretend_size = n * UNITS_PER_WORD ;


<s> if ( next_cum . words < MAX_ARGUMENT_SLOTS ) { int n = MAX_ARGUMENT_SLOTS - next_cum . words ;


<s> last_scheduled_insn = sc -> last_scheduled_insn ; memcpy ( rws_sum , sc -> rws_sum , sizeof ( rws_sum ) ) ;

memcpy ( rws_insn , sc -> rws_insn , sizeof ( rws_insn ) ) ;


<s> memcpy ( rws_insn , sc -> rws_insn , sizeof ( rws_insn ) ) ; first_instruction = sc -> first_instruction ; pending_data_specs = sc -> pending_data_specs ;


<s> int mask = <NUM_LIT> ; if ( ( mflag_sched_br_data_spec && ! reload_completed && optimize > <NUM_LIT> ) || ( mflag_sched_ar_data_spec && reload_completed ) ) { mask |= BEGIN_DATA ; if ( ! sel_sched_p ( ) && ( ( mflag_sched_br_in_data_spec && ! reload_completed ) || ( mflag_sched_ar_in_data_spec && reload_completed ) ) ) mask |= BE_IN_DATA ; } if ( mflag_sched_control_spec && ( ! sel_sched_p ( ) || reload_completed ) ) { mask |= BEGIN_CONTROL ;

if ( ! sel_sched_p ( ) && mflag_sched_in_control_spec ) mask |= BE_IN_CONTROL ;


<s> case CODE_FOR_prologue_allocate_stack : case CODE_FOR_prologue_allocate_stack_pr : case CODE_FOR_epilogue_deallocate_stack : case CODE_FOR_epilogue_deallocate_stack_pr : ret = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; break ; default : ret = single_set_2 ( insn , x ) ;


<s> return get_spec_unspec_code ( x ) != - <NUM_LIT> ;


<s> static void ia64_soft_fp_init_libfuncs ( void ) {


<s> if ( ( ts & BE_IN_SPEC ) && ! insn_can_be_in_speculative_p ( insn , ts ) ) return - <NUM_LIT> ; mode_no = get_mode_no_for_insn ( insn ) ; if ( mode_no != SPEC_MODE_INVALID ) { if ( ia64_get_insn_spec_ds ( insn ) == ds_get_speculation_types ( ts ) ) res = <NUM_LIT> ; else { res = <NUM_LIT> ; * new_pat = ia64_gen_spec_load ( insn , ts , mode_no ) ;


<s> static int ia64_spec_check_src_p ( rtx src ) { if ( GET_CODE ( src ) == IF_THEN_ELSE ) { rtx t ; t = XEXP ( src , <NUM_LIT> ) ; if ( GET_CODE ( t ) == NE ) { t = XEXP ( t , <NUM_LIT> ) ; if ( GET_CODE ( t ) == UNSPEC ) { int code ; code = XINT ( t , <NUM_LIT> ) ; if ( code == UNSPEC_LDCCLR || code == UNSPEC_LDCNC || code == UNSPEC_CHKACLR || code == UNSPEC_CHKANC || code == UNSPEC_CHKS ) { gcc_assert ( code != <NUM_LIT> ) ; return code ; } } } }


<s> t = XEXP ( t , <NUM_LIT> ) ; if ( GET_CODE ( t ) == UNSPEC ) { int code ; code = XINT ( t , <NUM_LIT> ) ; if ( code == UNSPEC_LDCCLR || code == UNSPEC_LDCNC || code == UNSPEC_CHKACLR || code == UNSPEC_CHKANC || code == UNSPEC_CHKS ) { gcc_assert ( code != <NUM_LIT> ) ; return code ;


<s> emit_move_insn ( scratch_r , tmp ) ; emit_move_insn ( scratch_b , scratch_r ) ; if ( ! addr_dead_p ) tmp = gen_rtx_POST_DEC ( Pmode , addr ) ; else tmp = addr ; tmp = gen_rtx_MEM ( Pmode , tmp ) ; emit_move_insn ( pic_offset_table_rtx , tmp ) ; is_desc = true ; addr = scratch_b ; } if ( sibcall_p ) insn = gen_sibcall_nogp ( addr ) ;

else if ( retval ) insn = gen_call_value_nogp ( retval , addr , retaddr ) ;


<s> rtx offset ; switch ( GET_CODE ( base ) ) { case REG : if ( ! reversed ) { out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_INC ( Pmode , base ) , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , dead ? <NUM_LIT> : gen_rtx_POST_DEC ( Pmode , base ) , <NUM_LIT> ) ; } else { emit_insn ( gen_adddi3 ( base , base , GEN_INT ( <NUM_LIT> ) ) ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_DEC ( Pmode , base ) , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_address ( in , DImode , <NUM_LIT> ) ; } break ; case POST_INC : gcc_assert ( ! reversed && ! dead ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , <NUM_LIT> , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , <NUM_LIT> , <NUM_LIT> ) ; break ; case POST_DEC : gcc_assert ( ! reversed && ! dead ) ; base = XEXP ( base , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_INC ( Pmode , base ) , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_MODIFY ( Pmode , base , plus_constant ( Pmode , base , - <NUM_LIT> ) ) , <NUM_LIT> ) ; break ; case POST_MODIFY : gcc_assert ( ! reversed && ! dead ) ; offset = XEXP ( base , <NUM_LIT> ) ; base = XEXP ( base , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_INC ( Pmode , base ) , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( offset , <NUM_LIT> ) ) == REG ) { out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , <NUM_LIT> , <NUM_LIT> ) ; fixup = gen_adddi3 ( base , base , GEN_INT ( - <NUM_LIT> ) ) ; } else { gcc_assert ( GET_CODE ( XEXP ( offset , <NUM_LIT> ) ) == CONST_INT ) ; if ( INTVAL ( XEXP ( offset , <NUM_LIT> ) ) < - <NUM_LIT> + <NUM_LIT> ) { out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , base , <NUM_LIT> ) ; fixup = gen_adddi3 ( base , base , GEN_INT ( INTVAL ( XEXP ( offset , <NUM_LIT> ) ) - <NUM_LIT> ) ) ; } else { out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_MODIFY ( Pmode , base , gen_rtx_PLUS ( Pmode , base , GEN_INT ( INTVAL ( XEXP ( offset , <NUM_LIT> ) ) - <NUM_LIT> ) ) ) , <NUM_LIT> ) ; } } break ; default : gcc_unreachable ( ) ; } break ; } default : gcc_unreachable ( ) ;


<s> else { unsigned HOST_WIDE_INT p [ <NUM_LIT> ] ; long l [ <NUM_LIT> ] ; real_to_target ( l , CONST_DOUBLE_REAL_VALUE ( in ) , TFmode ) ; if ( FLOAT_WORDS_BIG_ENDIAN ) { p [ <NUM_LIT> ] = ( ( ( unsigned HOST_WIDE_INT ) l [ <NUM_LIT> ] ) << <NUM_LIT> ) + l [ <NUM_LIT> ] ; p [ <NUM_LIT> ] = ( ( ( unsigned HOST_WIDE_INT ) l [ <NUM_LIT> ] ) << <NUM_LIT> ) + l [ <NUM_LIT> ] ; } else { p [ <NUM_LIT> ] = ( ( ( unsigned HOST_WIDE_INT ) l [ <NUM_LIT> ] ) << <NUM_LIT> ) + l [ <NUM_LIT> ] ; p [ <NUM_LIT> ] = ( ( ( unsigned HOST_WIDE_INT ) l [ <NUM_LIT> ] ) << <NUM_LIT> ) + l [ <NUM_LIT> ] ; } out [ <NUM_LIT> ] = GEN_INT ( p [ <NUM_LIT> ] ) ; out [ <NUM_LIT> ] = GEN_INT ( p [ <NUM_LIT> ] ) ; } break ; case MEM : { rtx base = XEXP ( in , <NUM_LIT> ) ; rtx offset ; switch ( GET_CODE ( base ) ) { case REG : if ( ! reversed ) { out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_INC ( Pmode , base ) , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , dead ? <NUM_LIT> : gen_rtx_POST_DEC ( Pmode , base ) , <NUM_LIT> ) ; } else { emit_insn ( gen_adddi3 ( base , base , GEN_INT ( <NUM_LIT> ) ) ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_DEC ( Pmode , base ) , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_address ( in , DImode , <NUM_LIT> ) ; } break ; case POST_INC : gcc_assert ( ! reversed && ! dead ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , <NUM_LIT> , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , <NUM_LIT> , <NUM_LIT> ) ; break ; case POST_DEC : gcc_assert ( ! reversed && ! dead ) ; base = XEXP ( base , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_INC ( Pmode , base ) , <NUM_LIT> ) ; out [ <NUM_LIT> ] = adjust_automodify_address ( in , DImode , gen_rtx_POST_MODIFY ( Pmode , base , plus_constant ( Pmode , base , - <NUM_LIT> ) ) , <NUM_LIT> ) ; break ; case POST_MODIFY : gcc_assert ( ! reversed && ! dead ) ; offset = XEXP ( base , <NUM_LIT> ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && reg_overlap_mentioned_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) { rtx base = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; while ( GET_CODE ( base ) != REG ) base = XEXP ( base , <NUM_LIT> ) ; if ( REGNO ( base ) == REGNO ( operands [ <NUM_LIT> ] ) ) reversed = true ; if ( refers_to_regno_p ( REGNO ( operands [ <NUM_LIT> ] ) , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> , base , <NUM_LIT> ) ) dead = true ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG && GET_CODE ( operands [ <NUM_LIT> ] ) == REG && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) reversed = true ; fixup [ <NUM_LIT> ] = ia64_split_tmode ( in , operands [ <NUM_LIT> ] , reversed , dead ) ; fixup [ <NUM_LIT> ] = ia64_split_tmode ( out , operands [ <NUM_LIT> ] , reversed , dead ) ; if ( GET_CODE ( EXP ) == MEM \ && ( GET_CODE ( XEXP ( EXP , <NUM_LIT> ) ) == POST_MODIFY \ || GET_CODE ( XEXP ( EXP , <NUM_LIT> ) ) == POST_INC \ || GET_CODE ( XEXP ( EXP , <NUM_LIT> ) ) == POST_DEC ) ) \ add_reg_note ( insn , REG_INC , XEXP ( XEXP ( EXP , <NUM_LIT> ) , <NUM_LIT> ) ) insn = emit_insn ( gen_rtx_SET ( out [ <NUM_LIT> ] , in [ <NUM_LIT> ] ) ) ;

MAYBE_ADD_REG_INC_NOTE ( insn , in [ <NUM_LIT> ] ) ;


<s> assemble_name ( file , fnname ) ; fputc ( '\n' , file ) ;


<s> void ia64_start_function ( FILE * file , const char * fnname , tree decl ATTRIBUTE_UNUSED ) { vms_start_function ( fnname ) ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , fnname ) ;


<s> static bool ia64_struct_retval_addr_is_first_parm_p ( tree fntype ) { tree ret_type = TREE_TYPE ( fntype ) ;

return ( abi_version_at_least ( <NUM_LIT> ) && ret_type && TYPE_MODE ( ret_type ) == BLKmode && TREE_ADDRESSABLE ( ret_type ) && lang_GNU_CXX ( ) ) ;


<s> if ( TARGET_ABI_OPEN_VMS || ( fntype && ia64_struct_retval_addr_is_first_parm_p ( fntype ) ) ) return NULL_RTX ; return gen_rtx_REG ( Pmode , GR_REG ( <NUM_LIT> ) ) ;


<s> if ( TARGET_ABI_OPEN_VMS || ( fntype && ia64_struct_retval_addr_is_first_parm_p ( fntype ) ) ) return NULL_RTX ;

return gen_rtx_REG ( Pmode , GR_REG ( <NUM_LIT> ) ) ;


<s> dest = ia64_single_set ( consumer ) ; gcc_assert ( dest ) ; mem = SET_DEST ( dest ) ; gcc_assert ( mem && GET_CODE ( mem ) == MEM ) ;


<s> set_optab_libfunc ( ne_optab , TFmode , <STR_LIT> ) ; set_optab_libfunc ( gt_optab , TFmode , <STR_LIT> ) ;

set_optab_libfunc ( ge_optab , TFmode , <STR_LIT> ) ;


<s> rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; rtx addr , addr_reg , tramp , eight = GEN_INT ( <NUM_LIT> ) ; if ( ! TARGET_GNU_AS ) { static bool declared_ia64_trampoline = false ; if ( ! declared_ia64_trampoline ) { declared_ia64_trampoline = true ; ( * targetm . asm_out . globalize_label ) ( asm_out_file , <STR_LIT> ) ; } } addr = convert_memory_address ( Pmode , XEXP ( m_tramp , <NUM_LIT> ) ) ; fnaddr = convert_memory_address ( Pmode , fnaddr ) ; static_chain = convert_memory_address ( Pmode , static_chain ) ; addr_reg = copy_to_reg ( addr ) ; m_tramp = adjust_automodify_address ( m_tramp , Pmode , addr_reg , <NUM_LIT> ) ;

tramp = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ;


<s> rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; rtx addr , addr_reg , tramp , eight = GEN_INT ( <NUM_LIT> ) ; if ( ! TARGET_GNU_AS ) { static bool declared_ia64_trampoline = false ; if ( ! declared_ia64_trampoline ) { declared_ia64_trampoline = true ; ( * targetm . asm_out . globalize_label ) ( asm_out_file , <STR_LIT> ) ; } } addr = convert_memory_address ( Pmode , XEXP ( m_tramp , <NUM_LIT> ) ) ; fnaddr = convert_memory_address ( Pmode , fnaddr ) ; static_chain = convert_memory_address ( Pmode , static_chain ) ;


<s> d . vmode = vmode ; d . nelt = nelt ; d . one_operand_p = false ; d . testing_p = false ; high = ( highp ? nelt / <NUM_LIT> : <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nelt / <NUM_LIT> ; ++ i ) {


<s> rtx sign = gen_reg_rtx ( mode ) ; bool neg ; neg = ia64_expand_vecint_compare ( LT , mode , sign , vec , zero ) ;


<s> static rtx ia64_unpack_sign ( rtx vec , bool unsignedp ) { machine_mode mode = GET_MODE ( vec ) ; rtx zero = CONST0_RTX ( mode ) ; if ( unsignedp ) return zero ; else { rtx sign = gen_reg_rtx ( mode ) ; bool neg ;

neg = ia64_expand_vecint_compare ( LT , mode , sign , vec , zero ) ;


<s> case UNSPEC_CHKACLR : case UNSPEC_CHKS : return may_trap_p_1 ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , flags ) ; }

return default_unspec_may_trap_p ( x , flags ) ;


<s> d . perm [ i ] = ei ; perm [ i ] = ei ; } switch ( which ) { default : gcc_unreachable ( ) ; case <NUM_LIT> : if ( d . testing_p || ! rtx_equal_p ( d . op0 , d . op1 ) ) { d . one_operand_p = false ; break ; } for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( d . perm [ i ] >= nelt ) d . perm [ i ] -= nelt ; case <NUM_LIT> : d . op1 = d . op0 ; d . one_operand_p = true ; break ; case <NUM_LIT> : for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d . perm [ i ] -= nelt ; d . op0 = d . op1 ; d . one_operand_p = true ; break ; } if ( d . testing_p ) { d . target = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; d . op1 = d . op0 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; if ( ! d . one_operand_p ) d . op1 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; start_sequence ( ) ; bool ret = ia64_expand_vec_perm_const_1 ( & d ) ; end_sequence ( ) ; return ret ; } if ( ia64_expand_vec_perm_const_1 ( & d ) ) return true ; if ( which == <NUM_LIT> && d . one_operand_p ) {

memcpy ( d . perm , perm , sizeof ( perm ) ) ;


<s> static bool ia64_vectorize_vec_perm_const ( machine_mode vmode , rtx target , rtx op0 , rtx op1 , const vec_perm_indices & sel ) { struct expand_vec_perm_d d ; unsigned char perm [ MAX_VECT_LEN ] ; unsigned int i , nelt , which ; d . target = target ; if ( op0 ) { rtx nop0 = force_reg ( vmode , op0 ) ; if ( op0 == op1 ) op1 = nop0 ; op0 = nop0 ; } if ( op1 ) op1 = force_reg ( vmode , op1 ) ; d . op0 = op0 ; d . op1 = op1 ; d . vmode = vmode ; gcc_assert ( VECTOR_MODE_P ( d . vmode ) ) ; d . nelt = nelt = GET_MODE_NUNITS ( d . vmode ) ; d . testing_p = ! target ; gcc_assert ( sel . length ( ) == nelt ) ; gcc_checking_assert ( sizeof ( d . perm ) == sizeof ( perm ) ) ; for ( i = which = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned int ei = sel [ i ] & ( <NUM_LIT> * nelt - <NUM_LIT> ) ; which |= ( ei < nelt ? <NUM_LIT> : <NUM_LIT> ) ; d . perm [ i ] = ei ; perm [ i ] = ei ; } switch ( which ) { default : gcc_unreachable ( ) ; case <NUM_LIT> : if ( d . testing_p || ! rtx_equal_p ( d . op0 , d . op1 ) ) { d . one_operand_p = false ; break ; } for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( d . perm [ i ] >= nelt ) d . perm [ i ] -= nelt ;


<s> switch ( mode ) { case E_V8QImode : case E_V4HImode : case E_V2SImode : return true ; case E_V2SFmode :


<s> set_optab_libfunc ( smod_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( smod_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( umod_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( umod_optab , DImode , <STR_LIT> ) ;


<s> tree id = TREE_VALUE ( TREE_VALUE ( attr ) ) ; const char * name ; if ( TREE_CODE ( id ) == IDENTIFIER_NODE ) name = IDENTIFIER_POINTER ( id ) ; else if ( TREE_CODE ( id ) == STRING_CST ) name = TREE_STRING_POINTER ( id ) ; else abort ( ) ; fprintf ( file , <STR_LIT> , name ) ;


<s> static bool ia64_vms_valid_pointer_mode ( scalar_int_mode mode ) {

return ( mode == SImode || mode == DImode ) ;


<s> return ( mode == SImode || mode == DImode ) ;


<s> static bool important_for_bundling_p ( rtx_insn * insn ) {

return ( INSN_P ( insn ) && ia64_safe_itanium_class ( insn ) != ITANIUM_CLASS_IGNORE && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER ) ;


<s> return ( INSN_P ( insn ) && ia64_safe_itanium_class ( insn ) != ITANIUM_CLASS_IGNORE && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER ) ;


<s> static void initiate_bundle_states ( void ) { bundle_states_num = <NUM_LIT> ; free_bundle_state_chain = NULL ; allocated_bundle_states_chain = NULL ;


<s> static void init_idents ( void ) { if ( small_ident1 == <NUM_LIT> ) {


<s> memset ( rws_sum , <NUM_LIT> , sizeof ( rws_sum ) ) ; first_instruction = <NUM_LIT> ;


<s> static void init_insn_group_barriers ( void ) { memset ( rws_sum , <NUM_LIT> , sizeof ( rws_sum ) ) ;


<s> index_to_bundle_states [ bundle_state -> insn_num ] = bundle_state ; * entry_ptr = bundle_state ; return TRUE ; }

else if ( bundle_state -> cost < ( * entry_ptr ) -> cost || ( bundle_state -> cost == ( * entry_ptr ) -> cost && ( ( * entry_ptr ) -> accumulated_insns_num > bundle_state -> accumulated_insns_num || ( ( * entry_ptr ) -> accumulated_insns_num == bundle_state -> accumulated_insns_num && ( ( * entry_ptr ) -> branch_deviation > bundle_state -> branch_deviation || ( ( * entry_ptr ) -> branch_deviation == bundle_state -> branch_deviation && ( * entry_ptr ) -> middle_bundle_stops > bundle_state -> middle_bundle_stops ) ) ) ) ) ) {


<s> if ( INSN_CODE ( insn ) == CODE_FOR_insn_group_barrier ) { gcc_assert ( GET_MODE ( insn ) != TImode ) ; if ( ! try_issue_nops ( curr_state , before_nops_num ) ) return ; if ( ! try_issue_insn ( curr_state , insn ) ) return ; memcpy ( temp_dfa_state , curr_state -> dfa_state , dfa_state_size ) ; if ( curr_state -> accumulated_insns_num % <NUM_LIT> != <NUM_LIT> ) curr_state -> middle_bundle_stops ++ ; if ( state_transition ( temp_dfa_state , dfa_pre_cycle_insn ) >= <NUM_LIT> && curr_state -> accumulated_insns_num % <NUM_LIT> != <NUM_LIT> ) { free_bundle_state ( curr_state ) ; return ; } } else if ( GET_MODE ( insn ) != TImode ) { if ( ! try_issue_nops ( curr_state , before_nops_num ) ) return ; if ( ! try_issue_insn ( curr_state , insn ) ) return ; curr_state -> accumulated_insns_num ++ ; gcc_assert ( ! unknown_for_bundling_p ( insn ) ) ; if ( ia64_safe_type ( insn ) == TYPE_L ) curr_state -> accumulated_insns_num ++ ; } else { if ( before_nops_num > <NUM_LIT> && get_attr_first_insn ( insn ) == FIRST_INSN_YES ) { free_bundle_state ( curr_state ) ; return ; } state_transition ( curr_state -> dfa_state , dfa_pre_cycle_insn ) ; state_transition ( curr_state -> dfa_state , NULL ) ; curr_state -> cost ++ ; if ( ! try_issue_nops ( curr_state , before_nops_num ) ) return ; if ( ! try_issue_insn ( curr_state , insn ) ) return ; curr_state -> accumulated_insns_num ++ ; if ( unknown_for_bundling_p ( insn ) ) { curr_state -> after_nops_num = <NUM_LIT> - curr_state -> accumulated_insns_num % <NUM_LIT> ; curr_state -> accumulated_insns_num += <NUM_LIT> - curr_state -> accumulated_insns_num % <NUM_LIT> ; } else if ( ia64_safe_type ( insn ) == TYPE_L ) curr_state -> accumulated_insns_num ++ ; } if ( ia64_safe_type ( insn ) == TYPE_B ) curr_state -> branch_deviation += <NUM_LIT> - ( curr_state -> accumulated_insns_num - <NUM_LIT> ) % <NUM_LIT> ; if ( try_bundle_end_p && curr_state -> accumulated_insns_num % <NUM_LIT> != <NUM_LIT> ) { if ( ! only_bundle_end_p && insert_bundle_state ( curr_state ) ) { state_t dfa_state ; struct bundle_state * curr_state1 ; struct bundle_state * allocated_states_chain ; curr_state1 = get_free_bundle_state ( ) ; dfa_state = curr_state1 -> dfa_state ; allocated_states_chain = curr_state1 -> allocated_states_chain ; * curr_state1 = * curr_state ; curr_state1 -> dfa_state = dfa_state ; curr_state1 -> allocated_states_chain = allocated_states_chain ; memcpy ( curr_state1 -> dfa_state , curr_state -> dfa_state , dfa_state_size ) ;


<s> unsigned int r ; for ( r = reg_fp ; r < number_of_ia64_frame_regs ; r ++ ) if ( emitted_frame_related_regs [ r ] == regno ) return true ;


<s> unsigned int i , n = REG_NREGS ( reg ) ; for ( i = <NUM_LIT> ; i < n ; ++ i ) current_frame_info . gr_used_mask |= <NUM_LIT> << ( regno + i ) ;


<s> regno = ( last_scratch_gr_reg + i + <NUM_LIT> ) & <NUM_LIT> ; if ( call_used_or_fixed_reg_p ( regno ) && ! fixed_regs [ regno ] && ! global_regs [ regno ] && ( ( current_frame_info . gr_used_mask >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) { last_scratch_gr_reg = regno ; return regno ; }


<s> ASM_GENERATE_INTERNAL_LABEL ( loop_lab , <STR_LIT> , labelno ++ ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ <NUM_LIT> ] = reg1 ; xops [ <NUM_LIT> ] = GEN_INT ( - PROBE_INTERVAL ) ; output_asm_insn ( <STR_LIT> , xops ) ; fputs ( <STR_LIT> , asm_out_file ) ; output_asm_insn ( <STR_LIT> , xops ) ;


<s> rtx xops [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( loop_lab , <STR_LIT> , labelno ++ ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ <NUM_LIT> ] = reg1 ; xops [ <NUM_LIT> ] = GEN_INT ( - PROBE_INTERVAL ) ; output_asm_insn ( <STR_LIT> , xops ) ; fputs ( <STR_LIT> , asm_out_file ) ; output_asm_insn ( <STR_LIT> , xops ) ; xops [ <NUM_LIT> ] = reg2 ; xops [ <NUM_LIT> ] = gen_rtx_REG ( BImode , PR_REG ( <NUM_LIT> ) ) ; output_asm_insn ( <STR_LIT> , xops ) ;

fprintf ( asm_out_file , <STR_LIT> , reg_names [ PR_REG ( <NUM_LIT> ) ] ) ;


<s> HOST_WIDE_INT off ; rtx base ; gcc_assert ( MEM_P ( dest ) ) ; if ( GET_CODE ( XEXP ( dest , <NUM_LIT> ) ) == REG ) { base = XEXP ( dest , <NUM_LIT> ) ; off = <NUM_LIT> ; } else { gcc_assert ( GET_CODE ( XEXP ( dest , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( dest , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) ; base = XEXP ( XEXP ( dest , <NUM_LIT> ) , <NUM_LIT> ) ; off = INTVAL ( XEXP ( XEXP ( dest , <NUM_LIT> ) , <NUM_LIT> ) ) ; } if ( base == hard_frame_pointer_rtx ) { saveop = <STR_LIT> ; off = - off ; } else { gcc_assert ( base == stack_pointer_rtx ) ; saveop = <STR_LIT> ; } src_regno = REGNO ( src ) ; switch ( src_regno ) { case BR_REG ( <NUM_LIT> ) : gcc_assert ( ! current_frame_info . r [ reg_save_b0 ] ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , saveop , off ) ; break ; case PR_REG ( <NUM_LIT> ) : gcc_assert ( ! current_frame_info . r [ reg_save_pr ] ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , saveop , off ) ; break ; case AR_LC_REGNUM : gcc_assert ( ! current_frame_info . r [ reg_save_ar_lc ] ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , saveop , off ) ; break ; case AR_PFS_REGNUM : gcc_assert ( ! current_frame_info . r [ reg_save_ar_pfs ] ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , saveop , off ) ; break ; case AR_UNAT_REGNUM : gcc_assert ( ! current_frame_info . r [ reg_save_ar_unat ] ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , saveop , off ) ; break ; case GR_REG ( <NUM_LIT> ) : case GR_REG ( <NUM_LIT> ) : case GR_REG ( <NUM_LIT> ) :


<s> int src_regno ; if ( src == pc_rtx ) { if ( unwind ) fprintf ( out_file , <STR_LIT> , ia64_dbx_register_number ( dest_regno ) ) ; return ; } src_regno = REGNO ( src ) ; switch ( src_regno ) { case PR_REG ( <NUM_LIT> ) : gcc_assert ( dest_regno == current_frame_info . r [ reg_save_pr ] ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> , ia64_dbx_register_number ( dest_regno ) ) ; break ; case AR_UNAT_REGNUM : gcc_assert ( dest_regno == current_frame_info . r [ reg_save_ar_unat ] ) ;


<s> if ( ! last_block ) { if ( unwind ) fprintf ( out_file , <STR_LIT> , ++ cfun -> machine -> state_num ) ;


<s> case ITANIUM_CLASS_STF : case ITANIUM_CLASS_ST : mem_ops_in_group [ ( current_cycle + <NUM_LIT> ) % <NUM_LIT> ] ++ ; break ; default : ; }


<s> if ( emitted_frame_related_regs [ r ] == <NUM_LIT> ) emitted_frame_related_regs [ r ] = current_frame_info . r [ r ] ;

else gcc_assert ( emitted_frame_related_regs [ r ] == current_frame_info . r [ r ] ) ;


<s> else gcc_assert ( emitted_frame_related_regs [ r ] == current_frame_info . r [ r ] ) ;


<s> static int rws_access_reg ( rtx reg , struct reg_flags flags , int pred ) { int regno = REGNO ( reg ) ; int n = REG_NREGS ( reg ) ; if ( n == <NUM_LIT> ) return rws_access_regno ( regno , flags , pred ) ; else { int need_barrier = <NUM_LIT> ;

while ( -- n >= <NUM_LIT> ) need_barrier |= rws_access_regno ( regno + n , flags , pred ) ;


<s> int regno = REGNO ( reg ) ; int n = REG_NREGS ( reg ) ; if ( n == <NUM_LIT> ) return rws_access_regno ( regno , flags , pred ) ; else { int need_barrier = <NUM_LIT> ; while ( -- n >= <NUM_LIT> ) need_barrier |= rws_access_regno ( regno + n , flags , pred ) ; return need_barrier ; }


<s> switch ( write_count ) { case <NUM_LIT> : if ( ! in_safe_group_barrier ) rws_update ( regno , flags , pred ) ; break ; case <NUM_LIT> : if ( flags . is_and && rws_sum [ regno ] . written_by_and ) ; else if ( flags . is_or && rws_sum [ regno ] . written_by_or ) ; else need_barrier = <NUM_LIT> ; if ( ! in_safe_group_barrier ) rws_update ( regno , flags , pred ) ; break ; case <NUM_LIT> : if ( flags . is_and && rws_sum [ regno ] . written_by_and ) ; else if ( flags . is_or && rws_sum [ regno ] . written_by_or ) ; else need_barrier = <NUM_LIT> ; if ( ! in_safe_group_barrier ) { rws_sum [ regno ] . written_by_and = flags . is_and ; rws_sum [ regno ] . written_by_or = flags . is_or ; } break ; default : gcc_unreachable ( ) ; } } else { if ( flags . is_branch ) { if ( REGNO_REG_CLASS ( regno ) == BR_REGS || regno == AR_PFS_REGNUM ) return <NUM_LIT> ; if ( REGNO_REG_CLASS ( regno ) == PR_REGS && ! rws_sum [ regno ] . written_by_fp ) return <NUM_LIT> ; } if ( flags . is_and && rws_sum [ regno ] . written_by_and ) return <NUM_LIT> ; if ( flags . is_or && rws_sum [ regno ] . written_by_or ) return <NUM_LIT> ; switch ( rws_sum [ regno ] . write_count ) { case <NUM_LIT> : break ; case <NUM_LIT> : need_barrier = <NUM_LIT> ; break ; case <NUM_LIT> : need_barrier = <NUM_LIT> ;


<s> else if ( regno == REG_VOLATILE ) rws_insn [ <NUM_LIT> ] = <NUM_LIT> ;


<s> static inline int rws_insn_test ( int regno ) { if ( regno == REG_AR_CFM ) return rws_insn [ <NUM_LIT> ] ; if ( regno == REG_VOLATILE ) return rws_insn [ <NUM_LIT> ] ; return <NUM_LIT> ;