<s> return regno >= <NUM_LIT> ? ( regno - <NUM_LIT> ) : ( regno + <NUM_LIT> ) ;


if ( args_so_farp -> regs + <NUM_LIT> < MMIX_MAX_ARGS_IN_REGS ) * pretend_sizep = ( MMIX_MAX_ARGS_IN_REGS - ( args_so_farp -> regs + <NUM_LIT> ) ) * <NUM_LIT> ;


<s> for ( i = MMIX_RESERVED_GNU_ARG_0_REGNUM ; i < MMIX_RESERVED_GNU_ARG_0_REGNUM + MMIX_MAX_ARGS_IN_REGS ; i ++ ) fixed_regs [ i ] = <NUM_LIT> ; } if ( ! TARGET_TOPLEVEL_SYMBOLS ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( reg_names [ i ] [ <NUM_LIT> ] == ':' ) reg_names [ i ] ++ ;


<s> if ( TARGET_ABI_GNU ) { static const int gnu_abi_reg_alloc_order [ ] = MMIX_GNU_ABI_REG_ALLOC_ORDER ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) reg_alloc_order [ i ] = gnu_abi_reg_alloc_order [ i ] ; for ( i = <NUM_LIT> ; i <= <NUM_LIT> ; i ++ ) call_used_regs [ i ] = <NUM_LIT> ; for ( i = MMIX_RESERVED_GNU_ARG_0_REGNUM ; i < MMIX_RESERVED_GNU_ARG_0_REGNUM + MMIX_MAX_ARGS_IN_REGS ; i ++ ) fixed_regs [ i ] = <NUM_LIT> ; } if ( ! TARGET_TOPLEVEL_SYMBOLS ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( reg_names [ i ] [ <NUM_LIT> ] == ':' ) reg_names [ i ] ++ ;


<s> const char * mmix_data_section_asm_op ( ) { return <STR_LIT> ;


<s> return gen_rtx_REG ( Pmode , MMIX_EH_RETURN_STACKADJ_REGNUM ) ;


<s> void mmix_setup_frame_addresses ( ) {


<s> int mmix_starting_frame_offset ( ) { return ( - <NUM_LIT> + ( MMIX_CFUN_HAS_LANDING_PAD ? - <NUM_LIT> : ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? - <NUM_LIT> : <NUM_LIT> ) ) ) ;


<s> void mmix_asm_output_aligned_local ( FILE * stream , const char * name , int size , int align ) {


<s> assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> , size ) ;


<s> const char * regname = reg_names [ MMIX_FIRST_INCOMING_ARG_REGNUM ] ; if ( delta >= <NUM_LIT> && delta < <NUM_LIT> ) fprintf ( stream , <STR_LIT> , regname , ( int ) delta ) ; else if ( delta < <NUM_LIT> && delta >= - <NUM_LIT> ) fprintf ( stream , <STR_LIT> , regname , regname , ( int ) - delta ) ; else { mmix_output_register_setting ( stream , <NUM_LIT> , delta , <NUM_LIT> ) ; fprintf ( stream , <STR_LIT> , regname , regname ) ;


<s> void mmix_asm_output_source_filename ( FILE * stream , const char * name ) { fprintf ( stream , <STR_LIT> ) ;

OUTPUT_QUOTED_STRING ( stream , name ) ;


<s> fprintf ( stream , <STR_LIT> ) ; OUTPUT_QUOTED_STRING ( stream , name ) ;


<s> aligned_p = <NUM_LIT> ; break ; } fputs ( <STR_LIT> , asm_out_file ) ; mmix_print_operand ( asm_out_file , x , 'B' ) ; fputc ( '\n' , asm_out_file ) ; return true ; case <NUM_LIT> : if ( GET_CODE ( x ) != CONST_INT ) { aligned_p = <NUM_LIT> ; break ; } fputs ( <STR_LIT> , asm_out_file ) ; mmix_print_operand ( asm_out_file , x , 'W' ) ; fputc ( '\n' , asm_out_file ) ; return true ;


<s> if ( TARGET_ABI_GNU ) { static const int gnu_abi_reg_alloc_order [ ] = MMIX_GNU_ABI_REG_ALLOC_ORDER ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) reg_alloc_order [ i ] = gnu_abi_reg_alloc_order [ i ] ; for ( i = <NUM_LIT> ; i <= <NUM_LIT> ; i ++ ) call_used_regs [ i ] = <NUM_LIT> ; for ( i = MMIX_RESERVED_GNU_ARG_0_REGNUM ;

i < MMIX_RESERVED_GNU_ARG_0_REGNUM + MMIX_MAX_ARGS_IN_REGS ;


<s> } if ( ! TARGET_TOPLEVEL_SYMBOLS ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( reg_names [ i ] [ <NUM_LIT> ] == ':' ) reg_names [ i ] ++ ;


<s> rtx mmix_dynamic_chain_address ( rtx frame ) {

return plus_constant ( frame , - <NUM_LIT> ) ;


<s> if ( offset < <NUM_LIT> ) { if ( offset > - <NUM_LIT> ) insn = emit_insn ( gen_adddi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( offset ) ) ) ; else { rtx tmpr = gen_rtx_REG ( DImode , <NUM_LIT> ) ; RTX_FRAME_RELATED_P ( emit_move_insn ( tmpr , GEN_INT ( offset ) ) ) = <NUM_LIT> ; insn = emit_insn ( gen_adddi3 ( stack_pointer_rtx , stack_pointer_rtx , tmpr ) ) ; } RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> if ( TREE_CODE ( decl ) == FUNCTION_DECL || TREE_CONSTANT ( decl ) || ( TREE_CODE ( decl ) == VAR_DECL && TREE_READONLY ( decl ) && ! TREE_SIDE_EFFECTS ( decl ) && ( ! DECL_INITIAL ( decl ) || TREE_CONSTANT ( DECL_INITIAL ( decl ) ) ) ) ) SYMBOL_REF_FLAG ( XEXP ( rtl , <NUM_LIT> ) ) = <NUM_LIT> ;


<s> HOST_WIDE_INT locals_size = get_frame_size ( ) ; int regno ; HOST_WIDE_INT stack_space_to_deallocate = ( current_function_outgoing_args_size + current_function_pretend_args_size + locals_size + <NUM_LIT> ) & ~ <NUM_LIT> ; HOST_WIDE_INT offset = current_function_outgoing_args_size ; for ( regno = <NUM_LIT> ; regno >= MMIX_FIRST_GLOBAL_REGNUM ; regno -- ) if ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) stack_space_to_deallocate += <NUM_LIT> ; if ( MMIX_CFUN_HAS_LANDING_PAD ) stack_space_to_deallocate += <NUM_LIT> ; else if ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ) stack_space_to_deallocate += <NUM_LIT> ; if ( frame_pointer_needed ) stack_space_to_deallocate += <NUM_LIT> ; if ( ( stack_space_to_deallocate % <NUM_LIT> ) != <NUM_LIT> ) internal_error ( <STR_LIT> , stack_space_to_deallocate ) ; for ( regno = MMIX_FIRST_GLOBAL_REGNUM ; regno <= <NUM_LIT> ; regno ++ ) if ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) {


<s> regno >= mmix_first_vararg_reg ; regno -- ) { if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( stack_pointer_rtx , offset ) ) , gen_rtx_REG ( DImode , regno ) ) ; offset -= <NUM_LIT> ; } } if ( frame_pointer_needed ) { rtx insn ; if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } insn = emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( stack_pointer_rtx , offset ) ) , hard_frame_pointer_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_adddi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( offset + <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; offset -= <NUM_LIT> ; } if ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ) { rtx tmpreg , retreg ; rtx insn ; if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } tmpreg = gen_rtx_REG ( DImode , <NUM_LIT> ) ; retreg = gen_rtx_REG ( DImode , MMIX_rJ_REGNUM ) ; emit_move_insn ( tmpreg , retreg ) ; insn = emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( stack_pointer_rtx , offset ) ) , tmpreg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( DImode , plus_constant ( stack_pointer_rtx , offset ) ) , retreg ) , REG_NOTES ( insn ) ) ; offset -= <NUM_LIT> ; } else if ( MMIX_CFUN_HAS_LANDING_PAD ) offset -= <NUM_LIT> ; if ( MMIX_CFUN_HAS_LANDING_PAD ) { if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } emit_move_insn ( gen_rtx_REG ( DImode , <NUM_LIT> ) , gen_rtx_REG ( DImode , MMIX_rO_REGNUM ) ) ; emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( stack_pointer_rtx , offset ) ) , gen_rtx_REG ( DImode , <NUM_LIT> ) ) ;


<s> HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } insn = emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( stack_pointer_rtx , offset ) ) , hard_frame_pointer_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_adddi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( offset + <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; offset -= <NUM_LIT> ; } if ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ) { rtx tmpreg , retreg ; rtx insn ; if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } tmpreg = gen_rtx_REG ( DImode , <NUM_LIT> ) ; retreg = gen_rtx_REG ( DImode , MMIX_rJ_REGNUM ) ; emit_move_insn ( tmpreg , retreg ) ; insn = emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( stack_pointer_rtx , offset ) ) , tmpreg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( DImode , plus_constant ( stack_pointer_rtx , offset ) ) , retreg ) , REG_NOTES ( insn ) ) ; offset -= <NUM_LIT> ; }

else if ( MMIX_CFUN_HAS_LANDING_PAD ) offset -= <NUM_LIT> ;


<s> HOST_WIDEST_INT value ; if ( c == 'U' ) return strict ? strict_memory_address_p ( Pmode , x ) : memory_address_p ( Pmode , x ) ; if ( c == 'R' ) return GET_CODE ( x ) != CONST_INT && GET_CODE ( x ) != CONST_DOUBLE && mmix_constant_address_p ( x ) && ( ! TARGET_BASE_ADDRESSES || ( GET_CODE ( x ) == LABEL_REF || ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_FLAG ( x ) ) ) ) ; if ( GET_CODE ( x ) != CONST_DOUBLE || GET_MODE ( x ) != VOIDmode ) return <NUM_LIT> ; value = mmix_intval ( x ) ;

if ( c == 'S' ) return mmix_shiftable_wyde_value ( value ) ;


