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


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

if ( d1 ) emit_move_insn ( target , gen_rtx_PLUS ( DImode , target , GEN_INT ( d1 ) ) ) ;


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

out_operands [ <NUM_LIT> ] = GEN_INT ( mode ) ;


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

out_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ;


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


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


<s> mode = alpha_compute_xfloating_mode_arg ( code , ALPHA_FPRM_CHOP ) ; out_operands [ <NUM_LIT> ] = GEN_INT ( mode ) ; noperands = <NUM_LIT> ; break ; case FLOAT_TRUNCATE : mode = alpha_compute_xfloating_mode_arg ( code , alpha_fprm ) ; out_operands [ <NUM_LIT> ] = GEN_INT ( mode ) ; noperands = <NUM_LIT> ; break ; default : break ; } alpha_emit_xfloating_libcall ( func , operands [ <NUM_LIT> ] , out_operands , noperands , gen_rtx_fmt_e ( orig_code , GET_MODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ) ;


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

emit_libcall_block ( tmp , target , reg , equiv ) ;


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

if ( TARGET_ABI_OPEN_VMS || ! flag_inhibit_size_directive ) {


<s> if ( insn && CALL_P ( insn ) ) output_asm_insn ( get_insn_template ( CODE_FOR_nop , NULL ) , NULL ) ; alpha_write_linkage ( file , fnname ) ; if ( TARGET_ABI_OPEN_VMS || ! flag_inhibit_size_directive ) { fputs ( <STR_LIT> , file ) ; assemble_name ( file , fnname ) ; putc ( '\n' , file ) ;


<s> val = operands [ <NUM_LIT> ] ; model = operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; addr = XEXP ( mem , <NUM_LIT> ) ; gcc_assert ( register_operand ( addr , DImode ) ) ; align = expand_simple_binop ( Pmode , AND , addr , GEN_INT ( - <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ; if ( val != const0_rtx ) val = emit_insxl ( mode , val , addr ) ; wdst = gen_reg_rtx ( DImode ) ; emit_insn ( gen_atomic_exchange_1 ( mode , wdst , mem , val , align , model ) ) ; emit_move_insn ( dst , gen_lowpart ( mode , wdst ) ) ;


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


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

emit_move_insn ( target , handler_slot ) ;


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


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

oldval = convert_modes ( DImode , mode , oldval , <NUM_LIT> ) ;


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

align = expand_simple_binop ( Pmode , AND , addr , GEN_INT ( - <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_DIRECT ) ;


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

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

rtx ua = get_unaligned_address ( operands [ <NUM_LIT> ] ) ;


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


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


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


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

ins_tmps [ i - <NUM_LIT> ] = expand_binop ( DImode , ior_optab , data_regs [ i ] , ins_tmps [ i - <NUM_LIT> ] , ins_tmps [ i - <NUM_LIT> ] , <NUM_LIT> , OPTAB_WIDEN ) ;


<s> for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { mask <<= <NUM_LIT> ; if ( ! ( ( value >> i ) & <NUM_LIT> ) ) mask |= <NUM_LIT> ;


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

result = gen_int_mode ( mask , DImode ) ;


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


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

fprintf ( asm_out_file , <STR_LIT> , arch ) ;


<s> FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) {


<s> if ( GET_CODE ( x ) == LO_SUM && XEXP ( x , <NUM_LIT> ) == pic_offset_table_rtx ) return true ;


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


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

return build_int_cst ( alpha_dimode_u , temp ) ;


<s> while ( op ) temp ++ , op &= op - <NUM_LIT> ; return build_int_cst ( alpha_dimode_u , temp ) ;


<s> temp = <NUM_LIT> ; while ( op ) temp ++ , op &= op - <NUM_LIT> ; return build_int_cst ( alpha_dimode_u , temp ) ;


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


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


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


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


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


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


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


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


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


<s> temp |= ( opint [ <NUM_LIT> ] >> <NUM_LIT> ) & <NUM_LIT> ; temp |= ( opint [ <NUM_LIT> ] >> <NUM_LIT> ) & <NUM_LIT> ; return build_int_cst ( alpha_dimode_u , temp ) ;


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


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

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


<s> temp = opint [ <NUM_LIT> ] & <NUM_LIT> ; temp |= ( opint [ <NUM_LIT> ] & <NUM_LIT> ) << <NUM_LIT> ; temp |= ( opint [ <NUM_LIT> ] & <NUM_LIT> ) << <NUM_LIT> ; temp |= ( opint [ <NUM_LIT> ] & <NUM_LIT> ) << <NUM_LIT> ; return build_int_cst ( alpha_dimode_u , temp ) ;


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


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


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


<s> tree val = fold_build2 ( code , vtype , op0 , op1 ) ; return fold_build1 ( VIEW_CONVERT_EXPR , alpha_dimode_u , val ) ;


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

else if ( targetm . calls . must_pass_in_stack ( arg ) ) return NULL_RTX ;


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

return gen_rtx_REG ( arg . mode , num_args + basereg ) ;


<s> bool onstack = targetm . calls . must_pass_in_stack ( arg ) ; int increment = onstack ? <NUM_LIT> : ALPHA_ARG_SIZE ( arg . mode , arg . type ) ; * cum += increment ; if ( ! onstack && cum -> num_args < <NUM_LIT> ) cum -> atypes [ cum -> num_args ] = alpha_arg_type ( arg . mode ) ; cum -> num_args += increment ;


<s> if ( ! decl ) return false ; return decl_has_samegp ( decl ) ;


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

return alpha_function_value_1 ( valtype , fn_decl_or_type , VOIDmode ) ;


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


<s> gcc_assert ( ! valtype || ! alpha_return_in_memory ( valtype , func ) ) ; if ( valtype ) mode = TYPE_MODE ( valtype ) ; mclass = GET_MODE_CLASS ( mode ) ; switch ( mclass ) { case MODE_INT : if ( ! ( TARGET_ABI_OPEN_VMS && valtype && AGGREGATE_TYPE_P ( valtype ) ) ) PROMOTE_MODE ( mode , dummy , valtype ) ; case MODE_COMPLEX_INT : case MODE_VECTOR_INT : regnum = <NUM_LIT> ; break ; case MODE_FLOAT : regnum = <NUM_LIT> ; break ; case MODE_COMPLEX_FLOAT : { 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 ) ) ) ) ) ; } case MODE_RANDOM : gcc_assert ( TARGET_ABI_OPEN_VMS && mode == BLKmode ) ; regnum = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } return gen_rtx_REG ( mode , regnum ) ;


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


<s> if ( call ) { tree fndecl = gimple_call_fndecl ( stmt ) ; if ( fndecl ) { tree arg0 , arg1 ; switch ( DECL_MD_FUNCTION_CODE ( fndecl ) ) { case ALPHA_BUILTIN_UMULH : arg0 = gimple_call_arg ( stmt , <NUM_LIT> ) ; arg1 = gimple_call_arg ( stmt , <NUM_LIT> ) ; new_stmt = gimple_build_assign ( gimple_call_lhs ( stmt ) , MULT_HIGHPART_EXPR , arg0 , arg1 ) ; break ; default : break ; } } } if ( new_stmt ) { gsi_replace ( gsi , new_stmt , true ) ; changed = true ; } return changed ;


<s> bool changed = false ; gimple * stmt = gsi_stmt ( * gsi ) ; tree call = gimple_call_fn ( stmt ) ; gimple * new_stmt = NULL ; if ( call ) { tree fndecl = gimple_call_fndecl ( stmt ) ; if ( fndecl ) { tree arg0 , arg1 ; switch ( DECL_MD_FUNCTION_CODE ( fndecl ) ) { case ALPHA_BUILTIN_UMULH : arg0 = gimple_call_arg ( stmt , <NUM_LIT> ) ; arg1 = gimple_call_arg ( stmt , <NUM_LIT> ) ; new_stmt = gimple_build_assign ( gimple_call_lhs ( stmt ) , MULT_HIGHPART_EXPR , arg0 , arg1 ) ; break ; default : break ; } }


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


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


<s> 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 ( ) ; insert_insn_on_edge ( seq , single_succ_edge ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) ) ; cfun -> machine -> gp_save_rtx = m ;


<s> static bool alpha_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) {

if ( IN_RANGE ( regno , <NUM_LIT> , <NUM_LIT> ) ) return ( mode == SFmode || mode == DFmode || mode == DImode || mode == SCmode || mode == DCmode ) ;


<s> static bool alpha_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { if ( IN_RANGE ( regno , <NUM_LIT> , <NUM_LIT> ) ) return ( mode == SFmode || mode == DFmode || mode == DImode || mode == SCmode || mode == DCmode ) ; return true ;


<s> HOST_WIDE_INT alpha_initial_elimination_offset ( unsigned int from , unsigned int to ATTRIBUTE_UNUSED ) { HOST_WIDE_INT ret ; ret = cfun -> machine -> sa_size ; ret += ALPHA_ROUND ( crtl -> outgoing_args_size ) ; switch ( from ) { case FRAME_POINTER_REGNUM : break ; case ARG_POINTER_REGNUM : ret += ( ALPHA_ROUND ( get_frame_size ( ) + crtl -> args . pretend_args_size ) - crtl -> args . pretend_args_size ) ; break ; default : gcc_unreachable ( ) ;


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

set_optab_libfunc ( smod_optab , DImode , <STR_LIT> ) ;


<s> return ggc_cleared_alloc < machine_function > ( ) ;


<s> if ( cfun -> machine -> gp_save_rtx != NULL_RTX ) instantiate_decl_rtl ( cfun -> machine -> gp_save_rtx ) ;


<s> static void alpha_instantiate_decls ( void ) {

if ( cfun -> machine -> gp_save_rtx != NULL_RTX ) instantiate_decl_rtl ( cfun -> machine -> gp_save_rtx ) ;


<s> if ( TREE_CODE ( exp ) == VAR_DECL && DECL_SECTION_NAME ( exp ) ) { const char * section = DECL_SECTION_NAME ( exp ) ;

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


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

if ( small_symbolic_operand ( x , Pmode ) ) return true ;


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

if ( local_symbolic_operand ( ofs , Pmode ) || dtp32_symbolic_operand ( ofs , Pmode ) || tp32_symbolic_operand ( ofs , Pmode ) ) return true ;


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


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


<s> static rtx alpha_legitimize_address ( rtx x , rtx oldx ATTRIBUTE_UNUSED , machine_mode mode ) {

rtx new_x = alpha_legitimize_address_1 ( x , NULL_RTX , mode ) ;


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


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

x = gen_rtx_PLUS ( GET_MODE ( x ) , gen_rtx_PLUS ( GET_MODE ( x ) , XEXP ( x , <NUM_LIT> ) , GEN_INT ( high ) ) , GEN_INT ( low ) ) ;


<s> static rtx alpha_libcall_value ( machine_mode mode , const_rtx ) { return alpha_function_value_1 ( NULL_TREE , NULL_TREE , mode ) ;


<s> return alpha_function_value_1 ( NULL_TREE , NULL_TREE , mode ) ;


<s> static bool alpha_linkage_symbol_p ( const char * symname ) {


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

if ( symlen > <NUM_LIT> ) return strcmp ( & symname [ symlen - <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ;


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

func = init_one_libfunc ( TARGET_ABI_OPEN_VMS ? ops -> vms_func : ops -> osf_func ) ;


<s> n = ARRAY_SIZE ( vax_cvt_ops ) ; } for ( i = <NUM_LIT> ; i < n ; ++ i , ++ ops ) if ( ops -> code == code ) { rtx func = ops -> libcall ; if ( ! func ) { func = init_one_libfunc ( TARGET_ABI_OPEN_VMS ? ops -> vms_func : ops -> osf_func ) ; ops -> libcall = func ;


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


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


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


return ( alpha_hard_regno_mode_ok ( <NUM_LIT> , mode1 ) ? alpha_hard_regno_mode_ok ( <NUM_LIT> , mode2 ) : true ) ;


<s> static bool alpha_mode_dependent_address_p ( const_rtx addr , addr_space_t as ATTRIBUTE_UNUSED ) { return GET_CODE ( addr ) == AND ;


<s> static int alpha_multipass_dfa_lookahead ( void ) {


else if ( ! strcmp ( alpha_fprm_string , <STR_LIT> ) ) alpha_fprm = ALPHA_FPRM_CHOP ;


<s> l2_size = cpu_table [ i ] . l2_size ; break ; } if ( i == ct_size ) error ( <STR_LIT> , alpha_tune_string ) ; } if ( line_size ) SET_OPTION_IF_UNSET ( & global_options , & global_options_set , param_l1_cache_line_size , line_size ) ; if ( l1_size ) SET_OPTION_IF_UNSET ( & global_options , & global_options_set , param_l1_cache_size , l1_size ) ; if ( l2_size ) SET_OPTION_IF_UNSET ( & global_options , & global_options_set , param_l2_cache_size , l2_size ) ; if ( ( alpha_fptm == ALPHA_FPTM_SU || alpha_fptm == ALPHA_FPTM_SUI ) && alpha_tp != ALPHA_TP_INSN && alpha_cpu != PROCESSOR_EV6 ) { warning ( <NUM_LIT> , <STR_LIT> ) ; alpha_tp = ALPHA_TP_INSN ; } if ( alpha_cpu == PROCESSOR_EV6 ) { alpha_tp = ALPHA_TP_PROG ; } if ( TARGET_FLOAT_VAX ) { if ( alpha_fprm == ALPHA_FPRM_MINF || alpha_fprm == ALPHA_FPRM_DYN ) { warning ( <NUM_LIT> , <STR_LIT> ) ; alpha_fprm = ALPHA_FPRM_NORM ; } if ( alpha_fptm == ALPHA_FPTM_SUI ) { warning ( <NUM_LIT> , <STR_LIT> ) ; alpha_fptm = ALPHA_FPTM_SU ; } if ( target_flags_explicit & MASK_LONG_DOUBLE_128 ) warning ( <NUM_LIT> , <STR_LIT> ) ; target_flags &= ~ MASK_LONG_DOUBLE_128 ; } { char * end ; int lat ; if ( ! alpha_mlat_string ) alpha_mlat_string = <STR_LIT> ; if ( ISDIGIT ( ( unsigned char ) alpha_mlat_string [ <NUM_LIT> ] ) && ( lat = strtol ( alpha_mlat_string , & end , <NUM_LIT> ) , * end == '\0' ) ) ; else if ( ( alpha_mlat_string [ <NUM_LIT> ] == 'L' || alpha_mlat_string [ <NUM_LIT> ] == 'l' ) && ISDIGIT ( ( unsigned char ) alpha_mlat_string [ <NUM_LIT> ] ) && alpha_mlat_string [ <NUM_LIT> ] == '\0' ) { static int const cache_latency [ ] [ <NUM_LIT> ] = { { <NUM_LIT> , <NUM_LIT> , - <NUM_LIT> } , { <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } , { <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } , } ; lat = alpha_mlat_string [ <NUM_LIT> ] - '0' ; if ( lat <= <NUM_LIT> || lat > <NUM_LIT> || cache_latency [ alpha_tune ] [ lat - <NUM_LIT> ] == - <NUM_LIT> ) { warning ( <NUM_LIT> , <STR_LIT> , lat , alpha_cpu_name [ alpha_tune ] ) ; lat = <NUM_LIT> ; } else lat = cache_latency [ alpha_tune ] [ lat - <NUM_LIT> ] ; } else if ( ! strcmp ( alpha_mlat_string , <STR_LIT> ) ) { lat = <NUM_LIT> ; } else { warning ( <NUM_LIT> , <STR_LIT> , alpha_mlat_string ) ; lat = <NUM_LIT> ; } alpha_memory_latency = lat ;


<s> else if ( ! flag_inhibit_size_directive ) fprintf ( file , <STR_LIT> , alpha_function_needs_gp || cfun -> is_thunk ) ;


<s> else { rtx tmp = alpha_emit_set_long_const ( gen_rtx_REG ( Pmode , <NUM_LIT> ) , delta ) ; emit_insn ( gen_adddi3 ( this_rtx , this_rtx , tmp ) ) ; } if ( vcall_offset ) { rtx tmp , tmp2 ; tmp = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , this_rtx ) ) ; lo = ( ( vcall_offset & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; hi = ( ( ( vcall_offset - lo ) & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; if ( hi + lo == vcall_offset ) { if ( hi ) emit_insn ( gen_adddi3 ( tmp , tmp , GEN_INT ( hi ) ) ) ; } else { tmp2 = alpha_emit_set_long_const ( gen_rtx_REG ( Pmode , <NUM_LIT> ) , vcall_offset ) ; emit_insn ( gen_adddi3 ( tmp , tmp , tmp2 ) ) ; lo = <NUM_LIT> ; } if ( lo ) tmp2 = gen_rtx_PLUS ( Pmode , tmp , GEN_INT ( lo ) ) ; else tmp2 = tmp ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , tmp2 ) ) ; emit_insn ( gen_adddi3 ( this_rtx , this_rtx , tmp ) ) ; } if ( ! TREE_USED ( function ) ) { assemble_external ( function ) ; TREE_USED ( function ) = <NUM_LIT> ; } funexp = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; funexp = gen_rtx_MEM ( FUNCTION_MODE , funexp ) ; insn = emit_call_insn ( gen_sibcall ( funexp , const0_rtx ) ) ; SIBLING_CALL_P ( insn ) = <NUM_LIT> ;


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


<s> if ( next ) { rtx pat = PATTERN ( next ) ; if ( GET_CODE ( pat ) == SET && GET_CODE ( SET_SRC ( pat ) ) == UNSPEC_VOLATILE && XINT ( SET_SRC ( pat ) , <NUM_LIT> ) == UNSPECV_LDGP1 ) emit_insn_after ( gen_unop ( ) , insn ) ; }


<s> static bool alpha_pass_by_reference ( cumulative_args_t , const function_arg_info & arg ) {

if ( arg . mode == SFmode || arg . mode == SCmode ) return ! arg . named ;


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


<s> if ( rclass == FLOAT_REGS ) return NO_REGS ; if ( rclass == ALL_REGS ) return GENERAL_REGS ; return rclass ; } if ( CONSTANT_P ( x ) ) return ( rclass == ALL_REGS ? GENERAL_REGS : rclass ) ; return rclass ;


<s> static void alpha_pre_atomic_barrier ( enum memmodel model ) { if ( need_atomic_barrier_p ( model , true ) ) emit_insn ( gen_memory_barrier ( ) ) ;


<s> HOST_WIDE_INT offset = <NUM_LIT> ; if ( GET_CODE ( addr ) == AND ) addr = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == PLUS && CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) ) { offset = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) ; addr = XEXP ( addr , <NUM_LIT> ) ; } if ( GET_CODE ( addr ) == LO_SUM ) { const char * reloc16 , * reloclo ; rtx op1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( op1 ) == CONST && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == UNSPEC ) { op1 = XEXP ( op1 , <NUM_LIT> ) ; switch ( XINT ( op1 , <NUM_LIT> ) ) { case UNSPEC_DTPREL : reloc16 = NULL ; reloclo = ( alpha_tls_size == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; break ; case UNSPEC_TPREL : reloc16 = NULL ; reloclo = ( alpha_tls_size == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; break ; default : output_operand_lossage ( <STR_LIT> ) ; return ; } output_addr_const ( file , XVECEXP ( op1 , <NUM_LIT> , <NUM_LIT> ) ) ; } else { reloc16 = <STR_LIT> ; 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 : gcc_assert ( TARGET_ABI_OPEN_VMS || this_is_asm_operands ) ; fprintf ( file , <STR_LIT> , XSTR ( addr , <NUM_LIT> ) ) ; return ; case CONST : gcc_assert ( TARGET_ABI_OPEN_VMS || this_is_asm_operands ) ; gcc_assert ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC , XSTR ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) , INTVAL ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ) ; return ; default : output_operand_lossage ( <STR_LIT> ) ; return ;


<s> static bool alpha_print_operand_punct_valid_p ( unsigned char code ) {


<s> top = get_insns ( ) ; pop_topmost_sequence ( ) ; return reg_set_between_p ( gen_rtx_REG ( Pmode , REG_RA ) , top , NULL ) ;


<s> if ( ( from == FLOAT_REGS ) == ( to == FLOAT_REGS ) ) return <NUM_LIT> ; if ( TARGET_FIX ) return ( from == FLOAT_REGS ) ? <NUM_LIT> : <NUM_LIT> ; return <NUM_LIT> + <NUM_LIT> * alpha_memory_latency ;


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

if ( TARGET_FIX ) return ( from == FLOAT_REGS ) ? <NUM_LIT> : <NUM_LIT> ;


<s> if ( GET_CODE ( pat ) == PARALLEL ) { rtx vec = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ;

if ( GET_CODE ( vec ) == TRAP_IF && XEXP ( vec , <NUM_LIT> ) == const1_rtx ) emit_insn_after ( gen_unop ( ) , insn ) ;


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


<s> return get_hard_reg_initial_val ( Pmode , REG_RA ) ;


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


<s> case E_SImode : case E_DImode : case E_TImode : return true ; case E_SFmode : case E_DFmode : return true ; case E_TFmode : return TARGET_HAS_XFLOATING_LIBS ; default : return false ; }


<s> static machine_mode alpha_secondary_memory_needed_mode ( machine_mode mode ) { if ( GET_MODE_CLASS ( mode ) == MODE_FLOAT ) return mode ; if ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> ) return mode ; return mode_for_size ( BITS_PER_WORD , GET_MODE_CLASS ( mode ) , <NUM_LIT> ) . require ( ) ;


<s> if ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> ) return mode ;

return mode_for_size ( BITS_PER_WORD , GET_MODE_CLASS ( mode ) , <NUM_LIT> ) . require ( ) ;


<s> if ( in_p ) { if ( ! aligned_memory_operand ( x , mode ) ) sri -> icode = direct_optab_handler ( reload_in_optab , mode ) ; } else sri -> icode = direct_optab_handler ( reload_out_optab , mode ) ; return NO_REGS ; } } if ( rclass == FLOAT_REGS ) { if ( MEM_P ( x ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == AND ) return GENERAL_REGS ; if ( in_p && INTEGRAL_MODE_P ( mode ) && ! MEM_P ( x ) && ! REG_P ( x ) && ! CONST_INT_P ( x ) ) return GENERAL_REGS ;


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

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


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

MEM_VOLATILE_P ( x ) = MEM_VOLATILE_P ( ref ) ;


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


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


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

mask = GEN_INT ( mode == QImode ? <NUM_LIT> : <NUM_LIT> ) ;


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

MEM_VOLATILE_P ( mem ) = MEM_VOLATILE_P ( orig_mem ) ;


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


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


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

if ( is_mm_relaxed ( mod_f ) ) emit_label ( XEXP ( label2 , <NUM_LIT> ) ) ;


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

x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ;


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

label2 = gen_rtx_LABEL_REF ( DImode , gen_label_rtx ( ) ) ;


<s> static bool alpha_split_complex_arg ( const_tree type ) {


<s> HOST_WIDE_INT t , f , diff ; machine_mode mode ; rtx target , subtarget , tmp ; mode = GET_MODE ( dest ) ; t = INTVAL ( t_rtx ) ; f = INTVAL ( f_rtx ) ; diff = t - f ; if ( ( ( code == NE || code == EQ ) && diff < <NUM_LIT> ) || ( code == GE || code == GT ) ) { code = reverse_condition ( code ) ; std :: swap ( t , f ) ; diff = - diff ; } subtarget = target = dest ; if ( mode != DImode ) { target = gen_lowpart ( DImode , dest ) ; if ( can_create_pseudo_p ( ) ) subtarget = gen_reg_rtx ( DImode ) ; else subtarget = target ;


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


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

if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , temp ) ) emit_move_insn ( operands [ <NUM_LIT> ] , temp ) ;


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


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

emit_insn ( ( * operation ) ( scratch , high_bit , operands [ <NUM_LIT> ] ) ) ;


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


<s> CASE_CONST_SCALAR_INT : case CONST_DOUBLE : gcc_assert ( operands [ <NUM_LIT> ] == CONST0_RTX ( mode ) ) ; 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 ;


<s> CASE_CONST_SCALAR_INT : case CONST_DOUBLE : gcc_assert ( operands [ <NUM_LIT> ] == CONST0_RTX ( mode ) ) ; 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> ) ;


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


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

else if ( ! flag_inhibit_size_directive ) {


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


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


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


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


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


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


<s> static bool alpha_vms_can_eliminate ( const int from ATTRIBUTE_UNUSED , const int to ) { switch ( alpha_procedure_type ) { case PT_NULL : return to == STACK_POINTER_REGNUM ; case PT_REGISTER : case PT_STACK : return ( to != STACK_POINTER_REGNUM || vms_unwind_regno != HARD_FRAME_POINTER_REGNUM ) ;


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


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

if ( to == STACK_POINTER_REGNUM ) offset += ALPHA_ROUND ( crtl -> outgoing_args_size ) ;


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


<s> if ( cfun -> machine -> links ) { hash_map < nofree_string_hash , alpha_links * > :: iterator iter = cfun -> machine -> links -> begin ( ) ; for ( ; iter != cfun -> machine -> links -> end ( ) ; ++ iter ) alpha_write_one_linkage ( ( * iter ) . first , ( * iter ) . second , stream ) ; }


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


<s> if ( link -> rkind == KIND_CODEADDR ) { fprintf ( stream , <STR_LIT> ) ; } else { if ( ! SYMBOL_REF_EXTERNAL_P ( link -> func ) && SYMBOL_REF_LOCAL_P ( link -> func ) ) { fprintf ( stream , <STR_LIT> , name ) ; fprintf ( stream , <STR_LIT> ) ; } else { fprintf ( stream , <STR_LIT> ) ; }


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


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


<s> if ( TARGET_EXPLICIT_RELOCS && TARGET_SMALL_DATA ) return true ; return ! TREE_PUBLIC ( decl ) || ! DECL_EXTERNAL ( decl ) ;


return ( TARGET_ABI_OSF && reload_completed && cfun -> machine -> frame_size == <NUM_LIT> ) ;


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

emit_frame_store_1 ( reg , base_reg , frame_bias , base_ofs , reg ) ;


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


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

addr = plus_constant ( Pmode , stack_pointer_rtx , frame_bias + base_ofs ) ;


<s> rtx ret = gen_reg_rtx ( DImode ) ; rtx ( * fn ) ( rtx , rtx , rtx ) ; switch ( mode ) { case E_QImode : fn = gen_insbl ; break ; case E_HImode : fn = gen_inswl ; break ; case E_SImode : fn = gen_insll ; break ; case E_DImode : fn = gen_insql ; break ; default : gcc_unreachable ( ) ; } op1 = force_reg ( mode , op1 ) ; emit_insn ( fn ( ret , op1 , op2 ) ) ; return ret ;


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


<s> static void emit_unlikely_jump ( rtx cond , rtx label ) { rtx x = gen_rtx_IF_THEN_ELSE ( VOIDmode , cond , label , pc_rtx ) ;

rtx_insn * insn = emit_jump_insn ( gen_rtx_SET ( pc_rtx , x ) ) ;


<s> virtual unsigned int execute ( function * ) { return rest_of_align_insns ( ) ;


<s> 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 , EXPAND_NORMAL ) ; if ( ! ( * insn_op -> predicate ) ( op [ arity ] , insn_op -> mode ) ) op [ arity ] = copy_to_mode_reg ( insn_op -> mode , op [ arity ] ) ; arity ++ ;


<s> const_rtx x = * iter ; if ( GET_CODE ( x ) == LO_SUM && XEXP ( x , <NUM_LIT> ) == pic_offset_table_rtx ) return true ;


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


<s> if ( GET_CODE ( x ) == LO_SUM ) iter . skip_subrtxes ( ) ; else if ( small_symbolic_operand ( x , Pmode ) ) return true ;


return ( ( alpha_tune == PROCESSOR_EV4 || alpha_tune == PROCESSOR_EV5 ) && optimize && ! optimize_size && alpha_tp != ALPHA_TP_INSN && flag_schedule_insns_after_reload ) ;


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


<s> case ALPHA_FPRM_MINF : return <STR_LIT> ; case ALPHA_FPRM_CHOP : return <STR_LIT> ; case ALPHA_FPRM_DYN : return <STR_LIT> ; default : gcc_unreachable ( ) ; } break ; case ROUND_SUFFIX_C : return <STR_LIT> ; default : gcc_unreachable ( ) ; }


<s> return <STR_LIT> ; case ALPHA_FPRM_DYN : return <STR_LIT> ; default : gcc_unreachable ( ) ; } break ; case ROUND_SUFFIX_C : return <STR_LIT> ; default : gcc_unreachable ( ) ;


<s> static rtx get_tls_get_addr ( void ) {

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


<s> return NULL ; case ALPHA_FPTM_U : return <STR_LIT> ; case ALPHA_FPTM_SU : return <STR_LIT> ; case ALPHA_FPTM_SUI : return <STR_LIT> ; default : gcc_unreachable ( ) ; } 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> ; case ALPHA_FPTM_SUI : return <STR_LIT> ; default : gcc_unreachable ( ) ;


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

return plus_constant ( Pmode , base , offset ) ;


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


ofs += INTVAL ( XEXP ( addr , <NUM_LIT> ) ) ;


<s> rtx get_unaligned_offset ( rtx addr , HOST_WIDE_INT ofs ) { if ( GET_CODE ( addr ) == PLUS ) { ofs += INTVAL ( XEXP ( addr , <NUM_LIT> ) ) ; addr = XEXP ( addr , <NUM_LIT> ) ; } return expand_simple_binop ( Pmode , PLUS , addr , GEN_INT ( ofs & <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_LIB_WIDEN ) ;


<s> const char * const GTY ( ( skip ) ) vms_func ;


<s> rtl_opt_pass * make_pass_align_insns ( gcc :: context * ctxt ) { return new pass_align_insns ( ctxt ) ;


<s> return new pass_handle_trap_shadows ( ctxt ) ;


<s> pass_align_insns ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_align_insns , ctxt ) {


<s> pass_handle_trap_shadows ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_handle_trap_shadows , ctxt ) {


<s> rtx tmp = op ; if ( SUBREG_P ( tmp ) ) tmp = SUBREG_REG ( tmp ) ;

if ( REG_P ( tmp ) && REGNO ( tmp ) >= FIRST_PSEUDO_REGISTER ) {


<s> if ( REG_P ( tmp ) && REGNO ( tmp ) >= FIRST_PSEUDO_REGISTER ) { op = reg_equiv_memory_loc ( REGNO ( tmp ) ) ; if ( op == <NUM_LIT> ) return <NUM_LIT> ;


<s> static unsigned int rest_of_align_insns ( void ) {


<s> static unsigned int rest_of_handle_trap_shadows ( void ) {


<s> static unsigned int rest_of_handle_trap_shadows ( void ) { alpha_handle_trap_shadows ( ) ;


<s> end_sequence ( ) ; if ( ! seq ) return NULL ; if ( INSN_P ( seq ) ) { 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> if ( INSN_P ( seq ) ) { 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> ; } return seq ;


<s> subrtx_var_iterator :: array_type array ; FOR_EACH_SUBRTX_VAR ( iter , array , x , ALL ) { rtx x = * iter ; if ( GET_CODE ( x ) == LO_SUM ) iter . skip_subrtxes ( ) ; else if ( small_symbolic_operand ( x , Pmode ) ) return true ;


<s> FOR_EACH_SUBRTX_VAR ( iter , array , x , ALL ) { rtx x = * iter ; if ( GET_CODE ( x ) == LO_SUM ) iter . skip_subrtxes ( ) ; else if ( small_symbolic_operand ( x , Pmode ) ) return true ; } return false ;


<s> else if ( small_symbolic_operand ( x , Pmode ) ) { * ptr = gen_rtx_LO_SUM ( Pmode , pic_offset_table_rtx , x ) ; iter . skip_subrtxes ( ) ;


<s> op = XVECEXP ( op , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( op ) != SYMBOL_REF ) return <NUM_LIT> ; switch ( SYMBOL_REF_TLS_MODEL ( op ) ) { case TLS_MODEL_LOCAL_DYNAMIC : return unspec == UNSPEC_DTPREL && size == alpha_tls_size ; case TLS_MODEL_INITIAL_EXEC : return unspec == UNSPEC_TPREL && size == <NUM_LIT> ; case TLS_MODEL_LOCAL_EXEC : return unspec == UNSPEC_TPREL && size == alpha_tls_size ; default : gcc_unreachable ( ) ; }


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

model = SYMBOL_REF_TLS_MODEL ( symbol ) ;


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


<s> code = gimple_assign_rhs_code ( stmt ) ; if ( ! CONVERT_EXPR_CODE_P ( code ) && ( ( code != PLUS_EXPR && code != POINTER_PLUS_EXPR ) || TREE_CODE ( gimple_assign_rhs2 ( stmt ) ) != INTEGER_CST || ! tree_fits_uhwi_p ( gimple_assign_rhs2 ( stmt ) ) ) ) return stmt ; lhs = gimple_assign_rhs1 ( stmt ) ;


<s> fputc ( '\n' , asm_out_file ) ; fprintf ( asm_out_file , <STR_LIT> , name ) ; if ( flags & SECTION_DEBUG ) fprintf ( asm_out_file , <STR_LIT> ) ; fputc ( '\n' , asm_out_file ) ;


<s> static void vms_asm_out_constructor ( rtx symbol , int priority ATTRIBUTE_UNUSED ) {


<s> assemble_integer ( symbol , UNITS_PER_WORD , BITS_PER_WORD , <NUM_LIT> ) ;


<s> tree attr = DECL_ATTRIBUTES ( decl ) ; fprintf ( file , <STR_LIT> , COMMON_ASM_OP ) ; assemble_name ( file , name ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED , size ) ; fprintf ( file , <STR_LIT> , align / BITS_PER_UNIT ) ; if ( attr ) { attr = lookup_attribute ( COMMON_OBJECT , attr ) ; if ( attr ) fprintf ( file , <STR_LIT> , IDENTIFIER_POINTER ( TREE_VALUE ( TREE_VALUE ( attr ) ) ) ) ; }


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


<s> i ++ , value >>= <NUM_LIT> ) if ( ( value & <NUM_LIT> ) != <NUM_LIT> && ( value & <NUM_LIT> ) != <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> int zap_mask ( HOST_WIDE_INT value ) { int i ;

for ( i = <NUM_LIT> ; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR ;


<s> const char * cpu ; int i ; if ( argc < <NUM_LIT> ) return NULL ; if ( strcmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) && strcmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) ) return NULL ; implver = __builtin_alpha_implver ( ) ; amask = __builtin_alpha_amask ( ~ <NUM_LIT> ) ; cpu = NULL ; for ( i = <NUM_LIT> ; cpu_types [ i ] . cpu != NULL ; i ++ ) if ( implver == cpu_types [ i ] . implver && ( ~ amask & cpu_types [ i ] . amask ) == cpu_types [ i ] . amask ) { cpu = cpu_types [ i ] . cpu ;


<s> if ( context -> cfa == <NUM_LIT> ) return _URC_END_OF_STACK ; if ( pc [ <NUM_LIT> ] == <NUM_LIT> ) sc = context -> cfa ; else if ( pc [ <NUM_LIT> ] == <NUM_LIT> ) { struct rt_sigframe { struct siginfo info ; struct ucontext uc ; } * rt_ = context -> cfa ; sc = & rt_ -> uc . uc_mcontext ; } else return _URC_END_OF_STACK ; new_cfa = sc -> sc_regs [ <NUM_LIT> ] ; fs -> cfa_how = CFA_REG_OFFSET ; fs -> cfa_reg = <NUM_LIT> ; fs -> cfa_offset = new_cfa - ( long ) context -> cfa ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { fs -> regs . reg [ i ] . how = REG_SAVED_OFFSET ;

fs -> regs . reg [ i ] . loc . offset = ( long ) & sc -> sc_regs [ i ] - new_cfa ;


<s> if ( context -> cfa == <NUM_LIT> ) return _URC_END_OF_STACK ; if ( pc [ <NUM_LIT> ] == <NUM_LIT> ) sc = context -> cfa ; else if ( pc [ <NUM_LIT> ] == <NUM_LIT> ) { struct rt_sigframe { struct siginfo info ; struct ucontext uc ; } * rt_ = context -> cfa ; sc = & rt_ -> uc . uc_mcontext ; } else return _URC_END_OF_STACK ; new_cfa = sc -> sc_regs [ <NUM_LIT> ] ; fs -> cfa_how = CFA_REG_OFFSET ; fs -> cfa_reg = <NUM_LIT> ; fs -> cfa_offset = new_cfa - ( long ) context -> cfa ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) {

fs -> regs . reg [ i ] . how = REG_SAVED_OFFSET ;


<s> for ( i = <NUM_LIT> ; i <= comp_arg_max ; i ++ ) new_comp_args [ i ] = comp_args [ i ] ; if ( comp_args ) free ( comp_args ) ;


<s> const char * * new_comp_args = ( const char * * ) xcalloc ( comp_arg_max + <NUM_LIT> , sizeof ( char * ) ) ; for ( i = <NUM_LIT> ; i <= comp_arg_max ; i ++ ) new_comp_args [ i ] = comp_args [ i ] ; if ( comp_args ) free ( comp_args ) ; comp_arg_max += <NUM_LIT> ; comp_args = new_comp_args ;


<s> addarg ( defines ) ; addarg ( <STR_LIT> ) ; } for ( i = <NUM_LIT> ; i < argc ; i ++ ) { int arg_len = strlen ( argv [ i ] ) ; if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> ) i ++ ; else if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> || strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> || strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> || strncmp ( argv [ i ] , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> || strncmp ( argv [ i ] , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> || strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> || ( arg_len > <NUM_LIT> && strncmp ( argv [ i ] , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) || ( arg_len > <NUM_LIT> && strncmp ( argv [ i ] , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) ) ; else if ( ( argv [ i ] [ <NUM_LIT> ] == '/' ) && ( strchr ( & argv [ i ] [ <NUM_LIT> ] , '/' ) == <NUM_LIT> ) ) addarg ( argv [ i ] ) ; else { char buff [ <NUM_LIT> ] , * ptr ; ptr = to_host_file_spec ( argv [ i ] ) ; arg_len = strlen ( ptr ) ; if ( ptr [ <NUM_LIT> ] == '[' ) sprintf ( buff , <STR_LIT> , cwdev , ptr ) ; else if ( strchr ( ptr , ':' ) ) sprintf ( buff , <STR_LIT> , ptr ) ; else sprintf ( buff , <STR_LIT> , cwd , ptr ) ; ptr = xstrdup ( buff ) ; addarg ( ptr ) ; } } addarg ( NULL ) ; if ( verbose ) { int i ; for ( i = <NUM_LIT> ; i < comp_arg_index ; i ++ ) printf ( <STR_LIT> , comp_args [ i ] ) ; putchar ( '\n' ) ;


<s> if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> ) { char * buff , * ptr ; i ++ ;

ptr = to_host_file_spec ( argv [ i ] ) ;


<s> i ++ ; ptr = to_host_file_spec ( argv [ i ] ) ; objfilename = xstrdup ( ptr ) ; buff = concat ( <STR_LIT> , ptr , NULL ) ;


<s> int i ; for ( i = <NUM_LIT> ; i < * p_argc ; i ++ ) { if ( strlen ( argv [ i ] ) < <NUM_LIT> ) continue ; if ( strncmp ( argv [ i ] , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { char * ptr ; int new_len , search_dirs_len ; ptr = to_host_dir_spec ( & argv [ i ] [ <NUM_LIT> ] ) ; new_len = strlen ( ptr ) ; search_dirs_len = strlen ( search_dirs ) ; search_dirs = xrealloc ( search_dirs , search_dirs_len + new_len + <NUM_LIT> ) ; if ( search_dirs_len > <NUM_LIT> ) strcat ( search_dirs , PATH_SEPARATOR_STR ) ; strcat ( search_dirs , ptr ) ; } else if ( strncmp ( argv [ i ] , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { char * ptr ; int new_len , defines_len ; ptr = & argv [ i ] [ <NUM_LIT> ] ; new_len = strlen ( ptr ) ; defines_len = strlen ( defines ) ; defines = xrealloc ( defines , defines_len + new_len + <NUM_LIT> ) ; if ( defines_len > <NUM_LIT> ) strcat ( defines , <STR_LIT> ) ; strcat ( defines , <STR_LIT> ) ; strcat ( defines , ptr ) ;


<s> static char * to_host_dir_spec ( char * dirspec ) { int len = strlen ( dirspec ) ; strcpy ( new_host_dirspec , dirspec ) ; if ( strchr ( new_host_dirspec , ']' ) || strchr ( new_host_dirspec , ':' ) ) return new_host_dirspec ; while ( len > <NUM_LIT> && new_host_dirspec [ len - <NUM_LIT> ] == '/' ) { new_host_dirspec [ len - <NUM_LIT> ] = <NUM_LIT> ; len -- ; } decc$to_vms ( new_host_dirspec , translate_unix , <NUM_LIT> , <NUM_LIT> ) ; strcpy ( new_host_dirspec , filename_buff ) ; return new_host_dirspec ;


<s> strcpy ( new_host_filespec , <STR_LIT> ) ;

if ( strchr ( filespec , ']' ) || strchr ( filespec , ':' ) ) strcpy ( new_host_filespec , filespec ) ;


<s> strcpy ( new_host_filespec , <STR_LIT> ) ; if ( strchr ( filespec , ']' ) || strchr ( filespec , ':' ) ) strcpy ( new_host_filespec , filespec ) ; else {


<s> static int translate_unix ( char * name , int type ATTRIBUTE_UNUSED ) { strcpy ( filename_buff , name ) ;


<s> const char * * new_link_args = ( const char * * ) xcalloc ( link_arg_max + <NUM_LIT> , sizeof ( char * ) ) ; for ( i = <NUM_LIT> ; i <= link_arg_max ; i ++ ) new_link_args [ i ] = link_args [ i ] ; if ( link_args ) free ( link_args ) ; link_arg_max += <NUM_LIT> ; link_args = new_link_args ; }


<s> const char * * new_link_args = ( const char * * ) xcalloc ( link_arg_max + <NUM_LIT> , sizeof ( char * ) ) ; for ( i = <NUM_LIT> ; i <= link_arg_max ; i ++ ) new_link_args [ i ] = link_args [ i ] ; if ( link_args ) free ( link_args ) ;


<s> else if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> ) return <STR_LIT> ; else { lib = xmalloc ( strlen ( name ) + <NUM_LIT> ) ; strcpy ( lib , <STR_LIT> ) ; strcat ( lib , name ) ; lib_path = locate_lib ( lib , search_dirs ) ; if ( lib_path ) return lib_path ; } fprintf ( stderr , <STR_LIT> , name , name , name ) ;


return ! ret && S_ISREG ( statbuf . st_mode ) ;


<s> if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; strcpy ( ptr , <STR_LIT> ) ; if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; } else { strcpy ( ptr , <STR_LIT> ) ; if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; strcpy ( ptr , <STR_LIT> ) ; if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; strcpy ( ptr , <STR_LIT> ) ; if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; }


<s> if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; } else { strcpy ( ptr , <STR_LIT> ) ; if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; strcpy ( ptr , <STR_LIT> ) ; if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; strcpy ( ptr , <STR_LIT> ) ; if ( is_regular_file ( buf ) ) return xstrdup ( to_host_file_spec ( buf ) ) ; }


<s> exefilename = xstrdup ( ptr ) ; out_len = strlen ( ptr ) ; buff = xmalloc ( out_len + <NUM_LIT> ) ; if ( share ) strcpy ( buff , <STR_LIT> ) ; else strcpy ( buff , <STR_LIT> ) ; strcat ( buff , ptr ) ; addarg ( buff ) ; if ( share ) { sharefilename = xmalloc ( out_len + <NUM_LIT> ) ; if ( ptr == strchr ( argv [ i ] , ']' ) ) strcpy ( sharefilename , ++ ptr ) ; else if ( ptr == strchr ( argv [ i ] , ':' ) ) strcpy ( sharefilename , ++ ptr ) ; else if ( ptr == strrchr ( argv [ i ] , '/' ) ) strcpy ( sharefilename , ++ ptr ) ; else strcpy ( sharefilename , argv [ i ] ) ; len = strlen ( sharefilename ) ; if ( strncasecmp ( & sharefilename [ len - <NUM_LIT> ] , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) sharefilename [ len - <NUM_LIT> ] = <NUM_LIT> ; for ( ptr = sharefilename ; * ptr ; ptr ++ ) * ptr = TOUPPER ( * ptr ) ;


<s> ptr = to_host_file_spec ( argv [ i ] ) ; exefilename = xstrdup ( ptr ) ; out_len = strlen ( ptr ) ; buff = xmalloc ( out_len + <NUM_LIT> ) ; if ( share ) strcpy ( buff , <STR_LIT> ) ; else strcpy ( buff , <STR_LIT> ) ; strcat ( buff , ptr ) ; addarg ( buff ) ; if ( share ) { sharefilename = xmalloc ( out_len + <NUM_LIT> ) ; if ( ptr == strchr ( argv [ i ] , ']' ) ) strcpy ( sharefilename , ++ ptr ) ; else if ( ptr == strchr ( argv [ i ] , ':' ) ) strcpy ( sharefilename , ++ ptr ) ; else if ( ptr == strrchr ( argv [ i ] , '/' ) ) strcpy ( sharefilename , ++ ptr ) ;

else strcpy ( sharefilename , argv [ i ] ) ;


<s> new_len -- ; } search_dirs = xrealloc ( search_dirs , search_dirs_len + new_len + <NUM_LIT> ) ; if ( search_dirs_len > <NUM_LIT> ) strcat ( search_dirs , PATH_SEPARATOR_STR ) ; strcat ( search_dirs , nbuff ) ; free ( nbuff ) ; } else if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> ) verbose = <NUM_LIT> ; else if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> ) addarg ( <STR_LIT> ) ; else if ( strncmp ( argv [ i ] , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { addarg ( <STR_LIT> ) ; debug = <NUM_LIT> ; }

else if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> ) staticp = <NUM_LIT> ;


<s> PDSCDEF * pv = * ( ( PDSCDEF * * ) context -> reg [ <NUM_LIT> ] ) ; if ( pv && ( ( long ) pv & <NUM_LIT> ) == <NUM_LIT> ) pv = * ( PDSCDEF * * ) pv ; if ( pv && ( ( pv -> pdsc$w_flags & <NUM_LIT> ) == PDSC$K_KIND_FP_STACK ) ) { int i , j ; fs -> cfa_offset = pv -> pdsc$l_size ; fs -> cfa_reg = pv -> pdsc$w_flags & PDSC$M_BASE_REG_IS_FP ? <NUM_LIT> : <NUM_LIT> ; fs -> retaddr_column = <NUM_LIT> ; fs -> cfa_how = CFA_REG_OFFSET ; fs -> regs . reg [ <NUM_LIT> ] . loc . offset = - pv -> pdsc$l_size ; fs -> regs . reg [ <NUM_LIT> ] . how = REG_SAVED_OFFSET ; fs -> regs . reg [ <NUM_LIT> ] . loc . offset = - ( pv -> pdsc$l_size - pv -> pdsc$w_rsa_offset ) ; fs -> regs . reg [ <NUM_LIT> ] . how = REG_SAVED_OFFSET ; for ( i = <NUM_LIT> , j = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( <NUM_LIT> << i & pv -> pdsc$l_ireg_mask ) { fs -> regs . reg [ i ] . loc . offset = - ( pv -> pdsc$l_size - pv -> pdsc$w_rsa_offset - <NUM_LIT> * ++ j ) ; fs -> regs . reg [ i ] . how = REG_SAVED_OFFSET ; } return _URC_NO_REASON ; } else if ( pv && ( ( pv -> pdsc$w_flags & <NUM_LIT> ) == PDSC$K_KIND_FP_REGISTER ) ) { fs -> cfa_offset = pv -> pdsc$l_size ; fs -> cfa_reg = pv -> pdsc$w_flags & PDSC$M_BASE_REG_IS_FP ? <NUM_LIT> : <NUM_LIT> ; fs -> retaddr_column = <NUM_LIT> ; fs -> cfa_how = CFA_REG_OFFSET ; fs -> regs . reg [ <NUM_LIT> ] . loc . reg = pv -> pdsc$b_save_ra ; fs -> regs . reg [ <NUM_LIT> ] . how = REG_SAVED_REG ; fs -> regs . reg [ <NUM_LIT> ] . loc . reg = pv -> pdsc$b_save_fp ; fs -> regs . reg [ <NUM_LIT> ] . how = REG_SAVED_REG ; return _URC_NO_REASON ;