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


<s> gcc_assert ( GET_CODE ( x ) == MEM ) ; x = XEXP ( x , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( x ) == SYMBOL_REF ) ; fnname = XSTR ( x , <NUM_LIT> ) ; len = strlen ( fnname ) ;

if ( len + SSIB_PREFIX_LEN > <NUM_LIT> ) len = <NUM_LIT> - SSIB_PREFIX_LEN ;


<s> if ( len + SSIB_PREFIX_LEN > <NUM_LIT> ) len = <NUM_LIT> - SSIB_PREFIX_LEN ; strcpy ( name , SSIB_PREFIX ) ; strncpy ( name + SSIB_PREFIX_LEN , fnname , len ) ; name [ len + SSIB_PREFIX_LEN ] = <NUM_LIT> ; return name ;


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

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


<s> gcc_assert ( decl ) ; name = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ; name = default_strip_name_encoding ( name ) ; len = strlen ( name ) ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { char * string ;


<s> if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { char * string ; string = alloca ( len + <NUM_LIT> ) ; sprintf ( string , <STR_LIT> , name ) ; DECL_SECTION_NAME ( decl ) = build_string ( len + <NUM_LIT> , string ) ; } else if ( TREE_PUBLIC ( decl ) ) DECL_SECTION_NAME ( decl ) = build_string ( len , name ) ; else { char * string ; string = alloca ( len + <NUM_LIT> ) ; sprintf ( string , <STR_LIT> , name ) ; DECL_SECTION_NAME ( decl ) = build_string ( len + <NUM_LIT> , string ) ;


<s> stmt = SSA_NAME_DEF_STMT ( lhs ) ; if ( TREE_CODE ( stmt ) == PHI_NODE ) return stmt ; if ( TREE_CODE ( stmt ) != MODIFY_EXPR || TREE_OPERAND ( stmt , <NUM_LIT> ) != lhs ) return lhs ; rhs = TREE_OPERAND ( stmt , <NUM_LIT> ) ;

if ( TREE_CODE ( rhs ) == WITH_SIZE_EXPR ) rhs = TREE_OPERAND ( rhs , <NUM_LIT> ) ;


<s> if ( TREE_CODE ( stmt ) == PHI_NODE ) return stmt ; if ( TREE_CODE ( stmt ) != MODIFY_EXPR || TREE_OPERAND ( stmt , <NUM_LIT> ) != lhs ) return lhs ; rhs = TREE_OPERAND ( stmt , <NUM_LIT> ) ;


<s> if ( flags & SECTION_VMS_GLOBAL ) fprintf ( asm_out_file , <STR_LIT> ) ; if ( flags & SECTION_VMS_INITIALIZE ) fprintf ( asm_out_file , <STR_LIT> ) ; 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 ) { ctors_section ( ) ; assemble_align ( BITS_PER_WORD ) ;


<s> static void vms_asm_out_destructor ( rtx symbol , int priority ATTRIBUTE_UNUSED ) { dtors_section ( ) ; assemble_align ( BITS_PER_WORD ) ;


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


<s> static unsigned int vms_section_type_flags ( tree decl , const char * name , int reloc ) { unsigned int flags = default_section_type_flags ( decl , name , reloc ) ;

if ( decl && DECL_ATTRIBUTES ( decl ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) flags |= SECTION_VMS_OVERLAY ;


<s> unsigned int flags = default_section_type_flags ( decl , name , reloc ) ; if ( decl && DECL_ATTRIBUTES ( decl ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) flags |= SECTION_VMS_OVERLAY ; if ( decl && DECL_ATTRIBUTES ( decl ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) flags |= SECTION_VMS_GLOBAL ; if ( decl && DECL_ATTRIBUTES ( decl ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) flags |= SECTION_VMS_INITIALIZE ;


<s> static int alpha_adjust_cost ( rtx_insn * insn , rtx link , rtx_insn * dep_insn , int cost ) { enum attr_type dep_insn_type ; if ( REG_NOTE_KIND ( link ) != <NUM_LIT> ) return cost ; if ( recog_memoized ( insn ) < <NUM_LIT> || recog_memoized ( dep_insn ) < <NUM_LIT> ) return cost ; dep_insn_type = get_attr_type ( dep_insn ) ; if ( dep_insn_type == TYPE_ILD || dep_insn_type == TYPE_FLD || dep_insn_type == TYPE_LDSYM ) cost += alpha_memory_latency - <NUM_LIT> ; return cost ;


<s> ldgp = alpha_function_needs_gp ? <NUM_LIT> : <NUM_LIT> ; while ( i ) { next = ( * next_group ) ( i , & in_use , & len ) ; if ( LABEL_P ( i ) ) { unsigned int new_align = <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> ;


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


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


<s> return TARGET_FLOAT_VAX ? FD : FT ; default : return I64 ; }


<s> ofs = build_decl ( BUILTINS_LOCATION , FIELD_DECL , get_identifier ( <STR_LIT> ) , integer_type_node ) ; DECL_FIELD_CONTEXT ( ofs ) = record ; DECL_CHAIN ( ofs ) = space ; TREE_THIS_VOLATILE ( ofs ) = <NUM_LIT> ; base = build_decl ( BUILTINS_LOCATION , FIELD_DECL , get_identifier ( <STR_LIT> ) , ptr_type_node ) ; DECL_FIELD_CONTEXT ( base ) = record ; DECL_CHAIN ( base ) = ofs ; TYPE_FIELDS ( record ) = base ; layout_type ( record ) ; va_list_gpr_counter_field = ofs ; return record ;


<s> * code = ( int ) swap_condition ( ( enum rtx_code ) * code ) ; } if ( ( * code == LT || * code == LTU ) && CONST_INT_P ( * op1 ) && INTVAL ( * op1 ) == <NUM_LIT> ) { * code = * code == LT ? LE : LEU ; * op1 = GEN_INT ( <NUM_LIT> ) ; }


<s> enum rtx_code code = GET_CODE ( operands [ <NUM_LIT> ] ) ; rtx op0 = operands [ <NUM_LIT> ] , op1 = operands [ <NUM_LIT> ] ; rtx tem ; if ( cmp_mode == TFmode ) { op0 = alpha_emit_xfloating_compare ( & code , op0 , op1 ) ; op1 = const0_rtx ; cmp_mode = DImode ; } switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : case UNORDERED : 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 ( cmp_mode == DFmode ) { cmp_code = swap_condition ( code ) ; branch_code = NE ; std :: swap ( op0 , op1 ) ; } else { cmp_code = reverse_condition ( code ) ; branch_code = EQ ; } break ; default :


<s> local_fast_math = <NUM_LIT> ; } if ( cmp_mode == DImode ) { if ( ! reg_or_0_operand ( op0 , DImode ) ) op0 = force_reg ( DImode , op0 ) ; if ( ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } if ( signed_comparison_operator ( cmp , VOIDmode ) && ( cmp_mode == DImode || local_fast_math ) && ( op0 == CONST0_RTX ( cmp_mode ) || op1 == CONST0_RTX ( cmp_mode ) ) ) return gen_rtx_fmt_ee ( code , VOIDmode , op0 , op1 ) ; if ( ! can_create_pseudo_p ( ) ) return NULL_RTX ; switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : case UNORDERED : break ; case NE : case ORDERED : code = reverse_condition ( code ) ; cmov_code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( cmp_mode == DImode && op1 == const0_rtx ) break ; code = swap_condition ( code ) ; std :: swap ( op0 , op1 ) ; break ; default : gcc_unreachable ( ) ; } if ( cmp_mode == DImode ) { if ( ! reg_or_0_operand ( op0 , DImode ) ) op0 = force_reg ( DImode , op0 ) ; if ( ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } if ( cmp_mode == DFmode && ! local_fast_math ) cmov_mode = CCmode ; tem = gen_reg_rtx ( cmp_mode ) ; emit_move_insn ( tem , gen_rtx_fmt_ee ( code , cmp_mode , op0 , op1 ) ) ;

return gen_rtx_fmt_ee ( cmov_code , cmov_mode , tem , CONST0_RTX ( cmp_mode ) ) ;


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


<s> break ; case GE : case GT : case GEU : case GTU : if ( cmp_mode == DImode && op1 == const0_rtx ) break ; code = swap_condition ( code ) ; if ( cmp_mode == DFmode ) cmp_code = code , code = NE ; std :: swap ( op0 , op1 ) ; break ; default : gcc_unreachable ( ) ; } if ( cmp_mode == DImode ) { if ( ! register_operand ( op0 , DImode ) ) op0 = force_reg ( DImode , op0 ) ; if ( ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } if ( cmp_code != UNKNOWN ) { tmp = gen_reg_rtx ( cmp_mode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmp , gen_rtx_fmt_ee ( cmp_code , cmp_mode , op0 , op1 ) ) ) ; op0 = cmp_mode != DImode ? gen_lowpart ( DImode , tmp ) : tmp ; op1 = const0_rtx ; }

emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , gen_rtx_fmt_ee ( code , DImode , op0 , op1 ) ) ) ;


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


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

if ( mode == QImode ) gen = gen_atomic_exchangeqi_1 ;


<s> bool nonvoid ; if ( fcode >= ALPHA_BUILTIN_max ) internal_error ( <STR_LIT> ) ; icode = code_for_builtin [ fcode ] ; if ( icode == <NUM_LIT> ) internal_error ( <STR_LIT> ) ; nonvoid = TREE_TYPE ( TREE_TYPE ( fndecl ) ) != void_type_node ; arity = <NUM_LIT> ; FOR_EACH_CALL_EXPR_ARG ( arg , iter , exp ) { const struct insn_operand_data * insn_op ; 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 , EXPAND_NORMAL ) ; if ( ! ( * insn_op -> predicate ) ( op [ arity ] , insn_op -> mode ) ) op [ arity ] = copy_to_mode_reg ( insn_op -> mode , op [ arity ] ) ; arity ++ ; } if ( nonvoid ) { 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 ) ;


<s> machine_mode mode ; rtx addr , align , wdst ; rtx ( * gen ) ( rtx , rtx , rtx , rtx , rtx , rtx , rtx , rtx , rtx ) ; 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> ] ;


<s> rtx ( * gen ) ( rtx , rtx , rtx , rtx , rtx , rtx , rtx , rtx , rtx ) ; 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 ) ; oldval = convert_modes ( DImode , mode , oldval , <NUM_LIT> ) ; if ( newval != const0_rtx ) newval = emit_insxl ( mode , newval , addr ) ;


<s> sp_adj2 = GEN_INT ( low ) ; } else { rtx tmp = gen_rtx_REG ( DImode , <NUM_LIT> ) ; sp_adj2 = alpha_emit_set_const ( tmp , DImode , frame_size , <NUM_LIT> , false ) ; if ( ! sp_adj2 ) { sp_adj2 = alpha_emit_set_long_const ( tmp , frame_size , - ( frame_size < <NUM_LIT> ) ) ; gcc_assert ( sp_adj2 ) ; } } if ( fp_is_frame_pointer ) { emit_insn ( gen_blockage ( ) ) ; mem = gen_frame_mem ( DImode , plus_constant ( Pmode , sa_reg , fp_offset ) ) ; emit_move_insn ( hard_frame_pointer_rtx , mem ) ; cfa_restores = alloc_reg_note ( REG_CFA_RESTORE , hard_frame_pointer_rtx , cfa_restores ) ; } else if ( TARGET_ABI_OPEN_VMS ) { emit_insn ( gen_blockage ( ) ) ; emit_move_insn ( hard_frame_pointer_rtx , gen_rtx_REG ( DImode , vms_save_fp_regno ) ) ; cfa_restores = alloc_reg_note ( REG_CFA_RESTORE , hard_frame_pointer_rtx , cfa_restores ) ; } emit_insn ( gen_blockage ( ) ) ; if ( sp_adj2 == const0_rtx ) insn = emit_move_insn ( stack_pointer_rtx , sp_adj1 ) ; else insn = emit_move_insn ( stack_pointer_rtx , gen_rtx_PLUS ( DImode , sp_adj1 , sp_adj2 ) ) ; REG_NOTES ( insn ) = cfa_restores ; add_reg_note ( insn , REG_CFA_DEF_CFA , stack_pointer_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { gcc_assert ( cfa_restores == NULL ) ; if ( TARGET_ABI_OPEN_VMS && alpha_procedure_type == PT_REGISTER ) { emit_insn ( gen_blockage ( ) ) ; insn = emit_move_insn ( hard_frame_pointer_rtx , gen_rtx_REG ( DImode , vms_save_fp_regno ) ) ; add_reg_note ( insn , REG_CFA_RESTORE , hard_frame_pointer_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; }


<s> 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_DOUBLE || GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_VECTOR ) { if ( alpha_split_const_mov ( mode , operands ) ) return true ; }

tmp = force_const_mem ( mode , operands [ <NUM_LIT> ] ) ;


<s> if ( aligned_memory_operand ( operands [ <NUM_LIT> ] , mode ) ) { if ( reload_in_progress ) { if ( mode == QImode ) seq = gen_reload_inqi_aligned ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; else seq = gen_reload_inhi_aligned ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( seq ) ; } else { rtx aligned_mem , bitnum ; rtx scratch = gen_reg_rtx ( SImode ) ; rtx subtarget ; bool copyout ; 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 ;


<s> RTX_FRAME_RELATED_P ( seq ) = <NUM_LIT> ; add_reg_note ( seq , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - frame_size ) ) ) ; } sa_bias = <NUM_LIT> ; sa_reg = stack_pointer_rtx ; if ( reg_offset + sa_size > <NUM_LIT> ) { int low = ( ( reg_offset & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; rtx sa_bias_rtx ; if ( low + sa_size <= <NUM_LIT> ) sa_bias = reg_offset - low , reg_offset = low ; else sa_bias = reg_offset , reg_offset = <NUM_LIT> ; sa_reg = gen_rtx_REG ( DImode , <NUM_LIT> ) ; sa_bias_rtx = GEN_INT ( sa_bias ) ; if ( add_operand ( sa_bias_rtx , DImode ) ) emit_insn ( gen_adddi3 ( sa_reg , stack_pointer_rtx , sa_bias_rtx ) ) ; else { emit_move_insn ( sa_reg , sa_bias_rtx ) ; emit_insn ( gen_adddi3 ( sa_reg , stack_pointer_rtx , sa_reg ) ) ; } } if ( TARGET_ABI_OPEN_VMS && alpha_procedure_type == PT_STACK ) emit_frame_store ( REG_PV , stack_pointer_rtx , <NUM_LIT> , <NUM_LIT> ) ; if ( imask & ( <NUM_LIT> << REG_RA ) ) { emit_frame_store ( REG_RA , sa_reg , sa_bias , reg_offset ) ; imask &= ~ ( <NUM_LIT> << REG_RA ) ; reg_offset += <NUM_LIT> ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( imask & ( <NUM_LIT> << i ) ) { emit_frame_store ( i , sa_reg , sa_bias , reg_offset ) ; reg_offset += <NUM_LIT> ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( fmask & ( <NUM_LIT> << i ) ) {


<s> for ( i = <NUM_LIT> ; i < words ; ++ i ) { tmp = change_address ( smem , DImode , gen_rtx_AND ( DImode , plus_constant ( DImode , smema , <NUM_LIT> * i ) , im8 ) ) ; set_mem_alias_set ( tmp , <NUM_LIT> ) ; emit_move_insn ( data_regs [ i ] , tmp ) ; } tmp = change_address ( smem , DImode , gen_rtx_AND ( DImode , plus_constant ( DImode , 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 ) ; for ( i = <NUM_LIT> ; i < words ; ++ i ) { emit_insn ( gen_extql ( data_regs [ i ] , data_regs [ i ] , sreg ) ) ;

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


<s> } else if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> ) { i0 = CONST_DOUBLE_LOW ( x ) ; i1 = - ( i0 < <NUM_LIT> ) ; } else { i0 = CONST_DOUBLE_LOW ( x ) ; i1 = CONST_DOUBLE_HIGH ( x ) ; }


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


<s> 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 ; } { if ( * cum >= <NUM_LIT> ) return NULL_RTX ;


<s> 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 ; } { if ( * cum >= <NUM_LIT> ) return NULL_RTX ; num_args = * cum ; if ( type == void_type_node ) basereg = <NUM_LIT> ; else if ( targetm . calls . must_pass_in_stack ( mode , type ) ) return NULL_RTX ; } return gen_rtx_REG ( mode , num_args + basereg ) ;


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


<s> 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_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 ) {


<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_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ; if ( indirect ) type = build_pointer_type_for_mode ( type , ptr_mode , true ) ;

r = alpha_gimplify_va_arg_1 ( type , base , offset , pre_p ) ;


<s> addend = offset ; ptr_type = build_pointer_type_for_mode ( type , ptr_mode , true ) ; if ( TREE_CODE ( type ) == COMPLEX_TYPE ) { tree real_part , imag_part , real_temp ; real_part = alpha_gimplify_va_arg_1 ( TREE_TYPE ( type ) , base , offset , pre_p ) ; real_temp = get_initialized_tmp_var ( real_part , pre_p , NULL ) ; imag_part = alpha_gimplify_va_arg_1 ( TREE_TYPE ( type ) , base , offset , pre_p ) ; return build2 ( COMPLEX_EXPR , type , real_temp , imag_part ) ; } else if ( TREE_CODE ( type ) == REAL_TYPE ) { tree fpaddend , cond , fourtyeight ; fourtyeight = build_int_cst ( TREE_TYPE ( addend ) , <NUM_LIT> * <NUM_LIT> ) ; fpaddend = fold_build2 ( MINUS_EXPR , TREE_TYPE ( addend ) , addend , fourtyeight ) ; cond = fold_build2 ( LT_EXPR , boolean_type_node , addend , fourtyeight ) ; addend = fold_build3 ( COND_EXPR , TREE_TYPE ( addend ) , cond , fpaddend , addend ) ;


<s> 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 BARRIER : goto close_shadow_notrapb ; 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 ) ; close_shadow_notrapb : trap_pending = <NUM_LIT> ; shadow . used . i = <NUM_LIT> ; shadow . used . fp = <NUM_LIT> ; shadow . used . mem = <NUM_LIT> ; shadow . defd = shadow . used ; }


<s> HOST_WIDE_INT ret ; ret = alpha_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> ret = alpha_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> 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> ) ;


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


<s> 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 ( 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 ) ) { 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 ) {


<s> else return true ; if ( GET_CODE ( x ) != SYMBOL_REF ) return true ; case SYMBOL_REF : return SYMBOL_REF_TLS_MODEL ( x ) == <NUM_LIT> ; 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 ;


<s> return SYMBOL_REF_TLS_MODEL ( x ) == <NUM_LIT> ; 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 ;


<s> emit_insn ( gen_movdi_er_tlsgd ( r16 , pic_offset_table_rtx , x , seq ) ) ; insn = gen_call_value_osf_tlsgd ( r0 , tga , seq ) ; insn = emit_call_insn ( insn ) ; RTL_CONST_CALL_P ( insn ) = <NUM_LIT> ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , r16 ) ; insn = get_insns ( ) ; end_sequence ( ) ; emit_libcall_block ( insn , dest , r0 , x ) ; return dest ; case TLS_MODEL_LOCAL_DYNAMIC : start_sequence ( ) ; r0 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; r16 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; tga = get_tls_get_addr ( ) ; scratch = gen_reg_rtx ( Pmode ) ; seq = GEN_INT ( alpha_next_sequence_number ++ ) ; emit_insn ( gen_movdi_er_tlsldm ( r16 , pic_offset_table_rtx , seq ) ) ; insn = gen_call_value_osf_tlsldm ( r0 , tga , seq ) ; insn = emit_call_insn ( insn ) ; RTL_CONST_CALL_P ( insn ) = <NUM_LIT> ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , r16 ) ; insn = get_insns ( ) ; end_sequence ( ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_TLSLDM_CALL ) ; emit_libcall_block ( insn , scratch , r0 , eqv ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_DTPREL ) ; eqv = gen_rtx_CONST ( Pmode , eqv ) ; if ( alpha_tls_size == <NUM_LIT> ) { dest = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , eqv ) ) ; emit_insn ( gen_adddi3 ( dest , dest , scratch ) ) ; return dest ; } if ( alpha_tls_size == <NUM_LIT> ) { insn = gen_rtx_HIGH ( Pmode , eqv ) ; insn = gen_rtx_PLUS ( Pmode , scratch , insn ) ; scratch = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , scratch , insn ) ) ; } return gen_rtx_LO_SUM ( Pmode , scratch , eqv ) ; case TLS_MODEL_INITIAL_EXEC : eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_TPREL ) ; eqv = gen_rtx_CONST ( Pmode , eqv ) ; tp = gen_reg_rtx ( Pmode ) ; scratch = gen_reg_rtx ( Pmode ) ; dest = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_get_thread_pointerdi ( tp ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , scratch , eqv ) ) ; emit_insn ( gen_adddi3 ( dest , tp , scratch ) ) ; return dest ; case TLS_MODEL_LOCAL_EXEC : eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_TPREL ) ; eqv = gen_rtx_CONST ( Pmode , eqv ) ; tp = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_get_thread_pointerdi ( tp ) ) ; if ( alpha_tls_size == <NUM_LIT> ) { insn = gen_rtx_HIGH ( Pmode , eqv ) ; insn = gen_rtx_PLUS ( Pmode , tp , insn ) ; tp = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tp , insn ) ) ; }

