<s> for ( j = <NUM_LIT> ; j < <NUM_LIT> ; ++ j ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) if ( ( mask [ j ] >> i ) & <NUM_LIT> ) sa_size ++ ; if ( TARGET_ABI_OPEN_VMS ) { if ( ( mask [ <NUM_LIT> ] >> REG_RA ) & <NUM_LIT> || frame_pointer_needed ) alpha_procedure_type = PT_STACK ; else if ( get_frame_size ( ) != <NUM_LIT> ) alpha_procedure_type = PT_REGISTER ; else alpha_procedure_type = PT_NULL ; if ( alpha_procedure_type == PT_STACK ) sa_size -= <NUM_LIT> ; vms_base_regno = ( frame_pointer_needed || cfun -> has_nonlocal_label || alpha_procedure_type == PT_STACK || crtl -> outgoing_args_size ) ? REG_PV : HARD_FRAME_POINTER_REGNUM ; vms_save_fp_regno = - <NUM_LIT> ; if ( vms_base_regno == HARD_FRAME_POINTER_REGNUM ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ! fixed_regs [ i ] && call_used_regs [ i ] && ! df_regs_ever_live_p ( i ) ) vms_save_fp_regno = i ; if ( ( vms_save_fp_regno == - <NUM_LIT> && alpha_procedure_type == PT_REGISTER ) || cfun -> machine -> uses_condition_handler ) vms_base_regno = REG_PV , alpha_procedure_type = PT_STACK ; else if ( alpha_procedure_type == PT_NULL ) vms_base_regno = REG_PV ; vms_unwind_regno = ( vms_base_regno == REG_PV ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM ) ; if ( alpha_procedure_type == PT_STACK ) sa_size +=

<NUM_LIT> + cfun -> machine -> uses_condition_handler ;


<s> * pretend_size = <NUM_LIT> * UNITS_PER_WORD ; } if ( cum >= <NUM_LIT> ) return ; if ( ! no_rtl ) { int count ; alias_set_type set = get_varargs_alias_set ( ) ; rtx tmp ; count = cfun -> va_list_gpr_size / UNITS_PER_WORD ; if ( count > <NUM_LIT> - cum ) count = <NUM_LIT> - cum ; gcc_assert ( ( VA_LIST_MAX_FPR_SIZE & <NUM_LIT> ) == <NUM_LIT> ) ; if ( cfun -> va_list_fpr_size & <NUM_LIT> ) { tmp = gen_rtx_MEM ( BLKmode , plus_constant ( Pmode , virtual_incoming_args_rtx , ( cum + <NUM_LIT> ) * UNITS_PER_WORD ) ) ; MEM_NOTRAP_P ( tmp ) = <NUM_LIT> ; set_mem_alias_set ( tmp , set ) ; move_block_from_reg ( <NUM_LIT> + cum , tmp , count ) ; } if ( cfun -> va_list_fpr_size & <NUM_LIT> ) { tmp = gen_rtx_MEM ( BLKmode , plus_constant ( Pmode

, virtual_incoming_args_rtx , cum * UNITS_PER_WORD ) ) ;


<s> scratch = operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; cond = gen_lowpart ( DImode , scratch ) ; alpha_pre_atomic_barrier ( model ) ; label = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label , <NUM_LIT> ) ) ; emit_load_locked ( mode , retval , mem ) ; emit_move_insn ( scratch , val ) ; emit_store_conditional ( mode , cond , mem , scratch ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; emit_unlikely_jump ( x , label ) ; alpha_post_atomic_barrier ( model )


<s> val = operands [ <NUM_LIT> ] ; align = operands [ <NUM_LIT> ] ; model = ( enum memmodel ) INTVAL ( operands [ <NUM_LIT> ] ) ; scratch = operands [ <NUM_LIT> ] ; mode = GET_MODE ( orig_mem ) ; addr = XEXP ( orig_mem , <NUM_LIT> ) ; mem = gen_rtx_MEM ( DImode , align ) ; MEM_VOLATILE_P ( mem ) = MEM_VOLATILE_P ( orig_mem ) ; if ( MEM_ALIAS_SET ( orig_mem ) == ALIAS_SET_MEMORY_BARRIER ) set_mem_alias_set ( mem , ALIAS_SET_MEMORY_BARRIER ) ; alpha_pre_atomic_barrier ( model ) ; label = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label , <NUM_LIT> ) ) ; emit_load_locked ( DImode , scratch , mem ) ; width = GEN_INT ( GET_MODE_BITSIZE ( mode


<s> if ( code == NOT ) { x = gen_rtx_AND ( mode , before , val ) ; emit_insn ( gen_rtx_SET ( VOIDmode , val , x ) ) ; x = gen_rtx_NOT ( mode , val ) ; } else x = gen_rtx_fmt_ee ( code , mode , before , val ) ; if ( after ) emit_insn ( gen_rtx_SET ( VOIDmode , after


<s> label = gen_rtx_LABEL_REF ( DImode , label ) ; if ( before == NULL ) before = scratch ; emit_load_locked ( mode , before , mem ) ; if ( code == NOT ) { x = gen_rtx_AND ( mode , before , val ) ; emit_insn ( gen_rtx_SET ( VOIDmode , val , x ) ) ; x = gen_rtx_NOT ( mode , val ) ; } else x = gen_rtx_fmt_ee ( code , mode , before , val ) ; if ( after ) emit_insn ( gen_rtx_SET ( VOIDmode , after , copy_rtx ( x ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , scratch , x ) ) ; emit_store_conditional ( mode , cond , mem , scratch ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; emit_unlikely_jump ( x , label ) ; alpha_post_atomic_barrier (


<s> oldval = operands [ <NUM_LIT> ] ; newval = operands [ <NUM_LIT> ] ; is_weak = ( operands [ <NUM_LIT> ] != const0_rtx ) ; mod_s = ( enum memmodel ) INTVAL ( operands [ <NUM_LIT> ] ) ; mod_f = ( enum memmodel ) INTVAL ( operands [ <NUM_LIT> ] ) ; mode = GET_MODE ( mem ) ; alpha_pre_atomic_barrier ( mod_s ) ; label1 = NULL_RTX ; if ( ! is_weak ) { label1 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label1 , <NUM_LIT> ) ) ; } label2 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_load_locked ( mode , retval , mem ) ; x = gen_lowpart ( DImode , retval ) ; if ( oldval == const0_rtx ) { emit_move_insn ( cond , const0_rtx ) ; x = gen_rtx_NE ( DImode , x , const0_rtx ) ; } else { x = gen_rtx_EQ ( DImode , x , oldval ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cond , x ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; } emit_unlikely_jump ( x , label2 ) ; emit_move_insn ( cond , newval ) ; emit_store_conditional ( mode , cond , mem , gen_lowpart ( mode , cond ) ) ; if ( ! is_weak ) { x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; emit_unlikely_jump ( x , label1 )


<s> label2 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_load_locked ( DImode , scratch , mem ) ; width = GEN_INT ( GET_MODE_BITSIZE ( mode ) ) ; mask = GEN_INT ( mode == QImode ? <NUM_LIT> : <NUM_LIT> ) ; emit_insn ( gen_extxl ( dest , scratch , width , addr ) ) ; if ( oldval == const0_rtx ) { emit_move_insn ( cond , const0_rtx ) ; x = gen_rtx_NE ( DImode , dest , const0_rtx ) ; } else { x = gen_rtx_EQ ( DImode , dest , oldval ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cond , x ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; } emit_unlikely_jump ( x , label2 ) ; emit_insn ( gen_mskxl ( cond , scratch , mask , addr ) ) ; if ( newval != const0_rtx ) emit_insn ( gen_iordi3 ( cond , cond ,


<s> alpha_pre_atomic_barrier ( mod_s ) ; label1 = NULL_RTX ; if ( ! is_weak ) { label1 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label1 , <NUM_LIT> ) ) ; } label2 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_load_locked ( DImode , scratch , mem ) ; width = GEN_INT ( GET_MODE_BITSIZE ( mode ) ) ; mask = GEN_INT ( mode == QImode ? <NUM_LIT> : <NUM_LIT> ) ; emit_insn ( gen_extxl ( dest , scratch , width , addr ) ) ; if ( oldval == const0_rtx ) { emit_move_insn ( cond , const0_rtx ) ; x = gen_rtx_NE ( DImode , dest , const0_rtx ) ; } else { x = gen_rtx_EQ ( DImode , dest , oldval ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cond , x ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; } emit_unlikely_jump ( x , label2 ) ; emit_insn ( gen_mskxl ( cond , scratch , mask , addr ) ) ; if ( newval != const0_rtx ) emit_insn ( gen_iordi3 ( cond , cond , newval


<s> HOST_WIDE_INT i0 , i1 ; rtx temp = NULL_RTX ; alpha_extract_integer ( operands [ <NUM_LIT> ] , & i0 , & i1 ) ; if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> || i1 == - ( i0 < <NUM_LIT> ) ) temp = alpha_emit_set_const ( operands [ <NUM_LIT> ] , mode , i0 , <NUM_LIT> , false ) ; if ( ! temp && TARGET_BUILD_CONSTANTS ) temp = alpha_emit_set_long_const ( operands [ <NUM_LIT> ] , i0 , i1 ) ; if ( temp


<s> arg2_stmt = va_list_skip_additions ( gimple_phi_arg_def ( offset_stmt , <NUM_LIT> ) ) ; if ( arg1_stmt == NULL || ! is_gimple_assign ( arg1_stmt ) || arg2_stmt == NULL || ! is_gimple_assign ( arg2_stmt ) ) goto escapes ; code1 = gimple_assign_rhs_code ( arg1_stmt ) ; code2 = gimple_assign_rhs_code ( arg2_stmt ) ; if ( code1 == COMPONENT_REF && ( code2 == MINUS_EXPR || code2 == PLUS_EXPR ) ) ; else if ( code2 == COMPONENT_REF && ( code1 == MINUS_EXPR || code1 == PLUS_EXPR ) ) { gimple tem = arg1_stmt ; code2 = code1 ; arg1_stmt = arg2_stmt ; arg2_stmt = tem ; } else goto escapes ; if ( ! tree_fits_shwi_p ( gimple_assign_rhs2 ( arg2_stmt ) ) ) goto escapes ; sub = tree_to_shwi ( gimple_assign_rhs2 ( arg2_stmt ) ) ; if ( code2 == MINUS_EXPR ) sub = - sub ; if ( sub < - <NUM_LIT> || sub > - <NUM_LIT> ) goto escapes ; arg1 = gimple_assign_rhs1 ( arg1_stmt ) ; arg2 = gimple_assign_rhs1 ( arg2_stmt ) ; if ( TREE_CODE ( arg2 ) == SSA_NAME ) { arg2_stmt = va_list_skip_additions ( arg2 ) ; if ( arg2_stmt == NULL || ! is_gimple_assign ( arg2_stmt ) || gimple_assign_rhs_code ( arg2_stmt ) != COMPONENT_REF ) goto escapes ; arg2 = gimple_assign_rhs1 ( arg2_stmt ) ; } if ( arg1 != arg2 ) goto escapes ; if ( TREE_CODE ( arg1 ) != COMPONENT_REF || TREE_OPERAND ( arg1 , <NUM_LIT> ) != va_list_gpr_counter_field || get_base_address ( arg1 ) != base ) goto escapes ; cfun -> va_list_fpr_size |= <NUM_LIT> ; return false ; } if ( offset_stmt && is_gimple_assign ( offset_stmt ) && gimple_assign_rhs_code ( offset_stmt ) == COMPONENT_REF ) offset = gimple_assign_rhs1 ( offset_stmt ) ; } if ( TREE_CODE ( offset ) != COMPONENT_REF || TREE_OPERAND ( offset , <NUM_LIT> ) != va_list_gpr_counter_field || get_base_address ( offset ) != base ) goto escapes ; else cfun -> va_list_fpr_size |= <NUM_LIT> ; return false ; escapes : si -> va_list_escapes = true ; return false


<s> word1 = force_reg ( DImode , gen_const_mem ( DImode , fnaddr ) ) ; word1 = expand_and ( DImode , word1 , GEN_INT ( HOST_WIDE_INT_C ( <NUM_LIT> ) ) , NULL ) ; } else { word1 = GEN_INT ( HOST_WIDE_INT_C ( <NUM_LIT> ) ) ; word2 = GEN_INT ( HOST_WIDE_INT_C ( <NUM_LIT> ) ) ; } mem = adjust_address ( m_tramp , DImode , <NUM_LIT> ) ; emit_move_insn ( mem , word1 ) ; mem = adjust_address ( m_tramp , DImode , <NUM_LIT> ) ; emit_move_insn ( mem , word2 ) ; mem = adjust_address ( m_tramp , Pmode


<s> if ( al == NULL ) { size_t buf_len ; char * linksym ; tree id ; if ( name [ <NUM_LIT> ] == '*' ) name ++ ; id = maybe_get_identifier ( name ) ; if ( id ) { while ( IDENTIFIER_TRANSPARENT_ALIAS ( id ) ) id = TREE_CHAIN ( id ) ; name = IDENTIFIER_POINTER ( id ) ; } buf_len = strlen ( name ) + <NUM_LIT> + <NUM_LIT> ; linksym = ( char * ) alloca ( buf_len ) ; snprintf ( linksym , buf_len , <STR_LIT> , cfun -> funcdef_no , name ) ; al = ggc_alloc < alpha_links


<s> case PT_REGISTER : case PT_STACK : return ( to != STACK_POINTER_REGNUM || vms_unwind_regno != HARD_FRAME_POINTER_REGNUM ) ; } gcc_unreachable (


<s> { HOST_WIDE_INT offset ; HOST_WIDE_INT pv_save_size = alpha_procedure_type == PT_STACK ? <NUM_LIT> : <NUM_LIT> ; switch ( from ) { case FRAME_POINTER_REGNUM : offset = ALPHA_ROUND ( sa_size + pv_save_size ) ; break ; case ARG_POINTER_REGNUM : offset = ( ALPHA_ROUND ( sa_size + pv_save_size + get_frame_size ( ) + crtl -> args . pretend_args_size ) - crtl -> args . pretend_args_size ) ; break ; default : gcc_unreachable ( ) ; } if ( to == STACK_POINTER_REGNUM ) offset

+= ALPHA_ROUND ( crtl -> outgoing_args_size ) ;


<s> hash_map < const char * , alpha_links * , string_traits > :: iterator iter = cfun -> machine -> links -> begin ( ) ; for ( ; iter != cfun -> machine -> links -> end ( ) ; ++ iter ) alpha_write_one_linkage ( ( * iter ) . first , ( * iter ) .


+ size + crtl -> args . pretend_args_size ) ;


<s> addr = plus_constant ( Pmode , stack_pointer_rtx , frame_bias + base_ofs ) ; mem = gen_rtx_MEM ( DImode , addr ) ; } add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , mem


<s> rtx ( * fn ) ( rtx , rtx , rtx ) ; switch ( mode ) { case QImode : fn = gen_insbl ; break ; case HImode : fn = gen_inswl ; break ; case SImode


<s> else if ( mode == DImode ) fn = gen_load_locked_di ; emit_insn ( fn ( reg


<s> static void emit_store_conditional ( machine_mode mode , rtx res , rtx mem , rtx val ) { rtx ( * fn ) ( rtx , rtx , rtx ) = NULL ; if ( mode == SImode ) fn = gen_store_conditional_si ; else if ( mode == DImode ) fn = gen_store_conditional_di ; emit_insn ( fn ( res , mem ,


<s> rtx x ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , cond , label , pc_rtx ) ; x = emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx


<s> static void emit_unlikely_jump ( rtx cond , rtx label ) { int very_unlikely = REG_BR_PROB_BASE


<s> static bool equal_keys ( const char * const & a , const char *


<s> } else base = XEXP ( ref , <NUM_LIT> ) ; if ( GET_CODE ( base ) == PLUS ) disp = INTVAL ( XEXP ( base , <NUM_LIT> ) ) , base = XEXP ( base , <NUM_LIT> ) ; else disp = <NUM_LIT> ; if ( MEM_ALIGN ( ref ) >= <NUM_LIT> ) offset = <NUM_LIT> ; else offset = disp & <NUM_LIT> ; gcc_assert ( offset + GET_MODE_SIZE ( GET_MODE ( ref ) ) <= GET_MODE_SIZE ( SImode ) ) ; * paligned_mem = widen_memory_access ( ref , SImode , - offset ) ; offset *=


<s> rtx base ; HOST_WIDE_INT disp , offset ; gcc_assert ( MEM_P ( ref ) ) ; if ( reload_in_progress && ! memory_address_p ( GET_MODE ( ref ) , XEXP ( ref , <NUM_LIT> ) ) ) { base = find_replacement ( & XEXP ( ref , <NUM_LIT> ) ) ; gcc_assert ( memory_address_p ( GET_MODE ( ref ) , base ) ) ; } else base = XEXP ( ref , <NUM_LIT> ) ; if ( GET_CODE ( base ) == PLUS ) disp = INTVAL ( XEXP ( base , <NUM_LIT> ) ) , base = XEXP ( base , <NUM_LIT> ) ; else disp = <NUM_LIT> ; if ( MEM_ALIGN ( ref ) >= <NUM_LIT> ) offset = <NUM_LIT> ; else offset = disp & <NUM_LIT> ; gcc_assert ( offset + GET_MODE_SIZE ( GET_MODE ( ref ) ) <= GET_MODE_SIZE ( SImode ) ) ; * paligned_mem = widen_memory_access ( ref , SImode , - offset ) ; offset *=


<s> gcc_assert ( MEM_P ( ref ) ) ; if ( reload_in_progress && ! memory_address_p ( GET_MODE ( ref ) , XEXP ( ref , <NUM_LIT> ) ) ) { base = find_replacement ( & XEXP ( ref , <NUM_LIT> ) ) ; gcc_assert ( memory_address_p ( GET_MODE ( ref ) , base ) ) ; } else base = XEXP ( ref , <NUM_LIT> ) ; if ( GET_CODE ( base ) == PLUS ) offset += INTVAL ( XEXP (

base , <NUM_LIT> ) ) , base = XEXP ( base , <NUM_LIT> ) ;


<s> } else base = XEXP ( ref , <NUM_LIT> ) ; if ( GET_CODE ( base ) == PLUS ) offset += INTVAL ( XEXP ( base , <NUM_LIT> )


<s> op = reg_equiv_memory_loc ( REGNO ( tmp ) ) ; if ( op == <NUM_LIT> ) return <NUM_LIT> ; } } return op


<s> for ( ; ; ) { enum tree_code code ; stmt = SSA_NAME_DEF_STMT ( lhs ) ; if ( gimple_code ( stmt ) == GIMPLE_PHI ) return stmt ; if ( ! is_gimple_assign ( stmt ) || gimple_assign_lhs ( stmt ) != lhs ) return NULL ; if ( TREE_CODE ( gimple_assign_rhs1 ( stmt ) ) != SSA_NAME ) return stmt ; code = gimple_assign_rhs_code ( stmt ) ; if ( ! CONVERT_EXPR_CODE_P ( code ) && ( ( code != PLUS_EXPR && code != POINTER_PLUS_EXPR ) || TREE_CODE ( gimple_assign_rhs2 ( stmt ) ) != INTEGER_CST || ! tree_fits_uhwi_p ( gimple_assign_rhs2 ( stmt ) )


<s> static bool vms_valid_pointer_mode ( machine_mode mode


<s> static bool vms_valid_pointer_mode ( machine_mode mode ) { return ( mode == SImode || mode


<s> if ( cum -> num_args < <NUM_LIT> && <NUM_LIT> < cum -> num_args + ALPHA_ARG_SIZE ( mode , type ) ) words = <NUM_LIT> - cum -> num_args ; if ( * cum < <NUM_LIT> && <NUM_LIT> < * cum + ALPHA_ARG_SIZE ( mode , type ) ) words = <NUM_LIT> - * cum ; return words * UNITS_PER_WORD


<s> static int alpha_arg_partial_bytes ( cumulative_args_t cum_v , machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED , bool named ATTRIBUTE_UNUSED ) { int words = <NUM_LIT> ; CUMULATIVE_ARGS * cum ATTRIBUTE_UNUSED = get_cumulative_args ( cum_v ) ; if ( cum -> num_args < <NUM_LIT> && <NUM_LIT> < cum -> num_args + ALPHA_ARG_SIZE ( mode , type ) ) words = <NUM_LIT> - cum -> num_args ; if ( * cum < <NUM_LIT> && <NUM_LIT> < * cum + ALPHA_ARG_SIZE ( mode , type ) ) words = <NUM_LIT> - * cum ; return words *


<s> break ; case DFmode : reg = gen_rtx_REG ( DFmode , <NUM_LIT> ) ; break ; case DImode : reg = gen_rtx_REG ( DImode , <NUM_LIT> ) ; break ; default : gcc_unreachable ( ) ; } tmp = gen_rtx_MEM ( QImode , func ) ; tmp = emit_call_insn ( gen_call_value ( reg , tmp , const0_rtx , const0_rtx , const0_rtx ) ) ; CALL_INSN_FUNCTION_USAGE ( tmp ) = usage ; RTL_CONST_CALL_P ( tmp ) = <NUM_LIT> ; tmp = get_insns ( ) ; end_sequence (


<s> reg = gen_rtx_REG ( DFmode , i + <NUM_LIT> ) ; emit_move_insn ( reg , mem ) ; cfa_restores = alloc_reg_note ( REG_CFA_RESTORE , reg , cfa_restores ) ; reg_offset += <NUM_LIT> ; } } if ( frame_size || eh_ofs ) { sp_adj1 = stack_pointer_rtx ; if ( eh_ofs ) { sp_adj1 = gen_rtx_REG ( DImode , <NUM_LIT> ) ; emit_move_insn ( sp_adj1 , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , eh_ofs ) ) ; } if ( frame_size < <NUM_LIT> && ! cfun -> calls_alloca ) sp_adj2 = GEN_INT ( frame_size ) ; else if ( frame_size < <NUM_LIT> ) { int low = ( ( frame_size & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; sp_adj2 = plus_constant ( Pmode , sp_adj1 , frame_size - low ) ; if ( sa_reg_exp && rtx_equal_p ( sa_reg_exp , sp_adj2 ) ) sp_adj1 = sa_reg ; else { sp_adj1 = gen_rtx_REG ( DImode , <NUM_LIT> ) ; emit_move_insn ( sp_adj1 , sp_adj2 ) ; } sp_adj2 = GEN_INT ( low ) ; } else { rtx tmp = gen_rtx_REG ( DImode , <NUM_LIT> ) ; sp_adj2 = alpha_emit_set_const ( tmp , DImode , frame_size , <NUM_LIT> , false ) ; if ( ! sp_adj2 ) { sp_adj2 = alpha_emit_set_long_const ( tmp , frame_size ) ; gcc_assert ( sp_adj2 ) ; } } if ( fp_is_frame_pointer ) { emit_insn ( gen_blockage ( ) ) ; mem = gen_frame_mem ( DImode , plus_constant ( Pmode , sa_reg , fp_offset ) ) ; emit_move_insn ( hard_frame_pointer_rtx , mem ) ; cfa_restores = alloc_reg_note ( REG_CFA_RESTORE , hard_frame_pointer_rtx , cfa_restores ) ; } else if ( TARGET_ABI_OPEN_VMS ) { emit_insn ( gen_blockage ( ) ) ; emit_move_insn ( hard_frame_pointer_rtx , gen_rtx_REG (


<s> } else { tmp2 = alpha_emit_set_long_const ( gen_rtx_REG ( Pmode , <NUM_LIT> ) , vcall_offset ) ; emit_insn ( gen_adddi3 ( tmp , tmp , tmp2 ) ) ; lo = <NUM_LIT> ; } if ( lo ) tmp2 = gen_rtx_PLUS ( Pmode , tmp , GEN_INT ( lo ) ) ; else tmp2 = tmp ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , tmp2 ) ) ; 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 ) ; insn = emit_call_insn ( gen_sibcall ( funexp , const0_rtx ) ) ; SIBLING_CALL_P ( insn )


<s> emit_load_locked ( mode , before , mem ) ; if ( code == NOT ) { x = gen_rtx_AND ( mode , before , val ) ; emit_insn ( gen_rtx_SET ( val , x ) ) ; x = gen_rtx_NOT ( mode , val ) ; } else x = gen_rtx_fmt_ee ( code , mode , before , val ) ; if ( after ) emit_insn ( gen_rtx_SET ( after , copy_rtx ( x ) ) ) ; emit_insn ( gen_rtx_SET ( scratch , x ) ) ; emit_store_conditional ( mode , cond


<s> x = gen_rtx_AND ( mode , before , val ) ; emit_insn ( gen_rtx_SET ( val , x ) ) ; x = gen_rtx_NOT ( mode , val ) ; } else x = gen_rtx_fmt_ee ( code , mode , before , val ) ; if ( after ) emit_insn ( gen_rtx_SET ( after , copy_rtx ( x ) ) ) ; emit_insn ( gen_rtx_SET ( scratch , x ) ) ; emit_store_conditional ( mode , cond , mem , scratch ) ; x = gen_rtx_EQ ( DImode , cond


<s> machine_mode mode ; rtx label1 , label2 , x ; cond = operands [ <NUM_LIT> ] ; retval = operands [ <NUM_LIT> ] ; mem = operands [ <NUM_LIT> ] ; oldval = operands [ <NUM_LIT> ] ; newval = operands [ <NUM_LIT> ] ; is_weak = ( operands [ <NUM_LIT> ] != const0_rtx ) ; mod_s = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; mod_f = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; mode = GET_MODE ( mem ) ; alpha_pre_atomic_barrier ( mod_s ) ; label1 = NULL_RTX ; if ( ! is_weak ) { label1 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label1 , <NUM_LIT> ) ) ; } label2 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_load_locked ( mode , retval , mem ) ; x = gen_lowpart ( DImode


<s> int alpha_split_conditional_move ( enum rtx_code code , rtx dest , rtx cond , rtx t_rtx , rtx f_rtx ) { HOST_WIDE_INT t , f , diff ; machine_mode mode ; rtx target , subtarget , tmp ; mode = GET_MODE ( dest ) ; t = INTVAL ( t_rtx ) ; f = INTVAL ( f_rtx ) ; diff = t - f ; if ( ( ( code == NE || code == EQ ) && diff < <NUM_LIT> ) || ( code == GE || code == GT ) ) { code = reverse_condition ( code ) ; diff = t , t = f , f = diff ; diff = t - f ; } subtarget = target = dest ; if ( mode != DImode ) { target = gen_lowpart ( DImode , dest ) ; if ( can_create_pseudo_p ( ) ) subtarget = gen_reg_rtx ( DImode ) ; else subtarget = target ; } if ( f == <NUM_LIT> && exact_log2 ( diff ) > <NUM_LIT> && ( diff <= <NUM_LIT> || alpha_tune == PROCESSOR_EV6 ) ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; tmp = gen_rtx_ASHIFT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( exact_log2 ( t ) ) ) ; emit_insn ( gen_rtx_SET ( target , tmp ) ) ; } else if ( f == <NUM_LIT> && t == - <NUM_LIT> ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; emit_insn ( gen_negdi2 ( target , copy_rtx ( subtarget ) ) ) ; } else if ( diff == <NUM_LIT> || diff == <NUM_LIT> || diff == <NUM_LIT> ) { rtx add_op ; tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; if ( diff == <NUM_LIT> ) emit_insn ( gen_adddi3 ( target , copy_rtx ( subtarget ) , GEN_INT ( f ) ) ) ; else { add_op = GEN_INT ( f ) ; if ( sext_add_operand ( add_op , mode ) ) { tmp = gen_rtx_MULT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( diff ) ) ; tmp = gen_rtx_PLUS ( DImode , tmp , add_op ) ; emit_insn ( gen_rtx_SET ( target , tmp ) ) ; } else return <NUM_LIT> ; } } else return


<s> machine_mode mode ; rtx target , subtarget , tmp ; mode = GET_MODE ( dest ) ; t = INTVAL ( t_rtx ) ; f = INTVAL ( f_rtx ) ; diff = t - f ; if ( ( ( code == NE || code == EQ ) && diff < <NUM_LIT> ) || ( code == GE || code == GT ) ) { code = reverse_condition ( code ) ; diff = t , t = f , f = diff ; diff = t - f ; } subtarget = target = dest ; if ( mode != DImode ) { target = gen_lowpart ( DImode , dest ) ; if ( can_create_pseudo_p ( ) ) subtarget = gen_reg_rtx ( DImode ) ; else subtarget = target ; } if ( f == <NUM_LIT> && exact_log2 ( diff ) > <NUM_LIT> && ( diff <= <NUM_LIT> || alpha_tune == PROCESSOR_EV6 ) ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; tmp = gen_rtx_ASHIFT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( exact_log2 ( t ) ) ) ; emit_insn ( gen_rtx_SET ( target , tmp ) ) ; } else if ( f == <NUM_LIT> && t == - <NUM_LIT> ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; emit_insn ( gen_negdi2 ( target , copy_rtx ( subtarget ) ) ) ; } else if ( diff == <NUM_LIT> || diff == <NUM_LIT> || diff == <NUM_LIT> ) { rtx add_op ; tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; if ( diff == <NUM_LIT> ) emit_insn ( gen_adddi3 ( target , copy_rtx ( subtarget ) , GEN_INT ( f ) ) ) ; else { add_op = GEN_INT ( f ) ; if ( sext_add_operand ( add_op , mode ) ) { tmp = gen_rtx_MULT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( diff ) ) ; tmp = gen_rtx_PLUS ( DImode , tmp , add_op ) ; emit_insn ( gen_rtx_SET ( target , tmp ) ) ; } else return


<s> if ( TREE_CODE ( base ) != COMPONENT_REF || TREE_OPERAND ( base , <NUM_LIT> ) != TYPE_FIELDS ( va_list_type_node ) ) return false ; offset_arg = <NUM_LIT> ; } base = get_base_address ( base ) ; if ( TREE_CODE ( base ) != VAR_DECL || ! bitmap_bit_p ( si -> va_list_vars , DECL_UID ( base ) + num_ssa_names ) ) return false ; offset = gimple_op ( stmt , <NUM_LIT> + offset_arg ) ; if ( TREE_CODE ( offset ) == SSA_NAME ) { gimple * offset_stmt = va_list_skip_additions ( offset ) ; if ( offset_stmt && gimple_code ( offset_stmt ) == GIMPLE_PHI ) { HOST_WIDE_INT sub ; gimple * arg1_stmt , * arg2_stmt ; tree arg1 , arg2 ; enum tree_code code1 , code2 ; if ( gimple_phi_num_args ( offset_stmt ) != <NUM_LIT> ) goto escapes ; arg1_stmt = va_list_skip_additions ( gimple_phi_arg_def ( offset_stmt , <NUM_LIT> ) ) ; arg2_stmt = va_list_skip_additions ( gimple_phi_arg_def ( offset_stmt , <NUM_LIT> ) ) ; if ( arg1_stmt == NULL || ! is_gimple_assign ( arg1_stmt ) || arg2_stmt == NULL || ! is_gimple_assign ( arg2_stmt ) ) goto escapes ; code1 = gimple_assign_rhs_code ( arg1_stmt ) ; code2 = gimple_assign_rhs_code ( arg2_stmt ) ; if ( code1 == COMPONENT_REF && ( code2 == MINUS_EXPR || code2 == PLUS_EXPR ) ) ; else if ( code2 == COMPONENT_REF && ( code1 == MINUS_EXPR || code1 == PLUS_EXPR ) ) { gimple * tem = arg1_stmt ; code2 = code1 ; arg1_stmt = arg2_stmt ; arg2_stmt = tem ; } else goto escapes ; if ( ! tree_fits_shwi_p ( gimple_assign_rhs2 ( arg2_stmt ) ) ) goto escapes ; sub = tree_to_shwi ( gimple_assign_rhs2 ( arg2_stmt ) ) ; if ( code2 == MINUS_EXPR ) sub = - sub ; if ( sub < - <NUM_LIT> || sub > - <NUM_LIT> ) goto escapes ; arg1 = gimple_assign_rhs1 ( arg1_stmt ) ; arg2 = gimple_assign_rhs1 ( arg2_stmt ) ; if ( TREE_CODE ( arg2 ) == SSA_NAME ) { arg2_stmt = va_list_skip_additions ( arg2 ) ; if ( arg2_stmt == NULL || ! is_gimple_assign ( arg2_stmt ) || gimple_assign_rhs_code ( arg2_stmt ) != COMPONENT_REF ) goto escapes ; arg2 = gimple_assign_rhs1 ( arg2_stmt ) ; } if ( arg1 != arg2


<s> static void emit_unlikely_jump ( rtx cond , rtx label ) { int very_unlikely = REG_BR_PROB_BASE / <NUM_LIT>


<s> x = gen_rtx_IF_THEN_ELSE ( VOIDmode , cond , label , pc_rtx ) ; x = emit_jump_insn ( gen_rtx_SET ( pc_rtx ,


<s> int regno = <NUM_LIT> , i ; start_sequence ( ) ; for ( i = <NUM_LIT> ; i < noperands ; ++ i ) { switch ( GET_MODE ( operands [ i ] ) ) { case TFmode : reg = gen_rtx_REG ( TFmode , regno ) ; regno += <NUM_LIT> ; break ; case DFmode : reg = gen_rtx_REG ( DFmode , regno + <NUM_LIT> ) ; regno += <NUM_LIT> ; break ; case VOIDmode : gcc_assert ( CONST_INT_P ( operands [ i ] ) ) ; case DImode : reg = gen_rtx_REG ( DImode , regno ) ; regno += <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } emit_move_insn ( reg , operands [ i ] ) ; use_reg ( & usage , reg ) ; } switch ( GET_MODE ( target ) ) { case TFmode : reg = gen_rtx_REG ( TFmode , <NUM_LIT> ) ; break ; case DFmode : reg = gen_rtx_REG ( DFmode , <NUM_LIT> ) ; break ; case DImode : reg = gen_rtx_REG ( DImode , <NUM_LIT> ) ; break ; default : gcc_unreachable ( ) ; } rtx mem = gen_rtx_MEM ( QImode , func ) ; rtx_insn * tmp = emit_call_insn ( gen_call_value ( reg , mem , const0_rtx , const0_rtx , const0_rtx ) ) ; CALL_INSN_FUNCTION_USAGE ( tmp ) = usage ; RTL_CONST_CALL_P ( tmp ) = <NUM_LIT> ; tmp = get_insns ( ) ; end_sequence (


<s> if ( mode == SFmode || mode == SCmode ) return ! named ; return mode == TFmode


<s> rtx x = gen_rtx_IF_THEN_ELSE ( VOIDmode , cond , label , pc_rtx ) ; rtx_insn * insn = emit_jump_insn ( gen_rtx_SET ( pc_rtx , x ) ) ; add_int_reg_note ( insn , REG_BR_PROB


<s> if ( ( sa_size == <NUM_LIT> && probed_size > probed - <NUM_LIT> ) || flag_stack_check || flag_stack_clash_protection ) emit_insn ( gen_stack_probe_internal ( GEN_INT ( - probed_size ) ) ) ; } if ( frame_size != <NUM_LIT> ) FRP ( emit_insn ( gen_adddi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - frame_size ) ) ) ) ; } else { HOST_WIDE_INT blocks = ( probed_size + <NUM_LIT> ) / <NUM_LIT> ; HOST_WIDE_INT leftover = probed_size + <NUM_LIT> - blocks * <NUM_LIT> ; rtx ptr = gen_rtx_REG ( DImode , <NUM_LIT> ) ; rtx count = gen_rtx_REG ( DImode , <NUM_LIT> ) ; rtx seq ; emit_move_insn ( count , GEN_INT ( blocks ) ) ; emit_insn ( gen_adddi3 ( ptr , stack_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_prologue_stack_probe_loop ( count , ptr ) ) ; if ( ( leftover > <NUM_LIT> && sa_size == <NUM_LIT> ) || flag_stack_check || flag_stack_clash_protection ) { rtx last = gen_rtx_MEM ( DImode , plus_constant ( Pmode , ptr , - leftover ) ) ; MEM_VOLATILE_P ( last ) = <NUM_LIT> ; emit_move_insn ( last , const0_rtx ) ; } if ( flag_stack_check || flag_stack_clash_protection ) { HOST_WIDE_INT lo , hi ; lo = ( ( frame_size & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; hi = frame_size - lo ; emit_move_insn ( ptr , GEN_INT ( hi ) ) ; emit_insn ( gen_adddi3 ( ptr , ptr , GEN_INT ( lo ) ) ) ; seq = emit_insn ( gen_subdi3 ( stack_pointer_rtx , stack_pointer_rtx , ptr ) ) ; } else { seq = emit_insn ( gen_adddi3 ( stack_pointer_rtx , ptr , GEN_INT ( - leftover ) ) ) ; } RTX_FRAME_RELATED_P ( seq ) = <NUM_LIT> ; add_reg_note ( seq , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - frame_size ) ) ) ; } sa_bias = <NUM_LIT> ; sa_reg = stack_pointer_rtx


<s> base_field = TYPE_FIELDS ( va_list_type_node ) ; offset_field = DECL_CHAIN ( base_field ) ; base_field = build3 ( COMPONENT_REF , TREE_TYPE ( base_field ) , valist , base_field , NULL_TREE ) ; offset_field = build3 ( COMPONENT_REF , TREE_TYPE ( offset_field ) , valist , offset_field , NULL_TREE ) ; base = get_formal_tmp_var ( base_field , pre_p ) ; t = fold_convert ( build_nonstandard_integer_type ( <NUM_LIT> , <NUM_LIT> ) , offset_field ) ; offset = get_initialized_tmp_var ( t , pre_p , NULL ) ; indirect = pass_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ; if ( indirect ) { if ( TREE_CODE ( type ) == COMPLEX_TYPE && targetm . calls . split_complex_arg ( type ) ) { tree real_part , imag_part , real_temp ; tree ptr_type = build_pointer_type_for_mode ( TREE_TYPE ( type ) , ptr_mode , true ) ; real_part = alpha_gimplify_va_arg_1 ( ptr_type , base , offset , pre_p ) ; real_part = build_va_arg_indirect_ref ( real_part ) ; real_temp = get_initialized_tmp_var ( real_part , pre_p , NULL ) ; imag_part = alpha_gimplify_va_arg_1 ( ptr_type , base , offset


<s> switch ( get_attr_type ( insn ) ) { case TYPE_ILD : case TYPE_LDSYM : case TYPE_FLD : case TYPE_LD_L : return EV4_IBX ; case TYPE_IADD : case TYPE_ILOG : case TYPE_ICMOV : case TYPE_ICMP : case TYPE_FST : case TYPE_SHIFT : case


<s> static rtx_insn * alphaev4_next_group ( rtx_insn * insn , int * pin_use , int * plen ) { int len , in_use ; len = in_use = <NUM_LIT> ; if ( ! INSN_P ( insn ) || GET_CODE ( PATTERN ( insn ) ) == CLOBBER || GET_CODE ( PATTERN ( insn ) ) == USE ) goto next_and_done ; while ( <NUM_LIT> ) { enum alphaev4_pipe pipe ; pipe = alphaev4_insn_pipe ( insn ) ; switch ( pipe ) { case EV4_STOP : if ( in_use ) goto done ; if ( recog_memoized ( insn ) < <NUM_LIT> ) len = - <NUM_LIT> ; else len = get_attr_length ( insn ) ; goto next_and_done ; case EV4_IBX : if ( in_use & EV4_IB0 ) { if ( in_use & EV4_IB1 ) goto done ; in_use |= EV4_IB1 ; } else in_use |= EV4_IB0 | EV4_IBX ; break ; case EV4_IB0 : if ( in_use & EV4_IB0 ) { if ( ! ( in_use & EV4_IBX ) || ( in_use & EV4_IB1 ) ) goto done ; in_use |= EV4_IB1 ; } in_use |= EV4_IB0 ; break ; case EV4_IB1 : if ( in_use & EV4_IB1 ) goto done ; in_use |= EV4_IB1 ; break ; default : gcc_unreachable ( ) ; } len += <NUM_LIT> ; if ( JUMP_P ( insn ) ) goto next_and_done ; next : insn = next_nonnote_insn ( insn ) ; if ( ! insn || ! INSN_P ( insn ) ) goto done ; if ( GET_MODE ( insn ) == TImode ) goto done ; if ( GET_CODE ( insn ) == CLOBBER || GET_CODE ( insn ) == USE ) goto next ; } next_and_done : insn = next_nonnote_insn ( insn ) ; done : * plen = len ; * pin_use = in_use ; return insn


<s> else if ( ( in_use & ( EV4_IBX | EV4_IB1 ) ) == EV4_IBX ) { in_use |= EV4_IB1 ; nop = gen_nop ( ) ; } else if ( TARGET_FP && ! ( in_use & EV4_IB1 ) ) { in_use |= EV4_IB1 ; nop = gen_fnop ( ) ; } else nop = gen_unop ( ) ; * pin_use = in_use ; return


<s> else len = get_attr_length ( insn ) ; goto next_and_done ; case EV5_E01 : if ( in_use & EV5_E0 ) { if ( in_use & EV5_E1 ) goto done ; in_use |= EV5_E1 ; } else in_use |= EV5_E0 | EV5_E01 ; break ; case EV5_E0 : if ( in_use & EV5_E0 ) { if ( ! ( in_use & EV5_E01 ) || ( in_use & EV5_E1 ) ) goto done ; in_use |= EV5_E1 ; } in_use |= EV5_E0 ; break ; case EV5_E1 : if ( in_use & EV5_E1 ) goto done ; in_use |= EV5_E1 ; break ; case EV5_FAM : if ( in_use & EV5_FA ) { if ( in_use & EV5_FM ) goto done ; in_use |= EV5_FM ; } else in_use |= EV5_FA | EV5_FAM ; break ; case EV5_FA : if ( in_use & EV5_FA ) goto done ; in_use |= EV5_FA ; break ; case EV5_FM : if ( in_use & EV5_FM ) goto done ; in_use |= EV5_FM ; break ; case EV5_NONE : break ; default : gcc_unreachable ( ) ; } len += <NUM_LIT> ; if ( JUMP_P ( insn ) ) goto next_and_done ; next : insn = next_nonnote_insn ( insn ) ; if ( ! insn || ! INSN_P ( insn ) ) goto done ; if ( GET_MODE ( insn ) == TImode ) goto done ; if ( GET_CODE ( insn ) == CLOBBER || GET_CODE ( insn ) == USE ) goto next ; } next_and_done : insn = next_nonnote_insn (


<s> if ( recog_memoized ( insn ) < <NUM_LIT> || recog_memoized ( dep_insn ) < <NUM_LIT> ) return cost ; dep_insn_type = get_attr_type ( dep_insn ) ; if ( dep_insn_type == TYPE_ILD || dep_insn_type == TYPE_FLD || dep_insn_type == TYPE_LDSYM ) cost += alpha_memory_latency - <NUM_LIT> ; return cost


<s> static void alpha_align_insns ( void ) { if ( alpha_tune == PROCESSOR_EV4 ) alpha_align_insns_1 ( <NUM_LIT> , alphaev4_next_group , alphaev4_next_nop ) ; else if ( alpha_tune == PROCESSOR_EV5 ) alpha_align_insns_1


<s> int prev_in_use , in_use , len , ldgp ; rtx_insn * i , * next ; shorten_branches ( get_insns ( ) ) ; unsigned int option_alignment = align_functions . levels [ <NUM_LIT> ] . get_value ( ) ; if ( option_alignment < <NUM_LIT> ) align = <NUM_LIT> ; else if ( ( unsigned int ) option_alignment < max_align ) align = option_alignment ; else align = max_align ; ofs = prev_in_use = <NUM_LIT> ; i = get_insns ( ) ; if ( NOTE_P ( i ) ) i = next_nonnote_insn ( i ) ; ldgp = alpha_function_needs_gp ? <NUM_LIT> : <NUM_LIT> ; while ( i ) { next = ( * next_group ) ( i , & in_use , & len ) ; if ( LABEL_P ( i ) ) { unsigned int new_align = label_to_alignment ( i ) . levels [ <NUM_LIT> ] . get_value ( ) ; if ( new_align >= align ) { align = new_align < max_align ? new_align : max_align ; ofs = <NUM_LIT> ; } else if ( ofs & ( new_align - <NUM_LIT> ) ) ofs = ( ofs | ( new_align - <NUM_LIT> ) ) + <NUM_LIT> ; gcc_assert ( ! len ) ; } else if ( in_use == <NUM_LIT> ) { if ( len < <NUM_LIT> ) { ofs = <NUM_LIT> ; align = <NUM_LIT> ; len = <NUM_LIT> ; } } else if ( ( int ) align < len ) { unsigned int new_log_align = len > <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ; rtx_insn * prev , * where ; where = prev = prev_nonnote_insn ( i ) ; if ( ! where || ! LABEL_P ( where ) ) where = i ; if ( ! ( TARGET_EXPLICIT_RELOCS && prev && CALL_P ( prev )


<s> static int alpha_arg_partial_bytes ( cumulative_args_t cum_v , const function_arg_info & arg ) { int words = <NUM_LIT> ; CUMULATIVE_ARGS * cum ATTRIBUTE_UNUSED = get_cumulative_args ( cum_v ) ; if ( cum -> num_args < <NUM_LIT> && <NUM_LIT> < cum -> num_args + ALPHA_ARG_SIZE ( arg . mode , arg . type ) ) words = <NUM_LIT> - cum -> num_args ; if ( * cum < <NUM_LIT> && <NUM_LIT> < * cum + ALPHA_ARG_SIZE ( arg . mode

, arg . type ) ) words = <NUM_LIT> - * cum ;


<s> return TARGET_FLOAT_VAX ? FF : FS ; case E_DFmode : return TARGET_FLOAT_VAX ? FD : FT ; default : return


<s> static tree alpha_builtin_decl ( unsigned code , bool initialize_p


<s> static void alpha_builtin_function ( const char * name , tree ftype , enum alpha_builtin code , unsigned ecf ) { tree decl = add_builtin_function ( name , ftype , ( int )

code , BUILT_IN_MD , NULL , NULL_TREE ) ;


<s> if ( ! reload_completed || ! TARGET_EXPLICIT_RELOCS ) return false ; if ( recog_memoized ( insn ) >= <NUM_LIT> ) return get_attr_cannot_copy ( insn ) ; else return false


<s> return ( GET_MODE_SIZE ( from ) == GET_MODE_SIZE ( to ) || !

reg_classes_intersect_p ( FLOAT_REGS , rclass ) ) ;


<s> static bool alpha_can_change_mode_class ( machine_mode from , machine_mode to , reg_class_t rclass ) { return ( GET_MODE_SIZE ( from ) == GET_MODE_SIZE ( to ) || ! reg_classes_intersect_p ( FLOAT_REGS


<s> for ( unsigned i = <NUM_LIT> ; ; ++ i ) { unsigned regno = EH_RETURN_DATA_REGNO ( i ) ; if ( regno == INVALID_REGNUM ) break ; sa_mask |= HOST_WIDE_INT_1U << regno ; } } if ( sa_mask || alpha_ra_ever_killed ( ) ) sa_mask |= HOST_WIDE_INT_1U << REG_RA ; } sa_size = popcount_hwi ( sa_mask ) ; frame_size = get_frame_size ( ) ; if ( TARGET_ABI_OPEN_VMS ) { if ( ( sa_mask >> REG_RA ) & <NUM_LIT> || frame_pointer_needed ) alpha_procedure_type = PT_STACK ; else if ( frame_size != <NUM_LIT> ) alpha_procedure_type = PT_REGISTER ; else alpha_procedure_type = PT_NULL ; if ( alpha_procedure_type == PT_STACK ) sa_size -= <NUM_LIT> ; vms_base_regno = ( frame_pointer_needed || cfun -> has_nonlocal_label || alpha_procedure_type == PT_STACK || crtl -> outgoing_args_size ) ? REG_PV : HARD_FRAME_POINTER_REGNUM ; vms_save_fp_regno = - <NUM_LIT> ; if ( vms_base_regno == HARD_FRAME_POINTER_REGNUM ) for ( unsigned i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ! fixed_regs [ i ] && call_used_or_fixed_reg_p ( i ) && ! df_regs_ever_live_p ( i ) ) { vms_save_fp_regno = i ; break ; } if ( ( vms_save_fp_regno == - <NUM_LIT> && alpha_procedure_type == PT_REGISTER ) || cfun -> machine -> uses_condition_handler ) vms_base_regno = REG_PV , alpha_procedure_type = PT_STACK ; else if ( alpha_procedure_type == PT_NULL ) vms_base_regno = REG_PV ; vms_unwind_regno = ( vms_base_regno == REG_PV ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM ) ; if ( alpha_procedure_type == PT_STACK ) sa_size += <NUM_LIT> + cfun -> machine -> uses_condition_handler ; } else { if ( sa_size & <NUM_LIT> ) sa_size ++ ; } sa_size *= <NUM_LIT> ; if ( TARGET_ABI_OPEN_VMS ) frame_size = ALPHA_ROUND ( sa_size + ( alpha_procedure_type == PT_STACK ? <NUM_LIT> : <NUM_LIT> ) + frame_size + crtl -> args . pretend_args_size ) ; else frame_size = ( ALPHA_ROUND ( crtl -> outgoing_args_size ) + sa_size + ALPHA_ROUND ( frame_size + crtl -> args . pretend_args_size ) ) ; cfun -> machine -> sa_mask = sa_mask ; cfun -> machine ->


<s> HOST_WIDE_INT frame_size ; int sa_size ; if ( ! cfun -> is_thunk ) { if ( TARGET_ABI_OPEN_VMS && alpha_procedure_type == PT_STACK ) sa_mask |= HOST_WIDE_INT_1U << HARD_FRAME_POINTER_REGNUM ; for ( unsigned i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( ! call_used_or_fixed_reg_p ( i ) && df_regs_ever_live_p ( i ) && i != REG_RA ) sa_mask |= HOST_WIDE_INT_1U << i ; if ( crtl -> calls_eh_return ) { for ( unsigned i = <NUM_LIT> ; ; ++ i ) { unsigned regno = EH_RETURN_DATA_REGNO ( i ) ; if ( regno == INVALID_REGNUM ) break ; sa_mask |= HOST_WIDE_INT_1U << regno ; } } if ( sa_mask || alpha_ra_ever_killed ( ) ) sa_mask |= HOST_WIDE_INT_1U << REG_RA ; } sa_size = popcount_hwi ( sa_mask ) ; frame_size = get_frame_size ( ) ; if ( TARGET_ABI_OPEN_VMS ) { if ( ( sa_mask >> REG_RA ) & <NUM_LIT> || frame_pointer_needed ) alpha_procedure_type = PT_STACK ; else if ( frame_size != <NUM_LIT> ) alpha_procedure_type = PT_REGISTER ; else alpha_procedure_type = PT_NULL ; if ( alpha_procedure_type == PT_STACK ) sa_size -= <NUM_LIT> ; vms_base_regno = ( frame_pointer_needed || cfun -> has_nonlocal_label || alpha_procedure_type == PT_STACK || crtl -> outgoing_args_size ) ? REG_PV : HARD_FRAME_POINTER_REGNUM ; vms_save_fp_regno = -


<s> static void alpha_conditional_register_usage ( void ) { int i ; if ( ! TARGET_FPREGS ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++

) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> ;


<s> static int alpha_does_function_need_gp ( void ) { rtx_insn * insn ; if ( ! TARGET_ABI_OSF ) return <NUM_LIT> ; if ( TARGET_PROFILING_NEEDS_GP && crtl -> profile ) return <NUM_LIT> ; if ( cfun -> is_thunk ) return <NUM_LIT> ; if ( crtl -> has_nonlocal_goto ) return <NUM_LIT> ; push_topmost_sequence ( )


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

startswith ( name , <STR_LIT> ) || startswith ( name , <STR_LIT> ) ) flags = SECTION_SMALL ;


<s> static section * alpha_elf_select_rtx_section ( machine_mode mode , rtx x , unsigned HOST_WIDE_INT align ) { if ( TARGET_SMALL_DATA && GET_MODE_SIZE ( mode ) <= g_switch_value


<s> static section * alpha_elf_select_rtx_section ( machine_mode mode , rtx x


<s> if ( cmp_mode == DFmode ) { if ( flag_unsafe_math_optimizations && cmp_code != UNORDERED ) { if ( op1 == CONST0_RTX ( DFmode ) ) cmp_code = UNKNOWN , branch_code = code ; else if ( op0 == CONST0_RTX ( DFmode ) ) { std :: swap ( op0 , op1 ) ; branch_code = swap_condition ( cmp_code ) ; cmp_code = UNKNOWN ; } } else { branch_mode = CCmode ; } } else { if ( code != LEU && code != LTU && code != GEU && code != GTU ) { if ( op1 == const0_rtx ) cmp_code = UNKNOWN , branch_code = code ; else if ( CONST_INT_P ( op1 ) && ( code == EQ || code == NE ) && ! ( symbolic_operand ( op0 , VOIDmode ) || ( REG_P ( op0 ) && REG_POINTER ( op0 ) ) ) ) { rtx n_op1 = GEN_INT ( - INTVAL ( op1 ) ) ; if ( ! satisfies_constraint_I ( op1 ) && ( satisfies_constraint_K ( n_op1 ) || satisfies_constraint_L ( n_op1 ) ) ) cmp_code = PLUS , branch_code = code , op1 = n_op1 ; } } if ( ! reg_or_0_operand ( op0 , DImode ) ) op0 = force_reg ( DImode , op0 ) ; if ( cmp_code != PLUS && ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } tem = op0


<s> cmp_mode = DImode ; } if ( cmp_mode == DFmode && ! TARGET_FIX ) return <NUM_LIT> ; cmp_code = UNKNOWN ; switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : case UNORDERED : if ( cmp_mode == DFmode ) cmp_code = code , code = NE ; break ; case NE : if ( cmp_mode == DImode && op1 == const0_rtx ) break ; case ORDERED : cmp_code = reverse_condition ( code ) ; code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( cmp_mode == DImode && op1 == const0_rtx ) break ; code = swap_condition ( code ) ; if ( cmp_mode == DFmode ) cmp_code = code , code = NE ; std :: swap ( op0 , op1 ) ; break ; default : gcc_unreachable (


<s> op0 = alpha_emit_xfloating_compare ( & code , op0 , op1 ) ; op1 = const0_rtx ; cmp_mode = DImode ; } if ( cmp_mode == DFmode && ! TARGET_FIX ) return <NUM_LIT> ; cmp_code = UNKNOWN ; switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : case UNORDERED : if ( cmp_mode == DFmode ) cmp_code = code , code = NE ; break ; case NE : if ( cmp_mode == DImode && op1 == const0_rtx ) break ; case ORDERED : cmp_code = reverse_condition ( code ) ; code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( cmp_mode == DImode && op1 == const0_rtx ) break ; code = swap_condition ( code ) ; if ( cmp_mode == DFmode ) cmp_code = code , code = NE ; std :: swap ( op0 , op1 ) ; break ; default : gcc_unreachable ( ) ; } if ( cmp_mode == DImode ) { if ( ! register_operand ( op0 , DImode ) ) op0 = force_reg ( DImode , op0 ) ; if ( ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } if ( cmp_code != UNKNOWN ) { tmp = gen_reg_rtx ( cmp_mode ) ; emit_insn ( gen_rtx_SET ( tmp , gen_rtx_fmt_ee ( cmp_code , cmp_mode , op0 , op1 ) ) ) ; op0 = cmp_mode != DImode ? gen_lowpart ( DImode , tmp ) : tmp ; op1 =


<s> rtx result = <NUM_LIT> ; int i ; if ( ! can_create_pseudo_p ( ) && mode == SImode && REG_P ( target ) && REGNO ( target ) < FIRST_PSEUDO_REGISTER ) { result = alpha_emit_set_const_1 ( target , mode , c , <NUM_LIT> , no_output ) ; if ( result ) return result ; target = no_output ? NULL : gen_lowpart ( DImode , target ) ; mode = DImode ; } else if ( mode == V8QImode || mode == V4HImode || mode == V2SImode ) { target = no_output ? NULL : gen_lowpart ( DImode , target ) ; mode = DImode ; } for ( i = <NUM_LIT> ; i <= n ; i ++ ) { result = alpha_emit_set_const_1 ( target , mode , c , i , no_output ) ; if ( result ) { rtx_insn * insn ; rtx set ; if ( no_output ) return result ; insn = get_last_insn ( ) ; set = single_set ( insn ) ; if ( ! CONSTANT_P ( SET_SRC ( set ) ) ) set_unique_reg_note ( get_last_insn ( ) , REG_EQUAL , GEN_INT ( c ) ) ; break ; } } if ( result )


<s> } else emit_move_insn ( target , GEN_INT ( d3 ) ) ; emit_move_insn ( target , gen_rtx_ASHIFT ( DImode , target , GEN_INT ( <NUM_LIT> ) ) ) ; if ( d2 ) emit_move_insn ( target , gen_rtx_PLUS ( DImode , target , GEN_INT ( d2 ) ) ) ; if ( d1 ) emit_move_insn ( target , gen_rtx_PLUS ( DImode , target , GEN_INT ( d1


<s> int mode ; rtx out_operands [ <NUM_LIT> ] ; func = alpha_lookup_xfloating_lib_func ( code ) ; mode = alpha_compute_xfloating_mode_arg ( code , alpha_fprm ) ; out_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; out_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; out_operands [ <NUM_LIT> ] =


<s> rtx func ; int mode ; rtx out_operands [ <NUM_LIT> ] ; func = alpha_lookup_xfloating_lib_func ( code ) ; mode = alpha_compute_xfloating_mode_arg ( code , alpha_fprm ) ; out_operands [ <NUM_LIT> ] = operands [ <NUM_LIT>


<s> switch ( cmp_code ) { case UNORDERED : cmp_code = EQ ; res_code = LT ; break ; case ORDERED : cmp_code = EQ ; res_code = GE ; break ; case NE : res_code = NE ; break ; case EQ : case LT : case GT : case LE : case GE : res_code = GT ; break ; default : gcc_unreachable ( ) ; } * pcode = res_code ; func = alpha_lookup_xfloating_lib_func ( cmp_code ) ; operands [ <NUM_LIT> ] = op0 ; operands [ <NUM_LIT> ] = op1 ; out = gen_reg_rtx ( DImode )


<s> case FIX : mode = alpha_compute_xfloating_mode_arg ( code , ALPHA_FPRM_CHOP ) ; out_operands [ <NUM_LIT> ] = GEN_INT ( mode ) ; noperands = <NUM_LIT> ; break ; case FLOAT_TRUNCATE : mode = alpha_compute_xfloating_mode_arg ( code , alpha_fprm ) ; out_operands [ <NUM_LIT> ] = GEN_INT ( mode ) ; noperands =


<s> emit_move_insn ( reg , operands [ i ] ) ; use_reg ( & usage , reg ) ; } switch ( GET_MODE ( target ) ) { case E_TFmode : reg = gen_rtx_REG ( TFmode , <NUM_LIT> ) ; break ; case E_DFmode : reg = gen_rtx_REG ( DFmode , <NUM_LIT> ) ; break ; case E_DImode : reg = gen_rtx_REG ( DImode , <NUM_LIT> ) ; break ; default : gcc_unreachable ( ) ; } rtx mem = gen_rtx_MEM ( QImode , func ) ; rtx_insn * tmp = emit_call_insn ( gen_call_value ( reg , mem , const0_rtx , const0_rtx , const0_rtx ) ) ; CALL_INSN_FUNCTION_USAGE ( tmp ) = usage ; RTL_CONST_CALL_P ( tmp ) = <NUM_LIT> ; tmp = get_insns ( ) ; end_sequence ( ) ; emit_libcall_block ( tmp , target , reg ,


<s> if ( insn && CALL_P ( insn ) ) output_asm_insn ( get_insn_template ( CODE_FOR_nop , NULL ) , NULL ) ; alpha_write_linkage ( file , fnname ) ; if ( TARGET_ABI_OPEN_VMS || ! flag_inhibit_size_directive )


<s> do { data_regs [ nregs ++ ] = tmp = gen_reg_rtx ( HImode ) ; emit_move_insn ( tmp , adjust_address ( orig_src , HImode , ofs ) ) ; bytes -= <NUM_LIT> ; ofs += <NUM_LIT> ; } while ( bytes >= <NUM_LIT> ) ; } else if ( ! TARGET_BWX ) { data_regs [ nregs ++ ] = tmp = gen_reg_rtx ( HImode ) ; alpha_expand_unaligned_load ( tmp , orig_src , <NUM_LIT> , ofs , <NUM_LIT> ) ; bytes -= <NUM_LIT> ; ofs += <NUM_LIT> ; } } while ( bytes > <NUM_LIT> ) { data_regs [ nregs ++ ] = tmp = gen_reg_rtx ( QImode ) ; emit_move_insn ( tmp , adjust_address ( orig_src , QImode , ofs ) ) ; bytes -= <NUM_LIT> ; ofs += <NUM_LIT> ; } gcc_assert ( nregs <= ARRAY_SIZE ( data_regs ) ) ; i = <NUM_LIT> , ofs = <NUM_LIT> ; if ( dst_align >= <NUM_LIT> ) { while ( i < nregs && GET_MODE ( data_regs [ i ] ) == DImode ) { emit_move_insn ( adjust_address ( orig_dst , DImode , ofs ) , data_regs [ i ] ) ; ofs += <NUM_LIT> ; i ++ ; } } if ( dst_align >= <NUM_LIT> ) { while ( i < nregs && GET_MODE ( data_regs [ i ] ) == DImode ) { tmp = expand_binop ( DImode , lshr_optab , data_regs [ i ] , GEN_INT ( <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( adjust_address ( orig_dst , SImode , ofs ) , gen_lowpart ( SImode , data_regs [ i ] ) ) ; emit_move_insn ( adjust_address ( orig_dst , SImode , ofs + <NUM_LIT> ) , gen_lowpart ( SImode , tmp ) ) ; ofs += <NUM_LIT> ; i ++ ; } while ( i < nregs && GET_MODE ( data_regs [ i ] ) == SImode ) { emit_move_insn ( adjust_address ( orig_dst , SImode , ofs ) , data_regs [ i ] ) ; ofs += <NUM_LIT> ; i ++ ; } } if ( i < nregs && GET_MODE ( data_regs [ i ] ) == DImode ) { for ( words = <NUM_LIT> ; i + words < nregs ; words ++ ) if ( GET_MODE ( data_regs [ i + words ] ) != DImode ) break ; if ( words == <NUM_LIT> ) alpha_expand_unaligned_store ( orig_dst , data_regs [ i ] , <NUM_LIT> , ofs ) ; else alpha_expand_unaligned_store_words ( data_regs + i , orig_dst , words , ofs ) ; i += words ; ofs += words * <NUM_LIT> ; } while ( i < nregs && GET_MODE ( data_regs [ i ] ) ==


<s> rtx handler_slot = gen_rtx_MEM ( DImode , handler_slot_address ) ; emit_move_insn ( target , handler_slot


<s> op0 = gen_lowpart ( mode , op0 ) ; if ( op1 == const0_rtx ) op1 = CONST0_RTX ( mode ) ; else op1 = gen_lowpart ( mode , op1 ) ; if ( op2 == const0_rtx ) op2 = CONST0_RTX ( mode ) ; else op2 = gen_lowpart ( mode


<s> mod_f = operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; addr = XEXP ( mem , <NUM_LIT> ) ; gcc_assert ( register_operand ( addr , DImode ) ) ; align = expand_simple_binop ( Pmode , AND , addr , GEN_INT ( - <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; oldval = convert_modes ( DImode , mode


<s> rtx addr , align , wdst ; cond = operands [ <NUM_LIT> ] ; dst = operands [ <NUM_LIT> ] ; mem = operands [ <NUM_LIT> ] ; oldval = operands [ <NUM_LIT> ] ; newval = operands [ <NUM_LIT> ] ; is_weak = operands [ <NUM_LIT> ] ; mod_s = operands [ <NUM_LIT> ] ; mod_f = operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; addr = XEXP ( mem , <NUM_LIT> ) ; gcc_assert ( register_operand ( addr , DImode ) ) ; align = expand_simple_binop ( Pmode , AND , addr , GEN_INT ( - <NUM_LIT> ) , NULL_RTX


<s> if ( MEM_P ( operands [ <NUM_LIT> ] ) && ! reg_or_0_operand ( operands [ <NUM_LIT> ] , mode ) ) operands [ <NUM_LIT> ] = force_reg ( mode , operands [ <NUM_LIT> ] ) ; if ( mode == Pmode && symbolic_operand ( operands [ <NUM_LIT> ] , mode ) ) { tmp = alpha_legitimize_address_1 ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , mode ) ; if ( tmp ) { if ( tmp == operands [ <NUM_LIT> ] ) return true ; operands [ <NUM_LIT> ] = tmp ; return false ; } } if ( ! CONSTANT_P ( operands [ <NUM_LIT> ] ) || input_operand ( operands [ <NUM_LIT> ] , mode ) ) return false ; if ( CONST_INT_P ( operands [ <NUM_LIT> ] ) || GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_VECTOR ) { if ( alpha_split_const_mov ( mode , operands ) ) return true ; } tmp = force_const_mem ( mode , operands [ <NUM_LIT> ] ) ; if ( tmp == NULL_RTX ) return false ; if ( reload_in_progress ) { emit_move_insn ( operands [ <NUM_LIT> ] , XEXP ( tmp , <NUM_LIT> ) ) ; operands [ <NUM_LIT> ] = replace_equiv_address ( tmp , operands


<s> else if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { if ( ! reg_or_0_operand ( operands [ <NUM_LIT> ] , mode ) ) operands [ <NUM_LIT> ] = force_reg ( mode , operands [ <NUM_LIT> ] ) ; alpha_expand_unaligned_store ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT>


<s> } } else { rtx temp1 , temp2 , subtarget , ua ; bool copyout ; temp1 = gen_reg_rtx ( DImode ) ; temp2 = gen_reg_rtx ( DImode ) ; subtarget = operands [ <NUM_LIT> ] ; if ( REG_P ( subtarget ) ) subtarget = gen_lowpart ( DImode , subtarget ) , copyout = false ; else subtarget = gen_reg_rtx ( DImode ) , copyout = true ; ua = get_unaligned_address ( operands [ <NUM_LIT> ] ) ; if ( mode == QImode ) seq = gen_unaligned_loadqi ( subtarget , ua , temp1 , temp2 ) ; else seq = gen_unaligned_loadhi ( subtarget , ua , temp1 , temp2 ) ; alpha_set_memflags ( seq , operands [ <NUM_LIT> ] ) ; emit_insn ( seq ) ; if ( copyout ) emit_move_insn ( operands [ <NUM_LIT> ] , gen_lowpart ( mode , subtarget ) ) ; } return true ; } if ( any_memory_operand ( operands [ <NUM_LIT> ] , mode ) ) { if ( aligned_memory_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx aligned_mem , bitnum ; rtx temp1 = gen_reg_rtx ( SImode ) ; rtx temp2 = gen_reg_rtx ( SImode ) ; get_aligned_mem ( operands [ <NUM_LIT> ] , & aligned_mem , & bitnum ) ; emit_insn ( gen_aligned_store ( aligned_mem , operands [ <NUM_LIT> ] , bitnum , temp1 , temp2 ) ) ; } else { rtx temp1 = gen_reg_rtx ( DImode ) ; rtx temp2 = gen_reg_rtx ( DImode ) ; rtx temp3 = gen_reg_rtx ( DImode ) ; rtx ua = get_unaligned_address ( operands [


<s> get_aligned_mem ( operands [ <NUM_LIT> ] , & aligned_mem , & bitnum ) ; subtarget = operands [ <NUM_LIT> ] ; if ( REG_P ( subtarget ) ) subtarget = gen_lowpart ( DImode , subtarget ) , copyout = false ; else subtarget = gen_reg_rtx ( DImode ) , copyout = true ; if ( mode == QImode ) seq = gen_aligned_loadqi ( subtarget , aligned_mem , bitnum , scratch ) ; else seq = gen_aligned_loadhi ( subtarget , aligned_mem , bitnum , scratch ) ; emit_insn ( seq ) ; if ( copyout ) emit_move_insn ( operands [ <NUM_LIT> ] , gen_lowpart ( mode , subtarget ) ) ; } } else { rtx temp1 , temp2 , subtarget , ua ; bool copyout ; temp1 = gen_reg_rtx ( DImode ) ; temp2 = gen_reg_rtx ( DImode ) ; subtarget = operands [ <NUM_LIT> ] ; if ( REG_P ( subtarget ) ) subtarget = gen_lowpart ( DImode , subtarget ) , copyout = false ; else subtarget = gen_reg_rtx ( DImode ) , copyout = true ; ua = get_unaligned_address ( operands [ <NUM_LIT> ] ) ; if ( mode == QImode ) seq = gen_unaligned_loadqi ( subtarget , ua , temp1 , temp2 ) ; else seq = gen_unaligned_loadhi ( subtarget , ua , temp1 , temp2 ) ; alpha_set_memflags ( seq , operands [ <NUM_LIT> ] ) ; emit_insn ( seq ) ; if ( copyout ) emit_move_insn ( operands [ <NUM_LIT> ] , gen_lowpart ( mode , subtarget ) ) ; } return true ; } if ( any_memory_operand ( operands [ <NUM_LIT> ] , mode ) ) { if ( aligned_memory_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx aligned_mem , bitnum ; rtx temp1 = gen_reg_rtx ( SImode ) ; rtx temp2 = gen_reg_rtx ( SImode ) ; get_aligned_mem ( operands [ <NUM_LIT> ] , & aligned_mem , & bitnum ) ; emit_insn ( gen_aligned_store ( aligned_mem , operands [ <NUM_LIT> ] , bitnum , temp1 , temp2 ) ) ; } else { rtx temp1 = gen_reg_rtx ( DImode ) ; rtx temp2 = gen_reg_rtx


<s> emit_insn ( gen_zero_extendqidi2 ( exth , memh ) ) ; exth = expand_simple_binop ( DImode , ASHIFT , exth , GEN_INT ( <NUM_LIT> ) , NULL , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; addr = expand_simple_binop ( DImode , IOR , extl , exth , NULL , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; if ( sign && GET_MODE ( tgt ) != HImode ) { addr = gen_lowpart ( HImode , addr ) ; emit_insn ( gen_extend_insn ( tgt , addr , GET_MODE ( tgt ) , HImode , <NUM_LIT> ) ) ; } else { if ( GET_MODE ( tgt ) != DImode ) addr = gen_lowpart ( GET_MODE ( tgt ) , addr ) ; emit_move_insn ( tgt , addr ) ; } return ; } meml = gen_reg_rtx ( DImode ) ; memh = gen_reg_rtx ( DImode ) ; addr = gen_reg_rtx ( DImode ) ; extl = gen_reg_rtx ( DImode ) ; exth = gen_reg_rtx ( DImode ) ; mema = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( mema ) == LO_SUM ) mema = force_reg ( Pmode , mema ) ; tmp = change_address ( mem , DImode , gen_rtx_AND ( DImode , plus_constant ( DImode , mema , ofs ) , GEN_INT ( - <NUM_LIT> ) ) ) ; set_mem_alias_set ( tmp , <NUM_LIT> ) ; emit_move_insn ( meml , tmp ) ; tmp = change_address ( mem , DImode , gen_rtx_AND ( DImode , plus_constant ( DImode , mema , ofs + size - <NUM_LIT> ) , GEN_INT ( - <NUM_LIT> ) ) ) ; set_mem_alias_set ( tmp , <NUM_LIT> ) ; emit_move_insn ( memh , tmp ) ; if ( sign && size ==


<s> return ; } dstl = gen_reg_rtx ( DImode ) ; dsth = gen_reg_rtx ( DImode ) ; insl = gen_reg_rtx ( DImode ) ; insh = gen_reg_rtx ( DImode ) ; dsta = XEXP ( dst , <NUM_LIT> ) ; if ( GET_CODE ( dsta ) == LO_SUM ) dsta = force_reg ( Pmode , dsta ) ; meml = change_address ( dst , DImode , gen_rtx_AND ( DImode , plus_constant ( DImode , dsta , ofs ) , GEN_INT ( - <NUM_LIT> ) ) ) ; set_mem_alias_set ( meml , <NUM_LIT> ) ; memh = change_address ( dst , DImode , gen_rtx_AND ( DImode , plus_constant ( DImode , dsta , ofs + size - <NUM_LIT> ) , GEN_INT ( - <NUM_LIT> ) ) ) ; set_mem_alias_set ( memh , <NUM_LIT> ) ; emit_move_insn ( dsth , memh ) ; emit_move_insn ( dstl , meml ) ; addr = copy_addr_to_reg ( plus_constant ( Pmode , dsta , ofs ) ) ; if ( src != CONST0_RTX ( GET_MODE ( src ) ) ) { emit_insn ( gen_insxh ( insh , gen_lowpart ( DImode , src ) , GEN_INT ( size * <NUM_LIT> ) , addr ) ) ; switch ( ( int ) size ) { case <NUM_LIT> : emit_insn ( gen_inswl ( insl , gen_lowpart ( HImode , src ) , addr ) ) ; break ; case <NUM_LIT> : emit_insn ( gen_insll ( insl , gen_lowpart ( SImode , src ) , addr ) ) ; break ; case


<s> st_addr_1 = change_address ( dmem , DImode , gen_rtx_AND ( DImode , dmema , im8 ) ) ; set_mem_alias_set ( st_addr_1 , <NUM_LIT> ) ; emit_move_insn ( st_tmp_2 , st_addr_2 ) ; emit_move_insn ( st_tmp_1 , st_addr_1 ) ; dreg = copy_addr_to_reg ( dmema ) ; if ( data_regs != NULL ) { for ( i = words - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { emit_insn ( gen_insqh ( ins_tmps [ i ] , data_regs [ i ] , dreg ) ) ; emit_insn ( gen_insql ( data_regs [ i ] , data_regs [ i ] , dreg ) ) ; } for ( i = words - <NUM_LIT> ; i > <NUM_LIT> ; -- i ) { ins_tmps [ i - <NUM_LIT> ] = expand_binop ( DImode , ior_optab , data_regs [ i ] , ins_tmps [ i - <NUM_LIT> ] , ins_tmps [ i - <NUM_LIT> ] ,


<s> if ( ! ( ( value >> i ) & <NUM_LIT> ) ) mask |= <NUM_LIT> ; } result = gen_int_mode ( mask , DImode


<s> if ( GET_CODE ( x ) == CONST_VECTOR ) x = simplify_subreg ( DImode , x , GET_MODE ( x ) , <NUM_LIT> ) ; gcc_assert ( CONST_INT_P ( x ) )


<s> fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_ABI_OSF ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_EXPLICIT_RELOCS ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_SUPPORT_ARCH | TARGET_BWX | TARGET_MAX | TARGET_FIX | TARGET_CIX ) { const char * arch ; if ( alpha_cpu == PROCESSOR_EV6 || TARGET_FIX || TARGET_CIX ) arch = <STR_LIT> ; else if ( TARGET_MAX ) arch = <STR_LIT> ; else if ( TARGET_BWX ) arch = <STR_LIT> ; else if ( alpha_cpu == PROCESSOR_EV5 ) arch = <STR_LIT> ; else arch = <STR_LIT> ; fprintf ( asm_out_file , <STR_LIT> ,


<s> FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) { const_rtx x = *


<s> case ALPHA_BUILTIN_EXTQH : return alpha_fold_builtin_extxx ( op , opint , op_const , <NUM_LIT> , true ) ; case ALPHA_BUILTIN_INSBL : return alpha_fold_builtin_insxx ( op , opint , op_const , <NUM_LIT> , false ) ; case ALPHA_BUILTIN_INSWL : return alpha_fold_builtin_insxx ( op , opint , op_const , <NUM_LIT> , false ) ; case ALPHA_BUILTIN_INSLL : return alpha_fold_builtin_insxx ( op , opint , op_const , <NUM_LIT> , false ) ; case ALPHA_BUILTIN_INSQL : return alpha_fold_builtin_insxx ( op , opint , op_const , <NUM_LIT> , false ) ; case ALPHA_BUILTIN_INSWH : return alpha_fold_builtin_insxx ( op , opint , op_const , <NUM_LIT> , true ) ; case ALPHA_BUILTIN_INSLH : return alpha_fold_builtin_insxx ( op , opint , op_const , <NUM_LIT> , true ) ; case ALPHA_BUILTIN_INSQH : return alpha_fold_builtin_insxx ( op , opint , op_const , <NUM_LIT> , true ) ; case ALPHA_BUILTIN_MSKBL : return alpha_fold_builtin_mskxx ( op , opint , op_const , <NUM_LIT> , false ) ; case ALPHA_BUILTIN_MSKWL : return alpha_fold_builtin_mskxx ( op , opint , op_const , <NUM_LIT> , false ) ; case ALPHA_BUILTIN_MSKLL : return alpha_fold_builtin_mskxx ( op , opint , op_const , <NUM_LIT> , false ) ; case ALPHA_BUILTIN_MSKQL : return alpha_fold_builtin_mskxx ( op , opint , op_const , <NUM_LIT> , false ) ; case ALPHA_BUILTIN_MSKWH : return alpha_fold_builtin_mskxx ( op , opint , op_const , <NUM_LIT> , true ) ; case ALPHA_BUILTIN_MSKLH : return alpha_fold_builtin_mskxx ( op , opint , op_const , <NUM_LIT> , true ) ; case ALPHA_BUILTIN_MSKQH : return alpha_fold_builtin_mskxx ( op , opint , op_const , <NUM_LIT> , true ) ; case ALPHA_BUILTIN_ZAP : opint [ <NUM_LIT> ] ^= <NUM_LIT> ; case ALPHA_BUILTIN_ZAPNOT : return alpha_fold_builtin_zapnot ( op , opint , op_const ) ; case ALPHA_BUILTIN_MINUB8 : return alpha_fold_vector_minmax ( MIN_EXPR , op , alpha_v8qi_u ) ; case ALPHA_BUILTIN_MINSB8 : return alpha_fold_vector_minmax ( MIN_EXPR , op , alpha_v8qi_s ) ; case ALPHA_BUILTIN_MINUW4 : return alpha_fold_vector_minmax ( MIN_EXPR , op , alpha_v4hi_u ) ; case ALPHA_BUILTIN_MINSW4 : return alpha_fold_vector_minmax ( MIN_EXPR , op , alpha_v4hi_s ) ; case ALPHA_BUILTIN_MAXUB8 : return alpha_fold_vector_minmax ( MAX_EXPR , op , alpha_v8qi_u ) ; case ALPHA_BUILTIN_MAXSB8 : return alpha_fold_vector_minmax ( MAX_EXPR , op , alpha_v8qi_s ) ; case ALPHA_BUILTIN_MAXUW4 : return alpha_fold_vector_minmax ( MAX_EXPR , op , alpha_v4hi_u ) ; case ALPHA_BUILTIN_MAXSW4 : return alpha_fold_vector_minmax ( MAX_EXPR , op , alpha_v4hi_s ) ; case ALPHA_BUILTIN_PERR : return alpha_fold_builtin_perr ( opint , op_const ) ; case ALPHA_BUILTIN_PKLB : return alpha_fold_builtin_pklb ( opint , op_const ) ; case ALPHA_BUILTIN_PKWB : return alpha_fold_builtin_pkwb ( opint , op_const ) ; case ALPHA_BUILTIN_UNPKBL : return alpha_fold_builtin_unpkbl ( opint , op_const ) ; case ALPHA_BUILTIN_UNPKBW : return alpha_fold_builtin_unpkbw ( opint , op_const ) ; case


<s> unsigned HOST_WIDE_INT temp ; if ( op_const == <NUM_LIT> ) return NULL ; if ( opint [ <NUM_LIT> ] == <NUM_LIT> ) temp = <NUM_LIT> ; else temp = <NUM_LIT> - floor_log2 ( opint [ <NUM_LIT> ] ) - <NUM_LIT> ; return build_int_cst ( alpha_dimode_u


<s> if ( op_const == <NUM_LIT> ) return NULL ; if ( opint [ <NUM_LIT> ] == <NUM_LIT> ) temp = <NUM_LIT> ; else temp = exact_log2 ( opint [ <NUM_LIT> ] & - opint [ <NUM_LIT> ] ) ; return build_int_cst ( alpha_dimode_u ,


<s> static tree alpha_fold_builtin_cttz ( unsigned HOST_WIDE_INT opint [ ] , long op_const ) { unsigned HOST_WIDE_INT temp ; if ( op_const == <NUM_LIT> ) return NULL ; if ( opint [ <NUM_LIT> ] == <NUM_LIT> ) temp = <NUM_LIT> ; else temp = exact_log2 ( opint [ <NUM_LIT> ] & - opint [ <NUM_LIT> ] ) ; return build_int_cst ( alpha_dimode_u


<s> static tree alpha_fold_builtin_extxx ( tree op [ ] , unsigned HOST_WIDE_INT opint [ ] , long op_const , unsigned HOST_WIDE_INT bytemask , bool is_high ) { long zap_const = <NUM_LIT> ; tree * zap_op = NULL ; if ( op_const & <NUM_LIT> ) { unsigned HOST_WIDE_INT loc ; loc = opint [ <NUM_LIT> ] & <NUM_LIT> ; loc *= BITS_PER_UNIT ; if ( loc != <NUM_LIT> ) { if ( op_const &


<s> byteloc = ( <NUM_LIT> - ( loc * <NUM_LIT> ) ) & <NUM_LIT> ; if ( byteloc == <NUM_LIT> ) zap_op = op ; else temp >>= byteloc ; bytemask >>= <NUM_LIT> ; } else { byteloc = loc * <NUM_LIT> ; if ( byteloc == <NUM_LIT> ) zap_op = op ; else temp <<= byteloc ; } opint [ <NUM_LIT> ] = temp ; opint [ <NUM_LIT> ] =


<s> if ( op_const & <NUM_LIT> ) { unsigned HOST_WIDE_INT loc ; loc = opint [ <NUM_LIT> ] & <NUM_LIT> ; bytemask <<= loc ; if ( is_high ) bytemask >>=


<s> unsigned HOST_WIDE_INT b = ( opint [ <NUM_LIT> ] >> ( i * <NUM_LIT> ) ) & <NUM_LIT> ; if ( a >= b ) temp += a - b ; else temp +=


<s> unsigned HOST_WIDE_INT temp ; if ( op_const == <NUM_LIT> ) return NULL ; temp = opint [ <NUM_LIT> ] & <NUM_LIT> ; temp |= ( opint [ <NUM_LIT> ] >> <NUM_LIT> ) & <NUM_LIT> ; return build_int_cst ( alpha_dimode_u


<s> static tree alpha_fold_builtin_unpkbl ( unsigned HOST_WIDE_INT opint [ ] , long op_const ) { unsigned HOST_WIDE_INT


<s> static tree alpha_fold_builtin_unpkbl ( unsigned HOST_WIDE_INT opint [ ] , long op_const ) { unsigned HOST_WIDE_INT temp ; if ( op_const == <NUM_LIT> ) return NULL ; temp = opint [ <NUM_LIT> ] &


<s> if ( op_const & <NUM_LIT> ) return build_int_cst ( alpha_dimode_u , opint [ <NUM_LIT> ] & mask ) ; if ( op ) return fold_build2 ( BIT_AND_EXPR , alpha_dimode_u , op [ <NUM_LIT> ] , build_int_cst ( alpha_dimode_u , mask ) ) ; } else if ( ( op_const & <NUM_LIT> ) && opint [ <NUM_LIT> ] == <NUM_LIT> ) return build_int_cst ( alpha_dimode_u , <NUM_LIT> ) ; return NULL


<s> tree op0 = fold_convert ( vtype , op [ <NUM_LIT> ] ) ; tree op1 = fold_convert ( vtype , op [ <NUM_LIT> ] ) ; tree val = fold_build2 ( code , vtype , op0 ,


<s> if ( arg . aggregate_type_p ( ) ) basereg = <NUM_LIT> ; else { gcc_checking_assert ( ! COMPLEX_MODE_P ( arg . mode ) ) ; if ( TARGET_FPREGS && GET_MODE_CLASS ( arg . mode ) == MODE_FLOAT ) basereg = <NUM_LIT> + <NUM_LIT> ; else basereg = <NUM_LIT> ; } { if ( arg . end_marker_p ( ) ) return alpha_arg_info_reg_val ( * cum ) ; num_args = cum -> num_args ; if ( num_args >= <NUM_LIT> || targetm . calls . must_pass_in_stack ( arg ) ) return NULL_RTX ; } { if ( * cum >= <NUM_LIT> ) return NULL_RTX ; num_args = * cum ; if ( arg . end_marker_p ( ) ) basereg = <NUM_LIT> ; else if ( targetm . calls . must_pass_in_stack


<s> if ( arg . end_marker_p ( ) ) return alpha_arg_info_reg_val ( * cum ) ; num_args = cum -> num_args ; if ( num_args >= <NUM_LIT> || targetm . calls . must_pass_in_stack ( arg ) ) return NULL_RTX ; } { if ( * cum >= <NUM_LIT> ) return NULL_RTX ; num_args = * cum ; if ( arg . end_marker_p ( ) ) basereg = <NUM_LIT> ; else if ( targetm . calls . must_pass_in_stack ( arg ) ) return NULL_RTX ; } return gen_rtx_REG ( arg . mode , num_args + basereg


<s> return alpha_function_value_1 ( valtype , fn_decl_or_type


<s> static rtx alpha_function_value ( const_tree valtype , const_tree fn_decl_or_type , bool ) { return alpha_function_value_1 ( valtype , fn_decl_or_type


<s> gcc_assert ( ! valtype || ! alpha_return_in_memory ( valtype , func ) ) ; if ( valtype ) mode = TYPE_MODE ( valtype ) ; mclass = GET_MODE_CLASS ( mode ) ; switch ( mclass ) { case MODE_INT : if ( ! ( TARGET_ABI_OPEN_VMS && valtype && AGGREGATE_TYPE_P ( valtype ) ) ) PROMOTE_MODE ( mode , dummy , valtype ) ; case MODE_COMPLEX_INT : case MODE_VECTOR_INT : regnum =


<s> return ( regno == <NUM_LIT> || regno == <NUM_LIT>

|| regno == <NUM_LIT> || regno == <NUM_LIT> ) ;


<s> base = get_formal_tmp_var ( base_field , pre_p ) ; t = fold_convert ( build_nonstandard_integer_type ( <NUM_LIT> , <NUM_LIT> ) , offset_field ) ; offset = get_initialized_tmp_var ( t , pre_p , NULL ) ; indirect = pass_va_arg_by_reference ( type ) ; if ( indirect ) { if ( TREE_CODE ( type ) == COMPLEX_TYPE && targetm . calls . split_complex_arg ( type ) ) { tree real_part , imag_part , real_temp ; tree ptr_type = build_pointer_type_for_mode ( TREE_TYPE ( type ) , ptr_mode , true ) ; real_part = alpha_gimplify_va_arg_1 ( ptr_type , base , offset , pre_p ) ; real_part = build_va_arg_indirect_ref ( real_part ) ; real_temp = get_initialized_tmp_var ( real_part , pre_p , NULL ) ; imag_part = alpha_gimplify_va_arg_1 ( ptr_type , base , offset , pre_p ) ; imag_part = build_va_arg_indirect_ref ( imag_part ) ; r = build2 ( COMPLEX_EXPR , type , real_temp , imag_part ) ; gimplify_assign ( unshare_expr ( offset_field ) , fold_convert ( TREE_TYPE ( offset_field ) , offset ) , pre_p ) ; return


<s> static tree alpha_gimplify_va_arg_1 ( tree type , tree base , tree offset , gimple_seq * pre_p ) { tree type_size , ptr_type , addend , t , addr ; gimple_seq internal_post ; if ( must_pass_va_arg_in_stack ( type ) ) { t = build_int_cst ( TREE_TYPE ( offset ) , <NUM_LIT> * <NUM_LIT> ) ; gimplify_assign ( offset , build2 ( MAX_EXPR , TREE_TYPE ( offset ) , offset , t ) , pre_p ) ; } addend = offset ; ptr_type = build_pointer_type_for_mode ( type , ptr_mode , true ) ; if ( TREE_CODE ( type ) == COMPLEX_TYPE ) { tree real_part , imag_part , real_temp ; real_part = alpha_gimplify_va_arg_1 ( TREE_TYPE ( type ) , base , offset , pre_p ) ; real_temp = get_initialized_tmp_var ( real_part , pre_p , NULL ) ; imag_part = alpha_gimplify_va_arg_1 ( TREE_TYPE ( type ) , base , offset , pre_p ) ; return build2 ( COMPLEX_EXPR , type , real_temp , imag_part ) ; } else if ( TREE_CODE ( type ) == REAL_TYPE ) { tree fpaddend , cond


<s> static bool alpha_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { if ( IN_RANGE ( regno , <NUM_LIT> , <NUM_LIT> ) ) return ( mode == SFmode ||

mode == DFmode || mode == DImode || mode == SCmode || mode == DCmode ) ;


<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


<s> static void alpha_instantiate_decls ( void ) { if ( cfun -> machine -> gp_save_rtx != NULL_RTX )

instantiate_decl_rtl ( cfun -> machine -> gp_save_rtx ) ;


<s> if ( TREE_CODE ( exp ) == VAR_DECL && DECL_SECTION_NAME ( exp ) ) { const char * section = DECL_SECTION_NAME ( exp ) ; if ( strcmp ( section , <STR_LIT> ) == <NUM_LIT> || strcmp

( section , <STR_LIT> ) == <NUM_LIT> ) return true ;


<s> if ( mode == DImode && GET_CODE ( x ) == AND && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && INTVAL ( XEXP ( x , <NUM_LIT> ) ) == - <NUM_LIT> ) x = XEXP ( x , <NUM_LIT> ) ; if ( SUBREG_P ( x ) && ( GET_MODE_SIZE ( GET_MODE ( x ) ) < GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( x ) ) ) ) ) x = SUBREG_REG ( x ) ; if ( REG_P ( x ) && ( strict ? STRICT_REG_OK_FOR_BASE_P ( x ) : NONSTRICT_REG_OK_FOR_BASE_P ( x ) ) ) return true ; if ( CONSTANT_ADDRESS_P ( x ) ) return true ; if ( LINKAGE_SYMBOL_REF_P ( x ) ) return true ; if ( GET_CODE ( x ) == PLUS ) { rtx ofs = XEXP ( x , <NUM_LIT> ) ; x = XEXP ( x , <NUM_LIT> ) ; if ( SUBREG_P ( x ) && ( GET_MODE_SIZE ( GET_MODE ( x ) ) < GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( x ) ) ) ) ) x = SUBREG_REG ( x ) ; if ( REG_P ( x ) ) { if ( ! strict && NONSTRICT_REG_OK_FP_BASE_P ( x ) && CONST_INT_P ( ofs ) ) return true ; if ( ( strict ? STRICT_REG_OK_FOR_BASE_P ( x ) : NONSTRICT_REG_OK_FOR_BASE_P ( x ) ) && CONSTANT_ADDRESS_P ( ofs ) ) return true ; } } else if ( TARGET_EXPLICIT_RELOCS && GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ) { if ( small_symbolic_operand ( x , Pmode ) )


<s> if ( SUBREG_P ( x ) && ( GET_MODE_SIZE ( GET_MODE ( x ) ) < GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( x ) ) ) ) ) x = SUBREG_REG ( x ) ; if ( REG_P ( x ) && ( strict ? STRICT_REG_OK_FOR_BASE_P ( x ) : NONSTRICT_REG_OK_FOR_BASE_P ( x ) ) ) return true ; if ( CONSTANT_ADDRESS_P ( x ) ) return true ; if ( LINKAGE_SYMBOL_REF_P ( x ) ) return true ; if ( GET_CODE ( x ) == PLUS ) { rtx ofs = XEXP ( x , <NUM_LIT> ) ; x = XEXP ( x , <NUM_LIT> ) ; if ( SUBREG_P ( x ) && ( GET_MODE_SIZE ( GET_MODE ( x ) ) < GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( x ) ) ) ) ) x = SUBREG_REG ( x ) ; if ( REG_P ( x ) ) { if ( ! strict && NONSTRICT_REG_OK_FP_BASE_P ( x ) && CONST_INT_P ( ofs ) ) return true ; if ( ( strict ? STRICT_REG_OK_FOR_BASE_P ( x ) : NONSTRICT_REG_OK_FOR_BASE_P ( x ) ) && CONSTANT_ADDRESS_P ( ofs ) ) return true ; } } else if ( TARGET_EXPLICIT_RELOCS && GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ) { if ( small_symbolic_operand ( x , Pmode ) ) return true ; if ( GET_CODE ( x ) == LO_SUM ) { rtx ofs = XEXP ( x , <NUM_LIT> ) ; x = XEXP ( x , <NUM_LIT> ) ; if ( SUBREG_P ( x ) && ( GET_MODE_SIZE ( GET_MODE ( x ) ) < GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( x ) ) ) ) ) x = SUBREG_REG ( x ) ; if ( ! ( REG_P ( x ) && ( strict ? STRICT_REG_OK_FOR_BASE_P ( x ) : NONSTRICT_REG_OK_FOR_BASE_P ( x ) ) ) ) return false ; if ( local_symbolic_operand ( ofs , Pmode ) || dtp32_symbolic_operand ( ofs , Pmode ) || tp32_symbolic_operand


<s> if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) x = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; else return true ; if ( GET_CODE ( x ) != SYMBOL_REF ) return true ; case SYMBOL_REF : return SYMBOL_REF_TLS_MODEL ( x ) == <NUM_LIT> ; case CONST_WIDE_INT : if ( TARGET_BUILD_CONSTANTS ) return true ; if ( x == CONST0_RTX ( mode ) ) return true ; mode =


<s> if ( TARGET_BUILD_CONSTANTS ) return true ; if ( x == CONST0_RTX ( mode ) ) return true ; mode = DImode ; gcc_assert ( CONST_WIDE_INT_NUNITS ( x ) == <NUM_LIT> ) ; i0 = CONST_WIDE_INT_ELT ( x , <NUM_LIT> ) ; if ( alpha_emit_set_const_1 ( NULL_RTX , mode , i0 , <NUM_LIT> , true ) == NULL ) return false ; i0 = CONST_WIDE_INT_ELT ( x , <NUM_LIT> ) ; goto do_integer ; case CONST_DOUBLE : if ( x == CONST0_RTX ( mode ) ) return true ; return false ; case CONST_VECTOR : if ( x == CONST0_RTX ( mode ) ) return true ; if ( GET_MODE_CLASS ( mode ) != MODE_VECTOR_INT ) return false ; if ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) return false ; case CONST_INT : if ( TARGET_BUILD_CONSTANTS ) return true ; i0 = alpha_extract_integer ( x ) ; do_integer : return alpha_emit_set_const_1 ( NULL_RTX , mode , i0 , <NUM_LIT> , true ) != NULL ; default : return false


<s> static rtx alpha_legitimize_address ( rtx x , rtx oldx ATTRIBUTE_UNUSED , machine_mode mode ) { rtx new_x = alpha_legitimize_address_1 ( x , NULL_RTX


<s> static rtx alpha_legitimize_address ( rtx x , rtx oldx ATTRIBUTE_UNUSED , machine_mode mode ) { rtx new_x = alpha_legitimize_address_1 ( x , NULL_RTX ,


<s> if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && REG_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { push_reload ( XEXP ( x , <NUM_LIT> ) , NULL_RTX , & XEXP ( x , <NUM_LIT> ) , NULL , BASE_REG_CLASS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; return x ; } if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && REGNO ( XEXP ( x , <NUM_LIT> ) ) < FIRST_PSEUDO_REGISTER && REGNO_OK_FOR_BASE_P ( REGNO ( XEXP ( x , <NUM_LIT> ) ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { HOST_WIDE_INT val = INTVAL ( XEXP ( x , <NUM_LIT> ) ) ; HOST_WIDE_INT low = ( ( val & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; HOST_WIDE_INT high = ( ( ( val - low ) & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; if ( high + low != val ) return NULL_RTX ; x = gen_rtx_PLUS ( GET_MODE ( x ) , gen_rtx_PLUS ( GET_MODE ( x ) , XEXP ( x , <NUM_LIT> ) , GEN_INT ( high ) ) , GEN_INT ( low ) ) ; push_reload ( XEXP ( x , <NUM_LIT> ) , NULL_RTX , & XEXP ( x , <NUM_LIT> ) , NULL , BASE_REG_CLASS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; return


<s> return x ; } if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && REGNO ( XEXP ( x , <NUM_LIT> ) ) < FIRST_PSEUDO_REGISTER && REGNO_OK_FOR_BASE_P ( REGNO ( XEXP ( x , <NUM_LIT> ) ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { HOST_WIDE_INT val = INTVAL ( XEXP ( x , <NUM_LIT> ) ) ; HOST_WIDE_INT low = ( ( val & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; HOST_WIDE_INT high = ( ( ( val - low ) & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; if ( high + low != val ) return NULL_RTX ; x = gen_rtx_PLUS ( GET_MODE ( x ) , gen_rtx_PLUS ( GET_MODE ( x ) , XEXP (

x , <NUM_LIT> ) , GEN_INT ( high ) ) , GEN_INT ( low ) ) ;


<s> static bool alpha_linkage_symbol_p ( const char * symname ) { int symlen = strlen ( symname


<s> static bool alpha_linkage_symbol_p ( const char * symname ) { int symlen = strlen ( symname ) ; if ( symlen > <NUM_LIT> ) return strcmp ( & symname [

symlen - <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ;


<s> long i ; gcc_assert ( TARGET_HAS_XFLOATING_LIBS ) ; if ( TARGET_FLOAT_VAX && ( code == FLOAT_EXTEND || code == FLOAT_TRUNCATE ) ) { ops = vax_cvt_ops ; n = ARRAY_SIZE ( vax_cvt_ops ) ; } for ( i = <NUM_LIT> ; i < n ; ++ i , ++ ops ) if ( ops -> code == code ) { rtx func = ops -> libcall ; if ( ! func ) { func = init_one_libfunc ( TARGET_ABI_OPEN_VMS ? ops


<s> static const char * alpha_mangle_type ( const_tree type ) { if ( TYPE_MAIN_VARIANT ( type ) == long_double_type_node && TARGET_LONG_DOUBLE_128 ) return <STR_LIT> ; return NULL


<s> static int alpha_memory_move_cost ( machine_mode , reg_class_t , bool ) { return <NUM_LIT>


<s> static int alpha_multipass_dfa_lookahead ( void ) { return ( alpha_tune == PROCESSOR_EV6 ? <NUM_LIT>


<s> static int alpha_multipass_dfa_lookahead ( void


<s> else if ( ! flag_inhibit_size_directive ) fprintf ( file , <STR_LIT>

, alpha_function_needs_gp || cfun -> is_thunk ) ;


<s> else { rtx tmp = alpha_emit_set_long_const ( gen_rtx_REG ( Pmode , <NUM_LIT> ) , delta ) ; emit_insn ( gen_adddi3 ( this_rtx , this_rtx , tmp ) ) ; } if ( vcall_offset ) { rtx tmp , tmp2 ; tmp = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , this_rtx ) ) ; lo = ( ( vcall_offset & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; hi = ( ( ( vcall_offset - lo ) & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; if ( hi + lo == vcall_offset ) { if ( hi ) emit_insn ( gen_adddi3 ( tmp , tmp , GEN_INT ( hi ) ) ) ; } else { tmp2 = alpha_emit_set_long_const ( gen_rtx_REG ( Pmode , <NUM_LIT> ) , vcall_offset ) ; emit_insn ( gen_adddi3 ( tmp , tmp , tmp2 ) ) ; lo = <NUM_LIT> ; } if ( lo ) tmp2 = gen_rtx_PLUS ( Pmode , tmp , GEN_INT ( lo ) ) ; else tmp2 = tmp ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , tmp2 ) ) ; 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 ) ; insn = emit_call_insn ( gen_sibcall ( funexp , const0_rtx ) ) ; SIBLING_CALL_P ( insn ) = <NUM_LIT> ; insn = get_insns


<s> if ( flag_align_loops && ! str_align_loops ) str_align_loops = <STR_LIT> ; if ( flag_align_jumps && ! str_align_jumps


<s> if ( arg . mode == SFmode || arg . mode == SCmode


<s> static bool alpha_pass_by_reference ( cumulative_args_t , const function_arg_info & arg ) { if ( arg . mode == SFmode || arg . mode ==


<s> if ( need_atomic_barrier_p ( model , false ) ) emit_insn ( gen_memory_barrier (


<s> if ( need_atomic_barrier_p ( model , true ) ) emit_insn


<s> static bool alpha_print_operand_punct_valid_p ( unsigned char code ) { return ( code == '/' || code == ',' || code == '-' || code == '~' || code == '#' || code


<s> if ( ( from == FLOAT_REGS ) == ( to == FLOAT_REGS ) ) return <NUM_LIT> ; if ( TARGET_FIX ) return ( from == FLOAT_REGS


<s> if ( GET_CODE ( pat ) == PARALLEL ) { rtx vec = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( vec ) == TRAP_IF && XEXP ( vec , <NUM_LIT> ) == const1_rtx ) emit_insn_after ( gen_unop


<s> static void alpha_reorg ( void ) { if ( current_function_has_exception_handlers ( ) ) alpha_pad_function_end ( ) ; rtx_insn * insn = prev_active_insn ( get_last_insn ( ) ) ; if ( insn && NONJUMP_INSN_P ( insn ) ) { rtx pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == PARALLEL ) { rtx vec = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( vec ) == TRAP_IF && XEXP ( vec , <NUM_LIT> ) == const1_rtx ) emit_insn_after (


<s> if ( TARGET_ABI_OPEN_VMS && TREE_CODE ( type ) != ARRAY_TYPE && ( unsigned HOST_WIDE_INT ) int_size_in_bytes ( type ) <= <NUM_LIT> ) return false ; if ( AGGREGATE_TYPE_P ( type ) ) return true ; } size = GET_MODE_SIZE ( mode ) ; switch ( GET_MODE_CLASS ( mode ) ) { case MODE_VECTOR_FLOAT : return true ; case MODE_COMPLEX_FLOAT : size = GET_MODE_UNIT_SIZE ( mode ) ; break ; case MODE_INT : case


<s> if ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> ) return mode ; return mode_for_size ( BITS_PER_WORD , GET_MODE_CLASS ( mode )


<s> } * pretend_size = <NUM_LIT> * UNITS_PER_WORD ; } if ( cum >= <NUM_LIT> ) return ; if ( ! no_rtl ) { int count ; alias_set_type set = get_varargs_alias_set ( ) ; rtx tmp ; count = cfun -> va_list_gpr_size / UNITS_PER_WORD ; if ( count > <NUM_LIT> - cum ) count = <NUM_LIT> - cum ; gcc_assert ( ( VA_LIST_MAX_FPR_SIZE & <NUM_LIT> ) == <NUM_LIT> ) ; if ( cfun -> va_list_fpr_size & <NUM_LIT> ) { tmp = gen_rtx_MEM ( BLKmode , plus_constant ( Pmode , virtual_incoming_args_rtx , ( cum + <NUM_LIT> ) * UNITS_PER_WORD ) ) ; MEM_NOTRAP_P ( tmp ) = <NUM_LIT> ; set_mem_alias_set ( tmp , set ) ; move_block_from_reg ( <NUM_LIT> + cum , tmp , count


<s> for ( insn = as_a < rtx_insn * > ( seq ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) ) FOR_EACH_SUBRTX_VAR ( iter , array , PATTERN ( insn ) , NONCONST ) { rtx x = * iter ; if ( MEM_P ( x ) ) { MEM_VOLATILE_P ( x ) = MEM_VOLATILE_P ( ref


<s> for ( insn = as_a < rtx_insn * > ( seq ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) ) FOR_EACH_SUBRTX_VAR ( iter , array , PATTERN ( insn ) , NONCONST ) { rtx x = * iter ; if ( MEM_P ( x ) ) { MEM_VOLATILE_P ( x ) = MEM_VOLATILE_P ( ref ) ; MEM_NOTRAP_P ( x ) = MEM_NOTRAP_P ( ref ) ; MEM_READONLY_P ( x ) = MEM_READONLY_P ( ref ) ; iter . skip_subrtxes (


<s> emit_label ( XEXP ( label , <NUM_LIT> ) ) ; emit_insn ( gen_load_locked ( mode , retval , mem ) ) ; emit_move_insn ( scratch , val ) ; emit_insn ( gen_store_conditional ( mode , cond , mem , scratch ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; emit_unlikely_jump ( x ,


<s> addr = XEXP ( orig_mem , <NUM_LIT> ) ; mem = gen_rtx_MEM ( DImode , align ) ; MEM_VOLATILE_P ( mem ) = MEM_VOLATILE_P ( orig_mem ) ; if ( MEM_ALIAS_SET ( orig_mem ) == ALIAS_SET_MEMORY_BARRIER ) set_mem_alias_set ( mem , ALIAS_SET_MEMORY_BARRIER ) ; alpha_pre_atomic_barrier ( model ) ; label = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label , <NUM_LIT> ) ) ; emit_insn ( gen_load_locked ( DImode , scratch , mem ) ) ; width = GEN_INT ( GET_MODE_BITSIZE ( mode ) ) ; mask = GEN_INT ( mode == QImode ? <NUM_LIT> :


<s> rtx label , mem , width , mask , x ; machine_mode mode ; enum memmodel model ; dest = operands [ <NUM_LIT> ] ; orig_mem = operands [ <NUM_LIT> ] ; val = operands [ <NUM_LIT> ] ; align = operands [ <NUM_LIT> ] ; model = ( enum memmodel ) INTVAL ( operands [ <NUM_LIT> ] ) ; scratch = operands [ <NUM_LIT> ] ; mode = GET_MODE ( orig_mem ) ; addr = XEXP ( orig_mem , <NUM_LIT> ) ; mem = gen_rtx_MEM ( DImode , align ) ; MEM_VOLATILE_P ( mem ) = MEM_VOLATILE_P


<s> else x = gen_rtx_fmt_ee ( code , mode , before , val ) ; if ( after ) emit_insn ( gen_rtx_SET ( after , copy_rtx ( x ) ) ) ; emit_insn ( gen_rtx_SET ( scratch , x ) ) ; emit_insn ( gen_store_conditional ( mode , cond , mem , scratch ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; emit_unlikely_jump ( x , label ) ; alpha_post_atomic_barrier ( model


<s> } else x = gen_rtx_fmt_ee ( code , mode , before , val ) ; if ( after ) emit_insn ( gen_rtx_SET ( after , copy_rtx ( x ) ) ) ; emit_insn ( gen_rtx_SET ( scratch , x ) ) ; emit_insn ( gen_store_conditional ( mode , cond , mem , scratch ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; emit_unlikely_jump ( x , label


<s> emit_move_insn ( cond , const0_rtx ) ; x = gen_rtx_NE ( DImode , x , const0_rtx ) ; } else { x = gen_rtx_EQ ( DImode , x , oldval ) ; emit_insn ( gen_rtx_SET ( cond , x ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; } emit_unlikely_jump ( x , label2 ) ; emit_move_insn ( cond , newval ) ; emit_insn ( gen_store_conditional ( mode , cond , mem , gen_lowpart ( mode , cond ) ) ) ; if ( ! is_weak ) { x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; emit_unlikely_jump ( x , label1 ) ; } if ( ! is_mm_relaxed ( mod_f ) ) emit_label ( XEXP ( label2 , <NUM_LIT> ) ) ; alpha_post_atomic_barrier ( mod_s ) ; if ( is_mm_relaxed ( mod_f ) ) emit_label ( XEXP ( label2 , <NUM_LIT>


<s> rtx label1 , label2 , x ; cond = operands [ <NUM_LIT> ] ; retval = operands [ <NUM_LIT> ] ; mem = operands [ <NUM_LIT> ] ; oldval = operands [ <NUM_LIT> ] ; newval = operands [ <NUM_LIT> ] ; is_weak = ( operands [ <NUM_LIT> ] != const0_rtx ) ; mod_s = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; mod_f = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; mode = GET_MODE ( mem ) ; alpha_pre_atomic_barrier ( mod_s ) ; label1 = NULL_RTX ; if ( ! is_weak ) { label1 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label1 , <NUM_LIT> ) ) ; } label2 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_insn ( gen_load_locked ( mode , retval , mem ) ) ; x = gen_lowpart ( DImode , retval ) ; if ( oldval == const0_rtx ) { emit_move_insn ( cond , const0_rtx ) ; x = gen_rtx_NE ( DImode , x , const0_rtx ) ; } else { x = gen_rtx_EQ ( DImode , x , oldval ) ; emit_insn ( gen_rtx_SET ( cond , x ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx


<s> newval = operands [ <NUM_LIT> ] ; align = operands [ <NUM_LIT> ] ; is_weak = ( operands [ <NUM_LIT> ] != const0_rtx ) ; mod_s = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; mod_f = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; scratch = operands [ <NUM_LIT> ] ; mode = GET_MODE ( orig_mem ) ; addr = XEXP ( orig_mem , <NUM_LIT> ) ; mem = gen_rtx_MEM ( DImode , align ) ; MEM_VOLATILE_P ( mem ) = MEM_VOLATILE_P ( orig_mem ) ; if ( MEM_ALIAS_SET ( orig_mem ) == ALIAS_SET_MEMORY_BARRIER ) set_mem_alias_set ( mem , ALIAS_SET_MEMORY_BARRIER ) ; alpha_pre_atomic_barrier ( mod_s ) ; label1 = NULL_RTX ; if ( ! is_weak ) { label1 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label1 , <NUM_LIT> ) ) ; } label2 = gen_rtx_LABEL_REF ( DImode ,


<s> static bool alpha_split_complex_arg ( const_tree type ) { return TYPE_MODE ( type


<s> static bool alpha_split_complex_arg ( const_tree type ) { return TYPE_MODE ( type )


<s> code = reverse_condition ( code ) ; std :: swap ( t , f ) ; diff = - diff ; } subtarget = target = dest ; if ( mode != DImode ) { target = gen_lowpart ( DImode , dest ) ; if ( can_create_pseudo_p ( ) ) subtarget = gen_reg_rtx ( DImode ) ; else subtarget = target ; } if ( f == <NUM_LIT> && exact_log2 ( diff ) > <NUM_LIT> && ( diff <= <NUM_LIT> || alpha_tune == PROCESSOR_EV6 ) ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; tmp = gen_rtx_ASHIFT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( exact_log2 ( t ) ) ) ; emit_insn ( gen_rtx_SET ( target , tmp ) ) ; } else if ( f == <NUM_LIT> && t == - <NUM_LIT> ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; emit_insn ( gen_negdi2 ( target , copy_rtx ( subtarget ) ) ) ; } else if ( diff == <NUM_LIT> || diff == <NUM_LIT> || diff == <NUM_LIT> ) { rtx add_op ; tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; if ( diff == <NUM_LIT> ) emit_insn ( gen_adddi3 ( target , copy_rtx ( subtarget ) , GEN_INT ( f ) ) ) ; else { add_op = GEN_INT ( f ) ; if ( sext_add_operand ( add_op , mode ) ) { tmp = gen_rtx_ASHIFT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( exact_log2 ( diff ) ) ) ; tmp = gen_rtx_PLUS ( DImode , tmp , add_op ) ; emit_insn ( gen_rtx_SET ( target , tmp ) ) ; } else return <NUM_LIT> ; } } else return


<s> if ( ! temp && TARGET_BUILD_CONSTANTS ) temp = alpha_emit_set_long_const ( operands [ <NUM_LIT> ] , i0 ) ; if ( temp ) { if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , temp ) ) emit_move_insn ( operands [


<s> rtx scratch ; int move ; alpha_split_tmode_pair ( operands , TFmode , false ) ; move = <NUM_LIT> ; if ( rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) move = <NUM_LIT> ; else if ( rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) { if ( rtx_equal_p ( operands [ <NUM_LIT> ] , high_bit ) ) move = <NUM_LIT> ; else move = - <NUM_LIT> ; } if ( move < <NUM_LIT> ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; scratch = operands [ move < <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ] ; emit_insn ( ( * operation ) ( scratch ,


<s> else move = - <NUM_LIT> ; } if ( move < <NUM_LIT> ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; scratch = operands [ move < <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ] ; emit_insn ( ( * operation ) ( scratch , high_bit , operands [ <NUM_LIT> ] ) ) ; if ( move


<s> HOST_WIDE_INT frame_size = cfun -> machine -> frame_size ; const HOST_WIDE_INT max_frame_size = HOST_WIDE_INT_1 << <NUM_LIT> ; HOST_WIDE_INT reg_offset ; char * entry_label = ( char * ) alloca ( strlen ( fnname ) + <NUM_LIT> ) ; char * tramp_label = ( char * ) alloca ( strlen ( fnname ) + <NUM_LIT> ) ; int i ; vms_start_function ( fnname ) ; alpha_fnname = fnname ; if ( TARGET_ABI_OPEN_VMS ) reg_offset = <NUM_LIT> + <NUM_LIT> * cfun -> machine -> uses_condition_handler ; else reg_offset = ALPHA_ROUND ( crtl -> outgoing_args_size ) ; imask = cfun -> machine -> sa_mask & <NUM_LIT> ; fmask = cfun -> machine -> sa_mask >> <NUM_LIT> ; if ( TARGET_ABI_OPEN_VMS || ! flag_inhibit_size_directive ) { fputs ( <STR_LIT> , file ) ; assemble_name ( file , fnname ) ; putc ( '\n' , file ) ; if ( TARGET_ABI_OSF && ! alpha_function_needs_gp && ! cfun -> is_thunk ) { putc ( '$' , file ) ; assemble_name ( file , fnname ) ; fputs ( <STR_LIT> , file ) ; } } if ( TARGET_ABI_OPEN_VMS && ! TREE_PUBLIC ( decl ) && DECL_CONTEXT ( decl ) && ! TYPE_P ( DECL_CONTEXT ( decl ) ) && TREE_CODE ( DECL_CONTEXT ( decl ) ) != TRANSLATION_UNIT_DECL ) { strcpy ( tramp_label , fnname ) ; strcat ( tramp_label , <STR_LIT> ) ; ASM_OUTPUT_LABEL ( file , tramp_label ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; } strcpy ( entry_label , fnname ) ; if ( TARGET_ABI_OPEN_VMS ) strcat ( entry_label , <STR_LIT> ) ; ASM_OUTPUT_LABEL ( file , entry_label ) ; inside_function = TRUE ; if ( TARGET_ABI_OPEN_VMS ) fprintf ( file , <STR_LIT> , vms_base_regno ) ; if ( TARGET_ABI_OSF && TARGET_IEEE_CONFORMANT && ! flag_inhibit_size_directive ) { fputs ( <STR_LIT> , file ) ; } alpha_auto_offset = - frame_size + crtl -> args . pretend_args_size ; alpha_arg_offset = - frame_size + <NUM_LIT> ; if ( TARGET_ABI_OPEN_VMS ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , vms_unwind_regno , frame_size >= max_frame_size ? <NUM_LIT> : frame_size , reg_offset ) ; else if ( ! flag_inhibit_size_directive ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , ( frame_pointer_needed ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM ) , frame_size >= max_frame_size ? <NUM_LIT> : frame_size , crtl -> args . pretend_args_size ) ; if ( TARGET_ABI_OPEN_VMS ) { if ( imask ) fprintf ( file , <STR_LIT> , imask & ~ ( <NUM_LIT> << REG_RA ) ) ; if ( fmask ) fprintf ( file , <STR_LIT> , fmask ) ; if ( alpha_procedure_type == PT_REGISTER ) fprintf ( file , <STR_LIT> , vms_save_fp_regno ) ; } else if ( ! flag_inhibit_size_directive ) { if ( imask


<s> putc ( '$' , file ) ; assemble_name ( file , fnname ) ; fputs ( <STR_LIT> , file ) ; } } if ( TARGET_ABI_OPEN_VMS && ! TREE_PUBLIC ( decl ) && DECL_CONTEXT ( decl ) && ! TYPE_P ( DECL_CONTEXT ( decl ) ) && TREE_CODE ( DECL_CONTEXT ( decl ) ) != TRANSLATION_UNIT_DECL ) { strcpy ( tramp_label , fnname ) ; strcat ( tramp_label , <STR_LIT> ) ; ASM_OUTPUT_LABEL ( file , tramp_label ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; } strcpy ( entry_label , fnname ) ; if ( TARGET_ABI_OPEN_VMS ) strcat ( entry_label , <STR_LIT> ) ; ASM_OUTPUT_LABEL ( file , entry_label ) ; inside_function = TRUE ; if ( TARGET_ABI_OPEN_VMS ) fprintf ( file , <STR_LIT> , vms_base_regno ) ; if ( TARGET_ABI_OSF && TARGET_IEEE_CONFORMANT && ! flag_inhibit_size_directive ) { fputs ( <STR_LIT> , file ) ; } alpha_auto_offset = - frame_size + crtl -> args . pretend_args_size ; alpha_arg_offset = - frame_size + <NUM_LIT> ; if ( TARGET_ABI_OPEN_VMS ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , vms_unwind_regno , frame_size >= max_frame_size ? <NUM_LIT> : frame_size , reg_offset ) ; else if ( ! flag_inhibit_size_directive ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , ( frame_pointer_needed ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM ) , frame_size >= max_frame_size ? <NUM_LIT> : frame_size , crtl -> args . pretend_args_size ) ; if ( TARGET_ABI_OPEN_VMS ) { if ( imask ) fprintf ( file , <STR_LIT> , imask & ~ ( <NUM_LIT> << REG_RA ) ) ; if ( fmask ) fprintf ( file , <STR_LIT> , fmask ) ; if ( alpha_procedure_type == PT_REGISTER ) fprintf ( file , <STR_LIT> , vms_save_fp_regno ) ; } else if ( ! flag_inhibit_size_directive


<s> base_stmt = va_list_skip_additions ( base ) ; if ( base_stmt && is_gimple_assign ( base_stmt ) && gimple_assign_rhs_code ( base_stmt ) == COMPONENT_REF ) base = gimple_assign_rhs1 ( base_stmt ) ; } if ( TREE_CODE ( base ) != COMPONENT_REF || TREE_OPERAND ( base , <NUM_LIT> ) != TYPE_FIELDS ( va_list_type_node ) ) return false ; offset_arg = <NUM_LIT> ; } base = get_base_address ( base ) ; if ( TREE_CODE ( base ) != VAR_DECL || ! bitmap_bit_p ( si -> va_list_vars , DECL_UID ( base ) + num_ssa_names ) ) return false ; offset = gimple_op ( stmt , <NUM_LIT> + offset_arg ) ; if ( TREE_CODE ( offset ) == SSA_NAME ) { gimple * offset_stmt = va_list_skip_additions ( offset ) ; if ( offset_stmt && gimple_code ( offset_stmt ) == GIMPLE_PHI ) { HOST_WIDE_INT sub ; gimple * arg1_stmt , * arg2_stmt ; tree arg1 , arg2 ; enum tree_code code1 , code2 ; if ( gimple_phi_num_args ( offset_stmt ) != <NUM_LIT> ) goto escapes ; arg1_stmt = va_list_skip_additions ( gimple_phi_arg_def ( offset_stmt , <NUM_LIT> ) ) ; arg2_stmt = va_list_skip_additions ( gimple_phi_arg_def ( offset_stmt , <NUM_LIT> ) ) ; if ( arg1_stmt == NULL || ! is_gimple_assign ( arg1_stmt ) || arg2_stmt == NULL || ! is_gimple_assign ( arg2_stmt ) ) goto escapes ; code1 = gimple_assign_rhs_code ( arg1_stmt ) ; code2 = gimple_assign_rhs_code ( arg2_stmt ) ; if ( code1 == COMPONENT_REF && ( code2 == MINUS_EXPR || code2 == PLUS_EXPR ) ) ; else if ( code2 == COMPONENT_REF && ( code1 == MINUS_EXPR || code1 == PLUS_EXPR ) ) { std :: swap ( arg1_stmt , arg2_stmt ) ; code2 = code1 ; } else goto escapes ; if ( ! tree_fits_shwi_p ( gimple_assign_rhs2 ( arg2_stmt ) ) ) goto escapes ; sub = tree_to_shwi ( gimple_assign_rhs2 ( arg2_stmt ) ) ; if ( code2 == MINUS_EXPR ) sub = - sub ; if ( sub < - <NUM_LIT> || sub > - <NUM_LIT> ) goto escapes ; arg1 = gimple_assign_rhs1 ( arg1_stmt ) ; arg2 = gimple_assign_rhs1 ( arg2_stmt ) ; if ( TREE_CODE ( arg2 ) == SSA_NAME ) { arg2_stmt = va_list_skip_additions ( arg2 ) ; if ( arg2_stmt == NULL || ! is_gimple_assign ( arg2_stmt ) || gimple_assign_rhs_code ( arg2_stmt ) != COMPONENT_REF ) goto escapes ; arg2 = gimple_assign_rhs1 ( arg2_stmt ) ; } if ( arg1 != arg2 ) goto escapes ; if ( TREE_CODE ( arg1 ) != COMPONENT_REF || TREE_OPERAND ( arg1 , <NUM_LIT> ) != va_list_gpr_counter_field || get_base_address ( arg1 ) != base ) goto escapes ; cfun -> va_list_fpr_size |=


<s> if ( TARGET_ABI_OPEN_VMS ) { const char * fnname ; char * trname ; fnname = XSTR ( fnaddr , <NUM_LIT> ) ; trname = ( char * ) alloca ( strlen ( fnname ) + <NUM_LIT> ) ; strcpy ( trname , fnname ) ; strcat ( trname , <STR_LIT> ) ; fnname = ggc_alloc_string ( trname , strlen ( trname ) + <NUM_LIT> ) ; word2 = gen_rtx_SYMBOL_REF ( Pmode , fnname ) ; word1 = force_reg ( DImode , gen_const_mem ( DImode , fnaddr ) ) ; word1 = expand_and ( DImode , word1 , GEN_INT ( HOST_WIDE_INT_C ( <NUM_LIT> ) ) , NULL ) ; } else { word1 = GEN_INT ( HOST_WIDE_INT_C ( <NUM_LIT> ) ) ; word2 = GEN_INT ( HOST_WIDE_INT_C ( <NUM_LIT> ) ) ; } mem = adjust_address ( m_tramp , DImode , <NUM_LIT> ) ; emit_move_insn ( mem ,


<s> strcat ( trname , <STR_LIT> ) ; fnname = ggc_alloc_string ( trname , strlen ( trname ) + <NUM_LIT> ) ; word2 = gen_rtx_SYMBOL_REF ( Pmode , fnname ) ; word1 = force_reg ( DImode , gen_const_mem ( DImode , fnaddr ) ) ; word1 = expand_and ( DImode , word1 , GEN_INT ( HOST_WIDE_INT_C ( <NUM_LIT> ) ) , NULL ) ; } else { word1 = GEN_INT ( HOST_WIDE_INT_C ( <NUM_LIT> ) ) ; word2 = GEN_INT ( HOST_WIDE_INT_C ( <NUM_LIT> ) ) ; } mem = adjust_address ( m_tramp , DImode , <NUM_LIT> ) ; emit_move_insn ( mem , word1 ) ; mem = adjust_address ( m_tramp


<s> rtx alpha_use_linkage ( rtx func ATTRIBUTE_UNUSED , bool lflag ATTRIBUTE_UNUSED , bool rflag ATTRIBUTE_UNUSED ) { return


<s> if ( TREE_CODE ( TREE_TYPE ( valist ) ) == ERROR_MARK ) return ; if ( NUM_ARGS < <NUM_LIT> ) offset = TARGET_ABI_OPEN_VMS ? UNITS_PER_WORD : <NUM_LIT> * UNITS_PER_WORD ; else offset = - <NUM_LIT> * UNITS_PER_WORD + crtl -> args . pretend_args_size ; if ( TARGET_ABI_OPEN_VMS ) { t = make_tree ( ptr_type_node , virtual_incoming_args_rtx ) ; t = fold_build_pointer_plus_hwi ( t , offset + NUM_ARGS * UNITS_PER_WORD ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist , t ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; } else { base_field = TYPE_FIELDS ( TREE_TYPE ( valist ) ) ; offset_field = DECL_CHAIN ( base_field ) ; base_field = build3 ( COMPONENT_REF , TREE_TYPE ( base_field ) , valist , base_field , NULL_TREE ) ; offset_field = build3 ( COMPONENT_REF , TREE_TYPE ( offset_field ) , valist , offset_field , NULL_TREE ) ; t = make_tree ( ptr_type_node , virtual_incoming_args_rtx ) ; t = fold_build_pointer_plus_hwi ( t , offset ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( base_field ) , base_field , t ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = build_int_cst ( NULL_TREE , NUM_ARGS


<s> t = make_tree ( ptr_type_node , virtual_incoming_args_rtx ) ; t = fold_build_pointer_plus_hwi ( t , offset ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( base_field ) , base_field , t ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = build_int_cst ( NULL_TREE , NUM_ARGS * UNITS_PER_WORD ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( offset_field ) , offset_field , t ) ; TREE_SIDE_EFFECTS ( t )


<s> return mode == V8QImode || mode == V4HImode


<s> return mode == V8QImode || mode == V4HImode ||


<s> switch ( alpha_procedure_type ) { case PT_NULL : return to == STACK_POINTER_REGNUM ; case PT_REGISTER


<s> offset = ( ALPHA_ROUND ( sa_size + pv_save_size + get_frame_size ( ) + crtl -> args . pretend_args_size ) - crtl -> args . pretend_args_size ) ; break ; default : gcc_unreachable ( ) ; } if ( to == STACK_POINTER_REGNUM ) offset +=

ALPHA_ROUND ( crtl -> outgoing_args_size ) ;


<s> in_section = NULL ; fputs ( <STR_LIT> , stream ) ; assemble_name ( stream , funname ) ; fputs ( <STR_LIT> , stream ) ; ASM_OUTPUT_LABEL ( stream , funname ) ; fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , funname ) ; fprintf ( stream , <STR_LIT> , alpha_procedure_type == PT_STACK ? <STR_LIT> : alpha_procedure_type == PT_REGISTER ? <STR_LIT> : <STR_LIT> ) ; if ( cfun ->


<s> static int alpha_write_one_linkage ( const char * name , alpha_links * link , FILE * stream ) { ASM_OUTPUT_INTERNAL_LABEL ( stream , XSTR ( link -> linkage , <NUM_LIT> ) ) ; if ( link -> rkind == KIND_CODEADDR ) { fprintf ( stream , <STR_LIT> ) ; } else { if ( ! SYMBOL_REF_EXTERNAL_P ( link -> func ) && SYMBOL_REF_LOCAL_P ( link -> func ) ) { fprintf ( stream , <STR_LIT> , name ) ; fprintf ( stream , <STR_LIT> ) ; } else { fprintf ( stream , <STR_LIT>


<s> tree decl = * node ; gcc_assert ( DECL_P ( decl ) ) ; DECL_COMMON ( decl ) = <NUM_LIT> ; return NULL_TREE


<s> static tree common_object_handler ( tree * node , tree name ATTRIBUTE_UNUSED , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ATTRIBUTE_UNUSED ) { tree decl = * node ; gcc_assert ( DECL_P ( decl ) ) ; DECL_COMMON ( decl )


<s> return ( TARGET_ABI_OSF && reload_completed && cfun -> machine -> frame_size ==


<s> bool direct_return ( void ) { return ( TARGET_ABI_OSF && reload_completed && cfun -> machine


<s> static void emit_frame_store ( unsigned int regno , rtx base_reg , HOST_WIDE_INT frame_bias , HOST_WIDE_INT base_ofs ) { rtx reg = gen_rtx_REG ( DImode , regno ) ; emit_frame_store_1 ( reg , base_reg , frame_bias ,


<s> static void emit_frame_store_1 ( rtx value , rtx base_reg , HOST_WIDE_INT frame_bias , HOST_WIDE_INT base_ofs , rtx frame_reg ) { rtx addr , mem ; rtx_insn * insn ; addr = plus_constant ( Pmode , base_reg , base_ofs ) ; mem = gen_frame_mem ( DImode , addr ) ; insn = emit_move_insn ( mem , value ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( frame_bias || value != frame_reg ) { if ( frame_bias ) { addr = plus_constant ( Pmode , stack_pointer_rtx , frame_bias


<s> case E_HImode : fn = gen_inswl ; break ; case E_SImode : fn = gen_insll ; break ; case E_DImode : fn = gen_insql ; break ; default : gcc_unreachable ( )


<s> static void emit_unlikely_jump ( rtx cond , rtx label ) { rtx x = gen_rtx_IF_THEN_ELSE ( VOIDmode , cond , label , pc_rtx ) ; rtx_insn * insn = emit_jump_insn ( gen_rtx_SET (


<s> if ( GET_CODE ( x ) == LO_SUM && XEXP (

x , <NUM_LIT> ) == pic_offset_table_rtx ) return true ;


<s> FOR_EACH_SUBRTX_VAR ( iter , array , x , ALL ) { rtx x = * iter


<s> return ( ( alpha_tune == PROCESSOR_EV4 || alpha_tune == PROCESSOR_EV5 ) && optimize && ! optimize_size && alpha_tp !=