<s> static void mmix_file_start ( void ) {


<s> rtx mmix_function_arg ( const CUMULATIVE_ARGS * argsp , enum machine_mode mode , tree type , int named ATTRIBUTE_UNUSED , int incoming ) {

if ( type == void_type_node ) return ( argsp -> regs < MMIX_MAX_ARGS_IN_REGS ) ? gen_rtx_REG ( mode , ( incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM ) + argsp -> regs ) : NULL_RTX ;


<s> if ( type == void_type_node ) return ( argsp -> regs < MMIX_MAX_ARGS_IN_REGS ) ? gen_rtx_REG ( mode , ( incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM ) + argsp -> regs ) : NULL_RTX ;

return ( argsp -> regs < MMIX_MAX_ARGS_IN_REGS && ! targetm . calls . must_pass_in_stack ( mode , type ) && ( GET_MODE_BITSIZE ( mode ) <= <NUM_LIT> || argsp -> lib || TARGET_LIBFUNC ) ) ? gen_rtx_REG ( mode , ( incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM ) + argsp -> regs ) : NULL_RTX ;


<s> for ( i = <NUM_LIT> ; i < nregs - <NUM_LIT> ; i ++ ) vec [ i ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( cmode , first_val_regnum + i ) , GEN_INT ( ( i + <NUM_LIT> ) * BITS_PER_UNIT ) ) ;

vec [ nregs - <NUM_LIT> ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( cmode , first_val_regnum + nregs - <NUM_LIT> ) , const0_rtx ) ;


<s> int mmix_function_value_regno_p ( int regno ) { return regno == MMIX_RETURN_VALUE_REGNUM ;


<s> rtx mmix_gen_compare_reg ( RTX_CODE code , rtx x , rtx y ) { enum machine_mode ccmode = SELECT_CC_MODE ( code , x , y ) ; rtx cc_reg ; enum machine_mode mode = GET_MODE ( x ) == VOIDmode ? GET_MODE ( y ) : GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_FLOAT ? DFmode : DImode ;

if ( ! mmix_valid_comparison ( code , mode , x ) ) return NULL_RTX ;


<s> enum machine_mode mode = GET_MODE ( x ) == VOIDmode ? GET_MODE ( y ) : GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_FLOAT ? DFmode : DImode ; if ( ! mmix_valid_comparison ( code , mode , x ) ) return NULL_RTX ; cc_reg = gen_reg_rtx ( ccmode ) ; if ( ! REG_P ( x ) && ! REG_P ( y ) ) x = force_reg ( mode , x ) ;

if ( ! REG_P ( y ) && ( GET_CODE ( y ) != CONST_INT || ! CONST_OK_FOR_LETTER_P ( INTVAL ( y ) , 'I' ) ) ) y = force_reg ( mode , y ) ;


<s> rtx mmix_get_hard_reg_initial_val ( enum machine_mode mode , int regno ) {

return get_hard_reg_initial_val ( mode , regno ) ;


<s> regno ++ ) if ( ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) fp_sp_offset += <NUM_LIT> ; return fp_sp_offset + ( MMIX_CFUN_HAS_LANDING_PAD ? <NUM_LIT> : ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? <NUM_LIT> : <NUM_LIT> ) ) + ( fromreg == MMIX_ARG_POINTER_REGNUM ? <NUM_LIT> : <NUM_LIT> ) ;


<s> static HOST_WIDEST_INT mmix_intval ( rtx x ) { unsigned HOST_WIDEST_INT retval ; if ( GET_CODE ( x ) == CONST_INT ) return INTVAL ( x ) ; if ( GET_CODE ( x ) == CONST_DOUBLE && GET_MODE ( x ) == VOIDmode ) { if ( sizeof ( HOST_WIDE_INT ) < sizeof ( HOST_WIDEST_INT ) ) { retval = ( unsigned ) CONST_DOUBLE_LOW ( x ) / <NUM_LIT> ; retval *= <NUM_LIT> ; retval |= CONST_DOUBLE_LOW ( x ) & <NUM_LIT> ; retval |= ( unsigned HOST_WIDEST_INT ) CONST_DOUBLE_HIGH ( x ) << ( HOST_BITS_PER_LONG ) ; } else retval = CONST_DOUBLE_HIGH ( x ) ; return retval ; } if ( GET_CODE ( x ) == CONST_DOUBLE ) { REAL_VALUE_TYPE value ; REAL_VALUE_FROM_CONST_DOUBLE ( value , x ) ; if ( GET_MODE ( x ) == DFmode ) { long bits [ <NUM_LIT> ] ;

REAL_VALUE_TO_TARGET_DOUBLE ( value , bits ) ;


<s> REAL_VALUE_TYPE value ; REAL_VALUE_FROM_CONST_DOUBLE ( value , x ) ; if ( GET_MODE ( x ) == DFmode ) { long bits [ <NUM_LIT> ] ; REAL_VALUE_TO_TARGET_DOUBLE ( value , bits ) ; return ( ( unsigned HOST_WIDEST_INT ) ( unsigned long ) bits [ <NUM_LIT> ] << ( unsigned HOST_WIDEST_INT ) <NUM_LIT> ) | ( unsigned HOST_WIDEST_INT ) ( unsigned long ) bits [ <NUM_LIT> ] ; } else if ( GET_MODE ( x ) == SFmode ) {


<s> if ( ! REG_P ( x1 ) || ! MMIX_REG_OK ( x1 ) ) return TARGET_BASE_ADDRESSES && mmix_constant_address_p ( x ) ; if ( REG_P ( x2 ) && MMIX_REG_OK ( x2 ) ) return <NUM_LIT> ; if ( GET_CODE ( x2 ) == CONST_INT && CONST_OK_FOR_LETTER_P ( INTVAL ( x2 ) , 'I' ) ) return <NUM_LIT> ; return <NUM_LIT> ; }


<s> int mmix_local_regno ( int regno ) { return regno <= MMIX_LAST_STACK_REGISTER_REGNUM && ! call_used_regs [ regno ] ;


<s> struct cc_type_conv { enum machine_mode cc_mode ; const struct cc_conv * const convs ; } ; static const struct cc_conv cc_fun_convs [ ] = { { ORDERED , <STR_LIT> , <STR_LIT> } , { UNORDERED , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_conv cc_fp_convs [ ] = { { GT , <STR_LIT> , NULL } , { LT , <STR_LIT> , NULL } , CCEND } ; static const struct cc_conv cc_fpeq_convs [ ] = { { NE , <STR_LIT> , <STR_LIT> } , { EQ , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_conv cc_uns_convs [ ] = { { GEU , <STR_LIT> , <STR_LIT> } , { GTU , <STR_LIT> , <STR_LIT> } , { LEU , <STR_LIT> , <STR_LIT> } , { LTU , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_conv cc_signed_convs [ ] = { { NE , <STR_LIT> , <STR_LIT> } , { EQ , <STR_LIT> , <STR_LIT> } , { GE , <STR_LIT> , <STR_LIT> } , { GT , <STR_LIT> , <STR_LIT> } , { LE , <STR_LIT> , <STR_LIT> } , { LT , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_conv cc_di_convs [ ] = { { NE , <STR_LIT> , <STR_LIT> } , { EQ , <STR_LIT> , <STR_LIT> } , { GE , <STR_LIT> , <STR_LIT> } , { GT , <STR_LIT> , <STR_LIT> } , { LE , <STR_LIT> , <STR_LIT> } , { LT , <STR_LIT> , <STR_LIT> } , { GTU , <STR_LIT> , <STR_LIT> } , { LEU , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_type_conv cc_convs [ ] = { { CC_FUNmode , cc_fun_convs } , { CC_FPmode , cc_fp_convs } , { CC_FPEQmode , cc_fpeq_convs } , { CC_UNSmode , cc_uns_convs } , { CCmode , cc_signed_convs } , { DImode , cc_di_convs } } ; size_t i ; int j ; enum machine_mode mode = GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ; RTX_CODE cc = GET_CODE ( x ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( cc_convs ) ; i ++ ) { if ( mode == cc_convs [ i ] . cc_mode ) { for ( j = <NUM_LIT> ; cc_convs [ i ] . convs [ j ] . cc != UNKNOWN ; j ++ ) if ( cc == cc_convs [ i ] . convs [ j ] . cc ) { const char * mmix_cc = ( reversed ? cc_convs [ i ] . convs [ j ] . reversed : cc_convs [ i ] . convs [ j ] . normal ) ; if ( mmix_cc == NULL ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( stream , <STR_LIT> , mmix_cc ) ; return ; } fatal_insn ( <STR_LIT> , x ) ; } } fatal_insn ( <STR_LIT> , x ) ;


<s> else if ( value > ( HOST_WIDEST_INT ) <NUM_LIT> && value < ( ( HOST_WIDEST_INT ) <NUM_LIT> << <NUM_LIT> ) * <NUM_LIT> ) fprintf ( stream , <STR_LIT> , ( unsigned int ) value ) ; else fprintf ( stream , hex_format , value ) ; if ( do_begin_end ) fprintf ( stream , <STR_LIT> ) ;


<s> if ( ( value < ( HOST_WIDEST_INT ) <NUM_LIT> && value > ( HOST_WIDEST_INT ) - <NUM_LIT> ) || ( value >= ( HOST_WIDEST_INT ) <NUM_LIT> && value <= ( HOST_WIDEST_INT ) <NUM_LIT> ) ) fprintf ( stream , <STR_LIT> , ( int ) value ) ; else if ( value > ( HOST_WIDEST_INT ) <NUM_LIT> && value < ( ( HOST_WIDEST_INT ) <NUM_LIT> << <NUM_LIT> ) * <NUM_LIT> ) fprintf ( stream , <STR_LIT> , ( unsigned int ) value ) ; else fprintf ( stream , hex_format , value ) ;

if ( do_begin_end ) fprintf ( stream , <STR_LIT> ) ;


<s> mmix_output_shifted_value ( stream , - ( unsigned HOST_WIDEST_INT ) value ) ; fprintf ( stream , <STR_LIT> , reg_names [ regno ] , reg_names [ regno ] ) ; } else if ( mmix_shiftable_wyde_value ( ~ ( unsigned HOST_WIDEST_INT ) value ) ) { mmix_output_shiftvalue_op_from_str ( stream , <STR_LIT> , ~ ( unsigned HOST_WIDEST_INT ) value ) ; fprintf ( stream , <STR_LIT> , reg_names [ regno ] ) ; mmix_output_shifted_value ( stream , ~ ( unsigned HOST_WIDEST_INT ) value ) ; fprintf ( stream , <STR_LIT> , reg_names [ regno ] , reg_names [ regno ] ) ; } else { static const char * const higher_parts [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; const char * op = <STR_LIT> ; const char * line_begin = <STR_LIT> ; int insns = <NUM_LIT> ; int i ; HOST_WIDEST_INT tmpvalue = value ; for ( i = <NUM_LIT> ; i < <NUM_LIT> && tmpvalue != <NUM_LIT> ; i ++ ) { if ( tmpvalue & <NUM_LIT> ) insns ++ ; tmpvalue >>= <NUM_LIT> ; } if ( TARGET_BASE_ADDRESSES && insns == <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , reg_names [ regno ] ) ; mmix_output_octa ( stream , value , <NUM_LIT> ) ; } else { for ( i = <NUM_LIT> ; i < <NUM_LIT> && value != <NUM_LIT> ; i ++ ) { if ( value & <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , line_begin , op , higher_parts [ i ] , reg_names [ regno ] , ( int ) ( value & <NUM_LIT> ) ) ; op = <STR_LIT> ; line_begin = <STR_LIT> ; } value >>= <NUM_LIT> ; } } } if ( do_begin_end ) fprintf ( stream , <STR_LIT> ) ;


<s> else { static const char * const higher_parts [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; const char * op = <STR_LIT> ; const char * line_begin = <STR_LIT> ; int insns = <NUM_LIT> ; int i ; HOST_WIDEST_INT tmpvalue = value ; for ( i = <NUM_LIT> ; i < <NUM_LIT> && tmpvalue != <NUM_LIT> ; i ++ ) { if ( tmpvalue & <NUM_LIT> ) insns ++ ; tmpvalue >>= <NUM_LIT> ; } if ( TARGET_BASE_ADDRESSES && insns == <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , reg_names [ regno ] ) ; mmix_output_octa ( stream , value , <NUM_LIT> ) ; } else { for ( i = <NUM_LIT> ; i < <NUM_LIT> && value != <NUM_LIT> ; i ++ ) { if ( value & <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , line_begin , op , higher_parts [ i ] , reg_names [ regno ] , ( int ) ( value & <NUM_LIT> ) ) ; op = <STR_LIT> ; line_begin = <STR_LIT> ; } value >>= <NUM_LIT> ; } } } if ( do_begin_end ) fprintf ( stream , <STR_LIT> ) ;


<s> if ( ! mmix_shiftable_wyde_value ( value ) ) { char s [ <NUM_LIT> + <NUM_LIT> + <NUM_LIT> ] ; sprintf ( s , HOST_WIDEST_INT_PRINT_HEX , value ) ; internal_error ( <STR_LIT> , s ) ; }

for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) {


<s> int i ; if ( ! mmix_shiftable_wyde_value ( value ) ) { char s [ <NUM_LIT> + <NUM_LIT> + <NUM_LIT> ] ; sprintf ( s , HOST_WIDEST_INT_PRINT_HEX , value ) ; internal_error ( <STR_LIT> , s ) ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( value & <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , ( int ) ( value & <NUM_LIT> ) ) ;


<s> static const char * const op_part [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; int i ; if ( ! mmix_shiftable_wyde_value ( value ) ) { char s [ sizeof ( <STR_LIT> ) ] ; sprintf ( s , HOST_WIDEST_INT_PRINT_HEX , value ) ; internal_error ( <STR_LIT> , s ) ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( value & <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , mainop , op_part [ i ] ) ; return ;


<s> if ( flag_pic ) { warning ( <NUM_LIT> , <STR_LIT> , ( flag_pic > <NUM_LIT> ) ? <STR_LIT> : <STR_LIT> ) ; flag_pic = <NUM_LIT> ; }


<s> void mmix_override_options ( void ) {


<s> static bool mmix_pass_by_reference ( const CUMULATIVE_ARGS * argsp , enum machine_mode mode , tree type , bool named ATTRIBUTE_UNUSED ) { if ( targetm . calls . must_pass_in_stack ( mode , type ) ) return true ;

if ( MMIX_FUNCTION_ARG_SIZE ( mode , type ) > <NUM_LIT> && ! TARGET_LIBFUNC && ( ! argsp || ! argsp -> lib ) ) return true ;


<s> if ( MMIX_FUNCTION_ARG_SIZE ( mode , type ) > <NUM_LIT> && ! TARGET_LIBFUNC && ( ! argsp || ! argsp -> lib ) ) return true ;


<s> enum reg_class mmix_preferred_output_reload_class ( rtx x ATTRIBUTE_UNUSED , enum reg_class class ) {

return GET_CODE ( x ) == MOD && GET_MODE ( x ) == DImode ? REMAINDER_REG : class ;


<s> return GET_CODE ( x ) == MOD && GET_MODE ( x ) == DImode ? REMAINDER_REG : class ;


<s> enum reg_class mmix_preferred_reload_class ( rtx x ATTRIBUTE_UNUSED , enum reg_class class ) { return GET_CODE ( x ) == MOD && GET_MODE ( x ) == DImode ? REMAINDER_REG : class ;


<s> case 'D' : mmix_output_condition ( stream , x , ( code == 'D' ) ) ; return ; case 'e' : if ( TARGET_FCMP_EPSILON ) fprintf ( stream , <STR_LIT> ) ; return ; case 'm' : if ( GET_CODE ( x ) != CONST_INT ) { fatal_insn ( <STR_LIT> , x ) ; } fprintf ( stream , HOST_WIDEST_INT_PRINT_DEC , ( HOST_WIDEST_INT ) ( mmix_intval ( x ) - <NUM_LIT> ) ) ; return ; case 'p' : fprintf ( stream , <STR_LIT> , cfun -> machine -> highest_saved_stack_register + <NUM_LIT> ) ; return ; case 'r' : if ( ! REG_P ( x ) ) fatal_insn ( <STR_LIT> , x ) ; mmix_output_destination_register = MMIX_OUTPUT_REGNO ( regno ) ; return ; case 'I' : if ( GET_CODE ( x ) != CONST_INT && ( GET_CODE ( x ) != CONST_DOUBLE || ( GET_MODE ( x ) != VOIDmode && GET_MODE ( x ) != DFmode && GET_MODE ( x ) != SFmode ) ) ) fatal_insn ( <STR_LIT> , x ) ; mmix_output_register_setting ( stream , mmix_output_destination_register , mmix_intval ( x ) , <NUM_LIT> ) ; return ; case 'U' : if ( TARGET_ZERO_EXTEND ) putc ( 'U' , stream ) ; return ; case 'v' : mmix_output_shifted_value ( stream , ( HOST_WIDEST_INT ) mmix_intval ( x ) ) ; return ; case 'V' : mmix_output_shifted_value ( stream , ( HOST_WIDEST_INT ) ~ mmix_intval ( x ) ) ; return ; case 'W' : if ( GET_CODE ( x ) != CONST_INT ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( stream , <STR_LIT> , ( int ) ( INTVAL ( x ) & <NUM_LIT> ) ) ; return ; case <NUM_LIT> : break ; default : internal_error ( <STR_LIT> , code ) ; } switch ( GET_CODE ( modified_x ) ) { case REG : regno = REGNO ( modified_x ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) internal_error ( <STR_LIT> , regno ) ; fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( regno ) ] ) ; return ; case MEM : output_address ( XEXP ( modified_x , <NUM_LIT> ) ) ; return ; case CONST_INT : if ( INTVAL ( modified_x ) > - <NUM_LIT> && INTVAL ( modified_x ) < <NUM_LIT> ) fprintf ( stream , <STR_LIT> , ( int ) ( INTVAL ( modified_x ) ) ) ; else fprintf ( stream , <STR_LIT> , ( int ) ( INTVAL ( modified_x ) ) & ( unsigned int ) ~ <NUM_LIT> ) ; return ; case CONST_DOUBLE : mmix_output_octa ( stream , mmix_intval ( modified_x ) , <NUM_LIT> ) ; return ;


<s> if ( REG_P ( x1 ) ) { fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( REGNO ( x1 ) ) ] ) ; if ( REG_P ( x2 ) ) { fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( REGNO ( x2 ) ) ] ) ; return ; } else if ( GET_CODE ( x2 ) == CONST_INT && CONST_OK_FOR_LETTER_P ( INTVAL ( x2 ) , 'I' ) ) { output_addr_const ( stream , x2 ) ; return ; } } } if ( TARGET_BASE_ADDRESSES && mmix_legitimate_constant_p ( x ) ) {


<s> if ( REG_P ( x1 ) ) { fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( REGNO ( x1 ) ) ] ) ; if ( REG_P ( x2 ) ) { fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( REGNO ( x2 ) ) ] ) ; return ; } else if ( GET_CODE ( x2 ) == CONST_INT && CONST_OK_FOR_LETTER_P ( INTVAL ( x2 ) , 'I' ) ) { output_addr_const ( stream , x2 ) ; return ; } } } if ( TARGET_BASE_ADDRESSES && mmix_legitimate_constant_p ( x ) ) { output_addr_const ( stream , x ) ;


<s> int mmix_print_operand_punct_valid_p ( int code ATTRIBUTE_UNUSED ) { return code == '+' || code == '.' ;


<s> int mmix_register_move_cost ( enum machine_mode mode ATTRIBUTE_UNUSED , enum reg_class from , enum reg_class to ) {

return ( from == GENERAL_REGS && from == to ) ? <NUM_LIT> : <NUM_LIT> ;


<s> int mmix_register_move_cost ( enum machine_mode mode ATTRIBUTE_UNUSED , enum reg_class from , enum reg_class to ) { return ( from == GENERAL_REGS && from == to ) ? <NUM_LIT> : <NUM_LIT> ;


<s> if ( ! TARGET_ABI_GNU && regno < current_function_args_info . regs - <NUM_LIT> ) { regno = current_function_args_info . regs - <NUM_LIT> ; if ( regno > MMIX_RETURN_VALUE_REGNUM - <NUM_LIT> ) regno = MMIX_RETURN_VALUE_REGNUM - <NUM_LIT> ; } cfun -> machine -> highest_saved_stack_register = regno ;


<s> regno -- ) if ( ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) || ( regno == MMIX_FRAME_POINTER_REGNUM && frame_pointer_needed ) ) break ; if ( ! TARGET_ABI_GNU && regno < current_function_args_info . regs - <NUM_LIT> ) { regno = current_function_args_info . regs - <NUM_LIT> ; if ( regno > MMIX_RETURN_VALUE_REGNUM - <NUM_LIT> ) regno = MMIX_RETURN_VALUE_REGNUM - <NUM_LIT> ; } cfun -> machine -> highest_saved_stack_register = regno ;


<s> rtx mmix_return_addr_rtx ( int count , rtx frame ATTRIBUTE_UNUSED ) {

return count == <NUM_LIT> ? ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? validize_mem ( gen_rtx_MEM ( Pmode , plus_constant ( frame_pointer_rtx , - <NUM_LIT> ) ) ) : get_hard_reg_initial_val ( Pmode , MMIX_INCOMING_RETURN_ADDRESS_REGNUM ) ) : NULL_RTX ;


<s> rtx mmix_return_addr_rtx ( int count , rtx frame ATTRIBUTE_UNUSED ) { return count == <NUM_LIT> ? ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? validize_mem ( gen_rtx_MEM ( Pmode , plus_constant ( frame_pointer_rtx , - <NUM_LIT> ) ) ) : get_hard_reg_initial_val ( Pmode , MMIX_INCOMING_RETURN_ADDRESS_REGNUM ) ) : NULL_RTX ;


<s> if ( args_so_farp -> regs + <NUM_LIT> < MMIX_MAX_ARGS_IN_REGS ) * pretend_sizep = ( MMIX_MAX_ARGS_IN_REGS - ( args_so_farp -> regs + <NUM_LIT> ) ) * <NUM_LIT> ;

if ( ( <NUM_LIT> + ( MMIX_FUNCTION_ARG_SIZE ( mode , vartype ) ) ) / <NUM_LIT> != <NUM_LIT> ) internal_error ( <STR_LIT> ) ;


<s> int mmix_shiftable_wyde_value ( unsigned HOST_WIDEST_INT value ) { int i ; int has_candidate = <NUM_LIT> ;


<s> int mmix_starting_frame_offset ( void ) {


<s> return ( - <NUM_LIT> + ( MMIX_CFUN_HAS_LANDING_PAD ? - <NUM_LIT> : ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? - <NUM_LIT> : <NUM_LIT> ) ) ) ;


<s> static void mmix_target_asm_function_epilogue ( FILE * stream , HOST_WIDE_INT locals_size ATTRIBUTE_UNUSED ) { fputc ( '\n' , stream ) ;


<s> fprintf ( stream , <STR_LIT> ) ; fprintf ( stream , <STR_LIT> ) ;


<s> fprintf ( stream , <STR_LIT> , reg_names [ MMIX_STATIC_CHAIN_REGNUM ] ) ; fprintf ( stream , <STR_LIT> ) ; fprintf ( stream , <STR_LIT> ) ;


regno -- ) if ( ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) return <NUM_LIT> ;


<s> if ( ( mode == CC_FPmode || mode == DFmode ) && ( code == GT || code == LT ) ) return <NUM_LIT> ; if ( ( mode == CC_FPEQmode || mode == DFmode ) && ( code == EQ || code == NE ) ) return <NUM_LIT> ; if ( ( mode == CC_FUNmode || mode == DFmode ) && ( code == ORDERED || code == UNORDERED ) ) return <NUM_LIT> ;


<s> if ( mode == VOIDmode && op != NULL_RTX ) mode = GET_MODE ( op ) ; if ( mode == CCmode || mode == CC_UNSmode || mode == DImode ) return <NUM_LIT> ;

if ( ( mode == CC_FPmode || mode == DFmode ) && ( code == GT || code == LT ) ) return <NUM_LIT> ;


<s> HOST_WIDE_INT locals_size = get_frame_size ( ) ; int regno ; HOST_WIDE_INT stack_space_to_deallocate = ( crtl -> outgoing_args_size + crtl -> args . pretend_args_size + locals_size + <NUM_LIT> ) & ~ <NUM_LIT> ; HOST_WIDE_INT offset = crtl -> outgoing_args_size ; for ( regno = <NUM_LIT> ; regno >= MMIX_FIRST_GLOBAL_REGNUM ; regno -- ) if ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) stack_space_to_deallocate += <NUM_LIT> ; if ( MMIX_CFUN_HAS_LANDING_PAD ) stack_space_to_deallocate += <NUM_LIT> ; else if ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ) stack_space_to_deallocate += <NUM_LIT> ; if ( frame_pointer_needed ) stack_space_to_deallocate += <NUM_LIT> ;


<s> offset -= <NUM_LIT> ; } if ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ) { rtx tmpreg , retreg ; rtx insn ; if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } tmpreg = gen_rtx_REG ( DImode , <NUM_LIT> ) ; retreg = gen_rtx_REG ( DImode , MMIX_rJ_REGNUM ) ; emit_move_insn ( tmpreg , retreg ) ; insn = emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , tmpreg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , retreg ) ) ; offset -= <NUM_LIT> ; } else if ( MMIX_CFUN_HAS_LANDING_PAD ) offset -= <NUM_LIT> ; if ( MMIX_CFUN_HAS_LANDING_PAD ) { if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } emit_move_insn ( gen_rtx_REG ( DImode , <NUM_LIT> ) , gen_rtx_REG ( DImode , MMIX_rO_REGNUM ) ) ; emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , gen_rtx_REG ( DImode , <NUM_LIT> ) ) ; offset -= <NUM_LIT> ; } offset -= ( locals_size + <NUM_LIT> ) & ~ <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno >= MMIX_FIRST_GLOBAL_REGNUM ; regno -- ) if ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) { rtx insn ; if ( offset < <NUM_LIT> ) {


<s> return mmix_function_arg_1 ( argsp , mode , type , named , false ) ;


<s> return ( argsp -> regs < MMIX_MAX_ARGS_IN_REGS && ! targetm . calls . must_pass_in_stack ( mode , type ) && ( GET_MODE_BITSIZE ( mode ) <= <NUM_LIT> || argsp -> lib || TARGET_LIBFUNC ) ) ? gen_rtx_REG ( mode , ( incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM ) + argsp -> regs ) : NULL_RTX ;


<s> int arg_size = MMIX_FUNCTION_ARG_SIZE ( mode , type ) ;

argsp -> regs = ( ( targetm . calls . must_pass_in_stack ( mode , type ) || ( arg_size > <NUM_LIT> && ! TARGET_LIBFUNC && ! argsp -> lib ) ) ? ( MMIX_MAX_ARGS_IN_REGS ) + <NUM_LIT> : argsp -> regs + ( <NUM_LIT> + arg_size ) / <NUM_LIT> ) ;


<s> int regno ; int fp_sp_offset = ( get_frame_size ( ) + crtl -> outgoing_args_size + <NUM_LIT> ) & ~ <NUM_LIT> ; if ( fromreg == MMIX_ARG_POINTER_REGNUM && toreg == MMIX_FRAME_POINTER_REGNUM ) return <NUM_LIT> ; for ( regno = MMIX_FIRST_GLOBAL_REGNUM ;


<s> int mmix_initial_elimination_offset ( int fromreg , int toreg ) { int regno ; int fp_sp_offset = ( get_frame_size ( ) + crtl -> outgoing_args_size + <NUM_LIT> ) & ~ <NUM_LIT> ; if ( fromreg == MMIX_ARG_POINTER_REGNUM && toreg == MMIX_FRAME_POINTER_REGNUM ) return <NUM_LIT> ; for ( regno = MMIX_FIRST_GLOBAL_REGNUM ; regno <= <NUM_LIT> ; regno ++ ) if ( ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) fp_sp_offset += <NUM_LIT> ; return fp_sp_offset + ( MMIX_CFUN_HAS_LANDING_PAD ? <NUM_LIT> : ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? <NUM_LIT> : <NUM_LIT> ) ) + ( fromreg == MMIX_ARG_POINTER_REGNUM ? <NUM_LIT> : <NUM_LIT> ) ;


<s> REAL_VALUE_TO_TARGET_DOUBLE ( value , bits ) ; return ( ( uint64_t ) ( unsigned long ) bits [ <NUM_LIT> ] << ( uint64_t ) <NUM_LIT> ) | ( uint64_t ) ( unsigned long ) bits [ <NUM_LIT> ] ; } else if ( GET_MODE ( x ) == SFmode ) { long bits ; REAL_VALUE_TO_TARGET_SINGLE ( value , bits ) ; return ( unsigned long ) bits ; }


<s> if ( flag_pic ) { warning ( <NUM_LIT> , <STR_LIT> , ( flag_pic > <NUM_LIT> ) ? <STR_LIT> : <STR_LIT> ) ; flag_pic = <NUM_LIT> ; }


<s> const char * const normal ; const char * const reversed ; } ; struct cc_type_conv { machine_mode cc_mode ; const struct cc_conv * const convs ; } ; static const struct cc_conv cc_fun_convs [ ] = { { ORDERED , <STR_LIT> , <STR_LIT> } , { UNORDERED , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_conv cc_fp_convs [ ] = { { GT , <STR_LIT> , NULL } , { LT , <STR_LIT> , NULL } , CCEND } ; static const struct cc_conv cc_fpeq_convs [ ] = { { NE , <STR_LIT> , <STR_LIT> } , { EQ , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_conv cc_uns_convs [ ] = { { GEU , <STR_LIT> , <STR_LIT> } , { GTU , <STR_LIT> , <STR_LIT> } , { LEU , <STR_LIT> , <STR_LIT> } , { LTU , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_conv cc_signed_convs [ ] = { { NE , <STR_LIT> , <STR_LIT> } , { EQ , <STR_LIT> , <STR_LIT> } , { GE , <STR_LIT> , <STR_LIT> } , { GT , <STR_LIT> , <STR_LIT> } , { LE , <STR_LIT> , <STR_LIT> } , { LT , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_conv cc_di_convs [ ] = { { NE , <STR_LIT> , <STR_LIT> } , { EQ , <STR_LIT> , <STR_LIT> } , { GE , <STR_LIT> , <STR_LIT> } , { GT , <STR_LIT> , <STR_LIT> } , { LE , <STR_LIT> , <STR_LIT> } , { LT , <STR_LIT> , <STR_LIT> } , { GTU , <STR_LIT> , <STR_LIT> } , { LEU , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_type_conv cc_convs [ ] = { { CC_FUNmode , cc_fun_convs } , { CC_FPmode , cc_fp_convs } , { CC_FPEQmode , cc_fpeq_convs } , { CC_UNSmode , cc_uns_convs } , { CCmode , cc_signed_convs } , { DImode , cc_di_convs } } ; size_t i ; int j ; machine_mode mode = GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ; RTX_CODE cc = GET_CODE ( x ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( cc_convs ) ; i ++ ) {

if ( mode == cc_convs [ i ] . cc_mode ) {


<s> static const struct cc_conv cc_di_convs [ ] = { { NE , <STR_LIT> , <STR_LIT> } , { EQ , <STR_LIT> , <STR_LIT> } , { GE , <STR_LIT> , <STR_LIT> } , { GT , <STR_LIT> , <STR_LIT> } , { LE , <STR_LIT> , <STR_LIT> } , { LT , <STR_LIT> , <STR_LIT> } , { GTU , <STR_LIT> , <STR_LIT> } , { LEU , <STR_LIT> , <STR_LIT> } , CCEND } ; static const struct cc_type_conv cc_convs [ ] = { { CC_FUNmode , cc_fun_convs } , { CC_FPmode , cc_fp_convs } , { CC_FPEQmode , cc_fpeq_convs } , { CC_UNSmode , cc_uns_convs } , { CCmode , cc_signed_convs } , { DImode , cc_di_convs } } ; size_t i ; int j ; machine_mode mode = GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ; RTX_CODE cc = GET_CODE ( x ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( cc_convs ) ; i ++ ) { if ( mode == cc_convs [ i ] . cc_mode ) { for ( j = <NUM_LIT> ; cc_convs [ i ] . convs [ j ] . cc != UNKNOWN ; j ++ ) if ( cc == cc_convs [ i ] . convs [ j ] . cc ) { const char * mmix_cc = ( reversed ? cc_convs [ i ] . convs [ j ] . reversed : cc_convs [ i ] . convs [ j ] . normal ) ; if ( mmix_cc == NULL ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( stream , <STR_LIT> , mmix_cc ) ; return ; } fatal_insn ( <STR_LIT> , x ) ; } }


<s> else if ( sizeof ( HOST_WIDE_INT ) == sizeof ( int64_t ) ) fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_HEX_PURE , ( HOST_WIDE_INT ) value ) ; else fprintf ( stream , <STR_LIT> PRIu64 , value ) ;


<s> if ( ! mmix_shiftable_wyde_value ( value ) ) { char s [ <NUM_LIT> + <NUM_LIT> + <NUM_LIT> ] ; sprintf ( s , <STR_LIT> PRIx64 , value ) ; internal_error ( <STR_LIT> , s ) ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( value & <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , ( int ) ( value & <NUM_LIT> ) ) ; return ; } value >>= <NUM_LIT> ; } fprintf ( stream , <STR_LIT> ) ;


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( value & <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , mainop , op_part [ i ] ) ; return ; } value >>= <NUM_LIT> ;


<s> if ( targetm . calls . must_pass_in_stack ( mode , type ) ) return true ; if ( MMIX_FUNCTION_ARG_SIZE ( mode , type ) > <NUM_LIT> && ! TARGET_LIBFUNC && ( ! argsp || ! argsp -> lib ) ) return true ;


<s> if ( targetm . calls . must_pass_in_stack ( mode , type ) ) return true ;


<s> case 'm' : if ( GET_CODE ( x ) != CONST_INT ) { fatal_insn ( <STR_LIT> , x ) ; } fprintf ( stream , <STR_LIT> PRId64 , ( int64_t ) ( mmix_intval ( x ) - <NUM_LIT> ) ) ; return ; case 'p' : fprintf ( stream , <STR_LIT> , cfun -> machine -> highest_saved_stack_register + <NUM_LIT> ) ; return ; case 'r' : if ( ! REG_P ( x ) ) fatal_insn ( <STR_LIT> , x ) ; mmix_output_destination_register = MMIX_OUTPUT_REGNO ( regno ) ; return ; case 'I' : if ( GET_CODE ( x ) != CONST_INT && ( GET_CODE ( x ) != CONST_DOUBLE || ( GET_MODE ( x ) != VOIDmode && GET_MODE ( x ) != DFmode && GET_MODE ( x ) != SFmode ) ) ) fatal_insn ( <STR_LIT> , x ) ; mmix_output_register_setting ( stream , mmix_output_destination_register , mmix_intval ( x ) , <NUM_LIT> ) ; return ; case 'U' : if ( TARGET_ZERO_EXTEND ) putc ( 'U' , stream ) ; return ; case 'v' : mmix_output_shifted_value ( stream , ( int64_t ) mmix_intval ( x ) ) ; return ; case 'V' : mmix_output_shifted_value ( stream , ( int64_t ) ~ mmix_intval ( x ) ) ; return ; case 'W' : if ( GET_CODE ( x ) != CONST_INT ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( stream , <STR_LIT> , ( int ) ( INTVAL ( x ) & <NUM_LIT> ) ) ; return ; case <NUM_LIT> : break ; default : internal_error ( <STR_LIT> , code ) ; }


<s> fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( REGNO ( x1 ) ) ] ) ; if ( REG_P ( x2 ) ) { fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( REGNO ( x2 ) ) ] ) ; return ; }

else if ( satisfies_constraint_I ( x2 ) ) {


<s> if ( REG_P ( x2 ) ) { fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( REGNO ( x2 ) ) ] ) ; return ; } else if ( satisfies_constraint_I ( x2 ) ) { output_addr_const ( stream , x2 ) ; return ; } } } if ( TARGET_BASE_ADDRESSES && mmix_legitimate_constant_p ( Pmode , x ) ) { output_addr_const ( stream , x ) ; return ;


<s> if ( ! TARGET_ABI_GNU && regno < crtl -> args . info . regs - <NUM_LIT> ) { regno = crtl -> args . info . regs - <NUM_LIT> ; if ( regno > MMIX_RETURN_VALUE_REGNUM - <NUM_LIT> ) regno = MMIX_RETURN_VALUE_REGNUM - <NUM_LIT> ; }

cfun -> machine -> highest_saved_stack_register = regno ;


regno -- ) if ( ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) || ( regno == MMIX_FRAME_POINTER_REGNUM && frame_pointer_needed ) ) break ;


<s> static bool mmix_rtx_costs ( rtx x ATTRIBUTE_UNUSED , int code ATTRIBUTE_UNUSED , int outer_code ATTRIBUTE_UNUSED , int opno ATTRIBUTE_UNUSED , int * total ATTRIBUTE_UNUSED , bool speed ATTRIBUTE_UNUSED ) {


<s> if ( args_so_farp -> regs + <NUM_LIT> < MMIX_MAX_ARGS_IN_REGS ) * pretend_sizep = ( MMIX_MAX_ARGS_IN_REGS - ( args_so_farp -> regs + <NUM_LIT> ) ) * <NUM_LIT> ; if ( ( <NUM_LIT> + ( MMIX_FUNCTION_ARG_SIZE ( mode , vartype ) ) ) / <NUM_LIT> != <NUM_LIT> ) internal_error ( <STR_LIT> ) ;


<s> CUMULATIVE_ARGS * args_so_farp = get_cumulative_args ( args_so_farp_v ) ; if ( args_so_farp -> regs + <NUM_LIT> < MMIX_MAX_ARGS_IN_REGS ) * pretend_sizep = ( MMIX_MAX_ARGS_IN_REGS - ( args_so_farp -> regs + <NUM_LIT> ) ) * <NUM_LIT> ;


<s> int regno ; int stack_space_to_allocate = ( crtl -> outgoing_args_size + crtl -> args . pretend_args_size + get_frame_size ( ) + <NUM_LIT> ) & ~ <NUM_LIT> ; if ( ! TARGET_USE_RETURN_INSN || ! reload_completed ) return <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno >= MMIX_FIRST_GLOBAL_REGNUM ; regno -- ) if ( ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) return <NUM_LIT> ;


<s> add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , retreg ) ) ; offset -= <NUM_LIT> ; } else if ( MMIX_CFUN_HAS_LANDING_PAD ) offset -= <NUM_LIT> ; if ( MMIX_CFUN_HAS_LANDING_PAD ) { if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } emit_move_insn ( gen_rtx_REG ( DImode , <NUM_LIT> ) , gen_rtx_REG ( DImode , MMIX_rO_REGNUM ) ) ; emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , gen_rtx_REG ( DImode , <NUM_LIT> ) ) ; offset -= <NUM_LIT> ; } offset -= ( locals_size + <NUM_LIT> ) & ~ <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno >= MMIX_FIRST_GLOBAL_REGNUM ; regno -- ) if ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) { rtx insn ; if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = ( stack_space_to_allocate > ( <NUM_LIT> - offset - <NUM_LIT> ) ? ( <NUM_LIT> - offset - <NUM_LIT> ) : stack_space_to_allocate ) ;


<s> if ( GET_CODE ( x ) != CONST_INT ) { fatal_insn ( <STR_LIT> , x ) ; } fprintf ( stream , <STR_LIT> PRId64 , ( int64_t ) ( mmix_intval ( x ) - <NUM_LIT> ) ) ; return ; case 'p' : fprintf ( stream , <STR_LIT> , cfun -> machine -> highest_saved_stack_register + <NUM_LIT> ) ; return ; case 'r' : if ( ! REG_P ( x ) ) fatal_insn ( <STR_LIT> , x ) ; mmix_output_destination_register = MMIX_OUTPUT_REGNO ( regno ) ; return ; case 'I' : if ( GET_CODE ( x ) != CONST_INT && ( GET_CODE ( x ) != CONST_DOUBLE || ( GET_MODE ( x ) != VOIDmode && GET_MODE ( x ) != DFmode && GET_MODE ( x ) != SFmode ) ) ) fatal_insn ( <STR_LIT> , x ) ; mmix_output_register_setting ( stream , mmix_output_destination_register , mmix_intval ( x ) , <NUM_LIT> ) ; return ; case 'U' : if ( TARGET_ZERO_EXTEND ) putc ( 'U' , stream ) ; return ; case 'v' : mmix_output_shifted_value ( stream , ( int64_t ) mmix_intval ( x ) ) ; return ; case 'V' : mmix_output_shifted_value ( stream , ( int64_t ) ~ mmix_intval ( x ) ) ; return ; case 'W' : if ( GET_CODE ( x ) != CONST_INT ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( stream , <STR_LIT> , ( int ) ( INTVAL ( x ) & <NUM_LIT> ) ) ; return ; case <NUM_LIT> : break ; default : internal_error ( <STR_LIT> , code ) ; } switch ( GET_CODE ( modified_x ) ) { case REG : regno = REGNO ( modified_x ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) internal_error ( <STR_LIT> , regno ) ; fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( regno ) ] ) ; return ; case MEM : output_address ( GET_MODE ( modified_x ) , XEXP ( modified_x , <NUM_LIT> ) ) ; return ;