return gen_rtx_LO_SUM ( Pmode , tp , eqv ) ;


<s> 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> hi = ( ( ( delta - lo ) & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ; if ( hi + lo == delta ) { if ( hi ) emit_insn ( gen_adddi3 ( this_rtx , this_rtx , GEN_INT ( hi ) ) ) ; if ( lo ) emit_insn ( gen_adddi3 ( this_rtx , this_rtx , 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_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 , - ( 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 ) ) ;


<s> rtx_insn * insn ; emit_insn ( gen_prologue_ldgp ( ) ) ; emit_note ( NOTE_INSN_PROLOGUE_END ) ; if ( aggregate_value_p ( TREE_TYPE ( TREE_TYPE ( function ) ) , function ) ) this_rtx = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; else this_rtx = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; 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_rtx , this_rtx , GEN_INT ( hi ) ) ) ; if ( lo ) emit_insn ( gen_adddi3 ( this_rtx , this_rtx , 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_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 , - ( 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_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 ) ) ;


<s> next = next_active_insn ( insn ) ; 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> if ( ! CALL_P ( insn ) || ! ( SIBLING_CALL_P ( insn ) || find_reg_note ( insn , REG_NORETURN , NULL_RTX ) ) ) continue ; next = NEXT_INSN ( insn ) ; if ( next == NULL ) continue ; if ( NOTE_P ( next ) && NOTE_KIND ( next ) == NOTE_INSN_CALL_ARG_LOCATION ) insn = next ; next = next_active_insn ( insn ) ; 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> return mode == TFmode || mode == TCmode ;


<s> if ( x == CONST0_RTX ( GET_MODE ( x ) ) ) return rclass ; if ( CONST_INT_P ( x ) || GET_CODE ( x ) == CONST_DOUBLE || GET_CODE ( x ) == CONST_VECTOR ) {

if ( rclass == FLOAT_REGS ) return NO_REGS ;


if ( current_function_has_exception_handlers ( ) ) alpha_pad_function_end ( ) ;


<s> } return false ; case MULT : if ( float_mode_p ) * total = cost_data -> fp_mult ; else if ( mode == DImode ) * total = cost_data -> int_mult_di ; else * total = cost_data -> int_mult_si ; return false ; case ASHIFT : if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= <NUM_LIT> ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } case ASHIFTRT : case LSHIFTRT : * total = cost_data -> int_shift ; return false ; case IF_THEN_ELSE : if ( float_mode_p ) * total = cost_data -> fp_add ; else * total = cost_data -> int_cmov ; return false ; case DIV : case UDIV : case MOD : case UMOD : if ( ! float_mode_p ) * total = cost_data -> int_div ; else if ( mode == SFmode ) * total = cost_data -> fp_div_sf ; else * total = cost_data -> fp_div_df ; return false ; case MEM : * total = COSTS_N_INSNS ( ! speed ? <NUM_LIT> : alpha_memory_latency ) ; return true ; case NEG : if ( ! float_mode_p ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } case ABS : if ( ! float_mode_p ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) + cost_data -> int_cmov ; return false ; } case FLOAT : case UNSIGNED_FLOAT : case FIX : case UNSIGNED_FIX : case FLOAT_TRUNCATE : * total = cost_data -> fp_add ;


<s> if ( cfun -> is_thunk ) { * imaskP = <NUM_LIT> ; * 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 ] && df_regs_ever_live_p ( i ) && i != REG_RA ) { if ( i < <NUM_LIT> ) imask |= ( <NUM_LIT> << i ) ; else fmask |= ( <NUM_LIT> << ( i - <NUM_LIT> ) ) ; } if ( crtl -> calls_eh_return ) { for ( i = <NUM_LIT> ; ; ++ i ) { unsigned regno = EH_RETURN_DATA_REGNO ( i ) ; if ( regno == INVALID_REGNUM ) break ; imask |= <NUM_LIT> << regno ; } }

