<s> struct unw_table_entry * _Unwind_FindTableEntry ( void * pc , unsigned long * segment_base , unsigned long * gp ) {


<s> data . segment_base = segment_base ; data . gp = gp ; data . ret = NULL ;

if ( dl_iterate_phdr ( _Unwind_IteratePhdrCallback , & data ) < <NUM_LIT> ) return NULL ;


<s> match = <NUM_LIT> ; phdr = info -> dlpi_phdr ; load_base = info -> dlpi_addr ; p_unwind = NULL ; p_dynamic = NULL ; seg_base = ~ ( Elf64_Addr ) <NUM_LIT> ; for ( n = info -> dlpi_phnum ; -- n >= <NUM_LIT> ; phdr ++ ) { if ( phdr -> p_type == PT_LOAD ) { Elf64_Addr vaddr = phdr -> p_vaddr + load_base ; if ( data -> pc >= vaddr && data -> pc < vaddr + phdr -> p_memsz ) match = <NUM_LIT> ; if ( vaddr < seg_base ) seg_base = vaddr ; } else if ( phdr -> p_type == PT_IA_64_UNWIND ) p_unwind = phdr ; else if ( phdr -> p_type == PT_DYNAMIC ) p_dynamic = phdr ; } if ( ! match || ! p_unwind ) return <NUM_LIT> ; f_base = ( struct unw_table_entry * ) ( p_unwind -> p_vaddr + load_base ) ; lo = <NUM_LIT> ; hi = p_unwind -> p_memsz / sizeof ( struct unw_table_entry ) ; while ( lo < hi ) { size_t mid = ( lo + hi ) / <NUM_LIT> ; f = f_base + mid ; if ( data -> pc < f -> start_offset + seg_base ) hi = mid ; else if ( data -> pc >= f -> end_offset + seg_base ) lo = mid + <NUM_LIT> ; else goto found ; } return <NUM_LIT> ; found : * data -> segment_base = seg_base ; * data -> gp = <NUM_LIT> ; data -> ret = f ; if ( p_dynamic ) {

Elf64_Dyn * dyn = ( Elf64_Dyn * ) ( p_dynamic -> p_vaddr + load_base ) ;


<s> static void ia64_hpux_add_pragma_builtin ( tree func ) { size_t i ; if ( ! flag_isoc94 && flag_iso ) { for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( c89_mathlib_name_list ) ; i ++ ) { if ( ! strcmp ( c89_mathlib_name_list [ i ] . realname , IDENTIFIER_POINTER ( func ) ) ) { add_to_renaming_pragma_list ( func , get_identifier ( c89_mathlib_name_list [ i ] . c89name ) ) ; } } }


<s> static void ia64_asm_unwind_emit ( FILE * out_file , rtx_insn * insn ) { bool unwind = ia64_except_unwind_info ( & global_options ) == UI_TARGET ; bool frame = dwarf2out_do_frame ( ) ; rtx note , pat ; bool handled_one ; if ( ! unwind && ! frame ) return ; 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_debugger_regno ( 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 ) ;


<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> 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> ) ) ;


<s> SET_TYPE_MODE ( float128t_type_node , TYPE_MODE ( float128_type_node ) ) ; } ( * lang_hooks . types . register_builtin_type ) ( float128t_type_node , <STR_LIT> ) ; ftype = build_function_type_list ( float128t_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 ) ; ia64_builtins [ IA64_BUILTIN_HUGE_VALQ ] = decl ; ftype = build_function_type_list ( float128t_type_node , const_string_type , NULL_TREE ) ; decl = add_builtin_function ( <STR_LIT> , ftype , IA64_BUILTIN_NANQ , BUILT_IN_MD , <STR_LIT> , NULL_TREE ) ; TREE_READONLY ( decl ) = <NUM_LIT> ; ia64_builtins [ IA64_BUILTIN_NANQ ] = decl ; decl = add_builtin_function ( <STR_LIT> , ftype , IA64_BUILTIN_NANSQ , BUILT_IN_MD , <STR_LIT> , NULL_TREE ) ; TREE_READONLY ( decl ) = <NUM_LIT> ; ia64_builtins [ IA64_BUILTIN_NANSQ ] = decl ; ftype = build_function_type_list ( float128t_type_node , float128t_type_node , NULL_TREE ) ; decl = add_builtin_function ( <STR_LIT> , ftype , IA64_BUILTIN_FABSQ , BUILT_IN_MD , <STR_LIT> , NULL_TREE ) ; TREE_READONLY ( decl ) = <NUM_LIT> ; ia64_builtins [ IA64_BUILTIN_FABSQ ] = decl ; ftype = build_function_type_list ( float128t_type_node , float128t_type_node , float128t_type_node , NULL_TREE ) ; decl = add_builtin_function ( <STR_LIT> , ftype , IA64_BUILTIN_COPYSIGNQ , BUILT_IN_MD , <STR_LIT> , NULL_TREE ) ; TREE_READONLY ( decl ) = <NUM_LIT> ; ia64_builtins [ IA64_BUILTIN_COPYSIGNQ ] = decl ; } else ( * lang_hooks . types . register_builtin_type ) ( long_double_type_node , <STR_LIT> ) ; vms_patch_builtins ( ) ; add_builtin_function ( ( name ) , ( type ) , ( code ) , BUILT_IN_MD , \ NULL , NULL_TREE ) decl = def_builtin ( <STR_LIT> , build_function_type_list ( ptr_type_node , NULL_TREE ) , IA64_BUILTIN_BSP ) ; ia64_builtins [ IA64_BUILTIN_BSP ] = decl ; decl = def_builtin ( <STR_LIT> , build_function_type_list ( void_type_node , NULL_TREE ) , IA64_BUILTIN_FLUSHRS ) ; ia64_builtins [ IA64_BUILTIN_FLUSHRS ] = decl ; if ( TARGET_HPUX ) {

if ( ( decl = builtin_decl_explicit ( BUILT_IN_FINITE ) ) != NULL_TREE ) set_user_assembler_name ( decl , <STR_LIT> ) ;


<s> if ( ! TARGET_HPUX && TYPE_MODE ( type ) == TFmode ) return <STR_LIT> ; if ( TYPE_MODE ( type ) == XFmode ) return TARGET_HPUX ? <STR_LIT> : <STR_LIT> ; if ( TYPE_MODE ( type ) == RFmode ) return <STR_LIT> ; return NULL ;


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

if ( type == float128_type_node || type == float64x_type_node ) return NULL ;


<s> if ( next_cum . words < MAX_ARGUMENT_SLOTS ) { int n = MAX_ARGUMENT_SLOTS - next_cum . words ; * pretend_size = n * UNITS_PER_WORD ; cfun -> machine -> n_varargs = n ; }


<s> 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 ; 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> ) ;


<s> gcc_assert ( op0 == dest && GET_CODE ( op1 ) == CONST_INT ) ; if ( INTVAL ( op1 ) < <NUM_LIT> ) { gcc_assert ( ! frame_pointer_needed ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , - INTVAL ( op1 ) ) ; } else process_epilogue ( out_file , insn , unwind , frame ) ; }


