<s> 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 ) ) ; MEM_NOTRAP_P ( tmp ) = <NUM_LIT> ; set_mem_alias_set ( tmp , set ) ;

move_block_from_reg ( <NUM_LIT> + cum + TARGET_FPREGS * <NUM_LIT> , tmp , count ) ;


<s> rtx in_pat = PATTERN ( in_insn ) ; if ( GET_CODE ( in_pat ) != PARALLEL ) return false ; for ( int i = <NUM_LIT> ; i < XVECLEN ( in_pat , <NUM_LIT> ) ; i ++ ) { rtx in_exp = XVECEXP ( in_pat , <NUM_LIT> , i ) ; if ( GET_CODE ( in_exp ) == CLOBBER || GET_CODE ( in_exp ) == USE || GET_CODE ( in_exp ) == TRAP_IF ) continue ; gcc_assert ( GET_CODE ( in_exp ) == SET ) ; if ( ! alpha_store_data_bypass_p_1 ( out_insn , in_exp ) ) return false ; } return true ;


<s> if ( ! MEM_P ( SET_DEST ( in_set ) ) ) return false ; rtx out_set = single_set ( out_insn ) ; if ( out_set ) return ! reg_mentioned_p ( SET_DEST ( out_set ) , SET_DEST ( in_set ) ) ; rtx out_pat = PATTERN ( out_insn ) ; if ( GET_CODE ( out_pat ) != PARALLEL ) return false ; for ( int i = <NUM_LIT> ; i < XVECLEN ( out_pat , <NUM_LIT> ) ; i ++ ) { rtx out_exp = XVECEXP ( out_pat , <NUM_LIT> , i ) ;

if ( GET_CODE ( out_exp ) == CLOBBER || GET_CODE ( out_exp ) == USE || GET_CODE ( out_exp ) == TRAP_IF ) continue ;


<s> TYPE_NAME ( record ) = type_decl ; ofs = build_decl ( FIELD_DECL , get_identifier ( <STR_LIT> ) , integer_type_node ) ; DECL_FIELD_CONTEXT ( ofs ) = record ; base = build_decl ( FIELD_DECL , get_identifier ( <STR_LIT> ) , ptr_type_node ) ; DECL_FIELD_CONTEXT ( base ) = record ; TREE_CHAIN ( base ) = ofs ; TYPE_FIELDS ( record ) = base ; layout_type ( record ) ;


<s> if ( ! TARGET_ABI_OSF ) return <NUM_LIT> ; if ( TARGET_PROFILING_NEEDS_GP && current_function_profile ) return <NUM_LIT> ; if ( current_function_is_thunk ) return <NUM_LIT> ; push_topmost_sequence ( ) ; insn = get_insns ( ) ; pop_topmost_sequence ( ) ; for ( ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER ) { enum attr_type type = get_attr_type ( insn ) ; if ( type == TYPE_LDSYM || type == TYPE_JSR ) return <NUM_LIT> ; if ( TARGET_EXPLICIT_RELOCS && for_each_rtx ( & PATTERN ( insn ) , find_lo_sum , NULL ) > <NUM_LIT> ) return <NUM_LIT> ; } return <NUM_LIT> ;


<s> insn = get_insns ( ) ; pop_topmost_sequence ( ) ; for ( ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER ) { enum attr_type type = get_attr_type ( insn ) ;

if ( type == TYPE_LDSYM || type == TYPE_JSR ) return <NUM_LIT> ;


<s> else reg_offset = ALPHA_ROUND ( current_function_outgoing_args_size ) ; alpha_sa_mask ( & imask , & fmask ) ; if ( TARGET_ABI_OSF ) { alpha_function_needs_gp = alpha_does_function_need_gp ( ) ; if ( alpha_function_needs_gp ) emit_insn ( gen_prologue_ldgp ( ) ) ; } if ( TARGET_PROFILING_NEEDS_GP && current_function_profile ) emit_insn ( gen_prologue_mcount ( ) ) ; if ( TARGET_ABI_UNICOSMK ) unicosmk_gen_dsib ( & imask ) ; if ( frame_size <= <NUM_LIT> ) { if ( frame_size > <NUM_LIT> ) { int probed = <NUM_LIT> ; do emit_insn ( gen_probe_stack ( GEN_INT ( TARGET_ABI_UNICOSMK ? - probed + <NUM_LIT> : - probed ) ) ) ; while ( ( probed += <NUM_LIT> ) < frame_size ) ; if ( sa_size == <NUM_LIT> && probed + <NUM_LIT> < frame_size ) emit_insn ( gen_probe_stack ( GEN_INT ( - frame_size ) ) ) ; } if ( frame_size != <NUM_LIT> ) FRP ( emit_insn ( gen_adddi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( TARGET_ABI_UNICOSMK ? - frame_size + <NUM_LIT> : - frame_size ) ) ) ) ; } else { HOST_WIDE_INT blocks = ( frame_size + <NUM_LIT> ) / <NUM_LIT> ; HOST_WIDE_INT leftover = frame_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 ( TARGET_ABI_UNICOSMK ? <NUM_LIT> - <NUM_LIT> : <NUM_LIT> ) ) ) ; emit_insn ( gen_prologue_stack_probe_loop ( count , ptr ) ) ; if ( leftover > <NUM_LIT> && sa_size == <NUM_LIT> ) { rtx last = gen_rtx_MEM ( DImode , plus_constant ( ptr , - leftover ) ) ; MEM_VOLATILE_P ( last ) = <NUM_LIT> ; emit_move_insn ( last , const0_rtx ) ; } if ( TARGET_ABI_WINDOWS_NT ) { 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_nt_lda ( 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 ) ) ) ;


<s> rtx alpha_gp_save_rtx ( ) { rtx r = get_hard_reg_initial_val ( DImode , <NUM_LIT> ) ; if ( GET_CODE ( r ) != MEM ) r = gen_mem_addressof ( r , NULL_TREE ) ;


<s> if ( GET_CODE ( r ) != MEM ) r = gen_mem_addressof ( r , NULL_TREE ) ; return r ;


<s> static int alpha_issue_rate ( ) { return ( alpha_cpu == PROCESSOR_EV4 ? <NUM_LIT> : <NUM_LIT> ) ;


<s> if ( ! has_hard_reg_initial_val ( Pmode , REG_RA ) ) return regs_ever_live [ REG_RA ] ;


<s> if ( ( mask [ <NUM_LIT> ] >> REG_RA ) & <NUM_LIT> ) 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 || current_function_has_nonlocal_label || alpha_procedure_type == PT_STACK || current_function_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 ] && ! regs_ever_live [ i ] ) vms_save_fp_regno = i ; if ( vms_save_fp_regno == - <NUM_LIT> && alpha_procedure_type == PT_REGISTER ) 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> ; } else { if ( sa_size & <NUM_LIT> ) sa_size ++ ; }