if ( imask || fmask || alpha_ra_ever_killed ( ) ) imask |= ( <NUM_LIT> << REG_RA ) ;


<s> if ( crtl -> calls_eh_return ) { for ( i = <NUM_LIT> ; ; ++ i ) { unsigned regno = EH_RETURN_DATA_REGNO ( i ) ; if ( regno == INVALID_REGNUM ) break ; imask |= <NUM_LIT> << regno ; } } if ( imask || fmask || alpha_ra_ever_killed ( ) ) imask |= ( <NUM_LIT> << REG_RA ) ;


<s> vms_base_regno = ( frame_pointer_needed || cfun -> has_nonlocal_label || alpha_procedure_type == PT_STACK || crtl -> outgoing_args_size ) ? REG_PV : HARD_FRAME_POINTER_REGNUM ; vms_save_fp_regno = - <NUM_LIT> ; if ( vms_base_regno == HARD_FRAME_POINTER_REGNUM ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ! fixed_regs [ i ] && call_used_regs [ i ] && ! df_regs_ever_live_p ( i ) ) vms_save_fp_regno = i ; if ( ( vms_save_fp_regno == - <NUM_LIT> && alpha_procedure_type == PT_REGISTER ) || cfun -> machine -> uses_condition_handler ) vms_base_regno = REG_PV , alpha_procedure_type = PT_STACK ;


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