<s> void mmix_asm_output_addr_diff_elt ( FILE * stream , rtx body ATTRIBUTE_UNUSED , int value , int rel ) {

fprintf ( stream , <STR_LIT> , value , rel ) ;


<s> fprintf ( stream , <STR_LIT> , value , rel ) ;


<s> fprintf ( stream , <STR_LIT> , value ) ;


<s> fprintf ( stream , <STR_LIT> , power ) ;

fprintf ( stream , <STR_LIT> , <NUM_LIT> << power , ( <NUM_LIT> << power ) - <NUM_LIT> ) ;


<s> void mmix_asm_output_align ( FILE * stream , int power ) { fprintf ( stream , <STR_LIT> , power ) ; fprintf ( stream , <STR_LIT> , <NUM_LIT> << power , ( <NUM_LIT> << power ) - <NUM_LIT> ) ;


fprintf ( stream , <STR_LIT> , size , align / BITS_PER_UNIT ) ;


<s> assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> , size , align / BITS_PER_UNIT ) ;


<s> assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> , size ) ;


<s> ASM_OUTPUT_ALIGN ( stream , exact_log2 ( align / BITS_PER_UNIT ) ) ; assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> , size ) ;


<s> while ( length > <NUM_LIT> ) { int chunk_size = length > <NUM_LIT> ? <NUM_LIT> : length ; fprintf ( stream , <STR_LIT> ) ; mmix_output_quoted_string ( stream , string , chunk_size ) ; string += chunk_size ; length -= chunk_size ; fprintf ( stream , <STR_LIT> ) ;


<s> void mmix_asm_output_def ( FILE * stream , const char * name , const char * value ) { assemble_name ( stream , name ) ;


<s> void mmix_asm_output_labelref ( FILE * stream , const char * name ) { int is_extern = <NUM_LIT> ; for ( ; ( * name == '@' || * name == '*' ) ; name ++ ) if ( * name == '@' ) is_extern = <NUM_LIT> ;


<s> int is_extern = <NUM_LIT> ; for ( ; ( * name == '@' || * name == '*' ) ; name ++ ) if ( * name == '@' ) is_extern = <NUM_LIT> ; asm_fprintf ( stream , <STR_LIT> , is_extern && TARGET_TOPLEVEL_SYMBOLS ? <STR_LIT> : <STR_LIT> , name ) ;


<s> if ( delta >= <NUM_LIT> && delta < <NUM_LIT> ) fprintf ( stream , <STR_LIT> , regname , ( int ) delta ) ; else if ( delta < <NUM_LIT> && delta >= - <NUM_LIT> ) fprintf ( stream , <STR_LIT> , regname , regname , ( int ) - delta ) ; else { mmix_output_register_setting ( stream , <NUM_LIT> , delta , <NUM_LIT> ) ; fprintf ( stream , <STR_LIT> , regname , regname ) ; } fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , XSTR ( XEXP ( DECL_RTL ( func ) , <NUM_LIT> ) , <NUM_LIT> ) ) ;


<s> fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( regno ) ] , reg_names [ MMIX_STACK_POINTER_REGNUM ] , reg_names [ MMIX_STACK_POINTER_REGNUM ] ) ;