<s> int alpha_using_fp ( ) { alpha_sa_size ( ) ; return vms_unwind_regno == HARD_FRAME_POINTER_REGNUM ;


<s> int direct_return ( ) { return ( ! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK && reload_completed && alpha_sa_size ( ) == <NUM_LIT> && get_frame_size ( ) == <NUM_LIT> && current_function_outgoing_args_size == <NUM_LIT> && current_function_pretend_args_size == <NUM_LIT> ) ;


<s> case ALPHA_FPRM_NORM : return NULL ; case ALPHA_FPRM_MINF : return <STR_LIT> ; case ALPHA_FPRM_CHOP : return <STR_LIT> ; case ALPHA_FPRM_DYN : return <STR_LIT> ; } break ; case ROUND_SUFFIX_C : return <STR_LIT> ;


<s> case ALPHA_FPTM_U : return <STR_LIT> ; case ALPHA_FPTM_SU : return <STR_LIT> ; case ALPHA_FPTM_SUI : return <STR_LIT> ; } break ; case TRAP_SUFFIX_U_SU_SUI : switch ( alpha_fptm ) { case ALPHA_FPTM_N : return NULL ; case ALPHA_FPTM_U : return <STR_LIT> ; case ALPHA_FPTM_SU : return <STR_LIT> ;


<s> if ( GET_CODE ( seq ) == SEQUENCE ) { int i = XVECLEN ( seq , <NUM_LIT> ) ; while ( -- i >= <NUM_LIT> ) RTX_FRAME_RELATED_P ( XVECEXP ( seq , <NUM_LIT> , i ) ) = <NUM_LIT> ; return emit_insn ( seq ) ; }


<s> while ( -- i >= <NUM_LIT> ) RTX_FRAME_RELATED_P ( XVECEXP ( seq , <NUM_LIT> , i ) ) = <NUM_LIT> ; return emit_insn ( seq ) ;


<s> char * unicosmk_data_section ( ) { static int count = <NUM_LIT> ;

sprintf ( unicosmk_section_buf , <STR_LIT> , count ++ ) ;


<s> static int count = <NUM_LIT> ; sprintf ( unicosmk_section_buf , <STR_LIT> , count ++ ) ; return unicosmk_section_buf ;


<s> case TYPE_SHIFT : case TYPE_IMUL : case TYPE_FBR : case TYPE_MVI : return EV4_IB0 ; case TYPE_IST : case TYPE_MISC : case TYPE_IBR : case TYPE_JSR : case TYPE_CALLPAL : case TYPE_FCPYS : case TYPE_FCMOV : case TYPE_FADD : case TYPE_FDIV : case TYPE_FMUL : case TYPE_ST_C : case TYPE_MB : case TYPE_FSQRT : case TYPE_FTOI : case TYPE_ITOF : return EV4_IB1 ; default : gcc_unreachable ( ) ;


<s> case EV4_IB1 : if ( in_use & EV4_IB1 ) goto done ; in_use |= EV4_IB1 ; break ; default : gcc_unreachable ( ) ; } len += <NUM_LIT> ; if ( GET_CODE ( insn ) == JUMP_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 ; }


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


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


<s> insn_type = get_attr_type ( insn ) ; dep_insn_type = get_attr_type ( dep_insn ) ;


<s> if ( REG_NOTE_KIND ( link ) != <NUM_LIT> ) return cost ; if ( recog_memoized ( insn ) < <NUM_LIT> || recog_memoized ( dep_insn ) < <NUM_LIT> ) return cost ; insn_type = get_attr_type ( insn ) ; dep_insn_type = get_attr_type ( dep_insn ) ;


<s> else if ( ( unsigned int ) align_functions < max_align ) align = align_functions ; else align = max_align ; ofs = prev_in_use = <NUM_LIT> ; i = get_insns ( ) ; if ( GET_CODE ( i ) == NOTE ) i = next_nonnote_insn ( i ) ; ldgp = alpha_function_needs_gp ? <NUM_LIT> : <NUM_LIT> ; while ( i ) { next = ( * next_group ) ( i , & in_use , & len ) ; if ( GET_CODE ( i ) == CODE_LABEL ) { unsigned int new_align = <NUM_LIT> << label_to_alignment ( i ) ; 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 prev , where ; where = prev = prev_nonnote_insn ( i ) ; if ( ! where || GET_CODE ( where ) != CODE_LABEL ) where = i ; if ( ! ( TARGET_EXPLICIT_RELOCS && prev && GET_CODE ( prev ) == CALL_INSN ) ) { emit_insn_before ( gen_realign ( GEN_INT ( new_log_align ) ) , where ) ; align = <NUM_LIT> << new_log_align ; ofs = <NUM_LIT> ; } } else if ( ldgp > <NUM_LIT> ) ldgp -= len ; else if ( ofs + len > ( int ) align ) { int nop_count = ( align - ofs ) / <NUM_LIT> ; rtx where ; where = prev_nonnote_insn ( i ) ; if ( where ) { if ( GET_CODE ( where ) == CODE_LABEL ) { rtx where2 = prev_nonnote_insn ( where ) ; if ( where2 && GET_CODE ( where2 ) == JUMP_INSN ) where = where2 ; } else if ( GET_CODE ( where ) == INSN ) where = i ; } else where = i ;

do emit_insn_before ( ( * next_nop ) ( & prev_in_use ) , where ) ;


<s> return TARGET_FLOAT_VAX ? FF : FS ; case DFmode : return TARGET_FLOAT_VAX ? FD : FT ; default : return I64 ; }


<s> DECL_ARTIFICIAL ( space ) = <NUM_LIT> ; DECL_IGNORED_P ( space ) = <NUM_LIT> ; ofs = build_decl ( FIELD_DECL , get_identifier ( <STR_LIT> ) , integer_type_node ) ; DECL_FIELD_CONTEXT ( ofs ) = record ; TREE_CHAIN ( ofs ) = space ; base = build_decl ( FIELD_DECL , get_identifier ( <STR_LIT> ) , ptr_type_node ) ;


<s> DECL_ARTIFICIAL ( space ) = <NUM_LIT> ; DECL_IGNORED_P ( space ) = <NUM_LIT> ; ofs = build_decl ( FIELD_DECL , get_identifier ( <STR_LIT> ) , integer_type_node ) ; DECL_FIELD_CONTEXT ( ofs ) = record ; TREE_CHAIN ( ofs ) = space ; base = build_decl ( FIELD_DECL , get_identifier ( <STR_LIT> ) , ptr_type_node ) ; DECL_FIELD_CONTEXT ( base ) = record ; TREE_CHAIN ( base ) = ofs ; TYPE_FIELDS ( record ) = base ; layout_type ( record ) ; va_list_gpr_counter_field = ofs ;


<s> static bool alpha_cannot_copy_insn_p ( rtx insn ) {

if ( ! reload_completed || ! TARGET_EXPLICIT_RELOCS ) return false ;


<s> return code == SYMBOL_REF || code == LABEL_REF || code == CONST ;


<s> switch ( c ) { case 'G' : return ( GET_MODE_CLASS ( GET_MODE ( value ) ) == MODE_FLOAT && value == CONST0_RTX ( GET_MODE ( value ) ) ) ; case 'H' : return ( GET_MODE ( value ) == VOIDmode && zap_mask ( CONST_DOUBLE_LOW ( value ) ) && zap_mask ( CONST_DOUBLE_HIGH ( value ) ) ) ; default :


<s> bool alpha_const_double_ok_for_letter_p ( rtx value , int c ) { switch ( c ) { case 'G' : return ( GET_MODE_CLASS ( GET_MODE ( value ) ) == MODE_FLOAT && value == CONST0_RTX ( GET_MODE ( value ) ) ) ; case 'H' : return ( GET_MODE ( value ) == VOIDmode && zap_mask ( CONST_DOUBLE_LOW ( value ) ) && zap_mask ( CONST_DOUBLE_HIGH ( value ) ) ) ; default :


<s> case 'L' : return ( ( value & <NUM_LIT> ) == <NUM_LIT> && ( ( value ) >> <NUM_LIT> == - <NUM_LIT> || value >> <NUM_LIT> == <NUM_LIT> ) ) ; case 'M' : return zap_mask ( value ) ; case 'N' :

return ( unsigned HOST_WIDE_INT ) ( ~ value ) < <NUM_LIT> ;


<s> return value == <NUM_LIT> ; case 'K' : return ( unsigned HOST_WIDE_INT ) ( value + <NUM_LIT> ) < <NUM_LIT> ; case 'L' : return ( ( value & <NUM_LIT> ) == <NUM_LIT> && ( ( value ) >> <NUM_LIT> == - <NUM_LIT> || value >> <NUM_LIT> == <NUM_LIT> ) ) ; case 'M' : return zap_mask ( value ) ; case 'N' :


<s> rtx insn ; if ( ! TARGET_ABI_OSF ) return <NUM_LIT> ; if ( TARGET_PROFILING_NEEDS_GP && current_function_profile ) return <NUM_LIT> ; if ( current_function_is_thunk ) return <NUM_LIT> ;

if ( current_function_has_nonlocal_goto ) return <NUM_LIT> ;


<s> if ( TARGET_SMALL_DATA && GET_MODE_SIZE ( mode ) <= g_switch_value ) sdata_section ( ) ; else default_elf_select_rtx_section ( mode , x , align ) ;


<s> static void alpha_elf_select_rtx_section ( enum machine_mode mode , rtx x , unsigned HOST_WIDE_INT align ) { if ( TARGET_SMALL_DATA && GET_MODE_SIZE ( mode ) <= g_switch_value ) sdata_section ( ) ; else default_elf_select_rtx_section ( mode , x , align ) ;


<s> branch_code = swap_condition ( cmp_code ) ; cmp_code = UNKNOWN ; } } else { branch_mode = CCmode ; } } else { cmp_mode = DImode ; if ( code != LEU && code != LTU && code != GEU && code != GTU ) { if ( op1 == const0_rtx ) cmp_code = UNKNOWN , branch_code = code ; else if ( GET_CODE ( op1 ) == CONST_INT && ( code == EQ || code == NE ) && ! ( symbolic_operand ( op0 , VOIDmode ) || ( GET_CODE ( op0 ) == REG && REG_POINTER ( op0 ) ) ) ) { HOST_WIDE_INT v = INTVAL ( op1 ) , n = - v ; if ( ! CONST_OK_FOR_LETTER_P ( v , 'I' ) && ( CONST_OK_FOR_LETTER_P ( n , 'K' ) || CONST_OK_FOR_LETTER_P ( n , 'L' ) ) ) { cmp_code = PLUS , branch_code = code ; op1 = GEN_INT ( n ) ; } } } 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 ; if ( cmp_code != UNKNOWN ) {


<s> cmp_code = code , branch_code = NE ; break ; case NE : case ORDERED : cmp_code = reverse_condition ( code ) , branch_code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( alpha_compare . fp_p ) { cmp_code = swap_condition ( code ) ; branch_code = NE ; tem = op0 , op0 = op1 , op1 = tem ; } else { cmp_code = reverse_condition ( code ) ; branch_code = EQ ; } break ; default : gcc_unreachable ( ) ; } if ( alpha_compare . fp_p ) { cmp_mode = DFmode ; if ( flag_unsafe_math_optimizations ) { if ( op1 == CONST0_RTX ( DFmode ) ) cmp_code = UNKNOWN , branch_code = code ; else if ( op0 == CONST0_RTX ( DFmode ) ) { tem = op0 , op0 = op1 , op1 = tem ; branch_code = swap_condition ( cmp_code ) ; cmp_code = UNKNOWN ; }


<s> int local_fast_math = flag_unsafe_math_optimizations ; rtx tem ; memset ( & alpha_compare , <NUM_LIT> , sizeof ( alpha_compare ) ) ; if ( fp_p != FLOAT_MODE_P ( mode ) ) { enum rtx_code cmp_code ; if ( ! TARGET_FIX ) return <NUM_LIT> ; switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : cmp_code = code , code = NE ; break ; case NE : cmp_code = EQ , code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( ! fp_p && op1 == const0_rtx ) cmp_code = code , code = NE ; else { cmp_code = swap_condition ( code ) ; code = NE ; tem = op0 , op0 = op1 , op1 = tem ; } break ; default : gcc_unreachable ( ) ; } tem = gen_reg_rtx ( cmp_op_mode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tem , gen_rtx_fmt_ee ( cmp_code , cmp_op_mode , op0 , op1 ) ) ) ; cmp_mode = cmp_op_mode = fp_p ? DImode : DFmode ; op0 = gen_lowpart ( cmp_op_mode , tem ) ;


<s> tem = op0 , op0 = op1 , op1 = tem ; } break ; default : gcc_unreachable ( ) ; } tem = gen_reg_rtx ( cmp_op_mode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tem , gen_rtx_fmt_ee ( cmp_code , cmp_op_mode , op0 , op1 ) ) ) ; cmp_mode = cmp_op_mode = fp_p ? DImode : DFmode ; op0 = gen_lowpart ( cmp_op_mode , tem ) ; op1 = CONST0_RTX ( cmp_op_mode ) ; fp_p = ! fp_p ; local_fast_math = <NUM_LIT> ; } if ( signed_comparison_operator ( cmp , VOIDmode ) && ( ! fp_p || local_fast_math ) && ( op0 == CONST0_RTX ( cmp_mode ) || op1 == CONST0_RTX ( cmp_mode ) ) ) return gen_rtx_fmt_ee ( code , VOIDmode , op0 , op1 ) ; if ( no_new_pseudos ) return NULL_RTX ; switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : break ; case NE : code = reverse_condition ( code ) ;


<s> emit_cmp_and_jump_insns ( in , const0_rtx , LT , const0_rtx , DImode , <NUM_LIT> , neglab ) ; emit_insn ( gen_rtx_SET ( VOIDmode , out , gen_rtx_FLOAT ( mode , in ) ) ) ; emit_jump_insn ( gen_jump ( donelab ) ) ; emit_barrier ( ) ; emit_label ( neglab ) ; emit_insn ( gen_lshrdi3 ( i0 , in , const1_rtx ) ) ; emit_insn ( gen_anddi3 ( i1 , in , const1_rtx ) ) ; emit_insn ( gen_iordi3 ( i0 , i0 , i1 ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , f0 , gen_rtx_FLOAT ( mode , i0 ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , out , gen_rtx_PLUS ( mode , f0 , f0 ) ) ) ;


<s> case EQ : case LE : case LT : case LEU : case LTU : case UNORDERED : if ( fp_p ) cmp_code = code , code = NE ; break ; case NE : if ( ! fp_p && op1 == const0_rtx ) break ; case ORDERED : cmp_code = reverse_condition ( code ) ; code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( ! fp_p && op1 == const0_rtx ) break ; code = swap_condition ( code ) ; if ( fp_p ) cmp_code = code , code = NE ;


<s> code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( ! fp_p && op1 == const0_rtx ) break ; code = swap_condition ( code ) ; if ( fp_p ) cmp_code = code , code = NE ; tmp = op0 , op0 = op1 , op1 = tmp ; break ; default : gcc_unreachable ( ) ; } if ( ! fp_p ) { 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 ) { enum machine_mode mode = fp_p ? DFmode : DImode ; tmp = gen_reg_rtx ( mode ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , tmp , gen_rtx_fmt_ee ( cmp_code , mode , op0 , op1 ) ) ) ;


<s> rtx result = <NUM_LIT> ; int i ; if ( no_new_pseudos && mode == SImode && GET_CODE ( target ) == REG && 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 , 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 ) ) ;


<s> if ( no_new_pseudos && mode == SImode && GET_CODE ( target ) == REG && 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 ) ;


<s> } else if ( n >= <NUM_LIT> + ( extra != <NUM_LIT> ) ) { if ( no_output ) return pc_rtx ; if ( no_new_pseudos ) { emit_insn ( gen_rtx_SET ( VOIDmode , target , GEN_INT ( high << <NUM_LIT> ) ) ) ; temp = target ; } else temp = copy_to_suggested_reg ( GEN_INT ( high << <NUM_LIT> ) , subtarget , mode ) ; if ( extra != <NUM_LIT> ) { if ( ! subtarget ) subtarget = gen_reg_rtx ( mode ) ; insn = gen_rtx_PLUS ( mode , temp , GEN_INT ( extra << <NUM_LIT> ) ) ; insn = gen_rtx_SET ( VOIDmode , subtarget , insn ) ; emit_insn ( insn ) ; temp = subtarget ; } if ( target == NULL ) target = gen_reg_rtx ( mode ) ; insn = gen_rtx_PLUS ( mode , temp , GEN_INT ( low ) ) ; insn = gen_rtx_SET ( VOIDmode , target , insn ) ; emit_insn ( insn ) ; return target ; } } if ( n == <NUM_LIT> || ( mode == SImode && no_new_pseudos ) ) return <NUM_LIT> ; for ( i = <NUM_LIT> ; i < n ; i ++ ) { new = ( ( c & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; if ( new != <NUM_LIT> ) { temp = alpha_emit_set_const ( subtarget , mode , c - new , i , no_output ) ; if ( temp ) { if ( no_output ) return temp ; return expand_binop ( mode , add_optab , temp , GEN_INT ( new ) , target , <NUM_LIT> , OPTAB_WIDEN ) ; } } temp = alpha_emit_set_const ( subtarget , mode , ~ c , i , no_output ) ; if ( temp ) { if ( no_output ) return temp ; return expand_unop ( mode , one_cmpl_optab , temp , target , <NUM_LIT> ) ; } bits = exact_log2 ( c & - c ) ; if ( bits > <NUM_LIT> ) for ( ; bits > <NUM_LIT> ; bits -- ) { new = c >> bits ; temp = alpha_emit_set_const ( subtarget , mode , new , i , no_output ) ; if ( ! temp && c < <NUM_LIT> ) { new = ( unsigned HOST_WIDE_INT ) c >> bits ; temp = alpha_emit_set_const ( subtarget , mode , new , i , no_output ) ; } if ( temp ) { if ( no_output ) return temp ; return expand_binop ( mode , ashl_optab , temp , GEN_INT ( bits ) , target , <NUM_LIT> , OPTAB_WIDEN ) ; } }

bits = ( MIN ( HOST_BITS_PER_WIDE_INT , GET_MODE_SIZE ( mode ) * <NUM_LIT> ) - floor_log2 ( c ) - <NUM_LIT> - ( HOST_BITS_PER_WIDE_INT < <NUM_LIT> ) ) ;


<s> emit_move_insn ( target , GEN_INT ( d4 ) ) ; if ( d3 ) emit_move_insn ( target , gen_rtx_PLUS ( DImode , target , GEN_INT ( d3 ) ) ) ; } 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 ) ) ) ; return target ;


<s> cmp_code = * pcode ; 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 :