if ( alpha_procedure_type == PT_STACK ) sa_size += <NUM_LIT> + cfun -> machine -> uses_condition_handler ;


<s> return true ; case SFmode : case DFmode : return true ; case TFmode : return TARGET_HAS_XFLOATING_LIBS ; default : return false ; }


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

tmp = gen_rtx_MEM ( BLKmode , plus_constant ( Pmode , virtual_incoming_args_rtx , cum * UNITS_PER_WORD ) ) ;


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


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

width = GEN_INT ( GET_MODE_BITSIZE ( mode ) ) ;


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

if ( after ) emit_insn ( gen_rtx_SET ( VOIDmode , after , copy_rtx ( x ) ) ) ;


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


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


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

if ( newval != const0_rtx ) emit_insn ( gen_iordi3 ( cond , cond , newval ) ) ;


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


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


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


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


<s> static void alpha_trampoline_init ( rtx m_tramp , tree fndecl , rtx chain_value ) { rtx fnaddr , mem , word1 , word2 ; fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; fnaddr = convert_memory_address ( Pmode , fnaddr ) ; chain_value = convert_memory_address ( Pmode , chain_value ) ; 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 ) ;


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

mem = adjust_address ( m_tramp , Pmode , <NUM_LIT> ) ;


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


<s> static bool alpha_vms_can_eliminate ( const int from ATTRIBUTE_UNUSED , const int to ) { alpha_sa_size ( ) ; 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 ) ; } gcc_unreachable ( ) ;


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


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

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