<s> fprintf ( stream , <STR_LIT> , reg_names [ MMIX_STACK_POINTER_REGNUM ] , reg_names [ MMIX_STACK_POINTER_REGNUM ] , reg_names [ MMIX_OUTPUT_REGNO ( regno ) ] , reg_names [ MMIX_STACK_POINTER_REGNUM ] ) ;


<s> fprintf ( stream , <STR_LIT> , nbytes ) ;


<s> fprintf ( stream , <STR_LIT> ) ; OUTPUT_QUOTED_STRING ( stream , name ) ;


<s> static void mmix_asm_output_source_filename ( FILE * stream , const char * name ) { fprintf ( stream , <STR_LIT> ) ; OUTPUT_QUOTED_STRING ( stream , name ) ;


<s> int mmix_asm_preferred_eh_data_format ( int code ATTRIBUTE_UNUSED , int global ATTRIBUTE_UNUSED ) {


<s> fprintf ( stream , <STR_LIT> , reg_names [ MMIX_STATIC_CHAIN_REGNUM ] ) ; fprintf ( stream , <STR_LIT> ) ; fprintf ( stream , <STR_LIT> ) ; fprintf ( stream , <STR_LIT> ) ; fprintf ( stream , <STR_LIT> ) ;


<s> fputs ( <STR_LIT> , asm_out_file ) ; mmix_print_operand ( asm_out_file , x , 'B' ) ; fputc ( '\n' , asm_out_file ) ; return true ; case <NUM_LIT> : if ( GET_CODE ( x ) != CONST_INT ) { aligned_p = <NUM_LIT> ; break ; } fputs ( <STR_LIT> , asm_out_file ) ; mmix_print_operand ( asm_out_file , x , 'W' ) ; fputc ( '\n' , asm_out_file ) ; return true ; case <NUM_LIT> : if ( GET_CODE ( x ) != CONST_INT ) { aligned_p = <NUM_LIT> ; break ; } fputs ( <STR_LIT> , asm_out_file ) ; mmix_print_operand ( asm_out_file , x , 'L' ) ; fputc ( '\n' , asm_out_file ) ; return true ;


<s> for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) reg_alloc_order [ i ] = gnu_abi_reg_alloc_order [ i ] ; for ( i = <NUM_LIT> ; i <= <NUM_LIT> ; i ++ ) call_used_regs [ i ] = <NUM_LIT> ; for ( i = MMIX_RESERVED_GNU_ARG_0_REGNUM ; i < MMIX_RESERVED_GNU_ARG_0_REGNUM + MMIX_MAX_ARGS_IN_REGS ; i ++ ) fixed_regs [ i ] = <NUM_LIT> ;


<s> rtx x1 = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ( GET_CODE ( x0 ) == SYMBOL_REF || GET_CODE ( x0 ) == LABEL_REF ) && ( GET_CODE ( x1 ) == CONST_INT || ( GET_CODE ( x1 ) == CONST_DOUBLE && GET_MODE ( x1 ) == VOIDmode ) ) ) addend = mmix_intval ( x1 ) ; else return constant_ok ; } else return constant_ok ; break ;