<s> int dest_regno = REGNO ( dest ) ; int src_regno ; if ( src == pc_rtx ) { if ( unwind ) fprintf ( out_file , <STR_LIT> , ia64_debugger_regno ( 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_debugger_regno ( dest_regno ) ) ; break ; case AR_UNAT_REGNUM : gcc_assert ( dest_regno == current_frame_info . r [ reg_save_ar_unat ] ) ; if ( unwind ) fprintf ( out_file , <STR_LIT> , ia64_debugger_regno ( dest_regno ) ) ; break ;


<s> int r ; rtx head = bb -> head ; if ( GET_CODE ( head ) != CODE_LABEL ) continue ; if ( GET_CODE ( NEXT_INSN ( head ) ) == NOTE && NOTE_LINE_NUMBER ( NEXT_INSN ( head ) ) == NOTE_INSN_BASIC_BLOCK ) head = NEXT_INSN ( head ) ; for ( r = PR_REG ( <NUM_LIT> ) ; r < PR_REG ( <NUM_LIT> ) ; r += <NUM_LIT> ) if ( REGNO_REG_SET_P ( bb -> global_live_at_start , r ) ) { rtx p = gen_rtx_REG ( BImode , r ) ; rtx n = emit_insn_after ( gen_pred_rel_mutex ( p ) , head ) ; if ( head == bb -> end ) bb -> end = n ; head = n ; } } for ( i = n_basic_blocks - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { basic_block bb = BASIC_BLOCK ( i ) ; rtx insn = bb -> head ; while ( <NUM_LIT> ) { if ( GET_CODE ( insn ) == CALL_INSN && GET_CODE ( PATTERN ( insn ) ) == COND_EXEC && find_reg_note ( insn , REG_NORETURN , NULL_RTX ) ) { rtx b = emit_insn_before ( gen_safe_across_calls_all ( ) , insn ) ; rtx a = emit_insn_after ( gen_safe_across_calls_normal ( ) , insn ) ; if ( bb -> head == insn ) bb -> head = b ; if ( bb -> end == insn ) bb -> end = a ; }


<s> if ( GET_CODE ( NEXT_INSN ( head ) ) == NOTE && NOTE_LINE_NUMBER ( NEXT_INSN ( head ) ) == NOTE_INSN_BASIC_BLOCK ) head = NEXT_INSN ( head ) ; for ( r = PR_REG ( <NUM_LIT> ) ; r < PR_REG ( <NUM_LIT> ) ; r += <NUM_LIT> ) if ( REGNO_REG_SET_P ( bb -> global_live_at_start , r ) ) { rtx p = gen_rtx_REG ( BImode , r ) ; rtx n = emit_insn_after ( gen_pred_rel_mutex ( p ) , head ) ; if ( head == bb -> end ) bb -> end = n ; head = n ; } } for ( i = n_basic_blocks - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { basic_block bb = BASIC_BLOCK ( i ) ; rtx insn = bb -> head ; while ( <NUM_LIT> ) { if ( GET_CODE ( insn ) == CALL_INSN && GET_CODE ( PATTERN ( insn ) ) == COND_EXEC && find_reg_note ( insn , REG_NORETURN , NULL_RTX ) ) { rtx b = emit_insn_before ( gen_safe_across_calls_all ( ) , insn ) ; rtx a = emit_insn_after ( gen_safe_across_calls_normal ( ) , insn ) ; if ( bb -> head == insn ) bb -> head = b ; if ( bb -> end == insn ) bb -> end = a ; } if ( insn == bb -> end ) break ; insn = NEXT_INSN ( insn ) ;


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


<s> if ( ! INSN_P ( insn ) ) continue ; if ( ia64_safe_type ( insn ) == TYPE_S ) { group_idx ^= <NUM_LIT> ; memset ( last_group + group_idx , <NUM_LIT> , sizeof last_group [ group_idx ] ) ;


<s> bundle_pos ++ ; } if ( GET_CODE ( insn ) != CODE_LABEL ) b = bundle + INTVAL ( XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ) ; else b = <NUM_LIT> ; bundle_pos = <NUM_LIT> ; continue ; } else if ( GET_CODE ( pat ) == UNSPEC_VOLATILE && XINT ( pat , <NUM_LIT> ) == <NUM_LIT> ) { int t = INTVAL ( XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ) ; if ( b ) while ( bundle_pos < t ) { emit_insn_before ( gen_nop_type ( b -> t [ bundle_pos ] ) , insn ) ; bundle_pos ++ ; } continue ; } if ( bundle_pos == <NUM_LIT> ) b = <NUM_LIT> ; if ( b && INSN_P ( insn ) ) {


<s> if ( GET_CODE ( pat ) == USE || GET_CODE ( pat ) == CLOBBER ) continue ; if ( ( GET_CODE ( pat ) == UNSPEC && XINT ( pat , <NUM_LIT> ) == <NUM_LIT> ) || GET_CODE ( insn ) == CODE_LABEL ) { if ( b ) while ( bundle_pos < <NUM_LIT> ) { emit_insn_before ( gen_nop_type ( b -> t [ bundle_pos ] ) , insn ) ; bundle_pos ++ ; } if ( GET_CODE ( insn ) != CODE_LABEL ) b = bundle + INTVAL ( XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ) ; else b = <NUM_LIT> ; bundle_pos = <NUM_LIT> ; continue ; } else if ( GET_CODE ( pat ) == UNSPEC_VOLATILE && XINT ( pat , <NUM_LIT> ) == <NUM_LIT> ) { int t = INTVAL ( XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ) ; if ( b ) while ( bundle_pos < t ) { emit_insn_before ( gen_nop_type ( b -> t [ bundle_pos ] ) , insn ) ; bundle_pos ++ ; } continue ; } if ( bundle_pos == <NUM_LIT> ) b = <NUM_LIT> ; if ( b && INSN_P ( insn ) ) { t = ia64_safe_type ( insn ) ; if ( asm_noperands ( PATTERN ( insn ) ) >= <NUM_LIT> || GET_CODE ( PATTERN ( insn ) ) == ASM_INPUT ) { while ( bundle_pos < <NUM_LIT> ) {


<s> if ( TARGET_AUTO_PIC ) target_flags |= MASK_CONST_GP ; if ( TARGET_INLINE_DIV_LAT && TARGET_INLINE_DIV_THR ) { warning ( <STR_LIT> ) ; target_flags &= ~ MASK_INLINE_DIV_THR ; } if ( ia64_fixed_range_string ) fix_range ( ia64_fixed_range_string ) ; ia64_flag_schedule_insns2 = flag_schedule_insns_after_reload ;


<s> int i , regno ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { regno = ( last_scratch_gr_reg + i + <NUM_LIT> ) & <NUM_LIT> ; if ( call_used_regs [ 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 ; } } abort ( ) ;


<s> static void process_epilogue ( ) { if ( block_num != n_basic_blocks - <NUM_LIT> ) { fprintf ( asm_out_file , <STR_LIT> ) ; need_copy_state = <NUM_LIT> ; }


<s> fprintf ( asm_out_file , <STR_LIT> ) ; need_copy_state = <NUM_LIT> ; }


<s> int iter = spill_fill_data . next_iter ; rtx insn ; insn = emit_insn ( ( * move_fn ) ( reg , spill_restore_mem ( reg , cfa_off ) , GEN_INT ( cfa_off ) ) ) ; spill_fill_data . prev_insn [ iter ] = insn ;


<s> insn = emit_insn ( ( * move_fn ) ( reg , spill_restore_mem ( reg , cfa_off ) , GEN_INT ( cfa_off ) ) ) ; spill_fill_data . prev_insn [ iter ] = insn ;


<s> mem = spill_restore_mem ( reg , cfa_off ) ; insn = emit_insn ( ( * move_fn ) ( mem , reg , GEN_INT ( cfa_off ) ) ) ; spill_fill_data . prev_insn [ iter ] = insn ; if ( frame_reg ) { rtx base ; HOST_WIDE_INT off ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( frame_pointer_needed ) { base = hard_frame_pointer_rtx ; off = - cfa_off ; }


<s> if ( rs >= <NUM_LIT> ) break ; for ( re = rs + <NUM_LIT> ; re < <NUM_LIT> && ! call_used_regs [ PR_REG ( re ) ] ; re ++ ) continue ; if ( out_state == <NUM_LIT> ) { fputs ( <STR_LIT> , asm_out_file ) ;


<s> for ( re = rs + <NUM_LIT> ; re < <NUM_LIT> && ! call_used_regs [ PR_REG ( re ) ] ; re ++ ) continue ; if ( out_state == <NUM_LIT> ) { fputs ( <STR_LIT> , asm_out_file ) ; out_state = <NUM_LIT> ; } else fputc ( ',' , asm_out_file ) ;

if ( re == rs + <NUM_LIT> ) fprintf ( asm_out_file , <STR_LIT> , rs ) ;


<s> for ( regno = GR_REG ( <NUM_LIT> ) ; regno <= GR_REG ( <NUM_LIT> ) ; regno ++ ) if ( ! regs_ever_live [ regno ] && call_used_regs [ regno ] && ! fixed_regs [ regno ] && ! global_regs [ regno ] && ( ( current_frame_info . gr_used_mask >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) { current_frame_info . gr_used_mask |= <NUM_LIT> << regno ; return regno ; } } if ( try_locals ) { regno = current_frame_info . n_local_regs ;

if ( regno < ( <NUM_LIT> - frame_pointer_needed ) ) {


<s> if ( ! nested && ( ! TYPE_SIZE ( type ) || integer_zerop ( TYPE_SIZE ( type ) ) ) ) return VOIDmode ; switch ( code ) { case VOID_TYPE : case INTEGER_TYPE : case ENUMERAL_TYPE : case BOOLEAN_TYPE : case CHAR_TYPE : case POINTER_TYPE : case OFFSET_TYPE : case REFERENCE_TYPE : case METHOD_TYPE : 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> ) ;


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


<s> static bool ia64_cannot_force_const_mem ( rtx x ) {

return tls_symbolic_operand_type ( x ) != <NUM_LIT> ;


<s> bool ia64_const_double_ok_for_letter_p ( rtx value , char c ) { switch ( c ) { case 'G' : return CONST_DOUBLE_OK_FOR_G ( value ) ;


<s> return CONST_OK_FOR_J ( value ) ; case 'K' : return CONST_OK_FOR_K ( value ) ; case 'L' : return CONST_OK_FOR_L ( value ) ; case 'M' : return CONST_OK_FOR_M ( value ) ; case 'N' : return CONST_OK_FOR_N ( value ) ; case 'O' : return CONST_OK_FOR_O ( value ) ; case 'P' :


<s> return CONST_OK_FOR_L ( value ) ; case 'M' : return CONST_OK_FOR_M ( value ) ; case 'N' : return CONST_OK_FOR_N ( value ) ; case 'O' : return CONST_OK_FOR_O ( value ) ;


<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> if ( regno == HARD_FRAME_POINTER_REGNUM ) regno = current_frame_info . reg_fp ; else if ( regno == current_frame_info . reg_fp ) regno = HARD_FRAME_POINTER_REGNUM ; } 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> ) ;

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> ) ) ;


<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> } gcc_assert ( 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_unop ( DImode , NOT , new_reg , NULL_RTX , true ) ; code = AND ; } new_reg = expand_simple_binop ( DImode , code , new_reg , val , NULL_RTX , true , OPTAB_DIRECT ) ; if ( mode != DImode ) new_reg = gen_lowpart ( mode , new_reg ) ;


<s> 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 ) ; insn = emit_call_insn ( insn ) ;

use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , pic_offset_table_rtx ) ;


<s> 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 ) ; insn = emit_call_insn ( insn ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , pic_offset_table_rtx ) ; } if ( sibcall_p ) use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , b0 ) ;


<s> case ORDERED : magic = QCMP_UNORD ; ncode = EQ ; break ; case LT : magic = QCMP_LT | QCMP_INV ; ncode = NE ; break ; case LE : magic = QCMP_LT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; case GT : magic = QCMP_GT | QCMP_INV ; ncode = NE ; break ; case GE : magic = QCMP_GT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; default : gcc_unreachable ( ) ; } start_sequence ( ) ; ret = emit_library_call_value ( cmptf_libfunc , <NUM_LIT> , LCT_CONST , DImode , <NUM_LIT> , op0 , TFmode , op1 , TFmode , GEN_INT ( magic ) , DImode ) ; cmp = gen_reg_rtx ( BImode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cmp , gen_rtx_fmt_ee ( ncode , BImode , ret , const0_rtx ) ) ) ; insns = get_insns ( ) ; end_sequence ( ) ; emit_libcall_block ( insns , cmp , cmp , gen_rtx_fmt_ee ( code , BImode , op0 , op1 ) ) ; code = NE ;


<s> else if ( GET_CODE ( src ) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P ( src ) ) emit_insn ( gen_load_fptr ( dest , src ) ) ; else if ( sdata_symbolic_operand ( src , VOIDmode ) ) emit_insn ( gen_load_gprel ( 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 ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) , hi ) ; } } tmp = gen_rtx_HIGH ( Pmode , src ) ; tmp = gen_rtx_PLUS ( Pmode , tmp , pic_offset_table_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , tmp ) ) ; tmp = gen_rtx_LO_SUM ( Pmode , dest , src ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , tmp ) ) ; if ( addend ) { tmp = gen_rtx_PLUS ( Pmode , dest , GEN_INT ( addend ) ) ;


<s> if ( ! reload_in_progress && ! reload_completed && ! ia64_move_ok ( op0 , op1 ) ) op1 = force_reg ( mode , op1 ) ; if ( ( mode == Pmode || mode == ptr_mode ) && symbolic_operand ( op1 , VOIDmode ) ) { HOST_WIDE_INT addend = <NUM_LIT> ; enum tls_model tls_kind ; rtx sym = op1 ; if ( GET_CODE ( op1 ) == CONST && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) { addend = INTVAL ( XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ) ; sym = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; } tls_kind = tls_symbolic_operand_type ( sym ) ; if ( tls_kind ) return ia64_expand_tls_address ( tls_kind , op0 , sym , op1 , addend ) ; if ( any_offset_symbol_operand ( sym , mode ) ) addend = <NUM_LIT> ; else if ( aligned_offset_symbol_operand ( sym , mode ) ) {


<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 ( 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 ;


<s> if ( GET_CODE ( op0 ) == REG && GR_REGNO_P ( REGNO ( op0 ) ) ) { rtx out [ <NUM_LIT> ] ; gcc_assert ( ! no_new_pseudos ) ; if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG && GET_MODE ( SUBREG_REG ( operands [ <NUM_LIT> ] ) ) == TImode ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG && GR_REGNO_P ( REGNO ( operands [ <NUM_LIT> ] ) ) ) ) { rtx op1 = operands [ <NUM_LIT> ] ; if ( GET_CODE ( op1 ) == SUBREG ) op1 = SUBREG_REG ( op1 ) ; else op1 = gen_rtx_REG ( TImode , REGNO ( op1 ) ) ; emit_move_insn ( gen_rtx_REG ( TImode , REGNO ( op0 ) ) , op1 ) ; return true ; } 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> ) ) ;


<s> x = gen_rtx_AND ( mode , cmp , operands [ <NUM_LIT> + negate ] ) ; emit_insn ( gen_rtx_SET ( VOIDmode , 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 ( VOIDmode , f , x ) ) ; x = gen_rtx_IOR ( mode , t , f ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , x ) ) ;


<s> case GT : case GTU : break ; case NE : case LE : case LEU : code = reverse_condition ( code ) ; negate = true ; break ; case GE : case GEU : code = reverse_condition ( code ) ; negate = true ; case LT : case LTU : code = swap_condition ( code ) ; x = op0 , op0 = op1 , op1 = x ; break ; default : gcc_unreachable ( ) ; } if ( code == GTU ) { switch ( mode ) { case V2SImode : { rtx t1 , t2 , mask ; t1 = gen_reg_rtx ( V2SImode ) ; emit_insn ( gen_subv2si3 ( t1 , op0 , op1 ) ) ; mask = GEN_INT ( - <NUM_LIT> ) ; mask = gen_rtx_CONST_VECTOR ( V2SImode , gen_rtvec ( <NUM_LIT> , mask , mask ) ) ; mask = force_reg ( V2SImode , mask ) ; t2 = gen_reg_rtx ( V2SImode ) ; emit_insn ( gen_andv2si3 ( t2 , op0 , mask ) ) ; x = gen_reg_rtx ( V2SImode ) ; emit_insn ( gen_xorv2si3 ( x , t1 , t2 ) ) ; code = GT ; op0 = x ; op1 = CONST0_RTX ( mode ) ; } break ; case V8QImode : case V4HImode : x = gen_reg_rtx ( mode ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , x , gen_rtx_US_MINUS ( mode , op0 , op1 ) ) ) ;


<s> xops [ <NUM_LIT> ] = xops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; switch ( code ) { case UMIN : code = LTU ; break ; case UMAX : code = GTU ; break ; case SMIN : code = LT ; break ; case SMAX : code = GT ; break ; default : gcc_unreachable ( ) ; }

xops [ <NUM_LIT> ] = gen_rtx_fmt_ee ( code , VOIDmode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> rtx l , h , x , s ; enum machine_mode wmode , mode ; rtx ( * unpack_l ) ( rtx , rtx , rtx ) ; rtx ( * unpack_h ) ( rtx , rtx , rtx ) ; rtx ( * plus ) ( rtx , rtx , rtx ) ; wmode = GET_MODE ( operands [ <NUM_LIT> ] ) ; mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; switch ( mode ) { case V8QImode : unpack_l = gen_unpack1_l ; unpack_h = gen_unpack1_h ; plus = gen_addv4hi3 ; break ; case V4HImode : unpack_l = gen_unpack2_l ; unpack_h = gen_unpack2_h ; plus = gen_addv2si3 ; break ; default : gcc_unreachable ( ) ; } if ( unsignedp ) x = CONST0_RTX ( mode ) ; else { bool neg ; x = gen_reg_rtx ( mode ) ;

neg = ia64_expand_vecint_compare ( LT , mode , x , operands [ <NUM_LIT> ] , CONST0_RTX ( mode ) ) ;


<s> break ; case V4HImode : unpack_l = gen_unpack2_l ; unpack_h = gen_unpack2_h ; plus = gen_addv2si3 ; break ; default : gcc_unreachable ( ) ; } if ( unsignedp ) x = CONST0_RTX ( mode ) ; else { bool neg ; x = gen_reg_rtx ( mode ) ; neg = ia64_expand_vecint_compare ( LT , mode , x , operands [ <NUM_LIT> ] , CONST0_RTX ( mode ) ) ; gcc_assert ( ! neg ) ; } l = gen_reg_rtx ( wmode ) ; h = gen_reg_rtx ( wmode ) ;


<s> bool ia64_extra_constraint ( rtx value , char c ) { switch ( c ) { case 'Q' : return memory_operand ( value , VOIDmode ) && ! MEM_VOLATILE_P ( value ) ; case 'R' : return ( GET_CODE ( value ) == CONST_INT && INTVAL ( value ) >= <NUM_LIT> && INTVAL ( value ) <= <NUM_LIT> ) ; case 'S' : return ( GET_CODE ( value ) == MEM && GET_RTX_CLASS ( GET_CODE ( XEXP ( value , <NUM_LIT> ) ) ) != RTX_AUTOINC && ( reload_in_progress || memory_operand ( value , VOIDmode ) ) ) ; case 'T' : return small_addr_symbolic_operand ( value , VOIDmode ) ; case 'U' : return value == CONST0_RTX ( GET_MODE ( value ) ) ; case 'W' : if ( GET_CODE ( value ) == CONST_VECTOR && GET_MODE_CLASS ( GET_MODE ( value ) ) == MODE_VECTOR_INT ) { value = simplify_subreg ( DImode , value , GET_MODE ( value ) , <NUM_LIT> ) ;

return ia64_const_ok_for_letter_p ( INTVAL ( value ) , 'J' ) ;


<s> default_file_start ( ) ; emit_safe_across_calls ( ) ;


<s> static void ia64_file_start ( void ) { ia64_flag_var_tracking = flag_var_tracking ; flag_var_tracking = <NUM_LIT> ; default_file_start ( ) ;


<s> args_byte_size += hfa_size ; fp_regs ++ ; } if ( ! cum -> prototype ) offset = <NUM_LIT> ; else if ( byte_size != offset ) int_regs += offset / UNITS_PER_WORD ; for ( ; offset < byte_size && int_regs < MAX_ARGUMENT_SLOTS ; i ++ ) { enum machine_mode gr_mode = DImode ; unsigned int gr_size ; if ( offset & <NUM_LIT> ) gr_mode = SImode ; else if ( byte_size - offset == <NUM_LIT> ) gr_mode = SImode ; loc [ i ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( gr_mode , ( basereg + int_regs ) ) , GEN_INT ( offset ) ) ; gr_size = GET_MODE_SIZE ( gr_mode ) ; offset += gr_size ; if ( gr_size == UNITS_PER_WORD || ( gr_size < UNITS_PER_WORD && offset % UNITS_PER_WORD == <NUM_LIT> ) ) int_regs ++ ; else if ( gr_size > UNITS_PER_WORD ) int_regs += gr_size / UNITS_PER_WORD ; } return gen_rtx_PARALLEL ( mode , gen_rtvec_v ( i , loc ) ) ; } else if ( mode == TFmode || mode == TCmode || ( ! FLOAT_MODE_P ( mode ) || cum -> fp_regs == MAX_ARGUMENT_SLOTS ) ) { int byte_size = ( ( mode == BLKmode ) ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ) ; if ( BYTES_BIG_ENDIAN && ( mode == BLKmode || ( type && AGGREGATE_TYPE_P ( type ) ) ) && 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 ( mode , gen_rtvec ( <NUM_LIT> , gr_reg ) ) ; }

else return gen_rtx_REG ( mode , basereg + cum -> words + offset ) ;


<s> int words = ia64_function_arg_words ( type , mode ) ; int offset = ia64_function_arg_offset ( cum , type , words ) ; enum machine_mode hfa_mode = VOIDmode ; if ( cum -> words >= MAX_ARGUMENT_SLOTS ) return ; cum -> words += words + offset ; if ( type ) hfa_mode = hfa_element_mode ( type , <NUM_LIT> ) ; if ( hfa_mode != VOIDmode && ( ! cum -> prototype || named ) ) { int fp_regs = cum -> fp_regs ; int int_regs = cum -> words - words ; int hfa_size = GET_MODE_SIZE ( hfa_mode ) ;


<s> int byte_size ; int args_byte_size ; byte_size = ( ( mode == BLKmode ) ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ) ; 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 ( mode == TFmode || mode == TCmode || ( ! FLOAT_MODE_P ( mode ) || cum -> fp_regs == MAX_ARGUMENT_SLOTS ) ) cum -> int_regs = cum -> words ;


<s> else return PARM_BOUNDARY ; } if ( GET_MODE_BITSIZE ( mode ) > PARM_BOUNDARY ) return PARM_BOUNDARY * <NUM_LIT> ; else return PARM_BOUNDARY ;


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


<s> static int ia64_function_arg_offset ( CUMULATIVE_ARGS * cum , tree type , int words ) { if ( ( 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 ; else return words > <NUM_LIT> ;


<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> if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ) ) return false ;

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


<s> return decl && ( * targetm . binds_local_p ) ( decl ) ;


<s> 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 ) ; else { bool need_parallel = false ; if ( BYTES_BIG_ENDIAN && ( mode == BLKmode || ( valtype && AGGREGATE_TYPE_P ( valtype ) ) ) ) need_parallel = true ; else if ( mode == XFmode || mode == XCmode || mode == RFmode ) need_parallel = true ; if ( need_parallel ) { rtx loc [ <NUM_LIT> ] ; int offset ; int bytesize ; int i ; offset = <NUM_LIT> ; bytesize = int_size_in_bytes ( valtype ) ; if ( bytesize == <NUM_LIT> ) return gen_rtx_REG ( mode , GR_RET_FIRST ) ; for ( i = <NUM_LIT> ; offset < bytesize ; i ++ ) { loc [ i ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( DImode , GR_RET_FIRST + i ) , GEN_INT ( offset ) ) ; offset += UNITS_PER_WORD ; } return gen_rtx_PARALLEL ( mode , gen_rtvec_v ( i , loc ) ) ; }


<s> if ( pass_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ) { tree ptrtype = build_pointer_type ( type ) ; tree addr = std_gimplify_va_arg_expr ( valist , ptrtype , pre_p , post_p ) ; 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 ) {


<s> tree arg , decl = * node ; init_idents ( ) ; arg = TREE_VALUE ( args ) ; if ( arg == small_ident1 || arg == small_ident2 ) { addr_area = ADDR_AREA_SMALL ; } else { warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ; * no_add_attrs = true ; } switch ( TREE_CODE ( decl ) ) { case VAR_DECL : if ( ( DECL_CONTEXT ( decl ) && TREE_CODE ( DECL_CONTEXT ( decl ) ) == FUNCTION_DECL ) && ! TREE_STATIC ( decl ) ) { error ( <STR_LIT> <STR_LIT> , decl ) ; * no_add_attrs = true ; }


<s> if ( from == current_frame_info . reg_fp || from == current_frame_info . reg_save_b0 || from == current_frame_info . reg_save_pr || from == current_frame_info . reg_save_ar_pfs || from == current_frame_info . reg_save_ar_unat || from == current_frame_info . reg_save_ar_lc ) return <NUM_LIT> ;

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


<s> int ia64_hard_regno_rename_ok ( int from , int to ) { if ( to == current_frame_info . reg_fp || to == current_frame_info . reg_save_b0 || to == current_frame_info . reg_save_pr || to == current_frame_info . reg_save_ar_pfs || to == current_frame_info . reg_save_ar_unat || to == current_frame_info . reg_save_ar_lc ) return <NUM_LIT> ; if ( from == current_frame_info . reg_fp || from == current_frame_info . reg_save_b0 || from == current_frame_info . reg_save_pr || from == current_frame_info . reg_save_ar_pfs || from == current_frame_info . reg_save_ar_unat || from == current_frame_info . reg_save_ar_lc ) return <NUM_LIT> ; 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> ) ;


<s> declared_ia64_trampoline = true ; ( * targetm . asm_out . globalize_label ) ( asm_out_file , <STR_LIT> ) ; } } addr = convert_memory_address ( Pmode , addr ) ; fnaddr = convert_memory_address ( Pmode , fnaddr ) ; static_chain = convert_memory_address ( Pmode , static_chain ) ; addr_reg = gen_reg_rtx ( Pmode ) ; emit_move_insn ( addr_reg , addr ) ; emit_move_insn ( gen_rtx_MEM ( Pmode , addr_reg ) , gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ) ;

emit_insn ( gen_adddi3 ( addr_reg , addr_reg , eight ) ) ;


<s> declared_ia64_trampoline = true ; ( * targetm . asm_out . globalize_label ) ( asm_out_file , <STR_LIT> ) ; } } addr = convert_memory_address ( Pmode , addr ) ; fnaddr = convert_memory_address ( Pmode , fnaddr ) ; static_chain = convert_memory_address ( Pmode , static_chain ) ; addr_reg = gen_reg_rtx ( Pmode ) ; emit_move_insn ( addr_reg , addr ) ; emit_move_insn ( gen_rtx_MEM ( Pmode , addr_reg ) , gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ) ; emit_insn ( gen_adddi3 ( addr_reg , addr_reg , eight ) ) ; emit_move_insn ( gen_rtx_MEM ( Pmode , addr_reg ) , copy_to_reg ( plus_constant ( addr , <NUM_LIT> ) ) ) ; emit_insn ( gen_adddi3 ( addr_reg , addr_reg , eight ) ) ; emit_move_insn ( gen_rtx_MEM ( Pmode , addr_reg ) , fnaddr ) ;


<s> case FRAME_POINTER_REGNUM : switch ( to ) { case HARD_FRAME_POINTER_REGNUM : if ( current_function_is_leaf ) offset = - current_frame_info . total_size ; else offset = - ( current_frame_info . total_size - current_function_outgoing_args_size - <NUM_LIT> ) ; break ; case STACK_POINTER_REGNUM : if ( current_function_is_leaf ) offset = <NUM_LIT> ; else offset = <NUM_LIT> + current_function_outgoing_args_size ; break ; default :


<s> switch ( GET_CODE ( x ) ) { case CONST_INT : case LABEL_REF : return true ; case CONST_DOUBLE : if ( GET_MODE ( x ) == VOIDmode ) return true ; return CONST_DOUBLE_OK_FOR_G ( x ) ; case CONST : case SYMBOL_REF : return tls_symbolic_operand_type ( x ) == <NUM_LIT> ; case CONST_VECTOR : { enum machine_mode mode = GET_MODE ( x ) ; if ( mode == V2SFmode ) return ia64_extra_constraint ( x , 'Y' ) ; return ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT && GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) ;


<s> 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> ; } break ; default :


<s> 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> ; } break ;


<s> if ( GET_CODE ( dst ) != MEM ) return <NUM_LIT> ; 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 ;


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

if ( register_operand ( src , VOIDmode ) ) return <NUM_LIT> ;


<s> static void ia64_output_function_end_prologue ( FILE * file ) {

if ( ! flag_unwind_tables && ( ! flag_exceptions || USING_SJLJ_EXCEPTIONS ) ) return ;


<s> case BR_REGS : if ( from != GR_REGS && from != GR_AND_BR_REGS ) return MEMORY_MOVE_COST ( mode , to , <NUM_LIT> ) ; break ; case AR_I_REGS : case AR_M_REGS : if ( from != GR_REGS ) return MEMORY_MOVE_COST ( mode , to , <NUM_LIT> ) ; break ; case GR_REGS : case FR_REGS : case FP_REGS : case GR_AND_FR_REGS : case GR_AND_BR_REGS : case ALL_REGS :


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

tmp = gen_rtx_MEM ( DImode , pic_offset_table_rtx ) ;


<s> enum machine_mode mode ; enum machine_mode hfa_mode ; HOST_WIDE_INT byte_size ; mode = TYPE_MODE ( valtype ) ; 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> ) ; if ( hfa_mode != VOIDmode ) { int hfa_size = GET_MODE_SIZE ( hfa_mode ) ; if ( byte_size / hfa_size > MAX_ARGUMENT_SLOTS ) return true ; else return false ;


<s> case PLUS : if ( CONST_OK_FOR_I ( INTVAL ( x ) ) ) * total = <NUM_LIT> ; else if ( CONST_OK_FOR_J ( INTVAL ( x ) ) ) * total = <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; default : if ( CONST_OK_FOR_K ( INTVAL ( x ) ) || CONST_OK_FOR_L ( INTVAL ( 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 MULT : if ( GET_MODE_SIZE ( GET_MODE ( x ) ) > <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case PLUS : case MINUS : case ASHIFT : case ASHIFTRT : case LSHIFTRT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ;


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


<s> else { HOST_WIDE_INT off ; unsigned int regno ; off = ( current_frame_info . spill_cfa_off + current_frame_info . spill_size ) ; for ( regno = GR_REG ( <NUM_LIT> ) ; regno <= GR_REG ( <NUM_LIT> ) ; ++ regno ) if ( TEST_HARD_REG_BIT ( current_frame_info . mask , regno ) ) off -= <NUM_LIT> ; if ( frame_pointer_needed ) src = hard_frame_pointer_rtx ; else { src = stack_pointer_rtx ; off += current_frame_info . total_size ;


<s> } 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 ( 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> ) ; }


<s> 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 ) ) \ REG_NOTES ( INSN ) = gen_rtx_EXPR_LIST ( REG_INC , \ XEXP ( XEXP ( EXP , <NUM_LIT> ) , <NUM_LIT> ) , \ REG_NOTES ( INSN ) ) insn = emit_insn ( gen_rtx_SET ( VOIDmode , out [ <NUM_LIT> ] , in [ <NUM_LIT> ] ) ) ; MAYBE_ADD_REG_INC_NOTE ( insn , in [ <NUM_LIT> ] ) ; MAYBE_ADD_REG_INC_NOTE ( insn , out [ <NUM_LIT> ] ) ; insn = emit_insn ( gen_rtx_SET ( VOIDmode , out [ <NUM_LIT> ] , in [ <NUM_LIT> ] ) ) ;


<s> if ( REGNO ( base ) == REGNO ( operands [ <NUM_LIT> ] ) ) reversed = true ; 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 ) ) \ REG_NOTES ( INSN ) = gen_rtx_EXPR_LIST ( REG_INC , \ XEXP ( XEXP ( EXP , <NUM_LIT> ) , <NUM_LIT> ) , \ REG_NOTES ( INSN ) ) insn = emit_insn ( gen_rtx_SET ( VOIDmode , out [ <NUM_LIT> ] , in [ <NUM_LIT> ] ) ) ;


<s> for ( i = <NUM_LIT> ; i < n ; ++ i ) current_frame_info . gr_used_mask |= <NUM_LIT> << ( regno + i ) ; }


<s> int i , regno ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { regno = ( last_scratch_gr_reg + i + <NUM_LIT> ) & <NUM_LIT> ;

if ( call_used_regs [ regno ] && ! fixed_regs [ regno ] && ! global_regs [ regno ] && ( ( current_frame_info . gr_used_mask >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) {


<s> if ( spill_fill_data . prev_addr [ iter ] ) { if ( CONST_OK_FOR_N ( disp ) ) { * spill_fill_data . prev_addr [ iter ] = gen_rtx_POST_MODIFY ( DImode , spill_fill_data . iter_reg [ iter ] , gen_rtx_PLUS ( DImode , spill_fill_data . iter_reg [ iter ] , disp_rtx ) ) ; REG_NOTES ( spill_fill_data . prev_insn [ iter ] ) = gen_rtx_EXPR_LIST ( REG_INC , spill_fill_data . iter_reg [ iter ] , REG_NOTES ( spill_fill_data . prev_insn [ iter ] ) ) ; } else { if ( ! CONST_OK_FOR_I ( disp ) ) { rtx tmp = gen_rtx_REG ( DImode , next_scratch_gr_reg ( ) ) ; emit_move_insn ( tmp , disp_rtx ) ; disp_rtx = tmp ; } emit_insn ( gen_adddi3 ( spill_fill_data . iter_reg [ iter ] , spill_fill_data . iter_reg [ iter ] , disp_rtx ) ) ; } } else if ( disp == <NUM_LIT> && spill_fill_data . init_reg [ iter ] == stack_pointer_rtx && frame_pointer_needed ) { mem = gen_rtx_MEM ( GET_MODE ( reg ) , hard_frame_pointer_rtx ) ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; return mem ; } else {


<s> if ( CONST_OK_FOR_N ( disp ) ) { * spill_fill_data . prev_addr [ iter ] = gen_rtx_POST_MODIFY ( DImode , spill_fill_data . iter_reg [ iter ] , gen_rtx_PLUS ( DImode , spill_fill_data . iter_reg [ iter ] , disp_rtx ) ) ; REG_NOTES ( spill_fill_data . prev_insn [ iter ] ) = gen_rtx_EXPR_LIST ( REG_INC , spill_fill_data . iter_reg [ iter ] , REG_NOTES ( spill_fill_data . prev_insn [ iter ] ) ) ; } else { if ( ! CONST_OK_FOR_I ( disp ) ) { rtx tmp = gen_rtx_REG ( DImode , next_scratch_gr_reg ( ) ) ; emit_move_insn ( tmp , disp_rtx ) ; disp_rtx = tmp ; } emit_insn ( gen_adddi3 ( spill_fill_data . iter_reg [ iter ] , spill_fill_data . iter_reg [ iter ] , disp_rtx ) ) ; } } else if ( disp == <NUM_LIT> && spill_fill_data . init_reg [ iter ] == stack_pointer_rtx && frame_pointer_needed ) {

mem = gen_rtx_MEM ( GET_MODE ( reg ) , hard_frame_pointer_rtx ) ;


<s> emit_move_insn ( memt , SUBREG_REG ( in ) ) ; return adjust_address ( memt , mode , <NUM_LIT> ) ; } else if ( force && GET_CODE ( in ) == REG ) { rtx memx = assign_stack_temp ( mode , <NUM_LIT> , <NUM_LIT> ) ; emit_move_insn ( memx , in ) ; return memx ;


<s> if ( GET_CODE ( addr ) == CONST ) { if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) tls_kind = SYMBOL_REF_TLS_MODEL ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ;


<s> rtx mem ; rtx_insn * insn ; mem = spill_restore_mem ( reg , cfa_off ) ; insn = emit_insn ( ( * move_fn ) ( mem , reg , GEN_INT ( cfa_off ) ) ) ; spill_fill_data . prev_insn [ iter ] = insn ; if ( frame_reg ) { rtx base ; HOST_WIDE_INT off ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( frame_pointer_needed ) { base = hard_frame_pointer_rtx ;


<s> for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( d -> perm [ i ] != elt ) return false ; switch ( d -> vmode ) { case V2SImode : case V2SFmode : perm2 [ <NUM_LIT> ] = elt ; perm2 [ <NUM_LIT> ] = elt + <NUM_LIT> ;

ok = expand_vselect_vconcat ( d -> target , d -> op0 , d -> op0 , perm2 , <NUM_LIT> ) ;


<s> if ( d -> vmode != V4HImode || d -> one_operand_p ) return false ; if ( d -> testing_p ) return true ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { perm2 [ i ] = d -> perm [ i ] & <NUM_LIT> ; rmask [ i ] = ( d -> perm [ i ] & <NUM_LIT> ? const0_rtx : constm1_rtx ) ; } mask = gen_rtx_CONST_VECTOR ( V4HImode , gen_rtvec_v ( <NUM_LIT> , rmask ) ) ; mask = force_reg ( V4HImode , mask ) ; t0 = gen_reg_rtx ( V4HImode ) ; t1 = gen_reg_rtx ( V4HImode ) ;

ok = expand_vselect ( t0 , d -> op0 , perm2 , <NUM_LIT> ) ;


<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 ( VOIDmode , target , x ) ;


<s> x = gen_rtx_VEC_CONCAT ( v2mode , op0 , op1 ) ; return expand_vselect ( target , x , perm , nelt ) ;


<s> rtx x ; v2mode = GET_MODE_2XWIDER_MODE ( GET_MODE ( op0 ) ) ;


<s> if ( regno >= LOC_REG ( <NUM_LIT> ) && regno < LOC_REG ( <NUM_LIT> - frame_pointer_needed ) && current_frame_info . n_local_regs < regno - LOC_REG ( <NUM_LIT> ) + <NUM_LIT> ) current_frame_info . n_local_regs = regno - LOC_REG ( <NUM_LIT> ) + <NUM_LIT> ; else if ( crtl -> is_leaf && regno >= GR_REG ( <NUM_LIT> ) && regno <= GR_REG ( <NUM_LIT> ) ) current_frame_info . gr_used_mask |= <NUM_LIT> << regno ;


<s> 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 ;


<s> inline hashval_t bundle_state_hasher :: hash ( const value_type * 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> static machine_mode hfa_element_mode ( const_tree type , bool nested ) { machine_mode element_mode = VOIDmode ; machine_mode mode ; enum tree_code code = TREE_CODE ( type ) ; int know_element_mode = <NUM_LIT> ; tree t ; if ( ! nested && ( ! TYPE_SIZE ( type ) || integer_zerop ( TYPE_SIZE ( type ) ) ) ) return VOIDmode ; switch ( code ) { case VOID_TYPE : case INTEGER_TYPE : case ENUMERAL_TYPE : case BOOLEAN_TYPE : case POINTER_TYPE : case OFFSET_TYPE : case REFERENCE_TYPE : case METHOD_TYPE : 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 :


<s> dep_class = ia64_safe_itanium_class ( dep_insn ) ; if ( dep_type == REG_DEP_TRUE && ( dep_class == ITANIUM_CLASS_ST || dep_class == ITANIUM_CLASS_STF ) && ( insn_class == ITANIUM_CLASS_BR || insn_class == ITANIUM_CLASS_SCALL ) ) return <NUM_LIT> ; if ( dw == MIN_DEP_WEAK ) return PARAM_VALUE ( PARAM_SCHED_MEM_TRUE_DEP_COST ) ; else if ( dw > MIN_DEP_WEAK ) {


<s> static int ia64_arg_partial_bytes ( cumulative_args_t cum_v , machine_mode mode , tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int words = ia64_function_arg_words ( type , mode ) ;

int offset = ia64_function_arg_offset ( cum , type , words ) ;


<s> return FS ; case DFmode : return FT ; default :


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


<s> 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 ) { HOST_WIDE_INT i ; emit_move_insn ( r2 , GEN_INT ( - ( first + PROBE_INTERVAL ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , r2 , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , r2 ) ) ) ; emit_stack_probe ( r2 ) ; for ( i = <NUM_LIT> * PROBE_INTERVAL ; i < size ; i += PROBE_INTERVAL ) { emit_insn ( gen_rtx_SET ( VOIDmode , r2 , plus_constant ( Pmode , r2 , - PROBE_INTERVAL ) ) ) ; emit_stack_probe ( r2 ) ; } emit_insn ( gen_rtx_SET ( VOIDmode , r2 , plus_constant ( Pmode , r2 , ( i - PROBE_INTERVAL ) - size ) ) ) ; emit_stack_probe ( r2 ) ; } else { HOST_WIDE_INT rounded_size ; emit_move_insn ( r2 , GEN_INT ( - first ) ) ; rounded_size = size & - PROBE_INTERVAL ; emit_insn ( gen_rtx_SET ( VOIDmode , r2 , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , r2 ) ) ) ; if ( rounded_size > ( <NUM_LIT> << <NUM_LIT> ) ) { emit_move_insn ( r3 , GEN_INT ( - rounded_size ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , r3 , gen_rtx_PLUS ( Pmode , r2 , r3 ) ) ) ; } else emit_insn ( gen_rtx_SET ( VOIDmode , r3 , gen_rtx_PLUS ( Pmode , r2 , GEN_INT ( - rounded_size ) ) ) ) ; emit_insn ( gen_probe_stack_range ( r2 , r2 , r3 ) ) ; if ( size != rounded_size ) { emit_insn ( gen_rtx_SET ( VOIDmode , r2 , plus_constant ( Pmode , r2 , rounded_size - size ) ) ) ; emit_stack_probe ( r2 ) ; } }


<s> emit_insn ( gen_rtx_SET ( VOIDmode , 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 ) { HOST_WIDE_INT i ; emit_move_insn ( r2 , GEN_INT ( - ( first + PROBE_INTERVAL ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , r2 , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , r2 ) ) ) ; emit_stack_probe ( r2 ) ; for ( i = <NUM_LIT> * PROBE_INTERVAL ; i < size ; i += PROBE_INTERVAL ) { emit_insn ( gen_rtx_SET ( VOIDmode , r2 , plus_constant ( Pmode , r2 , - PROBE_INTERVAL ) ) ) ; emit_stack_probe ( r2 ) ; } emit_insn ( gen_rtx_SET ( VOIDmode , r2 , plus_constant ( Pmode , r2 , ( i - PROBE_INTERVAL ) - size ) ) ) ; emit_stack_probe ( r2 ) ; } else { HOST_WIDE_INT rounded_size ; emit_move_insn ( r2 , GEN_INT ( - first ) ) ; rounded_size = size & - PROBE_INTERVAL ; emit_insn ( gen_rtx_SET ( VOIDmode , r2 , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , r2 ) ) ) ; if ( rounded_size > ( <NUM_LIT> << <NUM_LIT> ) ) { emit_move_insn ( r3 , GEN_INT ( - rounded_size ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , r3 , gen_rtx_PLUS ( Pmode , r2 , r3 ) ) ) ; } else emit_insn ( gen_rtx_SET ( VOIDmode , r3 , gen_rtx_PLUS ( Pmode , r2 , GEN_INT ( - rounded_size ) ) ) ) ; emit_insn ( gen_probe_stack_range ( r2 , r2 , r3 ) ) ; if ( size != rounded_size ) { emit_insn ( gen_rtx_SET ( VOIDmode , r2 , plus_constant ( Pmode , r2 , rounded_size - size ) ) ) ; emit_stack_probe ( r2 ) ; } } emit_insn ( gen_blockage ( ) ) ;


<s> if ( ! old_dst ) old_dst = gen_reg_rtx ( mode ) ; switch ( model ) { case MEMMODEL_ACQ_REL : case MEMMODEL_SEQ_CST : emit_insn ( gen_memory_barrier ( ) ) ; case MEMMODEL_RELAXED : case MEMMODEL_ACQUIRE : case MEMMODEL_CONSUME : if ( mode == SImode ) icode = CODE_FOR_fetchadd_acq_si ; else icode = CODE_FOR_fetchadd_acq_di ; break ; case MEMMODEL_RELEASE : 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 ( model == MEMMODEL_RELAXED || model == MEMMODEL_RELEASE || 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> ) ) ; }


<s> unsigned int fcode = DECL_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 ( ) ) ; return const0_rtx ; case IA64_BUILTIN_INFQ : case IA64_BUILTIN_HUGE_VALQ : { machine_mode target_mode = TYPE_MODE ( TREE_TYPE ( exp ) ) ; REAL_VALUE_TYPE inf ; rtx tmp ; real_inf ( & inf ) ; tmp = CONST_DOUBLE_FROM_REAL_VALUE ( inf , target_mode ) ; tmp = validize_mem ( force_const_mem ( target_mode , tmp ) ) ; if ( target == <NUM_LIT> ) target = gen_reg_rtx ( target_mode ) ; emit_move_insn ( target , tmp ) ; return target ; } case IA64_BUILTIN_FABSQ :


<s> return target ; case IA64_BUILTIN_FLUSHRS : emit_insn ( gen_flushrs ( ) ) ; return const0_rtx ; case IA64_BUILTIN_INFQ : case IA64_BUILTIN_HUGE_VALQ : { machine_mode target_mode = TYPE_MODE ( TREE_TYPE ( exp ) ) ; REAL_VALUE_TYPE inf ; rtx tmp ; real_inf ( & inf ) ; tmp = CONST_DOUBLE_FROM_REAL_VALUE ( inf , target_mode ) ; tmp = validize_mem ( force_const_mem ( target_mode , tmp ) ) ; if ( target == <NUM_LIT> ) target = gen_reg_rtx ( target_mode ) ; emit_move_insn ( target , tmp ) ; return target ; } case IA64_BUILTIN_FABSQ : case IA64_BUILTIN_COPYSIGNQ : return expand_call ( exp , target , ignore ) ; default :


<s> case UNGT : magic = QCMP_GT | QCMP_UNORD ; ncode = NE ; break ; case UNGE : magic = QCMP_GT | QCMP_EQ | QCMP_UNORD ; ncode = NE ; break ; case UNEQ : case LTGT : default : gcc_unreachable ( ) ; } start_sequence ( ) ; ret = emit_library_call_value ( cmptf_libfunc , <NUM_LIT> , LCT_CONST , DImode , <NUM_LIT> , * op0 , TFmode , * op1 , TFmode , GEN_INT ( magic ) , DImode ) ; cmp = gen_reg_rtx ( BImode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cmp , gen_rtx_fmt_ee ( ncode , BImode , ret , const0_rtx ) ) ) ; insns = get_insns ( ) ; end_sequence ( ) ; emit_libcall_block ( insns , cmp , cmp , gen_rtx_fmt_ee ( code , BImode , * op0 , * op1 ) ) ; code = NE ; } else { cmp = gen_reg_rtx ( BImode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cmp , gen_rtx_fmt_ee ( code , BImode , * op0 , * op1 ) ) ) ; code = NE ; } * expr = gen_rtx_fmt_ee ( code , VOIDmode , cmp , const0_rtx ) ; * op0 = cmp ;


<s> case ORDERED : magic = QCMP_UNORD ; ncode = EQ ; break ; case LT : magic = QCMP_LT | QCMP_INV ; ncode = NE ; break ; case LE : magic = QCMP_LT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; case GT : magic = QCMP_GT | QCMP_INV ; ncode = NE ; break ; case GE : magic = QCMP_GT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; case UNLT : magic = QCMP_LT | QCMP_UNORD ; ncode = NE ; break ; case UNLE : magic = QCMP_LT | QCMP_EQ | QCMP_UNORD ; ncode = NE ; break ; case UNGT : magic = QCMP_GT | QCMP_UNORD ; ncode = NE ; break ; case UNGE : magic = QCMP_GT | QCMP_EQ | QCMP_UNORD ; ncode = NE ; break ; case UNEQ :


<s> 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 , <NUM_LIT> , 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 ) ; tmp = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , tmp , tga_ret , tga_eqv ) ; if ( ! register_operand ( op0 , Pmode ) ) op0 = gen_reg_rtx ( Pmode ) ; if ( TARGET_TLS64 ) { emit_insn ( gen_load_dtprel ( op0 , op1 ) ) ; emit_insn ( gen_adddi3 ( op0 , tmp , op0 ) ) ; } else emit_insn ( gen_add_dtprel ( op0 , op1 , tmp ) ) ; break ; case TLS_MODEL_INITIAL_EXEC : addend_lo = ( ( addend & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; addend_hi = addend - addend_lo ; op1 = plus_constant ( Pmode , op1 , addend_hi ) ; addend = addend_lo ; tmp = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_load_tprel ( tmp , op1 ) ) ;


<s> x = gen_rtx_NOT ( mode , cmp ) ; x = gen_rtx_AND ( mode , x , of ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , x ) ) ; } else if ( of == CONST0_RTX ( mode ) ) { x = gen_rtx_AND ( mode , cmp , ot ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , x ) ) ; } else { rtx t , f ; t = gen_reg_rtx ( mode ) ;

x = gen_rtx_AND ( mode , cmp , operands [ <NUM_LIT> + negate ] ) ;


<s> emit_insn ( gen_rtx_SET ( VOIDmode , tmp , x ) ) ; emit_insn ( gen_addv4hi3 ( operands [ <NUM_LIT> ] , tmp , operands [ <NUM_LIT> ] ) ) ; return true ; } xops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; xops [ <NUM_LIT> ] = xops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; xops [ <NUM_LIT> ] = xops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; switch ( code ) { case UMIN : code = LTU ; break ; case UMAX : code = GTU ; break ; case SMIN : code = LT ; break ; case SMAX : code = GT ; break ; default : gcc_unreachable ( ) ; } xops [ <NUM_LIT> ] = gen_rtx_fmt_ee ( code , VOIDmode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> static rtx ia64_function_arg ( cumulative_args_t cum , machine_mode mode , const_tree type , bool named ) { return ia64_function_arg_1 ( cum , mode , type , named , false ) ;


<s> int words = ia64_function_arg_words ( type , mode ) ; int offset = ia64_function_arg_offset ( cum , 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 ( mode ) ; cum -> words += words + offset ; if ( TARGET_ABI_OPEN_VMS ) { cum -> int_regs = cum -> words ; cum -> fp_regs = cum -> words ; return ; } if ( type ) hfa_mode = hfa_element_mode ( type , <NUM_LIT> ) ; if ( hfa_mode != VOIDmode && ( ! cum -> prototype || 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 = ( ( mode == BLKmode ) ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ) ; 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 ( mode == TFmode || mode == TCmode || ( ! FLOAT_MODE_P ( mode ) || cum -> fp_regs == MAX_ARGUMENT_SLOTS ) ) cum -> int_regs = cum -> words ; else if ( cum -> prototype ) { if ( ! named ) cum -> int_regs = cum -> words ; else cum -> fp_regs += ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ? <NUM_LIT> : <NUM_LIT> ) ; } else { cum -> fp_regs += ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ? <NUM_LIT> : <NUM_LIT> ) ; cum -> int_regs = cum -> words ; }


<s> cum -> words += words + offset ; return ; } cum -> atypes [ cum -> words ] = ia64_arg_type ( mode ) ; cum -> words += words + offset ; if ( TARGET_ABI_OPEN_VMS ) { cum -> int_regs = cum -> words ; cum -> fp_regs = cum -> words ; return ; } if ( type ) hfa_mode = hfa_element_mode ( type , <NUM_LIT> ) ; if ( hfa_mode != VOIDmode && ( ! cum -> prototype || 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 = ( ( mode == BLKmode ) ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ) ; 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 ( mode == TFmode || mode == TCmode || ( ! FLOAT_MODE_P ( mode ) || cum -> fp_regs == MAX_ARGUMENT_SLOTS ) ) cum -> int_regs = cum -> words ; else if ( cum -> prototype ) { if ( ! named ) cum -> int_regs = cum -> words ; else cum -> fp_regs += ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ? <NUM_LIT> : <NUM_LIT> ) ; } else { cum -> fp_regs += ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ? <NUM_LIT> : <NUM_LIT> ) ; cum -> int_regs = cum -> words ; }


<s> static rtx ia64_function_incoming_arg ( cumulative_args_t cum , machine_mode mode , const_tree type , bool named ) { return ia64_function_arg_1 ( cum , mode , type , named , true ) ;


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


<s> tree addr = std_gimplify_va_arg_expr ( valist , ptrtype , pre_p , post_p ) ; return build_va_arg_indirect_ref ( addr ) ; }


<s> enum direction ia64_hpux_function_arg_padding ( machine_mode mode , const_tree type ) { if ( type && AGGREGATE_TYPE_P ( type ) && int_size_in_bytes ( type ) < UNITS_PER_WORD ) return upward ;

return DEFAULT_FUNCTION_ARG_PADDING ( mode , type ) ;


<s> enum direction ia64_hpux_function_arg_padding ( machine_mode mode , const_tree type ) { if ( type && AGGREGATE_TYPE_P ( type ) && int_size_in_bytes ( type ) < UNITS_PER_WORD ) return upward ; return DEFAULT_FUNCTION_ARG_PADDING ( mode , type ) ;


<s> TYPE_PRECISION ( fpreg_type ) = <NUM_LIT> ; layout_type ( fpreg_type ) ; ( * lang_hooks . types . register_builtin_type ) ( fpreg_type , <STR_LIT> ) ; 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 float128_type = make_node ( REAL_TYPE ) ; TYPE_PRECISION ( float128_type ) = <NUM_LIT> ; layout_type ( float128_type ) ; ( * lang_hooks . types . register_builtin_type ) ( float128_type , <STR_LIT> ) ; ftype = build_function_type_list ( float128_type , 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 ) ; ia64_builtins [ IA64_BUILTIN_HUGE_VALQ ] = decl ; ftype = build_function_type_list ( float128_type , float128_type , NULL_TREE ) ; decl = add_builtin_function ( <STR_LIT> , ftype , IA64_BUILTIN_FABSQ , BUILT_IN_MD , <STR_LIT> , NULL_TREE ) ; TREE_READONLY ( decl ) = <NUM_LIT> ; ia64_builtins [ IA64_BUILTIN_FABSQ ] = decl ; ftype = build_function_type_list ( float128_type , float128_type , float128_type , NULL_TREE ) ; decl = add_builtin_function ( <STR_LIT> , ftype , IA64_BUILTIN_COPYSIGNQ , BUILT_IN_MD , <STR_LIT> , NULL_TREE ) ; TREE_READONLY ( decl ) = <NUM_LIT> ; ia64_builtins [ IA64_BUILTIN_COPYSIGNQ ] = decl ; } else ( * lang_hooks . types . register_builtin_type ) ( long_double_type_node , <STR_LIT> ) ; vms_patch_builtins ( ) ; add_builtin_function ( ( name ) , ( type ) , ( code ) , BUILT_IN_MD , \ NULL , NULL_TREE ) decl = def_builtin ( <STR_LIT> , build_function_type_list ( ptr_type_node , NULL_TREE ) , IA64_BUILTIN_BSP ) ; ia64_builtins [ IA64_BUILTIN_BSP ] = decl ; decl = def_builtin ( <STR_LIT> , build_function_type_list ( void_type_node , NULL_TREE ) , IA64_BUILTIN_FLUSHRS ) ; ia64_builtins [ IA64_BUILTIN_FLUSHRS ] = decl ;


<s> return true ; case TFmode : return false ; return true ; default : return false ;


<s> case SFmode : return <NUM_LIT> ; case DFmode : return <NUM_LIT> ; case XFmode : return <NUM_LIT> ; case TImode : return SPEC_MODE_INVALID ; default : return SPEC_MODE_INVALID ; }


<s> case DFmode : return <NUM_LIT> ; case XFmode : return <NUM_LIT> ; case TImode : return SPEC_MODE_INVALID ; default : return SPEC_MODE_INVALID ; }


<s> cl_deferred_option * opt ; vec < cl_deferred_option > * v = ( vec < cl_deferred_option > * ) ia64_deferred_options ; if ( v ) FOR_EACH_VEC_ELT ( * v , i , opt ) { 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 = ( global_options_set . x_g_switch_value ? g_switch_value : IA64_DEFAULT_GVALUE ) ; init_machine_status = ia64_init_machine_status ; if ( align_functions <= <NUM_LIT> ) align_functions = <NUM_LIT> ; if ( align_loops <= <NUM_LIT> ) align_loops = <NUM_LIT> ;


<s> 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> 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 ( vcall_offset ) { if ( ! satisfies_constraint_J ( vcall_offset_rtx ) ) { rtx tmp2 = gen_rtx_REG ( Pmode , next_scratch_gr_reg ( ) ) ; emit_move_insn ( tmp2 , vcall_offset_rtx ) ; vcall_offset_rtx = tmp2 ; } emit_insn ( gen_adddi3 ( tmp , tmp , vcall_offset_rtx ) ) ; } if ( TARGET_ILP32 ) emit_insn ( gen_zero_extendsidi2 ( tmp , gen_rtx_MEM ( ptr_mode , tmp ) ) ) ; else emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , tmp ) ) ; emit_insn ( gen_adddi3 ( this_rtx , this_rtx , tmp ) ) ; } if ( ! TREE_USED ( function ) ) { assemble_external ( function ) ; TREE_USED ( function ) = <NUM_LIT> ; } funexp = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; funexp = gen_rtx_MEM ( FUNCTION_MODE , funexp ) ; ia64_expand_call ( NULL_RTX , funexp , NULL_RTX , <NUM_LIT> ) ; insn = get_last_insn ( ) ; SIBLING_CALL_P ( insn ) = <NUM_LIT> ; reload_completed = <NUM_LIT> ; epilogue_completed = <NUM_LIT> ; try_split ( PATTERN ( insn ) , insn , <NUM_LIT> ) ; emit_barrier ( ) ; emit_all_insn_group_barriers ( NULL ) ;


<s> switch ( GET_CODE ( x ) ) { case NE : str = <STR_LIT> ; break ; case UNORDERED : str = <STR_LIT> ; break ; case ORDERED : str = <STR_LIT> ; break ; case UNLT : str = <STR_LIT> ; break ; case UNLE : str = <STR_LIT> ; break ; case UNGT : str = <STR_LIT> ; break ; case UNGE : str = <STR_LIT> ; break ; case UNEQ : case LTGT : gcc_unreachable ( ) ; default : str = GET_RTX_NAME ( GET_CODE ( x ) ) ; break ; } fputs ( str , file ) ; return ; case 'E' : fprintf ( file , HOST_WIDE_INT_PRINT_DEC , <NUM_LIT> - INTVAL ( x ) ) ; return ; case 'e' : fprintf ( file , HOST_WIDE_INT_PRINT_DEC , <NUM_LIT> - INTVAL ( x ) ) ; return ; case 'F' : if ( x == CONST0_RTX ( GET_MODE ( x ) ) ) str = reg_names [ FR_REG ( <NUM_LIT> ) ] ; else if ( x == CONST1_RTX ( GET_MODE ( x ) ) ) str = reg_names [ FR_REG ( <NUM_LIT> ) ] ; else { gcc_assert ( GET_CODE ( x ) == REG ) ; str = reg_names [ REGNO ( x ) ] ; } fputs ( str , file ) ; return ; case 'G' : { long val [ <NUM_LIT> ] ; REAL_VALUE_TYPE rv ; REAL_VALUE_FROM_CONST_DOUBLE ( rv , x ) ; real_to_target ( val , & rv , GET_MODE ( x ) ) ; if ( GET_MODE ( x ) == SFmode ) fprintf ( file , <STR_LIT> , val [ <NUM_LIT> ] & <NUM_LIT> ) ; else if ( GET_MODE ( x ) == DFmode ) fprintf ( file , <STR_LIT> , ( WORDS_BIG_ENDIAN ? val [ <NUM_LIT> ] : val [ <NUM_LIT> ] ) & <NUM_LIT> , ( WORDS_BIG_ENDIAN ? val [ <NUM_LIT> ] : val [ <NUM_LIT> ] ) & <NUM_LIT> ) ; else output_operand_lossage ( <STR_LIT> ) ; } return ; case 'I' : fputs ( reg_names [ REGNO ( x ) + <NUM_LIT> ] , file ) ; return ; case 'J' : case 'j' : { unsigned int regno = REGNO ( XEXP ( x , <NUM_LIT> ) ) ; if ( GET_CODE ( x ) == EQ ) regno += <NUM_LIT> ; if ( code == 'j' ) regno ^= <NUM_LIT> ; fputs ( reg_names [ regno ] , file ) ; } return ; case 'O' : if ( MEM_VOLATILE_P ( x ) ) fputs ( <STR_LIT> , file ) ; return ;


<s> ip = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_ip_value ( ip ) ) ;

emit_library_call ( gen_mcount_func_rtx ( ) , LCT_NORMAL , VOIDmode , <NUM_LIT> , gen_rtx_REG ( Pmode , BR_REG ( <NUM_LIT> ) ) , Pmode , ip , Pmode , label , Pmode ) ;


<s> 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 ) ;


<s> 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 ( GET_MODE ( x ) ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_MODE_SIZE ( GET_MODE ( x ) ) > <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 ( GET_MODE ( x ) ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } case ASHIFT : case ASHIFTRT : case LSHIFTRT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> case SFmode : case DFmode : case XFmode : case RFmode : return true ; case TFmode :


<s> CUMULATIVE_ARGS next_cum = * get_cumulative_args ( cum ) ; ia64_function_arg_advance ( pack_cumulative_args ( & next_cum ) , mode , type , <NUM_LIT> ) ; if ( next_cum . words < MAX_ARGUMENT_SLOTS ) { int n = MAX_ARGUMENT_SLOTS - next_cum . words ; * pretend_size = n * UNITS_PER_WORD ;


<s> 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 ) ;


<s> 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 ( VOIDmode , out [ <NUM_LIT> ] , in [ <NUM_LIT> ] ) ) ;


<s> d . one_operand_p = ( which != <NUM_LIT> ) ; 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 ( ) ; ret = ia64_expand_vec_perm_const_1 ( & d ) ; end_sequence ( ) ; return ret ;


<s> } if ( which == <NUM_LIT> ) for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d . perm [ i ] -= nelt ; d . one_operand_p = ( which != <NUM_LIT> ) ; 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> ) ;


<s> case V2SFmode : return true ; default : return false ;


<s> set_optab_libfunc ( udiv_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( udiv_optab , DImode , <STR_LIT> ) ; 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> if ( attr ) { 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 ) ; } else fprintf ( file , <STR_LIT> , COMMON_ASM_OP ) ; assemble_name ( file , name ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size , align / BITS_PER_UNIT ) ;


<s> tree attr = DECL_ATTRIBUTES ( decl ) ; if ( attr ) attr = lookup_attribute ( <STR_LIT> , attr ) ; if ( attr ) { 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 ) ; } else fprintf ( file , <STR_LIT> , COMMON_ASM_OP ) ; assemble_name ( file , name ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size , align / BITS_PER_UNIT ) ; fputc ( '\n' , file ) ;


<s> fprintf ( asm_out_file , <STR_LIT> , reg_names [ REGNO ( xops [ <NUM_LIT> ] ) ] ) ; assemble_name_raw ( asm_out_file , end_lab ) ; fputc ( '\n' , asm_out_file ) ; 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 ) ; fprintf ( asm_out_file , <STR_LIT> ) ; assemble_name_raw ( asm_out_file , loop_lab ) ; fputc ( '\n' , asm_out_file ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , end_lab ) ; return <STR_LIT> ;