<s> hash_map < const char * , alpha_links * , string_traits > :: iterator iter = cfun -> machine -> links -> begin ( ) ;

for ( ; iter != cfun -> machine -> links -> end ( ) ; ++ iter ) alpha_write_one_linkage ( ( * iter ) . first , ( * iter ) . second , stream ) ;


<s> else return ALPHA_ROUND ( crtl -> outgoing_args_size ) + sa_size + ALPHA_ROUND ( size + crtl -> args . pretend_args_size ) ;


if ( TARGET_ABI_OPEN_VMS ) return ALPHA_ROUND ( sa_size + ( alpha_procedure_type == PT_STACK ? <NUM_LIT> : <NUM_LIT> ) + size + crtl -> args . pretend_args_size ) ;


<s> return ( TARGET_ABI_OSF && reload_completed && alpha_sa_size ( ) == <NUM_LIT> && get_frame_size ( ) == <NUM_LIT> && crtl -> outgoing_args_size == <NUM_LIT> && crtl -> args . pretend_args_size == <NUM_LIT> ) ;


<s> addr = plus_constant ( Pmode , stack_pointer_rtx , frame_bias + base_ofs ) ; mem = gen_rtx_MEM ( DImode , addr ) ; }

add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , mem , frame_reg ) ) ;