<s> if ( basic_align < <NUM_LIT> ) return <NUM_LIT> ; return basic_align ;


<s> const char * mmix_data_section_asm_op ( void ) {


<s> const char * mmix_data_section_asm_op ( void ) { return <STR_LIT> ;


<s> unsigned mmix_dbx_register_number ( unsigned regno ) {


<s> unsigned mmix_dbx_register_number ( unsigned regno ) { regno = MMIX_OUTPUT_REGNO ( regno ) ; return regno >= <NUM_LIT> ? ( regno - <NUM_LIT> ) : ( regno + <NUM_LIT> ) ;


<s> int mmix_eh_return_data_regno ( int n ) { if ( n >= <NUM_LIT> && n < <NUM_LIT> ) return MMIX_EH_RETURN_DATA_REGNO_START + n ;


<s> return gen_rtx_REG ( Pmode , MMIX_EH_RETURN_STACKADJ_REGNUM ) ;


<s> rtx mmix_eh_return_stackadj_rtx ( void ) {

return gen_rtx_REG ( Pmode , MMIX_EH_RETURN_STACKADJ_REGNUM ) ;


<s> if ( offset > - <NUM_LIT> ) insn = emit_insn ( gen_adddi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( offset ) ) ) ; else { rtx tmpr = gen_rtx_REG ( DImode , <NUM_LIT> ) ; RTX_FRAME_RELATED_P ( emit_move_insn ( tmpr , GEN_INT ( offset ) ) ) = <NUM_LIT> ; insn = emit_insn ( gen_adddi3 ( stack_pointer_rtx , stack_pointer_rtx , tmpr ) ) ; } RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { if ( insn_const_int_ok_for_constraint ( offset , CONSTRAINT_L ) ) emit_insn ( gen_adddi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( offset ) ) ) ; else { rtx tmpr = gen_rtx_REG ( DImode , <NUM_LIT> ) ; emit_move_insn ( tmpr , GEN_INT ( offset ) ) ;


<s> newstr [ <NUM_LIT> ] = '@' ; strcpy ( newstr + <NUM_LIT> , str ) ; XSTR ( XEXP ( rtl , <NUM_LIT> ) , <NUM_LIT> ) = ggc_alloc_string ( newstr , len + <NUM_LIT> ) ; }

if ( TREE_CODE ( decl ) == FUNCTION_DECL || TREE_CONSTANT ( decl ) || ( TREE_CODE ( decl ) == VAR_DECL && TREE_READONLY ( decl ) && ! TREE_SIDE_EFFECTS ( decl ) && ( ! DECL_INITIAL ( decl ) || TREE_CONSTANT ( DECL_INITIAL ( decl ) ) ) ) ) SYMBOL_REF_FLAG ( XEXP ( rtl , <NUM_LIT> ) ) = <NUM_LIT> ;


<s> regno -- ) if ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) stack_space_to_deallocate += <NUM_LIT> ; if ( MMIX_CFUN_HAS_LANDING_PAD ) stack_space_to_deallocate += <NUM_LIT> ; else if ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ) stack_space_to_deallocate += <NUM_LIT> ; if ( frame_pointer_needed ) stack_space_to_deallocate += <NUM_LIT> ; if ( ( stack_space_to_deallocate % <NUM_LIT> ) != <NUM_LIT> ) internal_error ( <STR_LIT> , stack_space_to_deallocate ) ; for ( regno = MMIX_FIRST_GLOBAL_REGNUM ; regno <= <NUM_LIT> ; regno ++ ) if ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) { if ( offset > <NUM_LIT> ) { mmix_emit_sp_add ( offset ) ; stack_space_to_deallocate -= offset ; offset = <NUM_LIT> ; } emit_move_insn ( gen_rtx_REG ( DImode , regno ) , gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ) ; offset += <NUM_LIT> ; } offset += ( locals_size + <NUM_LIT> ) & ~ <NUM_LIT> ; if ( MMIX_CFUN_HAS_LANDING_PAD ) offset += <NUM_LIT> ; else if ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ) offset += <NUM_LIT> ; if ( frame_pointer_needed ) { if ( offset > <NUM_LIT> ) { mmix_emit_sp_add ( offset ) ; stack_space_to_deallocate -= offset ;


<s> emit_move_insn ( tmpreg , retreg ) ; insn = emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , tmpreg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , retreg ) ) ; offset -= <NUM_LIT> ; } else if ( MMIX_CFUN_HAS_LANDING_PAD ) offset -= <NUM_LIT> ; if ( MMIX_CFUN_HAS_LANDING_PAD ) { if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; total_allocated_stack_space += stack_chunk ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } emit_move_insn ( gen_rtx_REG ( DImode , <NUM_LIT> ) , gen_rtx_REG ( DImode , MMIX_rO_REGNUM ) ) ; emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , gen_rtx_REG ( DImode , <NUM_LIT> ) ) ; offset -= <NUM_LIT> ; } offset -= ( locals_size + <NUM_LIT> ) & ~ <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno >= MMIX_FIRST_GLOBAL_REGNUM ; regno -- ) if ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) { rtx insn ; if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = ( stack_space_to_allocate > ( <NUM_LIT> - offset - <NUM_LIT> ) ? ( <NUM_LIT> - offset - <NUM_LIT> ) : stack_space_to_allocate ) ; mmix_emit_sp_add ( - stack_chunk ) ; total_allocated_stack_space += stack_chunk ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; }