<s> break ; case VOIDmode : gcc_assert ( GET_CODE ( operands [ i ] ) == CONST_INT ) ; case DImode : reg = gen_rtx_REG ( DImode , regno ) ; regno += <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } emit_move_insn ( reg , operands [ i ] ) ; usage = alloc_EXPR_LIST ( <NUM_LIT> , gen_rtx_USE ( VOIDmode , reg ) , usage ) ; } switch ( GET_MODE ( target ) ) { case TFmode : reg = gen_rtx_REG ( TFmode , <NUM_LIT> ) ; break ; case DFmode : reg = gen_rtx_REG ( DFmode , <NUM_LIT> ) ; break ;


<s> assemble_name ( file , fnname ) ; putc ( '\n' , file ) ; } inside_function = FALSE ; if ( TARGET_ABI_UNICOSMK ) {

unicosmk_output_ssib ( file , fnname ) ;


<s> if ( arg == error_mark_node ) return NULL_RTX ; if ( arity > MAX_ARGS ) return NULL_RTX ; insn_op = & insn_data [ icode ] . operand [ arity + nonvoid ] ; op [ arity ] = expand_expr ( arg , NULL_RTX , insn_op -> mode , <NUM_LIT> ) ; if ( ! ( * insn_op -> predicate ) ( op [ arity ] , insn_op -> mode ) ) op [ arity ] = copy_to_mode_reg ( insn_op -> mode , op [ arity ] ) ; } if ( nonvoid ) { enum machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; } switch ( arity ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target ) ; break ; case <NUM_LIT> : if ( nonvoid ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; default : gcc_unreachable ( ) ; } if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ; if ( nonvoid ) return target ; else return const0_rtx ;