<s> 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 ) ; mem = gen_rtx_MEM ( DImode , addr ) ;


<s> switch ( mode ) { case QImode : fn = gen_insbl ; break ; case HImode : fn = gen_inswl ; break ; case SImode : fn = gen_insll ; break ; case DImode : fn = gen_insql ;


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


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


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


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


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


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

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


<s> } else base = XEXP ( ref , <NUM_LIT> ) ;


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


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

if ( ! CONVERT_EXPR_CODE_P ( code ) && ( ( code != PLUS_EXPR && code != POINTER_PLUS_EXPR ) || TREE_CODE ( gimple_assign_rhs2 ( stmt ) ) != INTEGER_CST || ! tree_fits_uhwi_p ( gimple_assign_rhs2 ( stmt ) ) ) ) return 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> static bool vms_valid_pointer_mode ( machine_mode mode ) {

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


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


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


<s> if ( ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } if ( signed_comparison_operator ( cmp , VOIDmode ) && ( cmp_mode == DImode || local_fast_math ) && ( op0 == CONST0_RTX ( cmp_mode ) || op1 == CONST0_RTX ( cmp_mode ) ) ) return gen_rtx_fmt_ee ( code , VOIDmode , op0 , op1 ) ; if ( ! can_create_pseudo_p ( ) ) return NULL_RTX ; switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : case UNORDERED : break ; case NE : case ORDERED : code = reverse_condition ( code ) ; cmov_code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( cmp_mode == DImode && op1 == const0_rtx ) break ; code = swap_condition ( code ) ; std :: swap ( op0 , op1 ) ; break ; default : gcc_unreachable ( ) ; } if ( cmp_mode == DImode ) { if ( ! reg_or_0_operand ( op0 , DImode ) ) op0 = force_reg ( DImode , op0 ) ; if ( ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } if ( cmp_mode == DFmode && ! local_fast_math ) cmov_mode = CCmode ; tem = gen_reg_rtx ( cmp_mode ) ; emit_move_insn ( tem , gen_rtx_fmt_ee ( code , cmp_mode , op0 , op1 ) ) ; return gen_rtx_fmt_ee ( cmov_code , cmov_mode , tem , CONST0_RTX ( cmp_mode ) ) ;


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


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

emit_move_insn ( hard_frame_pointer_rtx , gen_rtx_REG ( DImode , vms_save_fp_regno ) ) ;


<s> if ( imask & ( <NUM_LIT> << REG_RA ) ) { emit_frame_store ( REG_RA , sa_reg , sa_bias , reg_offset ) ; imask &= ~ ( <NUM_LIT> << REG_RA ) ; reg_offset += <NUM_LIT> ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( imask & ( <NUM_LIT> << i ) ) { emit_frame_store ( i , sa_reg , sa_bias , reg_offset ) ; reg_offset += <NUM_LIT> ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( fmask & ( <NUM_LIT> << i ) ) { emit_frame_store ( i + <NUM_LIT> , sa_reg , sa_bias , reg_offset ) ; reg_offset += <NUM_LIT> ; } if ( TARGET_ABI_OPEN_VMS ) { if ( alpha_procedure_type == PT_REGISTER ) { rtx_insn * insn = emit_move_insn ( gen_rtx_REG ( DImode , vms_save_fp_regno ) , hard_frame_pointer_rtx ) ; add_reg_note ( insn , REG_CFA_REGISTER , NULL ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( alpha_procedure_type != PT_NULL && vms_base_regno != REG_PV ) emit_insn ( gen_force_movdi ( gen_rtx_REG ( DImode , vms_base_regno ) , gen_rtx_REG ( DImode , REG_PV ) ) ) ; if ( alpha_procedure_type != PT_NULL && vms_unwind_regno == HARD_FRAME_POINTER_REGNUM ) FRP ( emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; if ( crtl -> outgoing_args_size != <NUM_LIT> ) { rtx_insn * seq = emit_move_insn ( stack_pointer_rtx , plus_constant ( Pmode , hard_frame_pointer_rtx , - ( ALPHA_ROUND ( crtl -> outgoing_args_size ) ) ) ) ; RTX_FRAME_RELATED_P ( seq ) = ! frame_pointer_needed ; } } else { if ( frame_pointer_needed ) { if ( TARGET_CAN_FAULT_IN_PROLOGUE ) FRP ( emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; else FRP ( emit_insn ( gen_init_fp ( hard_frame_pointer_rtx , stack_pointer_rtx , sa_reg ) ) ) ; }


<s> * cum += increment ; if ( ! onstack && cum -> num_args < <NUM_LIT> ) cum -> atypes [ cum -> num_args ] = alpha_arg_type ( mode ) ; cum -> num_args += increment ;


<s> bool alpha_gimple_fold_builtin ( gimple_stmt_iterator * gsi ) { 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_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> tree fndecl = gimple_call_fndecl ( stmt ) ; if ( fndecl ) { tree arg0 , arg1 ; switch ( DECL_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 :


<s> line_size = cpu_table [ i ] . line_size ; l1_size = cpu_table [ i ] . l1_size ; l2_size = cpu_table [ i ] . l2_size ; target_flags &= ~ ( MASK_BWX | MASK_MAX | MASK_FIX | MASK_CIX ) ; target_flags |= cpu_table [ i ] . flags ; break ; } if ( i == ct_size ) error ( <STR_LIT> , alpha_cpu_string ) ; } if ( alpha_tune_string ) { for ( i = <NUM_LIT> ; i < ct_size ; i ++ ) if ( ! strcmp ( alpha_tune_string , cpu_table [ i ] . name ) ) { alpha_tune = cpu_table [ i ] . processor ; line_size = cpu_table [ i ] . line_size ; l1_size = cpu_table [ i ] . l1_size ; l2_size = cpu_table [ i ] . l2_size ; break ; } if ( i == ct_size ) error ( <STR_LIT> , alpha_tune_string ) ; } if ( line_size ) maybe_set_param_value ( PARAM_L1_CACHE_LINE_SIZE , line_size , global_options . x_param_values , global_options_set . x_param_values ) ; if ( l1_size ) maybe_set_param_value ( PARAM_L1_CACHE_SIZE , l1_size , global_options . x_param_values , global_options_set . x_param_values ) ; if ( l2_size ) maybe_set_param_value ( PARAM_L2_CACHE_SIZE , l2_size , global_options . x_param_values , global_options_set . x_param_values ) ; 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> ;


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


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


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

emit_store_conditional ( mode , cond , mem , scratch ) ;


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

x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ;


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


<s> 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 ( ) ) ; emit_load_locked ( DImode , scratch , mem ) ; width = GEN_INT ( GET_MODE_BITSIZE ( mode ) ) ; mask = GEN_INT ( mode == QImode ? <NUM_LIT> : <NUM_LIT> ) ; emit_insn ( gen_extxl ( dest , scratch , width , addr ) ) ; if ( oldval == const0_rtx ) { emit_move_insn ( cond , const0_rtx ) ; x = gen_rtx_NE ( DImode , dest , const0_rtx ) ; } else { x = gen_rtx_EQ ( DImode , dest , oldval ) ; emit_insn ( gen_rtx_SET ( cond , x ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ;


<s> width = GEN_INT ( GET_MODE_BITSIZE ( mode ) ) ; mask = GEN_INT ( mode == QImode ? <NUM_LIT> : <NUM_LIT> ) ; emit_insn ( gen_extxl ( dest , scratch , width , addr ) ) ; if ( oldval == const0_rtx ) { emit_move_insn ( cond , const0_rtx ) ; x = gen_rtx_NE ( DImode , dest , const0_rtx ) ; } else { x = gen_rtx_EQ ( DImode , dest , oldval ) ; emit_insn ( gen_rtx_SET ( cond , x ) ) ; x = gen_rtx_EQ ( DImode , cond , const0_rtx ) ; } emit_unlikely_jump ( x , label2 ) ; emit_insn ( gen_mskxl ( cond , scratch , mask , addr ) ) ; if ( newval != const0_rtx ) emit_insn ( gen_iordi3 ( cond , cond , newval ) ) ; emit_store_conditional ( DImode , cond , mem , 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> int alpha_split_conditional_move ( enum rtx_code code , rtx dest , rtx cond , rtx t_rtx , rtx f_rtx ) { HOST_WIDE_INT t , f , diff ; machine_mode mode ; rtx target , subtarget , tmp ; mode = GET_MODE ( dest ) ; t = INTVAL ( t_rtx ) ; f = INTVAL ( f_rtx ) ; diff = t - f ; if ( ( ( code == NE || code == EQ ) && diff < <NUM_LIT> ) || ( code == GE || code == GT ) ) { code = reverse_condition ( code ) ; diff = t , t = f , f = diff ; diff = t - f ; } subtarget = target = dest ; if ( mode != DImode ) { target = gen_lowpart ( DImode , dest ) ; if ( can_create_pseudo_p ( ) ) subtarget = gen_reg_rtx ( DImode ) ; else subtarget = target ; } if ( f == <NUM_LIT> && exact_log2 ( diff ) > <NUM_LIT> && ( diff <= <NUM_LIT> || alpha_tune == PROCESSOR_EV6 ) ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; tmp = gen_rtx_ASHIFT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( exact_log2 ( t ) ) ) ; emit_insn ( gen_rtx_SET ( target , tmp ) ) ; } else if ( f == <NUM_LIT> && t == - <NUM_LIT> ) { tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; emit_insn ( gen_negdi2 ( target , copy_rtx ( subtarget ) ) ) ; } else if ( diff == <NUM_LIT> || diff == <NUM_LIT> || diff == <NUM_LIT> ) { rtx add_op ; tmp = gen_rtx_fmt_ee ( code , DImode , cond , const0_rtx ) ; emit_insn ( gen_rtx_SET ( copy_rtx ( subtarget ) , tmp ) ) ; if ( diff == <NUM_LIT> ) emit_insn ( gen_adddi3 ( target , copy_rtx ( subtarget ) , GEN_INT ( f ) ) ) ; else { add_op = GEN_INT ( f ) ; if ( sext_add_operand ( add_op , mode ) ) { tmp = gen_rtx_MULT ( DImode , copy_rtx ( subtarget ) , GEN_INT ( diff ) ) ; tmp = gen_rtx_PLUS ( DImode , tmp , add_op ) ; emit_insn ( gen_rtx_SET ( target , tmp ) ) ; } else return <NUM_LIT> ; } }


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


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


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


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

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


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


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


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

return mode == TFmode || mode == TCmode ;


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

add_int_reg_note ( insn , REG_BR_PROB , very_unlikely ) ;


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


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

imag_part = alpha_gimplify_va_arg_1 ( ptr_type , base , offset , pre_p ) ;


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


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


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


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


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


<s> in_use |= EV5_FA ; nop = gen_fnop ( ) ; } else if ( TARGET_FP && ! ( in_use & EV5_FM ) ) { in_use |= EV5_FM ; nop = gen_fnop ( ) ;


<s> size_t i ; for ( i = <NUM_LIT> ; i < count ; ++ i , ++ p ) if ( ( target_flags & p -> target_mask ) == p -> target_mask ) alpha_builtin_function ( p -> name , ftype , p -> code , ( p -> is_const ? ECF_CONST : <NUM_LIT> ) | ECF_NOTHROW ) ;


<s> for ( i = <NUM_LIT> ; i < count ; ++ i , ++ p ) if ( ( target_flags & p -> target_mask ) == p -> target_mask ) alpha_builtin_function ( p -> name , ftype , p -> code , ( p -> is_const ? ECF_CONST : <NUM_LIT> ) | ECF_NOTHROW ) ;


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


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


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

if ( ! ( TARGET_EXPLICIT_RELOCS && prev && CALL_P ( prev ) ) ) {


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

if ( * cum < <NUM_LIT> && <NUM_LIT> < * cum + ALPHA_ARG_SIZE ( arg . mode , arg . type ) ) words = <NUM_LIT> - * cum ;


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


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


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

tree decl = add_builtin_function ( name , ftype , ( int ) code , BUILT_IN_MD , NULL , NULL_TREE ) ;


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


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


<s> static bool alpha_cannot_force_const_mem ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) { enum rtx_code code = GET_CODE ( x ) ; return code == SYMBOL_REF || code == LABEL_REF || code == CONST ;


<s> if ( ( * code == LT || * code == LTU ) && CONST_INT_P ( * op1 ) && INTVAL ( * op1 ) == <NUM_LIT> ) { * code = * code == LT ? LE : LEU ; * op1 = GEN_INT ( <NUM_LIT> ) ;


<s> static bool alpha_can_change_mode_class ( machine_mode from , machine_mode to , reg_class_t rclass ) {

return ( GET_MODE_SIZE ( from ) == GET_MODE_SIZE ( to ) || ! reg_classes_intersect_p ( FLOAT_REGS , rclass ) ) ;


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


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


<s> case ALPHA_FPRM_NORM : mode = <NUM_LIT> ; break ; case ALPHA_FPRM_MINF : mode = <NUM_LIT> ; break ; case ALPHA_FPRM_CHOP : mode = <NUM_LIT> ; break ; case ALPHA_FPRM_DYN : mode = <NUM_LIT> ;


<s> mode = <NUM_LIT> ; break ; case ALPHA_FPRM_MINF : mode = <NUM_LIT> ; break ; case ALPHA_FPRM_CHOP : mode = <NUM_LIT> ; break ; case ALPHA_FPRM_DYN : mode = <NUM_LIT> ;


<s> static void alpha_conditional_register_usage ( void ) { int i ;

if ( ! TARGET_FPREGS ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> ;


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


<s> push_topmost_sequence ( ) ; insn = get_insns ( ) ; pop_topmost_sequence ( ) ; for ( ; insn ; insn = NEXT_INSN ( insn ) ) if ( NONDEBUG_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER && get_attr_usegp ( insn ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> static int alpha_elf_reloc_rw_mask ( void ) { return flag_pic ? <NUM_LIT> : <NUM_LIT> ;


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


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


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

if ( TARGET_SMALL_DATA && GET_MODE_SIZE ( mode ) <= g_switch_value ) return sdata_section ;


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


<s> if ( ! TARGET_FIX ) return <NUM_LIT> ; switch ( code ) { case EQ : case LE : case LT : case LEU : case LTU : case UNORDERED : cmp_code = code , code = NE ; break ; case NE : case ORDERED : cmp_code = reverse_condition ( code ) , code = EQ ; break ; case GE : case GT : case GEU : case GTU : if ( cmp_mode == DImode && op1 == const0_rtx ) cmp_code = code , code = NE ; else { cmp_code = swap_condition ( code ) ; code = NE ; std :: swap ( op0 , op1 ) ; } break ; default : gcc_unreachable ( ) ; } if ( cmp_mode == DImode ) { if ( ! reg_or_0_operand ( op0 , DImode ) ) op0 = force_reg ( DImode , op0 ) ; if ( ! reg_or_8bit_operand ( op1 , DImode ) ) op1 = force_reg ( DImode , op1 ) ; } tem = gen_reg_rtx ( cmp_mode ) ; emit_insn ( gen_rtx_SET ( tem , gen_rtx_fmt_ee ( cmp_code , cmp_mode , op0 , op1 ) ) ) ; cmp_mode = cmp_mode == DImode ? E_DFmode : E_DImode ; op0 = gen_lowpart ( cmp_mode , tem ) ; op1 = CONST0_RTX ( cmp_mode ) ; cmp = gen_rtx_fmt_ee ( code , VOIDmode , op0 , op1 ) ; local_fast_math = <NUM_LIT> ;


<s> f0 = gen_reg_rtx ( mode ) ; emit_cmp_and_jump_insns ( in , const0_rtx , LT , const0_rtx , DImode , <NUM_LIT> , neglab ) ; emit_insn ( gen_rtx_SET ( 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 ( f0 , gen_rtx_FLOAT ( mode , i0 ) ) ) ; emit_insn ( gen_rtx_SET ( out , gen_rtx_PLUS ( mode , f0 , f0 ) ) ) ; emit_label ( donelab ) ;


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


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