insn = emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , gen_rtx_REG ( DImode , regno ) ) ;


<s> offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , gen_rtx_REG ( DImode , regno ) ) ; offset -= <NUM_LIT> ; } } if ( frame_pointer_needed ) { rtx insn ; if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; total_allocated_stack_space += stack_chunk ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } insn = emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , hard_frame_pointer_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_adddi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( offset + <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; offset -= <NUM_LIT> ; } if ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ) { rtx tmpreg , retreg ; rtx insn ; if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; total_allocated_stack_space += stack_chunk ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } tmpreg = gen_rtx_REG ( DImode , <NUM_LIT> ) ; retreg = gen_rtx_REG ( DImode , MMIX_rJ_REGNUM ) ; emit_move_insn ( tmpreg , retreg ) ; insn = emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , tmpreg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , retreg ) ) ; offset -= <NUM_LIT> ; } else if ( MMIX_CFUN_HAS_LANDING_PAD ) offset -= <NUM_LIT> ; if ( MMIX_CFUN_HAS_LANDING_PAD ) { if ( offset < <NUM_LIT> ) { HOST_WIDE_INT stack_chunk = stack_space_to_allocate > ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) ? ( <NUM_LIT> - <NUM_LIT> - <NUM_LIT> ) : stack_space_to_allocate ; mmix_emit_sp_add ( - stack_chunk ) ; total_allocated_stack_space += stack_chunk ; offset += stack_chunk ; stack_space_to_allocate -= stack_chunk ; } emit_move_insn ( gen_rtx_REG ( DImode , <NUM_LIT> ) , gen_rtx_REG ( DImode , MMIX_rO_REGNUM ) ) ; emit_move_insn ( gen_rtx_MEM ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , gen_rtx_REG ( DImode , <NUM_LIT> ) ) ; offset -= <NUM_LIT> ; }