<s> rtx ( * fn5 ) ( rtx , rtx , rtx , rtx , rtx ) ; addr = force_reg ( DImode , XEXP ( mem , <NUM_LIT> ) ) ; align = expand_simple_binop ( Pmode , AND , addr , GEN_INT ( - <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; oldval = convert_modes ( DImode , mode , oldval , <NUM_LIT> ) ; newval = emit_insxl ( mode , newval , addr ) ;


<s> rtx ( * fn4 ) ( rtx , rtx , rtx , rtx ) ; addr = force_reg ( DImode , XEXP ( mem , <NUM_LIT> ) ) ; align = expand_simple_binop ( Pmode , AND , addr , GEN_INT ( - <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; val = emit_insxl ( mode , val , addr ) ;


<s> enum machine_mode mode = GET_MODE ( mem ) ; rtx addr , align , wdst ; rtx ( * fn4 ) ( rtx , rtx , rtx , rtx ) ; addr = force_reg ( DImode , XEXP ( mem , <NUM_LIT> ) ) ; align = expand_simple_binop ( Pmode , AND , addr , GEN_INT ( - <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ;

val = emit_insxl ( mode , val , addr ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && ! 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 ) ) { rtx tmp ; tmp = alpha_legitimize_address ( 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 ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT || GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_DOUBLE || GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_VECTOR ) {


<s> operands [ <NUM_LIT> ] = tmp ; return false ; } } if ( ! CONSTANT_P ( operands [ <NUM_LIT> ] ) || input_operand ( operands [ <NUM_LIT> ] , mode ) ) return false ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT || GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_DOUBLE || GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_VECTOR ) { if ( alpha_split_const_mov ( mode , operands ) ) return true ; } operands [ <NUM_LIT> ] = force_const_mem ( mode , operands [ <NUM_LIT> ] ) ; if ( reload_in_progress ) { emit_move_insn ( operands [ <NUM_LIT> ] , XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ; operands [ <NUM_LIT> ] = copy_rtx ( operands [ <NUM_LIT> ] ) ;

XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) = operands [ <NUM_LIT> ] ;


<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 tmp = gen_reg_rtx ( mode ) ; alpha_expand_unaligned_load ( tmp , operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ; if ( tmp != operands [ <NUM_LIT> ] ) emit_move_insn ( operands [ <NUM_LIT> ] , tmp ) ; }

else if ( MEM_P ( operands [ <NUM_LIT> ] ) ) {


<s> rtx subtarget ; bool copyout ; get_aligned_mem ( operands [ <NUM_LIT> ] , & aligned_mem , & bitnum ) ; subtarget = operands [ <NUM_LIT> ] ; if ( GET_CODE ( subtarget ) == REG ) subtarget = gen_lowpart ( DImode , subtarget ) , copyout = false ; else subtarget = gen_reg_rtx ( DImode ) , copyout = true ; emit_insn ( ( mode == QImode ? gen_aligned_loadqi : gen_aligned_loadhi ) ( subtarget , aligned_mem , bitnum , scratch ) ) ; if ( copyout ) emit_move_insn ( operands [ <NUM_LIT> ] , gen_lowpart ( mode , subtarget ) ) ; } } else { rtx temp1 , temp2 , seq , subtarget ; bool copyout ; temp1 = gen_reg_rtx ( DImode ) ; temp2 = gen_reg_rtx ( DImode ) ; subtarget = operands [ <NUM_LIT> ] ; if ( GET_CODE ( subtarget ) == REG ) subtarget = gen_lowpart ( DImode , subtarget ) , copyout = false ; else subtarget = gen_reg_rtx ( DImode ) , copyout = true ; seq = ( ( mode == QImode ? gen_unaligned_loadqi : gen_unaligned_loadhi ) ( subtarget , get_unaligned_address ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , 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 ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM || ( GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG && GET_CODE ( SUBREG_REG ( operands [ <NUM_LIT> ] ) ) == MEM ) || ( reload_in_progress && GET_CODE ( operands [ <NUM_LIT> ] ) == REG && REGNO ( operands [ <NUM_LIT> ] ) >= FIRST_PSEUDO_REGISTER ) || ( reload_in_progress && GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG && GET_CODE ( SUBREG_REG ( operands [ <NUM_LIT> ] ) ) == REG && REGNO ( operands [ <NUM_LIT> ] ) >= FIRST_PSEUDO_REGISTER ) ) { 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 seq = ( ( mode == QImode ? gen_unaligned_storeqi : gen_unaligned_storehi ) ( get_unaligned_address ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , operands [ <NUM_LIT> ] , temp1 , temp2 , temp3 ) ) ; alpha_set_memflags ( seq , operands [ <NUM_LIT> ] ) ; emit_insn ( seq ) ;


<s> static void alpha_expand_unaligned_load_words ( rtx * out_regs , rtx smem , HOST_WIDE_INT words , HOST_WIDE_INT ofs ) { rtx const im8 = GEN_INT ( - <NUM_LIT> ) ; rtx const i64 = GEN_INT ( <NUM_LIT> ) ; rtx ext_tmps [ MAX_MOVE_WORDS ] , data_regs [ MAX_MOVE_WORDS + <NUM_LIT> ] ; rtx sreg , areg , tmp , smema ; HOST_WIDE_INT i ; smema = XEXP ( smem , <NUM_LIT> ) ; if ( GET_CODE ( smema ) == LO_SUM ) smema = force_reg ( Pmode , smema ) ; for ( i = <NUM_LIT> ; i < words ; ++ i ) { data_regs [ i ] = out_regs [ i ] ; ext_tmps [ i ] = gen_reg_rtx ( DImode ) ; } data_regs [ words ] = gen_reg_rtx ( DImode ) ; if ( ofs != <NUM_LIT> ) smem = adjust_address ( smem , GET_MODE ( smem ) , ofs ) ; for ( i = <NUM_LIT> ; i < words ; ++ i ) { tmp = change_address ( smem , DImode , gen_rtx_AND ( DImode , plus_constant ( smema , <NUM_LIT> * i ) , im8 ) ) ;


<s> } tmp = change_address ( smem , DImode , gen_rtx_AND ( DImode , plus_constant ( smema , <NUM_LIT> * words - <NUM_LIT> ) , im8 ) ) ; set_mem_alias_set ( tmp , <NUM_LIT> ) ; emit_move_insn ( data_regs [ words ] , tmp ) ; sreg = copy_addr_to_reg ( smema ) ; areg = expand_binop ( DImode , and_optab , sreg , GEN_INT ( <NUM_LIT> ) , NULL , <NUM_LIT> , OPTAB_WIDEN ) ; if ( WORDS_BIG_ENDIAN ) emit_move_insn ( sreg , plus_constant ( sreg , <NUM_LIT> ) ) ; for ( i = <NUM_LIT> ; i < words ; ++ i ) { if ( WORDS_BIG_ENDIAN ) { emit_insn ( gen_extqh_be ( data_regs [ i ] , data_regs [ i ] , sreg ) ) ;

emit_insn ( gen_extxl_be ( ext_tmps [ i ] , data_regs [ i + <NUM_LIT> ] , i64 , sreg ) ) ;


<s> emit_insn ( gen_insll_be ( insh , gen_lowpart ( SImode , src ) , addr ) ) ; break ; case <NUM_LIT> : emit_insn ( gen_insql_be ( insh , gen_lowpart ( DImode , src ) , addr ) ) ; break ; } emit_insn ( gen_insxh ( insl , gen_lowpart ( DImode , src ) , GEN_INT ( size * <NUM_LIT> ) , addr ) ) ; } switch ( ( int ) size ) { case <NUM_LIT> : emit_insn ( gen_mskxl_be ( dsth , dsth , GEN_INT ( <NUM_LIT> ) , addr ) ) ; break ; case <NUM_LIT> : { rtx msk = immed_double_const ( <NUM_LIT> , <NUM_LIT> , DImode ) ; emit_insn ( gen_mskxl_be ( dsth , dsth , msk , addr ) ) ; break ; } case <NUM_LIT> : emit_insn ( gen_mskxl_be ( dsth , dsth , constm1_rtx , addr ) ) ; break ; } emit_insn ( gen_mskxh ( dstl , dstl , GEN_INT ( size * <NUM_LIT> ) , addr ) ) ; } else { addr = copy_addr_to_reg ( plus_constant ( 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_le ( insl , gen_lowpart ( HImode , src ) , addr ) ) ; break ; case <NUM_LIT> : emit_insn ( gen_insll_le ( insl , gen_lowpart ( SImode , src ) , addr ) ) ; break ; case <NUM_LIT> : emit_insn ( gen_insql_le ( insl , src , addr ) ) ; break ; } } emit_insn ( gen_mskxh ( dsth , dsth , GEN_INT ( size * <NUM_LIT> ) , addr ) ) ; switch ( ( int ) size ) { case <NUM_LIT> : emit_insn ( gen_mskxl_le ( dstl , dstl , GEN_INT ( <NUM_LIT> ) , addr ) ) ; break ; case <NUM_LIT> : { rtx msk = immed_double_const ( <NUM_LIT> , <NUM_LIT> , DImode ) ;

emit_insn ( gen_mskxl_le ( dstl , dstl , msk , addr ) ) ;


<s> emit_insn ( gen_insql_be ( ins_tmps [ i ] , data_regs [ i ] , dreg ) ) ; emit_insn ( gen_insxh ( data_regs [ i ] , data_regs [ i ] , i64 , dreg ) ) ; } else { emit_insn ( gen_insxh ( ins_tmps [ i ] , data_regs [ i ] , i64 , dreg ) ) ; emit_insn ( gen_insql_le ( 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> ] , <NUM_LIT> , OPTAB_WIDEN ) ; } } if ( WORDS_BIG_ENDIAN ) { emit_insn ( gen_mskxl_be ( st_tmp_2 , st_tmp_2 , constm1_rtx , dreg ) ) ; emit_insn ( gen_mskxh ( st_tmp_1 , st_tmp_1 , i64 , dreg ) ) ; } else { emit_insn ( gen_mskxh ( st_tmp_2 , st_tmp_2 , i64 , dreg ) ) ; emit_insn ( gen_mskxl_le ( st_tmp_1 , st_tmp_1 , constm1_rtx , dreg ) ) ; } if ( data_regs != NULL ) { st_tmp_2 = expand_binop ( DImode , ior_optab , st_tmp_2 , ins_tmps [ words - <NUM_LIT> ] , st_tmp_2 , <NUM_LIT> , OPTAB_WIDEN ) ; st_tmp_1 = expand_binop ( DImode , ior_optab , st_tmp_1 , data_regs [ <NUM_LIT> ] , st_tmp_1 , <NUM_LIT> , OPTAB_WIDEN ) ; } if ( WORDS_BIG_ENDIAN ) emit_move_insn ( st_addr_1 , st_tmp_1 ) ; else emit_move_insn ( st_addr_2 , st_tmp_2 ) ;


<s> dmema = XEXP ( dmem , <NUM_LIT> ) ; if ( GET_CODE ( dmema ) == LO_SUM ) dmema = force_reg ( Pmode , dmema ) ; if ( data_regs != NULL ) for ( i = <NUM_LIT> ; i < words ; ++ i ) ins_tmps [ i ] = gen_reg_rtx ( DImode ) ; st_tmp_1 = gen_reg_rtx ( DImode ) ; st_tmp_2 = gen_reg_rtx ( DImode ) ; if ( ofs != <NUM_LIT> ) dmem = adjust_address ( dmem , GET_MODE ( dmem ) , ofs ) ; st_addr_2 = change_address ( dmem , DImode , gen_rtx_AND ( DImode , plus_constant ( dmema , words * <NUM_LIT> - <NUM_LIT> ) , im8 ) ) ; set_mem_alias_set ( st_addr_2 , <NUM_LIT> ) ; 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 ( WORDS_BIG_ENDIAN ) emit_move_insn ( dreg , plus_constant ( dreg , <NUM_LIT> ) ) ; if ( data_regs != NULL ) { for ( i = words - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { if ( WORDS_BIG_ENDIAN ) { emit_insn ( gen_insql_be ( ins_tmps [ i ] , data_regs [ i ] , dreg ) ) ;

emit_insn ( gen_insxh ( data_regs [ i ] , data_regs [ i ] , i64 , dreg ) ) ;


<s> HOST_WIDE_INT mask = <NUM_LIT> ; for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { mask <<= <NUM_LIT> ; if ( ! ( ( value >> i ) & <NUM_LIT> ) ) mask |= <NUM_LIT> ; } result = gen_int_mode ( mask , DImode ) ; } else { HOST_WIDE_INT mask_lo = <NUM_LIT> , mask_hi = <NUM_LIT> ; gcc_assert ( HOST_BITS_PER_WIDE_INT == <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { mask_hi <<= <NUM_LIT> ; if ( ! ( ( value >> i ) & <NUM_LIT> ) ) mask_hi |= <NUM_LIT> ; } for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { mask_lo <<= <NUM_LIT> ; if ( ! ( ( value >> i ) & <NUM_LIT> ) ) mask_lo |= <NUM_LIT> ; }

result = immed_double_const ( mask_lo , mask_hi , DImode ) ;


<s> mask_hi <<= <NUM_LIT> ; if ( ! ( ( value >> i ) & <NUM_LIT> ) ) mask_hi |= <NUM_LIT> ; } for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { mask_lo <<= <NUM_LIT> ; if ( ! ( ( value >> i ) & <NUM_LIT> ) ) mask_lo |= <NUM_LIT> ; } result = immed_double_const ( mask_lo , mask_hi , DImode ) ; } return result ;


<s> static void alpha_extract_integer ( rtx x , HOST_WIDE_INT * p0 , HOST_WIDE_INT * p1 ) { HOST_WIDE_INT i0 , i1 ; if ( GET_CODE ( x ) == CONST_VECTOR ) x = simplify_subreg ( DImode , x , GET_MODE ( x ) , <NUM_LIT> ) ; if ( GET_CODE ( x ) == CONST_INT ) { i0 = INTVAL ( x ) ; i1 = - ( i0 < <NUM_LIT> ) ; } else if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> ) { i0 = CONST_DOUBLE_LOW ( x ) ; i1 = - ( i0 < <NUM_LIT> ) ; }


<s> case 'T' : return GET_CODE ( value ) == HIGH ; case 'U' : return TARGET_ABI_UNICOSMK && symbolic_operand ( value , VOIDmode ) ; case 'W' : return ( GET_CODE ( value ) == CONST_VECTOR && value == CONST0_RTX ( GET_MODE ( value ) ) ) ;


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


<s> return for_each_rtx ( & PATTERN ( insn ) , find_lo_sum_using_gp , NULL ) > <NUM_LIT> ;


<s> 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_UMULH : return alpha_fold_builtin_umulh ( opint , op_const ) ; 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 ALPHA_BUILTIN_CTTZ : return alpha_fold_builtin_cttz ( opint , op_const ) ; case ALPHA_BUILTIN_CTLZ : return alpha_fold_builtin_ctlz ( opint , op_const ) ; case ALPHA_BUILTIN_CTPOP : return alpha_fold_builtin_ctpop ( opint , op_const ) ; case ALPHA_BUILTIN_AMASK : case ALPHA_BUILTIN_IMPLVER :


<s> static tree alpha_fold_builtin_cmpbge ( unsigned HOST_WIDE_INT opint [ ] , long op_const ) { if ( op_const == <NUM_LIT> ) { int i , val ; for ( i = <NUM_LIT> , val = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { unsigned HOST_WIDE_INT c0 = ( opint [ <NUM_LIT> ] >> ( i * <NUM_LIT> ) ) & <NUM_LIT> ; unsigned HOST_WIDE_INT c1 = ( opint [ <NUM_LIT> ] >> ( i * <NUM_LIT> ) ) & <NUM_LIT> ; if ( c0 >= c1 ) val |= <NUM_LIT> << i ;


<s> 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 ( long_integer_type_node , temp ) ;


<s> unsigned HOST_WIDE_INT temp , op ; if ( op_const == <NUM_LIT> ) return NULL ;


<s> if ( op_const == <NUM_LIT> ) return NULL ; op = opint [ <NUM_LIT> ] ; temp = <NUM_LIT> ; while ( op ) temp ++ , op &= op - <NUM_LIT> ; return build_int_cst ( long_integer_type_node , temp ) ;


<s> else temp = exact_log2 ( opint [ <NUM_LIT> ] & - opint [ <NUM_LIT> ] ) ; return build_int_cst ( long_integer_type_node , temp ) ;


<s> unsigned HOST_WIDE_INT loc ; loc = opint [ <NUM_LIT> ] & <NUM_LIT> ; if ( BYTES_BIG_ENDIAN ) loc ^= <NUM_LIT> ; loc *= <NUM_LIT> ; if ( loc != <NUM_LIT> ) { if ( op_const & <NUM_LIT> ) { unsigned HOST_WIDE_INT temp = opint [ <NUM_LIT> ] ; if ( is_high ) temp <<= loc ; else temp >>= loc ; opint [ <NUM_LIT> ] = temp ; zap_const = <NUM_LIT> ;


<s> bytemask <<= loc ; temp = opint [ <NUM_LIT> ] ; if ( is_high ) { 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> ] = bytemask ; return alpha_fold_builtin_zapnot ( zap_op , opint , op_const ) ; } return NULL ;


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


<s> loc = opint [ <NUM_LIT> ] & <NUM_LIT> ; if ( BYTES_BIG_ENDIAN ) loc ^= <NUM_LIT> ; bytemask <<= loc ; if ( is_high ) bytemask >>= <NUM_LIT> ; opint [ <NUM_LIT> ] = bytemask ^ <NUM_LIT> ;


<s> unsigned HOST_WIDE_INT a = ( opint [ <NUM_LIT> ] >> ( i * <NUM_LIT> ) ) & <NUM_LIT> ;

unsigned HOST_WIDE_INT b = ( opint [ <NUM_LIT> ] >> ( i * <NUM_LIT> ) ) & <NUM_LIT> ;


<s> 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 ( long_integer_type_node , temp ) ;


<s> temp = opint [ <NUM_LIT> ] & <NUM_LIT> ;

temp |= ( opint [ <NUM_LIT> ] >> <NUM_LIT> ) & <NUM_LIT> ;


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


<s> } case <NUM_LIT> : opint [ <NUM_LIT> ] = opint [ <NUM_LIT> ] ; case <NUM_LIT> : if ( opint [ <NUM_LIT> ] == <NUM_LIT> || opint [ <NUM_LIT> ] == <NUM_LIT> ) return build_int_cst ( long_integer_type_node , <NUM_LIT> ) ; break ; } return NULL ;


<s> mul_double ( opint [ <NUM_LIT> ] , <NUM_LIT> , opint [ <NUM_LIT> ] , <NUM_LIT> , & l , & h ) ; return build_int_cst ( long_integer_type_node , h ) ; }


temp |= ( opint [ <NUM_LIT> ] & <NUM_LIT> ) << <NUM_LIT> ;


<s> temp = opint [ <NUM_LIT> ] & <NUM_LIT> ; temp |= ( opint [ <NUM_LIT> ] & <NUM_LIT> ) << <NUM_LIT> ;


<s> if ( op_const & <NUM_LIT> ) return build_int_cst ( long_integer_type_node , opint [ <NUM_LIT> ] & mask ) ; if ( op ) return fold ( build2 ( BIT_AND_EXPR , long_integer_type_node , op [ <NUM_LIT> ] , build_int_cst ( long_integer_type_node , mask ) ) ) ; }

else if ( ( op_const & <NUM_LIT> ) && opint [ <NUM_LIT> ] == <NUM_LIT> ) return build_int_cst ( long_integer_type_node , <NUM_LIT> ) ;


<s> static tree alpha_fold_vector_minmax ( enum tree_code code , tree op [ ] , tree vtype ) { tree op0 = fold_convert ( vtype , op [ <NUM_LIT> ] ) ; tree op1 = fold_convert ( vtype , op [ <NUM_LIT> ] ) ; tree val = fold ( build2 ( code , vtype , op0 , op1 ) ) ; return fold_convert ( long_integer_type_node , val ) ;


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

return fold_convert ( long_integer_type_node , val ) ;


<s> if ( TARGET_ABI_OPEN_VMS || TARGET_ABI_UNICOSMK ) return std_gimplify_va_arg_expr ( valist , type , pre_p , post_p ) ; base_field = TYPE_FIELDS ( va_list_type_node ) ; offset_field = TREE_CHAIN ( base_field ) ; base_field = build ( COMPONENT_REF , TREE_TYPE ( base_field ) , valist , base_field , NULL_TREE ) ; offset_field = build ( COMPONENT_REF , TREE_TYPE ( offset_field ) , valist , offset_field , NULL_TREE ) ; base = get_formal_tmp_var ( base_field , pre_p ) ; t = fold_convert ( lang_hooks . types . type_for_size ( <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 ) type = build_pointer_type ( type ) ; r = alpha_gimplify_va_arg_1 ( type , base , offset , pre_p ) ;

t = build ( MODIFY_EXPR , void_type_node , offset_field , fold_convert ( TREE_TYPE ( offset_field ) , offset ) ) ;


<s> else if ( TREE_CODE ( type ) == REAL_TYPE ) { tree fpaddend , cond , fourtyeight ; fourtyeight = build_int_cst ( TREE_TYPE ( addend ) , <NUM_LIT> * <NUM_LIT> ) ; fpaddend = fold ( build ( MINUS_EXPR , TREE_TYPE ( addend ) , addend , fourtyeight ) ) ; cond = fold ( build ( LT_EXPR , boolean_type_node , addend , fourtyeight ) ) ; addend = fold ( build ( COND_EXPR , TREE_TYPE ( addend ) , cond , fpaddend , addend ) ) ; } addr = build ( PLUS_EXPR , ptr_type , fold_convert ( ptr_type , base ) , fold_convert ( ptr_type , addend ) ) ; internal_post = NULL ; gimplify_expr ( & addr , pre_p , & internal_post , is_gimple_val , fb_rvalue ) ; append_to_statement_list ( internal_post , pre_p ) ; type_size = TYPE_SIZE_UNIT ( TYPE_MAIN_VARIANT ( type ) ) ; if ( type_size == NULL || TREE_OVERFLOW ( type_size ) ) t = size_zero_node ;


<s> rtx seq , m = cfun -> machine -> gp_save_rtx ; if ( m == NULL ) { start_sequence ( ) ; m = assign_stack_local ( DImode , UNITS_PER_WORD , BITS_PER_WORD ) ;


<s> if ( m == NULL ) { start_sequence ( ) ; m = assign_stack_local ( DImode , UNITS_PER_WORD , BITS_PER_WORD ) ; m = validize_mem ( m ) ; emit_move_insn ( m , pic_offset_table_rtx ) ; seq = get_insns ( ) ; end_sequence ( ) ;

emit_insn_after ( seq , entry_of_function ( ) ) ;


<s> if ( value == <NUM_LIT> ) target_flags |= MASK_SOFT_FP ; break ; case OPT_mieee : case OPT_mieee_with_inexact : target_flags |= MASK_IEEE_CONFORMANT ; break ;


<s> for ( i = get_insns ( ) ; i ; i = NEXT_INSN ( i ) ) { if ( GET_CODE ( i ) == NOTE ) { switch ( NOTE_LINE_NUMBER ( i ) ) { case NOTE_INSN_EH_REGION_BEG : exception_nesting ++ ; if ( trap_pending ) goto close_shadow ; break ; case NOTE_INSN_EH_REGION_END : exception_nesting -- ; if ( trap_pending ) goto close_shadow ; break ; case NOTE_INSN_EPILOGUE_BEG : if ( trap_pending && alpha_tp >= ALPHA_TP_FUNC ) goto close_shadow ; break ; } } else if ( trap_pending ) { if ( alpha_tp == ALPHA_TP_FUNC ) { if ( GET_CODE ( i ) == JUMP_INSN && GET_CODE ( PATTERN ( i ) ) == RETURN ) goto close_shadow ; } else if ( alpha_tp == ALPHA_TP_INSN ) { if ( optimize > <NUM_LIT> ) { struct shadow_summary sum ; sum . used . i = <NUM_LIT> ; sum . used . fp = <NUM_LIT> ; sum . used . mem = <NUM_LIT> ; sum . defd = sum . used ; switch ( GET_CODE ( i ) ) { case INSN : if ( GET_CODE ( PATTERN ( i ) ) == USE || GET_CODE ( PATTERN ( i ) ) == CLOBBER ) break ; summarize_insn ( PATTERN ( i ) , & sum , <NUM_LIT> ) ; if ( ( sum . defd . i & shadow . defd . i ) || ( sum . defd . fp & shadow . defd . fp ) ) { goto close_shadow ; } shadow . used . i |= sum . used . i ;


<s> exception_nesting ++ ; if ( trap_pending ) goto close_shadow ; break ; case NOTE_INSN_EH_REGION_END : exception_nesting -- ; if ( trap_pending ) goto close_shadow ; break ; case NOTE_INSN_EPILOGUE_BEG : if ( trap_pending && alpha_tp >= ALPHA_TP_FUNC ) goto close_shadow ; break ; } } else if ( trap_pending ) { if ( alpha_tp == ALPHA_TP_FUNC ) { if ( GET_CODE ( i ) == JUMP_INSN && GET_CODE ( PATTERN ( i ) ) == RETURN ) goto close_shadow ; } else if ( alpha_tp == ALPHA_TP_INSN ) { if ( optimize > <NUM_LIT> ) { struct shadow_summary sum ; sum . used . i = <NUM_LIT> ; sum . used . fp = <NUM_LIT> ; sum . used . mem = <NUM_LIT> ; sum . defd = sum . used ; switch ( GET_CODE ( i ) ) { case INSN : if ( GET_CODE ( PATTERN ( i ) ) == USE || GET_CODE ( PATTERN ( i ) ) == CLOBBER ) break ; summarize_insn ( PATTERN ( i ) , & sum , <NUM_LIT> ) ; if ( ( sum . defd . i & shadow . defd . i ) || ( sum . defd . fp & shadow . defd . fp ) ) { goto close_shadow ; } shadow . used . i |= sum . used . i ; shadow . used . fp |= sum . used . fp ; shadow . used . mem |= sum . used . mem ; shadow . defd . i |= sum . defd . i ; shadow . defd . fp |= sum . defd . fp ; shadow . defd . mem |= sum . defd . mem ; if ( ( sum . defd . i & shadow . used . i ) || ( sum . defd . fp & shadow . used . fp ) || ( sum . defd . mem & shadow . used . mem ) ) { gcc_assert ( get_attr_trap ( i ) != TRAP_YES || ( ! ( sum . defd . i & sum . used . i ) && ! ( sum . defd . fp & sum . used . fp ) ) ) ; goto close_shadow ; } break ; case JUMP_INSN : case CALL_INSN : case CODE_LABEL : goto close_shadow ; default : gcc_unreachable ( ) ; } } else { close_shadow : n = emit_insn_before ( gen_trapb ( ) , i ) ; PUT_MODE ( n , TImode ) ; PUT_MODE ( i , TImode ) ; trap_pending = <NUM_LIT> ; shadow . used . i = <NUM_LIT> ; shadow . used . fp = <NUM_LIT> ; shadow . used . mem = <NUM_LIT> ; shadow . defd = shadow . used ; }


<s> addr = memory_address ( SImode , plus_constant ( tramp , jmpofs ) ) ; temp1 = force_reg ( SImode , gen_rtx_MEM ( SImode , addr ) ) ; temp1 = expand_and ( SImode , temp1 , GEN_INT ( <NUM_LIT> ) , NULL_RTX ) ; temp1 = expand_binop ( SImode , ior_optab , temp1 , temp , temp1 , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( gen_rtx_MEM ( SImode , addr ) , temp1 ) ; } emit_library_call ( init_one_libfunc ( <STR_LIT> ) , <NUM_LIT> , VOIDmode , <NUM_LIT> , tramp , Pmode ) ; if ( jmpofs >= <NUM_LIT> ) emit_insn ( gen_imb ( ) ) ;


<s> ret = alpha_sa_size ( ) ; ret += ALPHA_ROUND ( current_function_outgoing_args_size ) ; switch ( from ) { case FRAME_POINTER_REGNUM : break ; case ARG_POINTER_REGNUM : ret += ( ALPHA_ROUND ( get_frame_size ( ) + current_function_pretend_args_size ) - current_function_pretend_args_size ) ; break ; default : gcc_unreachable ( ) ; } return ret ;


<s> HOST_WIDE_INT alpha_initial_elimination_offset ( unsigned int from , unsigned int to ATTRIBUTE_UNUSED ) { HOST_WIDE_INT ret ; ret = alpha_sa_size ( ) ; ret += ALPHA_ROUND ( current_function_outgoing_args_size ) ;


<s> tree ftype , attrs [ <NUM_LIT> ] ; size_t i ; dimode_integer_type_node = lang_hooks . types . type_for_mode ( DImode , <NUM_LIT> ) ; attrs [ <NUM_LIT> ] = tree_cons ( get_identifier ( <STR_LIT> ) , NULL , NULL ) ; attrs [ <NUM_LIT> ] = tree_cons ( get_identifier ( <STR_LIT> ) , NULL , attrs [ <NUM_LIT> ] ) ; ftype = build_function_type ( dimode_integer_type_node , void_list_node ) ; p = zero_arg_builtins ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( zero_arg_builtins ) ; ++ i , ++ p ) if ( ( target_flags & p -> target_mask ) == p -> target_mask ) lang_hooks . builtin_function ( p -> name , ftype , p -> code , BUILT_IN_MD , NULL , attrs [ p -> is_const ] ) ; ftype = build_function_type_list ( dimode_integer_type_node , dimode_integer_type_node , NULL_TREE ) ; p = one_arg_builtins ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( one_arg_builtins ) ; ++ i , ++ p ) if ( ( target_flags & p -> target_mask ) == p -> target_mask ) lang_hooks . builtin_function ( p -> name , ftype , p -> code , BUILT_IN_MD , NULL , attrs [ p -> is_const ] ) ; ftype = build_function_type_list ( dimode_integer_type_node , dimode_integer_type_node , dimode_integer_type_node , NULL_TREE ) ; p = two_arg_builtins ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( two_arg_builtins ) ; ++ i , ++ p ) if ( ( target_flags & p -> target_mask ) == p -> target_mask ) lang_hooks . builtin_function ( p -> name , ftype , p -> code , BUILT_IN_MD , NULL , attrs [ p -> is_const ] ) ; ftype = build_function_type ( ptr_type_node , void_list_node ) ; lang_hooks . builtin_function ( <STR_LIT> , ftype , ALPHA_BUILTIN_THREAD_POINTER , BUILT_IN_MD , NULL , attrs [ <NUM_LIT> ] ) ; ftype = build_function_type_list ( void_type_node , ptr_type_node , NULL_TREE ) ; lang_hooks . builtin_function ( <STR_LIT> , ftype , ALPHA_BUILTIN_SET_THREAD_POINTER , BUILT_IN_MD , NULL , attrs [ <NUM_LIT> ] ) ;


<s> for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( two_arg_builtins ) ; ++ i , ++ p ) if ( ( target_flags & p -> target_mask ) == p -> target_mask ) lang_hooks . builtin_function ( p -> name , ftype , p -> code , BUILT_IN_MD , NULL , attrs [ p -> is_const ] ) ; ftype = build_function_type ( ptr_type_node , void_list_node ) ; lang_hooks . builtin_function ( <STR_LIT> , ftype , ALPHA_BUILTIN_THREAD_POINTER , BUILT_IN_MD , NULL , attrs [ <NUM_LIT> ] ) ; ftype = build_function_type_list ( void_type_node , ptr_type_node , NULL_TREE ) ; lang_hooks . builtin_function ( <STR_LIT> , ftype , ALPHA_BUILTIN_SET_THREAD_POINTER , BUILT_IN_MD , NULL , attrs [ <NUM_LIT> ] ) ; alpha_v8qi_u = build_vector_type ( unsigned_intQI_type_node , <NUM_LIT> ) ; alpha_v8qi_s = build_vector_type ( intQI_type_node , <NUM_LIT> ) ; alpha_v4hi_u = build_vector_type ( unsigned_intHI_type_node , <NUM_LIT> ) ; alpha_v4hi_s = build_vector_type ( intHI_type_node , <NUM_LIT> ) ;


<s> set_optab_libfunc ( udiv_optab , SImode , <NUM_LIT> ) ; set_optab_libfunc ( sdiv_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( udiv_optab , DImode , <STR_LIT> ) ; } else if ( TARGET_ABI_OPEN_VMS ) { set_optab_libfunc ( sdiv_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( udiv_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( udiv_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( smod_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( smod_optab , DImode , <STR_LIT> ) ;

set_optab_libfunc ( umod_optab , SImode , <STR_LIT> ) ;


<s> return ( ( struct machine_function * ) ggc_alloc_cleared ( sizeof ( struct machine_function ) ) ) ;


<s> static bool alpha_in_small_data_p ( tree exp ) { if ( TREE_CODE ( exp ) == STRING_CST ) return false ; if ( TREE_CODE ( exp ) == FUNCTION_DECL ) return false ; if ( TREE_CODE ( exp ) == VAR_DECL && DECL_SECTION_NAME ( exp ) ) { const char * section = TREE_STRING_POINTER ( DECL_SECTION_NAME ( exp ) ) ;

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


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

if ( size > <NUM_LIT> && ( unsigned HOST_WIDE_INT ) size <= g_switch_value ) return true ;


<s> 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 ( GET_CODE ( x ) == SUBREG && ( 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 ( ofs , Pmode ) ) return true ;


<s> case CONST : case LABEL_REF : case SYMBOL_REF : case HIGH : return true ; case CONST_DOUBLE : if ( x == CONST0_RTX ( mode ) ) return true ; if ( FLOAT_MODE_P ( mode ) ) return false ; goto do_integer ; 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 ; goto do_integer ; case CONST_INT : do_integer :

if ( TARGET_BUILD_CONSTANTS ) return true ;


<s> if ( GET_MODE_CLASS ( mode ) != MODE_VECTOR_INT ) return false ; if ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) return false ; goto do_integer ; case CONST_INT : do_integer : if ( TARGET_BUILD_CONSTANTS ) return true ; alpha_extract_integer ( x , & i0 , & i1 ) ; if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> || i1 == ( - i0 < <NUM_LIT> ) ) return alpha_emit_set_const_1 ( x , mode , i0 , <NUM_LIT> , true ) != NULL ; return false ;


<s> if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x , <NUM_LIT> ) ) < FIRST_PSEUDO_REGISTER && REGNO_OK_FOR_BASE_P ( REGNO ( XEXP ( x , <NUM_LIT> ) ) ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { 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 , type ) ; return x ; }


<s> } if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x , <NUM_LIT> ) ) < FIRST_PSEUDO_REGISTER && REGNO_OK_FOR_BASE_P ( REGNO ( XEXP ( x , <NUM_LIT> ) ) ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { 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 const char * alpha_mangle_fundamental_type ( tree type ) { if ( TYPE_MAIN_VARIANT ( type ) == long_double_type_node && TARGET_LONG_DOUBLE_128 ) return <STR_LIT> ; return NULL ;


<s> rtx alpha_need_linkage ( const char * name ATTRIBUTE_UNUSED , int is_local ATTRIBUTE_UNUSED ) {


<s> fprintf ( stream , <STR_LIT> ) ; if ( ! TARGET_GAS && write_symbols == DBX_DEBUG ) fprintf ( stream , <STR_LIT> ) ; } else if ( write_symbols == DBX_DEBUG ) return ; else if ( name != current_function_file && strcmp ( name , current_function_file ) != <NUM_LIT> ) { if ( inside_function && ! TARGET_GAS ) fprintf ( stream , <STR_LIT> , num_source_filenames ) ; else { ++ num_source_filenames ; current_function_file = name ; fprintf ( stream , <STR_LIT> , num_source_filenames ) ;


<s> else if ( write_symbols == DBX_DEBUG ) return ; else if ( name != current_function_file && strcmp ( name , current_function_file ) != <NUM_LIT> ) { if ( inside_function && ! TARGET_GAS ) fprintf ( stream , <STR_LIT> , num_source_filenames ) ; else { ++ num_source_filenames ; current_function_file = name ; fprintf ( stream , <STR_LIT> , num_source_filenames ) ; } output_quoted_string ( stream , name ) ;


<s> lo = ( ( delta & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; hi = ( ( ( delta - lo ) & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; if ( hi + lo == delta ) { if ( hi ) emit_insn ( gen_adddi3 ( this , this , GEN_INT ( hi ) ) ) ; if ( lo ) emit_insn ( gen_adddi3 ( this , this , GEN_INT ( lo ) ) ) ; } else { rtx tmp = alpha_emit_set_long_const ( gen_rtx_REG ( Pmode , <NUM_LIT> ) , delta , - ( delta < <NUM_LIT> ) ) ; emit_insn ( gen_adddi3 ( this , this , tmp ) ) ; } if ( vcall_offset ) { rtx tmp , tmp2 ; tmp = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , this ) ) ; 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 , - ( vcall_offset < <NUM_LIT> ) ) ; 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 , this , 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 ) ;


<s> enum reg_class alpha_preferred_reload_class ( rtx x , enum reg_class class ) { if ( x == CONST0_RTX ( GET_MODE ( x ) ) ) return class ; if ( GET_CODE ( x ) == CONST_INT || GET_CODE ( x ) == CONST_DOUBLE || GET_CODE ( x ) == CONST_VECTOR ) { if ( class == FLOAT_REGS ) return NO_REGS ;

if ( class == ALL_REGS ) return GENERAL_REGS ;


<s> enum reg_class alpha_preferred_reload_class ( rtx x , enum reg_class class ) { if ( x == CONST0_RTX ( GET_MODE ( x ) ) ) return class ; if ( GET_CODE ( x ) == CONST_INT || GET_CODE ( x ) == CONST_DOUBLE || GET_CODE ( x ) == CONST_VECTOR ) { if ( class == FLOAT_REGS ) return NO_REGS ; if ( class == ALL_REGS ) return GENERAL_REGS ;


<s> static int alpha_ra_ever_killed ( void ) { rtx top ; if ( ! has_hard_reg_initial_val ( Pmode , REG_RA ) ) return regs_ever_live [ REG_RA ] ; push_topmost_sequence ( ) ; top = get_insns ( ) ; pop_topmost_sequence ( ) ;

return reg_set_between_p ( gen_rtx_REG ( Pmode , REG_RA ) , top , NULL_RTX ) ;


<s> mode = TYPE_MODE ( type ) ; if ( AGGREGATE_TYPE_P ( type ) ) return true ; } size = GET_MODE_SIZE ( mode ) ; switch ( GET_MODE_CLASS ( mode ) ) {


<s> * fmaskP = <NUM_LIT> ; return ; } if ( TARGET_ABI_OPEN_VMS && alpha_procedure_type == PT_STACK ) imask |= ( <NUM_LIT> << HARD_FRAME_POINTER_REGNUM ) ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( ! fixed_regs [ i ] && ! call_used_regs [ i ] && regs_ever_live [ i ] && i != REG_RA && ( ! TARGET_ABI_UNICOSMK || i != HARD_FRAME_POINTER_REGNUM ) ) { if ( i < <NUM_LIT> ) imask |= ( <NUM_LIT> << i ) ; else fmask |= ( <NUM_LIT> << ( i - <NUM_LIT> ) ) ; } if ( current_function_calls_eh_return ) { for ( i = <NUM_LIT> ; ; ++ i ) { unsigned regno = EH_RETURN_DATA_REGNO ( i ) ; if ( regno == INVALID_REGNUM ) break ; imask |= <NUM_LIT> << regno ;


<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_UNICOSMK ) { alpha_procedure_type = ( sa_size || get_frame_size ( ) != <NUM_LIT> || current_function_outgoing_args_size || current_function_stdarg || current_function_calls_alloca || frame_pointer_needed ) ? PT_STACK : PT_REGISTER ; if ( alpha_procedure_type == PT_STACK ) sa_size = <NUM_LIT> ; } else if ( TARGET_ABI_OPEN_VMS ) { if ( ( mask [ <NUM_LIT> ] >> REG_RA ) & <NUM_LIT> ) alpha_procedure_type = PT_STACK ; else if ( get_frame_size ( ) != <NUM_LIT> ) alpha_procedure_type = PT_REGISTER ; else alpha_procedure_type = PT_NULL ;


<s> case SImode : case DImode : case TImode : return true ; case SFmode : case DFmode : return true ; case TFmode : return TARGET_HAS_XFLOATING_LIBS ; default : return false ;


<s> CUMULATIVE_ARGS cum = * pcum ; FUNCTION_ARG_ADVANCE ( cum , mode , type , <NUM_LIT> ) ; if ( cum . num_reg_words < <NUM_LIT> ) { if ( ! no_rtl ) { emit_insn ( gen_umk_mismatch_args ( GEN_INT ( cum . num_reg_words ) ) ) ; emit_insn ( gen_arg_home_umk ( ) ) ; } * pretend_size = <NUM_LIT> ; } if ( cum . num_args < <NUM_LIT> ) { if ( ! no_rtl ) { emit_move_insn ( gen_rtx_REG ( DImode , <NUM_LIT> ) , virtual_incoming_args_rtx ) ; emit_insn ( gen_arg_home ( ) ) ; } * pretend_size = <NUM_LIT> * UNITS_PER_WORD ; } if ( cum >= <NUM_LIT> ) return ; if ( ! no_rtl ) { int count , 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 ( 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 ( virtual_incoming_args_rtx , cum * UNITS_PER_WORD ) ) ; MEM_NOTRAP_P ( tmp ) = <NUM_LIT> ; set_mem_alias_set ( tmp , set ) ;

move_block_from_reg ( <NUM_LIT> + cum + TARGET_FPREGS * <NUM_LIT> , tmp , count ) ;


<s> void alpha_set_memflags ( rtx insn , rtx ref ) { rtx * base_ptr ; if ( GET_CODE ( ref ) != MEM ) return ; if ( ! MEM_VOLATILE_P ( ref ) && ! MEM_IN_STRUCT_P ( ref ) && ! MEM_SCALAR_P ( ref ) && ! MEM_NOTRAP_P ( ref ) && ! MEM_READONLY_P ( ref ) ) return ; if ( INSN_P ( insn ) ) base_ptr = & PATTERN ( insn ) ; else base_ptr = & insn ;

for_each_rtx ( base_ptr , alpha_set_memflags_1 , ( void * ) ref ) ;


<s> rtx * base_ptr ; if ( GET_CODE ( ref ) != MEM ) return ;

if ( ! MEM_VOLATILE_P ( ref ) && ! MEM_IN_STRUCT_P ( ref ) && ! MEM_SCALAR_P ( ref ) && ! MEM_NOTRAP_P ( ref ) && ! MEM_READONLY_P ( ref ) ) return ;


<s> static int alpha_set_memflags_1 ( rtx * xp , void * data ) { rtx x = * xp , orig = ( rtx ) data ; if ( GET_CODE ( x ) != MEM ) return <NUM_LIT> ; MEM_VOLATILE_P ( x ) = MEM_VOLATILE_P ( orig ) ; MEM_IN_STRUCT_P ( x ) = MEM_IN_STRUCT_P ( orig ) ; MEM_SCALAR_P ( x ) = MEM_SCALAR_P ( orig ) ;

MEM_NOTRAP_P ( x ) = MEM_NOTRAP_P ( orig ) ;


<s> static int alpha_set_memflags_1 ( rtx * xp , void * data ) { rtx x = * xp , orig = ( rtx ) data ; if ( GET_CODE ( x ) != MEM ) return <NUM_LIT> ; MEM_VOLATILE_P ( x ) = MEM_VOLATILE_P ( orig ) ; MEM_IN_STRUCT_P ( x ) = MEM_IN_STRUCT_P ( orig ) ; MEM_SCALAR_P ( x ) = MEM_SCALAR_P ( orig ) ; MEM_NOTRAP_P ( x ) = MEM_NOTRAP_P ( orig ) ;

MEM_READONLY_P ( x ) = MEM_READONLY_P ( orig ) ;


<s> enum machine_mode mode = GET_MODE ( mem ) ; rtx label , x , cond = gen_rtx_REG ( DImode , REGNO ( scratch ) ) ; emit_insn ( gen_memory_barrier ( ) ) ; label = gen_label_rtx ( ) ; emit_label ( label ) ; label = gen_rtx_LABEL_REF ( DImode , label ) ;

if ( before == NULL ) before = scratch ;


<s> emit_label ( label ) ; 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 , gen_rtx_NOT ( mode , before ) , 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 ) ) ;


<s> if ( oldval == 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 ( scratch , newval ) ; emit_store_conditional ( mode , cond , mem , scratch ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; emit_unlikely_jump ( x , label1 ) ;


<s> label1 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; label2 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ; emit_label ( XEXP ( label1 , <NUM_LIT> ) ) ; emit_load_locked ( DImode , scratch , mem ) ; width = GEN_INT ( GET_MODE_BITSIZE ( mode ) ) ; mask = GEN_INT ( mode == QImode ? <NUM_LIT> : <NUM_LIT> ) ; if ( WORDS_BIG_ENDIAN ) emit_insn ( gen_extxl_be ( dest , scratch , width , addr ) ) ; else emit_insn ( gen_extxl_le ( dest , scratch , width , addr ) ) ; if ( oldval == 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 ) ;


<s> static bool alpha_split_complex_arg ( tree type ) { return TYPE_MODE ( type ) != TCmode ;


<s> diff = t - f ; } subtarget = target = dest ; if ( mode != DImode ) { target = gen_lowpart ( DImode , dest ) ; if ( ! no_new_pseudos ) 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 ( VOIDmode , copy_rtx ( subtarget ) , tmp ) ) ; tmp = gen_rtx_ASHIFT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( exact_log2 ( t ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , 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 ( VOIDmode , 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 ( VOIDmode , 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 ) ;


<s> 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 ) { if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , temp ) ) emit_move_insn ( operands [ <NUM_LIT> ] , temp ) ; return true ;


<s> rtx label , x , cond = gen_lowpart ( DImode , scratch ) ; emit_insn ( gen_memory_barrier ( ) ) ; 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 ) ;


<s> emit_insn ( gen_memory_barrier ( ) ) ; 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 ) ) ; mask = GEN_INT ( mode == QImode ? <NUM_LIT> : <NUM_LIT> ) ; if ( WORDS_BIG_ENDIAN ) { emit_insn ( gen_extxl_be ( dest , scratch , width , addr ) ) ;

emit_insn ( gen_mskxl_be ( scratch , scratch , mask , addr ) ) ;


<s> void alpha_split_lock_test_and_set_12 ( enum machine_mode mode , rtx dest , rtx addr , rtx val , rtx align , rtx scratch ) { rtx label , mem , width , mask , x ; mem = gen_rtx_MEM ( DImode , align ) ; MEM_VOLATILE_P ( mem ) = <NUM_LIT> ; emit_insn ( gen_memory_barrier ( ) ) ; 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 ) ) ; mask = GEN_INT ( mode == QImode ? <NUM_LIT> : <NUM_LIT> ) ; if ( WORDS_BIG_ENDIAN ) { emit_insn ( gen_extxl_be ( dest , scratch , width , addr ) ) ; emit_insn ( gen_mskxl_be ( scratch , scratch , mask , addr ) ) ; } else { emit_insn ( gen_extxl_le ( dest , scratch , width , addr ) ) ; emit_insn ( gen_mskxl_le ( scratch , scratch , mask , addr ) ) ; }

emit_insn ( gen_iordi3 ( scratch , scratch , val ) ) ;


<s> 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 , high_bit , operands [ <NUM_LIT> ] ) ) ; if ( move > <NUM_LIT> ) {


<s> break ; case MEM : operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; break ; case CONST_DOUBLE : gcc_assert ( operands [ <NUM_LIT> ] == CONST0_RTX ( TFmode ) ) ; operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] = const0_rtx ; break ; default : gcc_unreachable ( ) ; } switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { case REG :

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


<s> gcc_assert ( operands [ <NUM_LIT> ] == CONST0_RTX ( TFmode ) ) ; operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] = const0_rtx ; break ; default : gcc_unreachable ( ) ; } switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { case REG : operands [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; operands [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( operands [ <NUM_LIT> ] ) ) ; break ; case MEM : operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; break ; default : gcc_unreachable ( ) ;


<s> if ( PHI_NUM_ARGS ( offset ) != <NUM_LIT> ) goto escapes ; arg1 = va_list_skip_additions ( PHI_ARG_DEF ( offset , <NUM_LIT> ) ) ; arg2 = va_list_skip_additions ( PHI_ARG_DEF ( offset , <NUM_LIT> ) ) ; if ( TREE_CODE ( arg2 ) != MINUS_EXPR && TREE_CODE ( arg2 ) != PLUS_EXPR ) { tree tem = arg1 ; arg1 = arg2 ; arg2 = tem ; if ( TREE_CODE ( arg2 ) != MINUS_EXPR && TREE_CODE ( arg2 ) != PLUS_EXPR ) goto escapes ; } if ( ! host_integerp ( TREE_OPERAND ( arg2 , <NUM_LIT> ) , <NUM_LIT> ) ) goto escapes ; sub = tree_low_cst ( TREE_OPERAND ( arg2 , <NUM_LIT> ) , <NUM_LIT> ) ; if ( TREE_CODE ( arg2 ) == MINUS_EXPR ) sub = - sub ; if ( sub < - <NUM_LIT> || sub > - <NUM_LIT> ) goto escapes ; arg2 = va_list_skip_additions ( TREE_OPERAND ( arg2 , <NUM_LIT> ) ) ;


<s> rtx tmp ; tmp = JUMP_LABEL ( insn ) ; if ( ! tmp ) return NULL_RTX ; tmp = NEXT_INSN ( tmp ) ; if ( ! tmp ) return NULL_RTX ; if ( GET_CODE ( tmp ) == JUMP_INSN && GET_CODE ( PATTERN ( tmp ) ) == ADDR_DIFF_VEC ) return PATTERN ( tmp ) ;


<s> if ( ! tmp ) return NULL_RTX ; tmp = NEXT_INSN ( tmp ) ; if ( ! tmp ) return NULL_RTX ; if ( GET_CODE ( tmp ) == JUMP_INSN && GET_CODE ( PATTERN ( tmp ) ) == ADDR_DIFF_VEC ) return PATTERN ( tmp ) ; return NULL_RTX ;


<s> for ( j = i + <NUM_LIT> ; j < n_labels ; j ++ ) if ( XEXP ( XVECEXP ( jump_table , <NUM_LIT> , i ) , <NUM_LIT> ) == XEXP ( XVECEXP ( jump_table , <NUM_LIT> , j ) , <NUM_LIT> ) ) count ++ ; if ( count > best_count ) best_count = count , best_label = XVECEXP ( jump_table , <NUM_LIT> , i ) ; } } return best_label ? best_label : const0_rtx ;


<s> rtx best_label = NULL_RTX ; if ( jump_table ) { int n_labels = XVECLEN ( jump_table , <NUM_LIT> ) ; int best_count = - <NUM_LIT> ; int i , j ; for ( i = <NUM_LIT> ; i < n_labels ; i ++ ) { int count = <NUM_LIT> ; for ( j = i + <NUM_LIT> ; j < n_labels ; j ++ ) if ( XEXP ( XVECEXP ( jump_table , <NUM_LIT> , i ) , <NUM_LIT> ) == XEXP ( XVECEXP ( jump_table , <NUM_LIT> , j ) , <NUM_LIT> ) ) count ++ ;

if ( count > best_count ) best_count = count , best_label = XVECEXP ( jump_table , <NUM_LIT> , i ) ;


<s> rtx alpha_use_linkage ( rtx linkage ATTRIBUTE_UNUSED , tree cfundecl ATTRIBUTE_UNUSED , int lflag ATTRIBUTE_UNUSED , int rflag ATTRIBUTE_UNUSED ) {


<s> base_field = TYPE_FIELDS ( TREE_TYPE ( valist ) ) ; offset_field = TREE_CHAIN ( base_field ) ; base_field = build ( COMPONENT_REF , TREE_TYPE ( base_field ) , valist , base_field , NULL_TREE ) ; offset_field = build ( COMPONENT_REF , TREE_TYPE ( offset_field ) , valist , offset_field , NULL_TREE ) ; t = make_tree ( ptr_type_node , virtual_incoming_args_rtx ) ; t = build ( PLUS_EXPR , ptr_type_node , t , build_int_cst ( NULL_TREE , offset ) ) ;

t = build ( MODIFY_EXPR , TREE_TYPE ( base_field ) , base_field , t ) ;


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


<s> if ( ! ( * targetm . binds_local_p ) ( decl ) ) return false ;

if ( TARGET_EXPLICIT_RELOCS && TARGET_SMALL_DATA ) return true ;


<s> int direct_return ( void ) { return ( ! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK && reload_completed && alpha_sa_size ( ) == <NUM_LIT> && get_frame_size ( ) == <NUM_LIT> && current_function_outgoing_args_size == <NUM_LIT> && current_function_pretend_args_size == <NUM_LIT> ) ;


<s> set_mem_alias_set ( mem , alpha_sr_alias_set ) ; 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 ( stack_pointer_rtx , frame_bias + base_ofs ) ; mem = gen_rtx_MEM ( DImode , addr ) ; } REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , mem , frame_reg ) , REG_NOTES ( insn ) ) ; }


<s> } else { if ( mode == QImode ) fn = gen_insbl_le ; else fn = gen_inswl_le ; } emit_insn ( fn ( ret , op1 , op2 ) ) ; return ret ;


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


<s> else if ( mode == DImode ) fn = gen_store_conditional_di ;


<s> if ( mode == SImode ) fn = gen_store_conditional_si ; else if ( mode == DImode ) fn = gen_store_conditional_di ; emit_insn ( fn ( res , mem , val ) ) ;


<s> static void emit_unlikely_jump ( rtx cond , rtx label ) { rtx very_unlikely = GEN_INT ( REG_BR_PROB_BASE / <NUM_LIT> - <NUM_LIT> ) ; rtx x ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , cond , label , pc_rtx ) ;

x = emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , x ) ) ;


<s> static void emit_unlikely_jump ( rtx cond , rtx label ) {


<s> static int find_lo_sum_using_gp ( rtx * px , void * data ATTRIBUTE_UNUSED ) {

return GET_CODE ( * px ) == LO_SUM && XEXP ( * px , <NUM_LIT> ) == pic_offset_table_rtx ;


<s> else lo |= cum . num_reg_words ; hi = ( cum . num_args << <NUM_LIT> ) | cum . num_arg_words ; lo = lo | ( ( HOST_WIDE_INT ) cum . num_args << <NUM_LIT> ) | ( ( HOST_WIDE_INT ) cum . num_arg_words << <NUM_LIT> ) ; hi = <NUM_LIT> ; ciw = immed_double_const ( lo , hi , DImode ) ; return gen_rtx_UNSPEC ( DImode , gen_rtvec ( <NUM_LIT> , ciw ) , UNSPEC_UMK_LOAD_CIW ) ; } size = ALPHA_ARG_SIZE ( mode , type , named ) ; num_args = cum . num_reg_words ; if ( cum . force_stack || cum . num_reg_words + size > <NUM_LIT> || targetm . calls . must_pass_in_stack ( mode , type ) ) return NULL_RTX ; else if ( type && TYPE_MODE ( type ) == BLKmode ) { rtx reg1 , reg2 ; reg1 = gen_rtx_REG ( DImode , num_args + <NUM_LIT> ) ; reg1 = gen_rtx_EXPR_LIST ( DImode , reg1 , const0_rtx ) ; if ( size == <NUM_LIT> ) return NULL_RTX ; else if ( size == <NUM_LIT> ) return gen_rtx_PARALLEL ( mode , gen_rtvec ( <NUM_LIT> , reg1 ) ) ; else { reg2 = gen_rtx_REG ( DImode , num_args + <NUM_LIT> ) ;


<s> rtx function_arg ( CUMULATIVE_ARGS cum , enum machine_mode mode , tree type , int named ATTRIBUTE_UNUSED ) { int basereg ; int num_args ; if ( type && AGGREGATE_TYPE_P ( type ) ) basereg = <NUM_LIT> ; else { gcc_assert ( ! COMPLEX_MODE_P ( mode ) ) ; if ( TARGET_FPREGS && GET_MODE_CLASS ( mode ) == MODE_FLOAT ) basereg = <NUM_LIT> + <NUM_LIT> ; else basereg = <NUM_LIT> ; } { if ( mode == VOIDmode ) return alpha_arg_info_reg_val ( cum ) ; num_args = cum . num_args ; if ( num_args >= <NUM_LIT> || targetm . calls . must_pass_in_stack ( mode , type ) ) return NULL_RTX ; } { int size ; if ( mode == VOIDmode ) { int i ; HOST_WIDE_INT lo ; HOST_WIDE_INT hi ; rtx ciw ; lo = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < cum . num_reg_words && i < <NUM_LIT> ; i ++ ) if ( cum . reg_args_type [ i ] ) lo |= ( <NUM_LIT> << ( <NUM_LIT> - i ) ) ; if ( cum . num_reg_words == <NUM_LIT> && cum . reg_args_type [ <NUM_LIT> ] ) lo |= <NUM_LIT> ; else lo |= cum . num_reg_words ; hi = ( cum . num_args << <NUM_LIT> ) | cum . num_arg_words ; lo = lo | ( ( HOST_WIDE_INT ) cum . num_args << <NUM_LIT> ) | ( ( HOST_WIDE_INT ) cum . num_arg_words << <NUM_LIT> ) ; hi = <NUM_LIT> ; ciw = immed_double_const ( lo , hi , DImode ) ; return gen_rtx_UNSPEC ( DImode , gen_rtvec ( <NUM_LIT> , ciw ) , UNSPEC_UMK_LOAD_CIW ) ; } size = ALPHA_ARG_SIZE ( mode , type , named ) ; num_args = cum . num_reg_words ; if ( cum . force_stack || cum . num_reg_words + size > <NUM_LIT> || targetm . calls . must_pass_in_stack ( mode , type ) ) return NULL_RTX ; else if ( type && TYPE_MODE ( type ) == BLKmode ) { rtx reg1 , reg2 ;


<s> case MODE_VECTOR_INT : regnum = <NUM_LIT> ; break ; case MODE_FLOAT : regnum = <NUM_LIT> ; break ; case MODE_COMPLEX_FLOAT : { enum machine_mode cmode = GET_MODE_INNER ( mode ) ; return gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( cmode , <NUM_LIT> ) , const0_rtx ) , gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( cmode , <NUM_LIT> ) , GEN_INT ( GET_MODE_SIZE ( cmode ) ) ) ) ) ; } default : gcc_unreachable ( ) ;


<s> rtx function_value ( tree valtype , tree func ATTRIBUTE_UNUSED , enum machine_mode mode ) { unsigned int regnum , dummy ; enum mode_class class ; gcc_assert ( ! valtype || ! alpha_return_in_memory ( valtype , func ) ) ; if ( valtype ) mode = TYPE_MODE ( valtype ) ; class = GET_MODE_CLASS ( mode ) ; switch ( class ) { case MODE_INT : PROMOTE_MODE ( mode , dummy , valtype ) ; case MODE_COMPLEX_INT : case MODE_VECTOR_INT : regnum = <NUM_LIT> ; break ; case MODE_FLOAT : regnum = <NUM_LIT> ; break ;


<s> void get_aligned_mem ( rtx ref , rtx * paligned_mem , rtx * pbitnum ) { rtx base ; HOST_WIDE_INT disp , offset ; gcc_assert ( GET_CODE ( ref ) == MEM ) ; 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> ;

* paligned_mem = widen_memory_access ( ref , SImode , - offset ) ;


<s> 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> ; * paligned_mem = widen_memory_access ( ref , SImode , - offset ) ; if ( WORDS_BIG_ENDIAN ) offset = <NUM_LIT> - ( GET_MODE_BITSIZE ( GET_MODE ( ref ) ) + offset * <NUM_LIT> ) ; else offset *= <NUM_LIT> ;


<s> rtx insn ; if ( cfun -> machine -> some_ld_name ) return cfun -> machine -> some_ld_name ;

for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) && for_each_rtx ( & PATTERN ( insn ) , get_some_local_dynamic_name_1 , <NUM_LIT> ) ) return cfun -> machine -> some_ld_name ;


<s> for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) && for_each_rtx ( & PATTERN ( insn ) , get_some_local_dynamic_name_1 , <NUM_LIT> ) ) return cfun -> machine -> some_ld_name ; gcc_unreachable ( ) ;


if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_DYNAMIC ) {


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

return plus_constant ( base , offset + extra_offset ) ;


<s> 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> struct alpha_funcs GTY ( ( ) ) { int num ;

splay_tree GTY ( ( param1_is ( char * ) , param2_is ( struct alpha_links * ) ) ) links ;


<s> splay_tree GTY ( ( param1_is ( char * ) , param2_is ( struct alpha_links * ) ) ) links ;


<s> reloclo = <STR_LIT> ; output_addr_const ( file , op1 ) ; } if ( offset ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC , offset ) ; addr = XEXP ( addr , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case REG : basereg = REGNO ( addr ) ; break ; case SUBREG : basereg = subreg_regno ( addr ) ; break ; default : gcc_unreachable ( ) ; } fprintf ( file , <STR_LIT> , basereg , ( basereg == <NUM_LIT> ? reloc16 : reloclo ) ) ; return ; } switch ( GET_CODE ( addr ) ) { case REG : basereg = REGNO ( addr ) ; break ; case SUBREG : basereg = subreg_regno ( addr ) ; break ; case CONST_INT : offset = INTVAL ( addr ) ; break ; case SYMBOL_REF :

fprintf ( file , <STR_LIT> , XSTR ( addr , <NUM_LIT> ) ) ;


<s> rtx resolve_reload_operand ( rtx op ) { if ( reload_in_progress ) { rtx tmp = op ; if ( GET_CODE ( tmp ) == SUBREG ) tmp = SUBREG_REG ( tmp ) ; if ( GET_CODE ( tmp ) == REG && REGNO ( tmp ) >= FIRST_PSEUDO_REGISTER ) {

op = reg_equiv_memory_loc [ REGNO ( tmp ) ] ;


<s> rtx resolve_reload_operand ( rtx op ) { if ( reload_in_progress ) { rtx tmp = op ;

if ( GET_CODE ( tmp ) == SUBREG ) tmp = SUBREG_REG ( tmp ) ;


<s> if ( ( mode == QImode || mode == HImode ) && ! TARGET_BWX ) { if ( GET_CODE ( x ) == MEM || ( GET_CODE ( x ) == REG && REGNO ( x ) >= FIRST_PSEUDO_REGISTER ) || ( GET_CODE ( x ) == SUBREG && ( GET_CODE ( SUBREG_REG ( x ) ) == MEM || ( GET_CODE ( SUBREG_REG ( x ) ) == REG && REGNO ( SUBREG_REG ( x ) ) >= FIRST_PSEUDO_REGISTER ) ) ) ) { if ( ! in || ! aligned_memory_operand ( x , mode ) ) return GENERAL_REGS ; } } if ( class == FLOAT_REGS ) { if ( GET_CODE ( x ) == MEM && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == AND ) return GENERAL_REGS ; if ( GET_CODE ( x ) == SUBREG && ( GET_MODE_SIZE ( GET_MODE ( x ) ) > GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( x ) ) ) ) ) return GENERAL_REGS ; if ( in && INTEGRAL_MODE_P ( mode ) && ! ( memory_operand ( x , mode ) || x == const0_rtx ) ) return GENERAL_REGS ;


<s> insn = seq ; while ( insn != NULL_RTX ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = NEXT_INSN ( insn ) ; } seq = emit_insn ( seq ) ; } else { seq = emit_insn ( seq ) ;

RTX_FRAME_RELATED_P ( seq ) = <NUM_LIT> ;


<s> } seq = emit_insn ( seq ) ; } else { seq = emit_insn ( seq ) ; RTX_FRAME_RELATED_P ( seq ) = <NUM_LIT> ; }


<s> if ( GET_CODE ( x ) == LO_SUM ) return - <NUM_LIT> ; return small_symbolic_operand ( x , Pmode ) != <NUM_LIT> ;


<s> rtx split_small_symbolic_operand ( rtx x ) { x = copy_insn ( x ) ; for_each_rtx ( & x , split_small_symbolic_operand_1 , NULL ) ; return x ;


<s> rtx split_small_symbolic_operand ( rtx x ) { x = copy_insn ( x ) ; for_each_rtx ( & x , split_small_symbolic_operand_1 , NULL ) ;


<s> if ( GET_CODE ( x ) == LO_SUM ) return - <NUM_LIT> ; if ( small_symbolic_operand ( x , Pmode ) ) { x = gen_rtx_LO_SUM ( Pmode , pic_offset_table_rtx , x ) ; * px = x ; return - <NUM_LIT> ; }


<s> } break ; case MEM : if ( set ) sum -> defd . mem = <NUM_LIT> ; else sum -> used . mem = <NUM_LIT> ; summarize_insn ( XEXP ( x , <NUM_LIT> ) , sum , <NUM_LIT> ) ; break ; case CONST_INT : case CONST_DOUBLE : case SYMBOL_REF : case LABEL_REF : case CONST : case SCRATCH : case ASM_INPUT : break ; case COMPARE : case PLUS : case MINUS : case MULT : case DIV : case MOD : case UDIV : case UMOD : case AND : case IOR : case XOR : case ASHIFT : case ROTATE : case ASHIFTRT : case LSHIFTRT : case ROTATERT : case SMIN : case SMAX : case UMIN : case UMAX : case NE : case EQ : case GE : case GT : case LE : case LT : case GEU : case GTU : case LEU : case LTU : summarize_insn ( XEXP ( x , <NUM_LIT> ) , sum , <NUM_LIT> ) ; summarize_insn ( XEXP ( x , <NUM_LIT> ) , sum , <NUM_LIT> ) ; break ; case NEG : case NOT : case SIGN_EXTEND : case ZERO_EXTEND : case TRUNCATE : case FLOAT_EXTEND : case FLOAT_TRUNCATE : case FLOAT : case FIX : case UNSIGNED_FLOAT : case UNSIGNED_FIX : case ABS : case SQRT : case FFS : summarize_insn ( XEXP ( x , <NUM_LIT> ) , sum , <NUM_LIT> ) ; break ; default : format_ptr = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) switch ( format_ptr [ i ] ) { case 'e' :

summarize_insn ( XEXP ( x , i ) , sum , <NUM_LIT> ) ;


<s> enum tls_model model ; if ( GET_CODE ( symbol ) != SYMBOL_REF ) return <NUM_LIT> ; model = SYMBOL_REF_TLS_MODEL ( symbol ) ; if ( model == TLS_MODEL_LOCAL_EXEC && alpha_tls_size == <NUM_LIT> ) model = TLS_MODEL_INITIAL_EXEC ;


<s> if ( GET_CODE ( symbol ) != SYMBOL_REF ) return <NUM_LIT> ;

model = SYMBOL_REF_TLS_MODEL ( symbol ) ;


<s> rtx unicosmk_add_call_info_word ( rtx x ATTRIBUTE_UNUSED ) { return NULL_RTX ;


<s> void unicosmk_add_extern ( const char * name ) { struct unicosmk_extern_list * p ; p = ( struct unicosmk_extern_list * ) xmalloc ( sizeof ( struct unicosmk_extern_list ) ) ; p -> next = unicosmk_extern_head ; p -> name = name ; unicosmk_extern_head = p ;


<s> p -> next = unicosmk_extern_head ; p -> name = name ; unicosmk_extern_head = p ;


<s> if ( current_section_align != <NUM_LIT> ) fprintf ( asm_out_file , <STR_LIT> , name , current_section_align , kind ) ; else fprintf ( asm_out_file , <STR_LIT> , name , kind ) ;


<s> fputs ( <STR_LIT> , asm_out_file ) ; if ( flags & SECTION_MAIN ) fputs ( <STR_LIT> , asm_out_file ) ; if ( flags & SECTION_CODE ) kind = <STR_LIT> ; else if ( flags & SECTION_PUBLIC ) kind = <STR_LIT> ;


<s> static int count = <NUM_LIT> ; sprintf ( unicosmk_section_buf , <STR_LIT> , count ++ ) ;


<s> sprintf ( unicosmk_section_buf , <STR_LIT> , count ++ ) ; return unicosmk_section_buf ;


<s> vec = gen_rtx_EXPR_LIST ( VOIDmode , lab , vec ) ; machine -> addr_list = gen_rtx_EXPR_LIST ( VOIDmode , vec , machine -> addr_list ) ;


<s> void unicosmk_defer_case_vector ( rtx lab , rtx vec ) {

struct machine_function * machine = cfun -> machine ;


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


<s> unicosmk_output_module_name ( asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) fprintf ( asm_out_file , <STR_LIT> , i , i ) ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) fprintf ( asm_out_file , <STR_LIT> , i , i ) ; putc ( '\n' , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ;


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


<s> static void unicosmk_gen_dsib ( unsigned long * imaskP ATTRIBUTE_UNUSED ) {


<s> if ( fixed_size != <NUM_LIT> ) fixed_size += <NUM_LIT> ; if ( from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return - fixed_size ; else if ( from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return <NUM_LIT> ; else if ( from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) return ( ALPHA_ROUND ( current_function_outgoing_args_size ) + ALPHA_ROUND ( get_frame_size ( ) ) ) ; else if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) return ( ALPHA_ROUND ( fixed_size ) + ALPHA_ROUND ( get_frame_size ( ) + current_function_outgoing_args_size ) ) ;


<s> static void unicosmk_insert_attributes ( tree decl , tree * attr_ptr ATTRIBUTE_UNUSED ) {

if ( DECL_P ( decl ) && ( TREE_PUBLIC ( decl ) || TREE_CODE ( decl ) == FUNCTION_DECL ) ) unicosmk_unique_section ( decl , <NUM_LIT> ) ;


<s> if ( type == NULL ) return false ; if ( TREE_CODE ( TYPE_SIZE ( type ) ) != INTEGER_CST ) return true ;

if ( TREE_ADDRESSABLE ( type ) ) return true ;


<s> if ( TREE_CODE ( TYPE_SIZE ( type ) ) != INTEGER_CST ) return true ; if ( TREE_ADDRESSABLE ( type ) ) return true ;

return ALPHA_ARG_SIZE ( mode , type , <NUM_LIT> ) > <NUM_LIT> ;


<s> static int unicosmk_need_dex ( rtx x ATTRIBUTE_UNUSED ) {


<s> int idx ; ( * targetm . asm_out . internal_label ) ( file , <STR_LIT> , CODE_LABEL_NUMBER ( lab ) ) ; for ( idx = <NUM_LIT> ; idx < vlen ; idx ++ ) { ASM_OUTPUT_ADDR_VEC_ELT ( file , CODE_LABEL_NUMBER ( XEXP ( XVECEXP ( body , <NUM_LIT> , idx ) , <NUM_LIT> ) ) ) ; }


<s> ( * targetm . asm_out . internal_label ) ( file , <STR_LIT> , CODE_LABEL_NUMBER ( lab ) ) ; for ( idx = <NUM_LIT> ; idx < vlen ; idx ++ ) { ASM_OUTPUT_ADDR_VEC_ELT ( file , CODE_LABEL_NUMBER ( XEXP ( XVECEXP ( body , <NUM_LIT> , idx ) , <NUM_LIT> ) ) ) ; }


<s> void unicosmk_output_align ( FILE * file , int align ) { if ( inside_function ) fprintf ( file , <STR_LIT> , align ) ;

else fprintf ( file , <STR_LIT> , align ) ;


<s> else fprintf ( file , <STR_LIT> , align ) ;


<s> common_section ( ) ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , name ) ; fprintf ( file , <STR_LIT> , floor_log2 ( align / BITS_PER_UNIT ) ) ; fprintf ( file , <STR_LIT> , size ) ; name_tree = get_identifier ( name ) ; TREE_ASM_WRITTEN ( name_tree ) = <NUM_LIT> ;


<s> common_section ( ) ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , name ) ;

fprintf ( file , <STR_LIT> , floor_log2 ( align / BITS_PER_UNIT ) ) ;


<s> static const char * const externs [ ] = { <STR_LIT> } ; int i ; int n ; n = ARRAY_SIZE ( externs ) ;

for ( i = <NUM_LIT> ; i < n ; i ++ ) fprintf ( file , <STR_LIT> , externs [ i ] ) ;


<s> static void unicosmk_output_default_externs ( FILE * file ) { static const char * const externs [ ] = { <STR_LIT> } ; int i ; int n ; n = ARRAY_SIZE ( externs ) ; for ( i = <NUM_LIT> ; i < n ; i ++ ) fprintf ( file , <STR_LIT> , externs [ i ] ) ;


<s> for ( dex = unicosmk_dex_list ; dex ; dex = dex -> next ) { fprintf ( file , <STR_LIT> , i ) ; assemble_name ( file , dex -> name ) ;


<s> static void unicosmk_output_dex ( FILE * file ) { struct unicosmk_dex * dex ; int i ; if ( unicosmk_dex_list == NULL ) return ;


<s> for ( p = unicosmk_extern_head ; p != <NUM_LIT> ; p = p -> next ) { real_name = default_strip_name_encoding ( p -> name ) ; if ( len && p -> name [ <NUM_LIT> ] == '*' && ! memcmp ( real_name , user_label_prefix , len ) ) real_name += len ; name_tree = get_identifier ( real_name ) ; if ( ! TREE_ASM_WRITTEN ( name_tree ) ) { TREE_ASM_WRITTEN ( name_tree ) = <NUM_LIT> ;


<s> int len ; tree name_tree ; len = strlen ( user_label_prefix ) ; for ( p = unicosmk_extern_head ; p != <NUM_LIT> ; p = p -> next ) { real_name = default_strip_name_encoding ( p -> name ) ; if ( len && p -> name [ <NUM_LIT> ] == '*' && ! memcmp ( real_name , user_label_prefix , len ) ) real_name += len ; name_tree = get_identifier ( real_name ) ; if ( ! TREE_ASM_WRITTEN ( name_tree ) ) { TREE_ASM_WRITTEN ( name_tree ) = <NUM_LIT> ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , p -> name ) ; putc ( '\n' , file ) ;


<s> char * ptr = clean_name ; if ( ! ISALPHA ( * name ) ) * ptr ++ = '$' ; memcpy ( ptr , name , len + <NUM_LIT> ) ; clean_symbol_name ( clean_name ) ; fputs ( clean_name , file ) ;


<s> const char * name = lbasename ( main_input_filename ) ; unsigned len = strlen ( name ) ; char * clean_name = alloca ( len + <NUM_LIT> ) ;


<s> for ( i = <NUM_LIT> ; i < len ; i ++ ) fprintf ( file , <STR_LIT> , ( int ) ( fnname [ i ] ) ) ; if ( ( len % <NUM_LIT> ) == <NUM_LIT> ) fputs ( <STR_LIT> , file ) ; else fprintf ( file , <STR_LIT> , ( <NUM_LIT> - ( len % <NUM_LIT> ) ) * <NUM_LIT> ) ; for ( x = machine -> first_ciw ; x ; x = XEXP ( x , <NUM_LIT> ) ) { ciw = XEXP ( x , <NUM_LIT> ) ;

fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DOUBLE_HEX <STR_LIT> , CONST_DOUBLE_HIGH ( ciw ) , CONST_DOUBLE_LOW ( ciw ) ) ;


<s> len = strlen ( fnname ) ; fprintf ( file , <STR_LIT> , len ) ; fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , fnname ) ; putc ( '\n' , file ) ; fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; for ( i = <NUM_LIT> ; i < len ; i ++ ) fprintf ( file , <STR_LIT> , ( int ) ( fnname [ i ] ) ) ;

if ( ( len % <NUM_LIT> ) == <NUM_LIT> ) fputs ( <STR_LIT> , file ) ;


<s> static int unicosmk_special_name ( const char * name ) { if ( name [ <NUM_LIT> ] == '*' ) ++ name ; if ( name [ <NUM_LIT> ] == '$' ) ++ name ; if ( name [ <NUM_LIT> ] != 'r' && name [ <NUM_LIT> ] != 'f' && name [ <NUM_LIT> ] != 'R' && name [ <NUM_LIT> ] != 'F' ) return <NUM_LIT> ; switch ( name [ <NUM_LIT> ] ) { case '1' : case '2' : return ( name [ <NUM_LIT> ] == '\0' || ( ISDIGIT ( name [ <NUM_LIT> ] ) && name [ <NUM_LIT> ] == '\0' ) ) ; case '3' : return ( name [ <NUM_LIT> ] == '\0' || ( ( name [ <NUM_LIT> ] == '0' || name [ <NUM_LIT> ] == '1' ) && name [ <NUM_LIT> ] == '\0' ) ) ; default : return ( ISDIGIT ( name [ <NUM_LIT> ] ) && name [ <NUM_LIT> ] == '\0' ) ; }