<s> char loop_lab [ <NUM_LIT> ] , end_lab [ <NUM_LIT> ] ; rtx xops [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( loop_lab , <STR_LIT> , labelno ) ; ASM_GENERATE_INTERNAL_LABEL ( end_lab , <STR_LIT> , labelno ++ ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ <NUM_LIT> ] = reg1 ; xops [ <NUM_LIT> ] = reg2 ;

xops [ <NUM_LIT> ] = gen_rtx_REG ( BImode , PR_REG ( <NUM_LIT> ) ) ;


<s> rtx op1 = XEXP ( src , <NUM_LIT> ) ; gcc_assert ( op0 == dest && GET_CODE ( op1 ) == CONST_INT ) ; if ( INTVAL ( op1 ) < <NUM_LIT> ) { gcc_assert ( ! frame_pointer_needed ) ; if ( unwind ) fprintf ( asm_out_file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , - INTVAL ( op1 ) ) ; } else process_epilogue ( asm_out_file , insn , unwind , frame ) ; } else { gcc_assert ( src == hard_frame_pointer_rtx ) ; process_epilogue ( asm_out_file , insn , unwind , frame ) ; } } else if ( dest == hard_frame_pointer_rtx ) { gcc_assert ( src == stack_pointer_rtx ) ;


<s> int regno = REGNO ( reg ) ; int n = HARD_REGNO_NREGS ( REGNO ( reg ) , GET_MODE ( reg ) ) ; if ( n == <NUM_LIT> ) return rws_access_regno ( regno , flags , pred ) ;


<s> static int rws_access_reg ( rtx reg , struct reg_flags flags , int pred ) { int regno = REGNO ( reg ) ; int n = HARD_REGNO_NREGS ( REGNO ( reg ) , GET_MODE ( 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> static inline void rws_insn_set ( int regno ) { gcc_assert ( ! TEST_HARD_REG_BIT ( rws_insn , regno ) ) ;


<s> static inline int rws_insn_test ( int regno ) {

return TEST_HARD_REG_BIT ( rws_insn , regno ) ;


<s> rtx old_reg , new_reg , cmp_reg , ar_ccv , label ; enum insn_code icode ; if ( ( mode == SImode || mode == DImode ) && ( code == PLUS || code == MINUS ) && fetchadd_operand ( val , mode ) ) { if ( code == MINUS ) val = GEN_INT ( - INTVAL ( val ) ) ; if ( ! old_dst ) old_dst = gen_reg_rtx ( mode ) ; switch ( model ) { case MEMMODEL_ACQ_REL : case MEMMODEL_SEQ_CST : case MEMMODEL_SYNC_SEQ_CST : emit_insn ( gen_memory_barrier ( ) ) ; case MEMMODEL_RELAXED : case MEMMODEL_ACQUIRE : case MEMMODEL_SYNC_ACQUIRE : case MEMMODEL_CONSUME : if ( mode == SImode ) icode = CODE_FOR_fetchadd_acq_si ; else icode = CODE_FOR_fetchadd_acq_di ; break ; case MEMMODEL_RELEASE : case MEMMODEL_SYNC_RELEASE : 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 ) ;

new_reg = expand_simple_unop ( DImode , code , new_reg , NULL_RTX , true ) ;


<s> 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 ) ) ;


<s> { machine_mode target_mode = TYPE_MODE ( TREE_TYPE ( exp ) ) ; REAL_VALUE_TYPE inf ; rtx tmp ; real_inf ( & inf ) ; tmp = const_double_from_real_value ( inf , target_mode ) ; tmp = validize_mem ( force_const_mem ( target_mode , tmp ) ) ; if ( target == <NUM_LIT> ) target = gen_reg_rtx ( target_mode ) ; emit_move_insn ( target , tmp ) ; return target ; } case IA64_BUILTIN_FABSQ :


<s> rtx cmp ; if ( GET_MODE ( * op0 ) == BImode ) { gcc_assert ( ( code == NE || code == EQ ) && * op1 == const0_rtx ) ; cmp = * op0 ; } else if ( TARGET_HPUX && GET_MODE ( * op0 ) == TFmode ) { enum qfcmp_magic { QCMP_INV = <NUM_LIT> , QCMP_UNORD = <NUM_LIT> , QCMP_EQ = <NUM_LIT> , QCMP_LT = <NUM_LIT> , QCMP_GT = <NUM_LIT> } ; int magic ; enum rtx_code ncode ; rtx ret , insns ; gcc_assert ( cmptf_libfunc && GET_MODE ( * op1 ) == TFmode ) ; switch ( code ) { case EQ : magic = QCMP_EQ ; ncode = NE ; break ; case NE : magic = QCMP_EQ ; ncode = EQ ; break ; case UNORDERED : magic = QCMP_UNORD ; ncode = NE ; break ; case ORDERED : magic = QCMP_UNORD ; ncode = EQ ; break ; case LT : magic = QCMP_LT | QCMP_INV ; ncode = NE ; break ; case LE : magic = QCMP_LT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; case GT : magic = QCMP_GT | QCMP_INV ; ncode = NE ; break ; case GE : magic = QCMP_GT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; case UNLT : magic = QCMP_LT | QCMP_UNORD ; ncode = NE ; break ; case UNLE : magic = QCMP_LT | QCMP_EQ | QCMP_UNORD ; ncode = NE ; break ; case UNGT : magic = QCMP_GT | QCMP_UNORD ; ncode = NE ; break ; case UNGE : magic = QCMP_GT | QCMP_EQ | QCMP_UNORD ; ncode = NE ; break ; case UNEQ : case LTGT : default : gcc_unreachable ( ) ; } start_sequence ( ) ; ret = emit_library_call_value ( cmptf_libfunc , <NUM_LIT> , LCT_CONST , DImode , <NUM_LIT> , * op0 , TFmode , * op1 , TFmode , GEN_INT ( magic ) , DImode ) ; cmp = gen_reg_rtx ( BImode ) ;

emit_insn ( gen_rtx_SET ( cmp , gen_rtx_fmt_ee ( ncode , BImode , ret , const0_rtx ) ) ) ;


<s> rtx cmp ; if ( GET_MODE ( * op0 ) == BImode ) { gcc_assert ( ( code == NE || code == EQ ) && * op1 == const0_rtx ) ; cmp = * op0 ; } else if ( TARGET_HPUX && GET_MODE ( * op0 ) == TFmode ) { enum qfcmp_magic { QCMP_INV = <NUM_LIT> , QCMP_UNORD = <NUM_LIT> , QCMP_EQ = <NUM_LIT> , QCMP_LT = <NUM_LIT> , QCMP_GT = <NUM_LIT> } ; int magic ; enum rtx_code ncode ; rtx ret , insns ; gcc_assert ( cmptf_libfunc && GET_MODE ( * op1 ) == TFmode ) ; switch ( code ) { case EQ : magic = QCMP_EQ ; ncode = NE ; break ; case NE : magic = QCMP_EQ ; ncode = EQ ; break ; case UNORDERED : magic = QCMP_UNORD ; ncode = NE ; break ; case ORDERED : magic = QCMP_UNORD ; ncode = EQ ; break ; case LT : magic = QCMP_LT | QCMP_INV ; ncode = NE ; break ; case LE : magic = QCMP_LT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; case GT : magic = QCMP_GT | QCMP_INV ; ncode = NE ; break ; case GE : magic = QCMP_GT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; case UNLT : magic = QCMP_LT | QCMP_UNORD ; ncode = NE ; break ; case UNLE : magic = QCMP_LT | QCMP_EQ | QCMP_UNORD ; ncode = NE ; break ; case UNGT : magic = QCMP_GT | QCMP_UNORD ; ncode = NE ; break ; case UNGE : magic = QCMP_GT | QCMP_EQ | QCMP_UNORD ; ncode = NE ; break ; case UNEQ : case LTGT : default : gcc_unreachable ( ) ; } start_sequence ( ) ; ret = emit_library_call_value ( cmptf_libfunc , <NUM_LIT> , LCT_CONST , DImode , <NUM_LIT> , * op0 , TFmode , * op1 , TFmode , GEN_INT ( magic ) , DImode ) ; cmp = gen_reg_rtx ( BImode ) ; emit_insn ( gen_rtx_SET ( cmp , gen_rtx_fmt_ee ( ncode , BImode , ret , const0_rtx ) ) ) ; insns = get_insns ( ) ; end_sequence ( ) ; emit_libcall_block ( insns , cmp , cmp , gen_rtx_fmt_ee ( code , BImode , * op0 , * op1 ) ) ; code = NE ; } else { cmp = gen_reg_rtx ( BImode ) ; emit_insn ( gen_rtx_SET ( cmp , gen_rtx_fmt_ee ( code , BImode , * op0 , * op1 ) ) ) ;


<s> case LE : case LEU : code = reverse_condition ( code ) ; negate = true ; break ; case GE : case GEU : code = reverse_condition ( code ) ; negate = true ; case LT : case LTU : code = swap_condition ( code ) ; x = op0 , op0 = op1 , op1 = x ; break ; default : gcc_unreachable ( ) ; } if ( code == GTU ) { switch ( mode ) { case V2SImode : { rtx t1 , t2 , mask ; mask = gen_int_mode ( <NUM_LIT> , SImode ) ; mask = gen_rtx_CONST_VECTOR ( V2SImode , gen_rtvec ( <NUM_LIT> , mask , mask ) ) ; mask = force_reg ( mode , mask ) ; t1 = gen_reg_rtx ( mode ) ; emit_insn ( gen_subv2si3 ( t1 , op0 , mask ) ) ; t2 = gen_reg_rtx ( mode ) ; emit_insn ( gen_subv2si3 ( t2 , op1 , mask ) ) ; op0 = t1 ;


<s> bool negate = false ; rtx x ; switch ( code ) { case EQ : case GT : case GTU : break ; case NE : case LE : case LEU : code = reverse_condition ( code ) ; negate = true ; break ; case GE : case GEU : code = reverse_condition ( code ) ; negate = true ; case LT : case LTU : code = swap_condition ( code ) ; x = op0 , op0 = op1 , op1 = x ; break ; default : gcc_unreachable ( ) ; } if ( code == GTU ) { switch ( mode ) { case V2SImode : { rtx t1 , t2 , mask ; mask = gen_int_mode ( <NUM_LIT> , SImode ) ; mask = gen_rtx_CONST_VECTOR ( V2SImode , gen_rtvec ( <NUM_LIT> , mask , mask ) ) ; mask = force_reg ( mode , mask ) ; t1 = gen_reg_rtx ( mode ) ; 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 V8QImode : case 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 ;


<s> if ( dep_type == REG_DEP_TRUE && ( dep_class == ITANIUM_CLASS_ST || dep_class == ITANIUM_CLASS_STF ) && ( insn_class == ITANIUM_CLASS_BR || insn_class == ITANIUM_CLASS_SCALL ) ) return <NUM_LIT> ; if ( dw == MIN_DEP_WEAK ) return PARAM_VALUE ( PARAM_SCHED_MEM_TRUE_DEP_COST ) ; else if ( dw > MIN_DEP_WEAK ) { if ( mflag_sched_fp_mem_deps_zero_cost && dep_class == ITANIUM_CLASS_STF ) return <NUM_LIT> ; else return cost ;


<s> enum attr_itanium_class dep_class ; enum attr_itanium_class insn_class ; insn_class = ia64_safe_itanium_class ( insn ) ; dep_class = ia64_safe_itanium_class ( dep_insn ) ; if ( dep_type == REG_DEP_TRUE && ( dep_class == ITANIUM_CLASS_ST || dep_class == ITANIUM_CLASS_STF ) && ( insn_class == ITANIUM_CLASS_BR || insn_class == ITANIUM_CLASS_SCALL ) ) return <NUM_LIT> ; if ( dw == MIN_DEP_WEAK ) return PARAM_VALUE ( PARAM_SCHED_MEM_TRUE_DEP_COST ) ; else if ( dw > MIN_DEP_WEAK ) { if ( mflag_sched_fp_mem_deps_zero_cost && dep_class == ITANIUM_CLASS_STF ) return <NUM_LIT> ; else return cost ; }

if ( dep_type != REG_DEP_OUTPUT ) return cost ;


<s> return const0_rtx ; case IA64_BUILTIN_INFQ : case IA64_BUILTIN_HUGE_VALQ : { machine_mode target_mode = TYPE_MODE ( TREE_TYPE ( exp ) ) ; REAL_VALUE_TYPE inf ; rtx tmp ; real_inf ( & inf ) ; tmp = const_double_from_real_value ( inf , target_mode ) ; tmp = validize_mem ( force_const_mem ( target_mode , tmp ) ) ; if ( target == <NUM_LIT> ) target = gen_reg_rtx ( target_mode ) ; emit_move_insn ( target , tmp ) ; return target ; }


<s> ret = emit_library_call_value ( cmptf_libfunc , <NUM_LIT> , LCT_CONST , DImode , <NUM_LIT> , * op0 , TFmode , * op1 , TFmode , GEN_INT ( magic ) , DImode ) ; cmp = gen_reg_rtx ( BImode ) ; emit_insn ( gen_rtx_SET ( cmp , gen_rtx_fmt_ee ( ncode , BImode , ret , const0_rtx ) ) ) ; rtx_insn * insns = get_insns ( ) ; end_sequence ( ) ; emit_libcall_block ( insns , cmp , cmp , gen_rtx_fmt_ee ( code , BImode , * op0 , * op1 ) ) ; code = NE ; } else { cmp = gen_reg_rtx ( BImode ) ; emit_insn ( gen_rtx_SET ( cmp , gen_rtx_fmt_ee ( code , BImode , * op0 , * op1 ) ) ) ; code = NE ; }

* expr = gen_rtx_fmt_ee ( code , VOIDmode , cmp , const0_rtx ) ;


<s> else if ( TARGET_HPUX && GET_MODE ( * op0 ) == TFmode ) { enum qfcmp_magic { QCMP_INV = <NUM_LIT> , QCMP_UNORD = <NUM_LIT> , QCMP_EQ = <NUM_LIT> , QCMP_LT = <NUM_LIT> , QCMP_GT = <NUM_LIT> } ; int magic ; enum rtx_code ncode ; rtx ret ; gcc_assert ( cmptf_libfunc && GET_MODE ( * op1 ) == TFmode ) ; switch ( code ) { case EQ : magic = QCMP_EQ ; ncode = NE ; break ; case NE : magic = QCMP_EQ ; ncode = EQ ; break ; case UNORDERED : magic = QCMP_UNORD ; ncode = NE ; break ; case ORDERED : magic = QCMP_UNORD ; ncode = EQ ; break ; case LT : magic = QCMP_LT | QCMP_INV ; ncode = NE ; break ; case LE : magic = QCMP_LT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; case GT : magic = QCMP_GT | QCMP_INV ; ncode = NE ; break ; case GE : magic = QCMP_GT | QCMP_EQ | QCMP_INV ; ncode = NE ; break ; case UNLT : magic = QCMP_LT | QCMP_UNORD ; ncode = NE ; break ; case UNLE : magic = QCMP_LT | QCMP_EQ | QCMP_UNORD ; ncode = NE ; break ; case UNGT : magic = QCMP_GT | QCMP_UNORD ; ncode = NE ; break ; case UNGE : magic = QCMP_GT | QCMP_EQ | QCMP_UNORD ; ncode = NE ; break ; case UNEQ : case LTGT : default : gcc_unreachable ( ) ; } start_sequence ( ) ; ret = emit_library_call_value ( cmptf_libfunc , <NUM_LIT> , LCT_CONST , DImode , <NUM_LIT> , * op0 , TFmode , * op1 , TFmode , GEN_INT ( magic ) , DImode ) ; cmp = gen_reg_rtx ( BImode ) ; emit_insn ( gen_rtx_SET ( cmp , gen_rtx_fmt_ee ( ncode , BImode , ret , const0_rtx ) ) ) ; rtx_insn * insns = get_insns ( ) ; end_sequence ( ) ; emit_libcall_block ( insns , cmp , cmp , gen_rtx_fmt_ee ( code , BImode , * op0 , * op1 ) ) ; code = NE ; } else { cmp = gen_reg_rtx ( BImode ) ;

emit_insn ( gen_rtx_SET ( cmp , gen_rtx_fmt_ee ( code , BImode , * op0 , * op1 ) ) ) ;


<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> tree type = TREE_TYPE ( TREE_TYPE ( fndecl ) ) ; 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 ) ;


<s> int addp4_optimize_ok ( rtx op1 , rtx op2 ) {


<s> rtx_insn * insn ; insn = emit_insn ( ( * move_fn ) ( reg , spill_restore_mem ( reg , cfa_off ) , GEN_INT ( cfa_off ) ) ) ; spill_fill_data . prev_insn [ iter ] = insn ;


<s> static void do_restore ( rtx ( * move_fn ) ( rtx , rtx , rtx ) , rtx reg , HOST_WIDE_INT cfa_off ) { int iter = spill_fill_data . next_iter ; rtx_insn * insn ;

insn = emit_insn ( ( * move_fn ) ( reg , spill_restore_mem ( reg , cfa_off ) , GEN_INT ( cfa_off ) ) ) ;


<s> insn = emit_insn ( ( * move_fn ) ( mem , reg , GEN_INT ( cfa_off ) ) ) ; spill_fill_data . prev_insn [ iter ] = insn ; if ( frame_reg ) { rtx base ; HOST_WIDE_INT off ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( frame_pointer_needed ) { base = hard_frame_pointer_rtx ; off = - cfa_off ; } else { base = stack_pointer_rtx ; off = current_frame_info . total_size - cfa_off ; }

add_reg_note ( insn , REG_CFA_OFFSET , gen_rtx_SET ( gen_rtx_MEM ( GET_MODE ( reg ) , plus_constant ( Pmode , base , off ) ) , frame_reg ) ) ;


<s> rtx_insn * last_label = <NUM_LIT> ; int insns_since_last_label = <NUM_LIT> ; init_insn_group_barriers ( ) ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( LABEL_P ( insn ) ) { if ( insns_since_last_label ) last_label = insn ; insns_since_last_label = <NUM_LIT> ; } else if ( NOTE_P ( insn ) && NOTE_KIND ( insn ) == NOTE_INSN_BASIC_BLOCK ) { if ( insns_since_last_label ) last_label = insn ; insns_since_last_label = <NUM_LIT> ; } else if ( NONJUMP_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == UNSPEC_VOLATILE && XINT ( PATTERN ( insn ) , <NUM_LIT> ) == UNSPECV_INSN_GROUP_BARRIER ) { init_insn_group_barriers ( ) ; last_label = <NUM_LIT> ; } else if ( NONDEBUG_INSN_P ( insn ) ) { insns_since_last_label = <NUM_LIT> ; if ( group_barrier_needed ( insn ) ) { if ( last_label ) { if ( dump ) fprintf ( dump , <STR_LIT> , INSN_UID ( last_label ) ) ; emit_insn_before ( gen_insn_group_barrier ( GEN_INT ( <NUM_LIT> ) ) , last_label ) ; insn = last_label ;


<s> if ( NOTE_INSN_BASIC_BLOCK_P ( NEXT_INSN ( head ) ) ) head = NEXT_INSN ( head ) ; for ( r = PR_REG ( <NUM_LIT> ) ; r < PR_REG ( <NUM_LIT> ) ; r += <NUM_LIT> ) if ( REGNO_REG_SET_P ( df_get_live_in ( bb ) , r ) ) { rtx p = gen_rtx_REG ( BImode , r ) ; rtx_insn * n = emit_insn_after ( gen_pred_rel_mutex ( p ) , head ) ; if ( head == BB_END ( bb ) ) BB_END ( bb ) = n ; head = n ; } } FOR_EACH_BB_REVERSE_FN ( bb , cfun ) { rtx_insn * insn = BB_HEAD ( bb ) ; while ( <NUM_LIT> ) { if ( CALL_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == COND_EXEC && find_reg_note ( insn , REG_NORETURN , NULL_RTX ) ) { rtx_insn * b = emit_insn_before ( gen_safe_across_calls_all ( ) , insn ) ;

rtx_insn * a = emit_insn_after ( gen_safe_across_calls_normal ( ) , insn ) ;


<s> if ( re == rs + <NUM_LIT> ) fprintf ( asm_out_file , <STR_LIT> , rs ) ; else fprintf ( asm_out_file , <STR_LIT> , rs , re - <NUM_LIT> ) ; rs = re + <NUM_LIT> ; }

if ( out_state ) fputc ( '\n' , asm_out_file ) ;


<s> for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( d -> perm [ i ] != elt ) return false ; switch ( d -> vmode ) { case E_V2SImode : case E_V2SFmode : perm2 [ <NUM_LIT> ] = elt ; perm2 [ <NUM_LIT> ] = elt + <NUM_LIT> ; ok = expand_vselect_vconcat ( d -> target , d -> op0 , d -> op0 , perm2 , <NUM_LIT> ) ; gcc_assert ( ok ) ; break ; case E_V8QImode : if ( BYTES_BIG_ENDIAN ) elt = <NUM_LIT> - elt ; elt *= BITS_PER_UNIT ; temp = gen_reg_rtx ( DImode ) ; emit_insn ( gen_extzv ( temp , gen_lowpart ( DImode , d -> op0 ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( elt ) ) ) ; emit_insn ( gen_mux1_brcst_qi ( d -> target , gen_lowpart ( QImode , temp ) ) ) ;


<s> unsigned char perm2 [ <NUM_LIT> ] ; rtx temp ; bool ok ; if ( ! d -> one_operand_p ) return false ; elt = d -> perm [ <NUM_LIT> ] ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( d -> perm [ i ] != elt ) return false ; switch ( d -> vmode ) { case E_V2SImode : case E_V2SFmode : perm2 [ <NUM_LIT> ] = elt ; perm2 [ <NUM_LIT> ] = elt + <NUM_LIT> ;

ok = expand_vselect_vconcat ( d -> target , d -> op0 , d -> op0 , perm2 , <NUM_LIT> ) ;


<s> static bool expand_vec_perm_identity ( struct expand_vec_perm_d * d ) { unsigned i , nelt = d -> nelt ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) if ( d -> perm [ i ] != i ) return false ;

if ( ! d -> testing_p ) emit_move_insn ( d -> target , d -> op0 ) ;


<s> unsigned contents , i , nelt , nelt2 ; unsigned h0 , h1 , h2 , h3 ; rtx_insn * seq ; bool ok ; if ( d -> one_operand_p ) return false ; nelt = d -> nelt ; nelt2 = nelt / <NUM_LIT> ; contents = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) contents |= <NUM_LIT> << d -> perm [ i ] ; memset ( remap , <NUM_LIT> , sizeof ( remap ) ) ; dremap = * d ; h0 = ( <NUM_LIT> << nelt2 ) - <NUM_LIT> ; h1 = h0 << nelt2 ; h2 = h0 << nelt ; h3 = h0 << ( nelt + nelt2 ) ; if ( ( contents & ( h0 | h2 ) ) == contents ) { for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned which = i / <NUM_LIT> + ( i & <NUM_LIT> ? nelt : <NUM_LIT> ) ; remap [ which ] = i ; dremap . perm [ i ] = which ; } } else if ( ( contents & ( h1 | h3 ) ) == contents ) { for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned which = i / <NUM_LIT> + nelt2 + ( i & <NUM_LIT> ? nelt : <NUM_LIT> ) ; remap [ which ] = i ; dremap . perm [ i ] = which ; } } else if ( ( contents & <NUM_LIT> ) == contents ) { for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned which = ( i & ~ <NUM_LIT> ) + ( i & <NUM_LIT> ? nelt : <NUM_LIT> ) ; remap [ which ] = i ; dremap . perm [ i ] = which ; } } else if ( ( contents & <NUM_LIT> ) == contents ) { for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned which = ( i | <NUM_LIT> ) + ( i & <NUM_LIT> ? nelt : <NUM_LIT> ) ; remap [ which ] = i ; dremap . perm [ i ] = which ; } } else if ( floor_log2 ( contents ) - ctz_hwi ( contents ) < ( int ) nelt ) {