offset -= ( locals_size + <NUM_LIT> ) & ~ <NUM_LIT> ;


<s> static void mmix_file_end ( void ) { switch_to_section ( data_section ) ;


<s> switch_to_section ( data_section ) ;


<s> static void mmix_file_start ( void ) {


<s> return ( cfun -> has_nonlocal_label ) ;


<s> bool mmix_frame_pointer_required ( void ) {


<s> return mmix_function_arg_1 ( argsp , arg , false ) ;


<s> static rtx mmix_function_arg_1 ( const cumulative_args_t argsp_v , const function_arg_info & arg , bool incoming ) { CUMULATIVE_ARGS * argsp = get_cumulative_args ( argsp_v ) ; machine_mode mode = arg . mode == VOIDmode ? DImode : arg . mode ; if ( arg . end_marker_p ( ) ) return ( argsp -> regs < MMIX_MAX_ARGS_IN_REGS ) ? gen_rtx_REG ( mode , ( incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM ) + argsp -> regs ) : NULL_RTX ; return ( argsp -> regs < MMIX_MAX_ARGS_IN_REGS && ! targetm . calls . must_pass_in_stack ( arg ) && ( GET_MODE_BITSIZE ( mode ) <= <NUM_LIT> || argsp -> lib || TARGET_LIBFUNC ) ) ? gen_rtx_REG ( mode , ( incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM ) + argsp -> regs ) : NULL_RTX ;


<s> CUMULATIVE_ARGS * argsp = get_cumulative_args ( argsp_v ) ; machine_mode mode = arg . mode == VOIDmode ? DImode : arg . mode ; if ( arg . end_marker_p ( ) ) return ( argsp -> regs < MMIX_MAX_ARGS_IN_REGS ) ? gen_rtx_REG ( mode , ( incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM ) + argsp -> regs ) : NULL_RTX ;

return ( argsp -> regs < MMIX_MAX_ARGS_IN_REGS && ! targetm . calls . must_pass_in_stack ( arg ) && ( GET_MODE_BITSIZE ( mode ) <= <NUM_LIT> || argsp -> lib || TARGET_LIBFUNC ) ) ? gen_rtx_REG ( mode , ( incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM ) + argsp -> regs ) : NULL_RTX ;


<s> int arg_size = MMIX_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) ; argsp -> regs = ( ( targetm . calls . must_pass_in_stack ( arg ) || ( arg_size > <NUM_LIT> && ! TARGET_LIBFUNC && ! argsp -> lib ) ) ? ( MMIX_MAX_ARGS_IN_REGS ) + <NUM_LIT> : argsp -> regs + ( <NUM_LIT> + arg_size ) / <NUM_LIT> ) ;


<s> int mmix_function_arg_regno_p ( int regno , int incoming ) { int first_arg_regnum = incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM ; return regno >= first_arg_regnum && regno < first_arg_regnum + MMIX_MAX_ARGS_IN_REGS ;


<s> int mmix_function_arg_regno_p ( int regno , int incoming ) {


<s> static rtx mmix_function_incoming_arg ( cumulative_args_t argsp , const function_arg_info & arg ) {

return mmix_function_arg_1 ( argsp , arg , true ) ;


<s> machine_mode cmode ; int first_val_regnum = MMIX_OUTGOING_RETURN_VALUE_REGNUM ; rtx vec [ MMIX_MAX_REGS_FOR_VALUE ] ; int i ; int nregs ; if ( ! outgoing ) return gen_rtx_REG ( mode , MMIX_RETURN_VALUE_REGNUM ) ; if ( TARGET_ABI_GNU || GET_MODE_BITSIZE ( mode ) <= BITS_PER_WORD ) return gen_rtx_REG ( mode , MMIX_OUTGOING_RETURN_VALUE_REGNUM ) ; if ( COMPLEX_MODE_P ( mode ) ) cmode = TYPE_MODE ( TREE_TYPE ( valtype ) ) ;


<s> } nregs = ( ( GET_MODE_BITSIZE ( mode ) + BITS_PER_WORD - <NUM_LIT> ) / BITS_PER_WORD ) ; if ( nregs > MMIX_MAX_REGS_FOR_VALUE ) internal_error ( <STR_LIT> , nregs , MMIX_MAX_REGS_FOR_VALUE ) ; for ( i = <NUM_LIT> ; i < nregs - <NUM_LIT> ; i ++ ) vec [ i ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( cmode , first_val_regnum + i ) , GEN_INT ( ( i + <NUM_LIT> ) * BITS_PER_UNIT ) ) ; vec [ nregs - <NUM_LIT> ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( cmode , first_val_regnum + nregs - <NUM_LIT> ) , const0_rtx ) ;

return gen_rtx_PARALLEL ( mode , gen_rtvec_v ( nregs , vec ) ) ;


<s> machine_mode ccmode = SELECT_CC_MODE ( code , x , y ) ; return gen_reg_rtx ( ccmode ) ;


<s> machine_mode ccmode = SELECT_CC_MODE ( code , x , y ) ;


<s> rtx mmix_get_hard_reg_initial_val ( machine_mode mode , int regno ) { return get_hard_reg_initial_val ( mode , regno ) ;


<s> regno ++ ) if ( ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) fp_sp_offset += <NUM_LIT> ; return fp_sp_offset + ( MMIX_CFUN_HAS_LANDING_PAD ? <NUM_LIT> : ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? <NUM_LIT> : <NUM_LIT> ) ) + ( fromreg == MMIX_ARG_POINTER_REGNUM ? <NUM_LIT> : <NUM_LIT> ) ;


<s> static void mmix_init_libfuncs ( void ) { set_optab_libfunc ( ffs_optab , SImode , <STR_LIT> ) ;


<s> set_optab_libfunc ( ffs_optab , SImode , <STR_LIT> ) ;


<s> static struct machine_function * mmix_init_machine_status ( void ) { return ggc_cleared_alloc < machine_function > ( ) ;


<s> static struct machine_function * mmix_init_machine_status ( void ) {

return ggc_cleared_alloc < machine_function > ( ) ;


<s> if ( GET_CODE ( x ) == CONST_DOUBLE && GET_MODE ( x ) == VOIDmode ) return CONST_DOUBLE_HIGH ( x ) ; if ( GET_CODE ( x ) == CONST_DOUBLE ) { if ( GET_MODE ( x ) == DFmode ) { long bits [ <NUM_LIT> ] ; REAL_VALUE_TO_TARGET_DOUBLE ( * CONST_DOUBLE_REAL_VALUE ( x ) , bits ) ;

return ( ( uint64_t ) ( unsigned long ) bits [ <NUM_LIT> ] << ( uint64_t ) <NUM_LIT> ) | ( uint64_t ) ( unsigned long ) bits [ <NUM_LIT> ] ;


<s> if ( ! REG_P ( x1 ) ) { rtx tem = x1 ; x1 = x2 ; x2 = tem ; } if ( ! REG_P ( x1 ) || ! MMIX_REG_OK ( x1 ) ) return TARGET_BASE_ADDRESSES && mmix_constant_address_p ( x ) ; if ( REG_P ( x2 ) && MMIX_REG_OK ( x2 ) ) return <NUM_LIT> ; if ( satisfies_constraint_I ( x2 ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> static bool mmix_legitimate_constant_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) { RTX_CODE code = GET_CODE ( x ) ; if ( code == CONST_INT || code == CONST_DOUBLE ) return <NUM_LIT> ;


<s> static rtx mmix_libcall_value ( machine_mode mode , const_rtx fun ATTRIBUTE_UNUSED ) {

return gen_rtx_REG ( mode , MMIX_RETURN_VALUE_REGNUM ) ;


<s> unsigned mmix_local_alignment ( tree type ATTRIBUTE_UNUSED , unsigned basic_align ) {

if ( basic_align < <NUM_LIT> ) return <NUM_LIT> ;


<s> return ( regno <= MMIX_LAST_STACK_REGISTER_REGNUM && ! call_used_or_fixed_reg_p ( regno ) ) ;


<s> void mmix_make_decl_one_only ( tree decl ) {


<s> void mmix_make_decl_one_only ( tree decl ) { DECL_WEAK ( decl ) = <NUM_LIT> ;


<s> int mmix_opposite_regno ( int regno , int incoming ) { if ( incoming && regno == MMIX_OUTGOING_RETURN_VALUE_REGNUM ) return MMIX_RETURN_VALUE_REGNUM ; if ( ! incoming && regno == MMIX_RETURN_VALUE_REGNUM ) return MMIX_OUTGOING_RETURN_VALUE_REGNUM ; if ( ! mmix_function_arg_regno_p ( regno , incoming ) ) return regno ; return regno - ( incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM - MMIX_FIRST_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM - MMIX_FIRST_INCOMING_ARG_REGNUM ) ;


targetm . asm_out . aligned_op . hi = <STR_LIT> ;


<s> static const struct cc_type_conv cc_convs [ ] = { { E_CC_FUNmode , cc_fun_convs } , { E_CC_FPmode , cc_fp_convs } , { E_CC_FPEQmode , cc_fpeq_convs } , { E_CC_UNSmode , cc_uns_convs } , { E_CCmode , cc_signed_convs } , { E_DImode , cc_di_convs } } ; size_t i ; int j ; machine_mode mode = GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ; RTX_CODE cc = GET_CODE ( x ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( cc_convs ) ; i ++ ) { if ( mode == cc_convs [ i ] . cc_mode ) { for ( j = <NUM_LIT> ; cc_convs [ i ] . convs [ j ] . cc != UNKNOWN ; j ++ ) if ( cc == cc_convs [ i ] . convs [ j ] . cc ) { const char * mmix_cc = ( reversed ? cc_convs [ i ] . convs [ j ] . reversed : cc_convs [ i ] . convs [ j ] . normal ) ; if ( mmix_cc == NULL ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( stream , <STR_LIT> , mmix_cc ) ; return ; } fatal_insn ( <STR_LIT> , x ) ; } } fatal_insn ( <STR_LIT> , x ) ;


<s> if ( do_begin_end ) fprintf ( stream , <STR_LIT> ) ;

if ( ( value < ( int64_t ) <NUM_LIT> && value > ( int64_t ) - <NUM_LIT> ) || ( value >= ( int64_t ) <NUM_LIT> && value <= ( int64_t ) <NUM_LIT> ) ) fprintf ( stream , <STR_LIT> , ( int ) value ) ;


<s> fputc ( '"' , stream ) ; while ( * string && ( unsigned char ) * string < <NUM_LIT> && ! ISCNTRL ( * string ) && strchr ( unwanted_chars , * string ) == NULL && string < string_end ) { fputc ( * string , stream ) ; string ++ ; } fputc ( '"' , stream ) ; if ( string < string_end ) fprintf ( stream , <STR_LIT> ) ; } if ( string < string_end ) { fprintf ( stream , <STR_LIT> , * string & <NUM_LIT> ) ;


<s> static const char * const unwanted_chars = <STR_LIT> ; while ( string < string_end ) { if ( * string && ( unsigned char ) * string < <NUM_LIT> && ! ISCNTRL ( * string ) && strchr ( unwanted_chars , * string ) == NULL ) { fputc ( '"' , stream ) ; while ( * string && ( unsigned char ) * string < <NUM_LIT> && ! ISCNTRL ( * string ) && strchr ( unwanted_chars , * string ) == NULL && string < string_end ) { fputc ( * string , stream ) ; string ++ ; } fputc ( '"' , stream ) ;

if ( string < string_end ) fprintf ( stream , <STR_LIT> ) ;


<s> mmix_output_shifted_value ( stream , ~ ( uint64_t ) value ) ; fprintf ( stream , <STR_LIT> , reg_names [ regno ] , reg_names [ regno ] ) ; } else { static const char * const higher_parts [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; const char * op = <STR_LIT> ; const char * line_begin = <STR_LIT> ; int insns = <NUM_LIT> ; int i ; int64_t tmpvalue = value ; for ( i = <NUM_LIT> ; i < <NUM_LIT> && tmpvalue != <NUM_LIT> ; i ++ ) { if ( tmpvalue & <NUM_LIT> ) insns ++ ; tmpvalue >>= <NUM_LIT> ; } if ( TARGET_BASE_ADDRESSES && insns == <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , reg_names [ regno ] ) ; mmix_output_octa ( stream , value , <NUM_LIT> ) ; } else { for ( i = <NUM_LIT> ; i < <NUM_LIT> && value != <NUM_LIT> ; i ++ ) { if ( value & <NUM_LIT> ) {

fprintf ( stream , <STR_LIT> , line_begin , op , higher_parts [ i ] , reg_names [ regno ] , ( int ) ( value & <NUM_LIT> ) ) ;


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( value & <NUM_LIT> ) { fprintf ( stream , <STR_LIT> , ( int ) ( value & <NUM_LIT> ) ) ; return ;


<s> fprintf ( stream , <STR_LIT> , ( int ) ( value & <NUM_LIT> ) ) ; return ; } value >>= <NUM_LIT> ; } fprintf ( stream , <STR_LIT> ) ;


<s> static void mmix_output_shiftvalue_op_from_str ( FILE * stream , const char * mainop , int64_t value ) { static const char * const op_part [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; int i ; if ( ! mmix_shiftable_wyde_value ( value ) ) { char s [ sizeof ( <STR_LIT> ) ] ; sprintf ( s , <STR_LIT> PRIx64 , value ) ; internal_error ( <STR_LIT> , s ) ; }

for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) {


<s> if ( targetm . calls . must_pass_in_stack ( arg ) ) return true ;

if ( MMIX_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) > <NUM_LIT> && ! TARGET_LIBFUNC && ( ! argsp || ! argsp -> lib ) ) return true ;


<s> static bool mmix_pass_by_reference ( cumulative_args_t argsp_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * argsp = get_cumulative_args ( argsp_v ) ; if ( targetm . calls . must_pass_in_stack ( arg ) ) return true ; if ( MMIX_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) > <NUM_LIT> && ! TARGET_LIBFUNC && ( ! argsp || ! argsp -> lib ) ) return true ; return false ;


<s> static reg_class_t mmix_preferred_reload_class ( rtx x , reg_class_t rclass ) {

return GET_CODE ( x ) == MOD && GET_MODE ( x ) == DImode ? REMAINDER_REG : rclass ;


<s> case 'i' : mmix_output_shiftvalue_op_from_str ( stream , <STR_LIT> , ( uint64_t ) mmix_intval ( x ) ) ; return ; case 'o' : mmix_output_shiftvalue_op_from_str ( stream , <STR_LIT> , ( uint64_t ) mmix_intval ( x ) ) ; return ; case 's' : mmix_output_shiftvalue_op_from_str ( stream , <STR_LIT> , ( uint64_t ) mmix_intval ( x ) ) ; return ; case 'd' : case 'D' : mmix_output_condition ( stream , x , ( code == 'D' ) ) ; return ; case 'e' : if ( TARGET_FCMP_EPSILON ) fprintf ( stream , <STR_LIT> ) ; return ; case 'm' : if ( GET_CODE ( x ) != CONST_INT ) { fatal_insn ( <STR_LIT> , x ) ; } fprintf ( stream , <STR_LIT> PRId64 , ( int64_t ) ( mmix_intval ( x ) - <NUM_LIT> ) ) ; return ; case 'r' : if ( ! REG_P ( x ) ) fatal_insn ( <STR_LIT> , x ) ; mmix_output_destination_register = MMIX_OUTPUT_REGNO ( regno ) ; return ; case 'I' : if ( GET_CODE ( x ) != CONST_INT && ( GET_CODE ( x ) != CONST_DOUBLE || ( GET_MODE ( x ) != VOIDmode && GET_MODE ( x ) != DFmode && GET_MODE ( x ) != SFmode ) ) ) fatal_insn ( <STR_LIT> , x ) ; mmix_output_register_setting ( stream , mmix_output_destination_register , mmix_intval ( x ) , <NUM_LIT> ) ; return ; case 'U' : if ( TARGET_ZERO_EXTEND ) putc ( 'U' , stream ) ; return ; case 'v' : mmix_output_shifted_value ( stream , ( int64_t ) mmix_intval ( x ) ) ; return ; case 'V' : mmix_output_shifted_value ( stream , ( int64_t ) ~ mmix_intval ( x ) ) ; return ; case 'W' : if ( GET_CODE ( x ) != CONST_INT ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( stream , <STR_LIT> , ( int ) ( INTVAL ( x ) & <NUM_LIT> ) ) ; return ;


<s> if ( REG_P ( x1 ) ) { fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( REGNO ( x1 ) ) ] ) ; if ( REG_P ( x2 ) ) { fprintf ( stream , <STR_LIT> , reg_names [ MMIX_OUTPUT_REGNO ( REGNO ( x2 ) ) ] ) ; return ; } else if ( satisfies_constraint_I ( x2 ) ) { output_addr_const ( stream , x2 ) ; return ; } } }

if ( TARGET_BASE_ADDRESSES && mmix_legitimate_constant_p ( Pmode , x ) ) {


<s> static bool mmix_print_operand_punct_valid_p ( unsigned char code ) { return code == '+' || code == '.' || code == '!' ;


<s> return ( from == GENERAL_REGS && from == to ) ? <NUM_LIT> : <NUM_LIT> ;


<s> if ( ! TARGET_ABI_GNU && regno < crtl -> args . info . regs - <NUM_LIT> ) { regno = crtl -> args . info . regs - <NUM_LIT> ;

if ( regno > MMIX_RETURN_VALUE_REGNUM - <NUM_LIT> ) regno = MMIX_RETURN_VALUE_REGNUM - <NUM_LIT> ;


<s> static void mmix_reorg ( void ) { int regno ; for ( regno = MMIX_LAST_STACK_REGISTER_REGNUM ; regno >= <NUM_LIT> ;

regno -- ) if ( ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) || ( regno == MMIX_FRAME_POINTER_REGNUM && frame_pointer_needed ) ) break ;


<s> rtx mmix_return_addr_rtx ( int count , rtx frame ATTRIBUTE_UNUSED ) { return count == <NUM_LIT> ? ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? validize_mem ( gen_rtx_MEM ( Pmode , plus_constant ( Pmode , frame_pointer_rtx , - <NUM_LIT> ) ) ) : get_hard_reg_initial_val ( Pmode , MMIX_INCOMING_RETURN_ADDRESS_REGNUM ) ) : NULL_RTX ;


<s> static bool mmix_rtx_costs ( rtx x ATTRIBUTE_UNUSED , machine_mode mode ATTRIBUTE_UNUSED , int outer_code ATTRIBUTE_UNUSED , int opno ATTRIBUTE_UNUSED , int * total ATTRIBUTE_UNUSED , bool speed ATTRIBUTE_UNUSED ) { return false ;


<s> if ( rclass == REMAINDER_REG || rclass == HIMULT_REG || rclass == SYSTEM_REGS ) return GENERAL_REGS ; return NO_REGS ;


<s> void mmix_setup_frame_addresses ( void ) {


<s> if ( ( <NUM_LIT> + ( MMIX_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) ) ) / <NUM_LIT> != <NUM_LIT> ) internal_error ( <STR_LIT> ) ;


<s> int has_candidate = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( value & <NUM_LIT> ) { if ( has_candidate ) return <NUM_LIT> ;


<s> static HOST_WIDE_INT mmix_starting_frame_offset ( void ) {


<s> static HOST_WIDE_INT mmix_starting_frame_offset ( void ) { return ( - <NUM_LIT> + ( MMIX_CFUN_HAS_LANDING_PAD ? - <NUM_LIT> : ( MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? - <NUM_LIT> : <NUM_LIT> ) ) ) ;


<s> for ( ; ( * name == '@' || * name == '*' ) ; name ++ ) ; return name ;


<s> return gen_rtx_REG ( Pmode , MMIX_STRUCT_VALUE_REGNUM ) ;


<s> cfun -> machine -> in_prologue = <NUM_LIT> ;


<s> static void mmix_target_asm_function_prologue ( FILE * ) {

cfun -> machine -> in_prologue = <NUM_LIT> ;


<s> mem = adjust_address ( m_tramp , DImode , <NUM_LIT> * UNITS_PER_WORD ) ; emit_move_insn ( mem , fnaddr ) ; mem = adjust_address ( m_tramp , DImode , <NUM_LIT> ) ; emit_insn ( gen_sync_icache ( mem , GEN_INT ( TRAMPOLINE_SIZE - <NUM_LIT> ) ) ) ;


<s> int regno ; int stack_space_to_allocate = ( crtl -> outgoing_args_size + crtl -> args . pretend_args_size + get_frame_size ( ) + <NUM_LIT> ) & ~ <NUM_LIT> ;

if ( ! TARGET_USE_RETURN_INSN || ! reload_completed ) return <NUM_LIT> ;


<s> int mmix_use_simple_return ( void ) { int regno ; int stack_space_to_allocate = ( crtl -> outgoing_args_size + crtl -> args . pretend_args_size + get_frame_size ( ) + <NUM_LIT> ) & ~ <NUM_LIT> ; if ( ! TARGET_USE_RETURN_INSN || ! reload_completed ) return <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno >= MMIX_FIRST_GLOBAL_REGNUM ; regno -- ) if ( ( ( ( regno != MMIX_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) ) || IS_MMIX_EH_RETURN_DATA_REG ( regno ) ) return <NUM_LIT> ; if ( frame_pointer_needed ) stack_space_to_allocate += <NUM_LIT> ;