<s> if ( a < b ) return ( struct quot_rem ) { <NUM_LIT> , a } ; if ( b <= a ) { quot_digits = LZ ( b ) - LZ ( a ) ; quot_digits += ( a >= ( b << quot_digits ) ) ; b <<= quot_digits ; } while ( b <= a ) { b <<= <NUM_LIT> ; quot_digits ++ ; } if ( a & <NUM_LIT> ) { b >>= <NUM_LIT> ; if ( a >= b ) { a -= b ; extra = <NUM_LIT> << ( quot_digits - <NUM_LIT> ) ; } else { a -= b >> <NUM_LIT> ; extra = <NUM_LIT> << quot_digits ; } quot_digits -- ; } b -- ; switch ( quot_digits ) { case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : DS ; case <NUM_LIT> : ; } { struct quot_rem ret ; ret . quot = ( a & ( ( <NUM_LIT> << quot_digits ) - <NUM_LIT> ) ) + extra ; ret . rem = a >> quot_digits ; return ret ;


<s> for ( tmp = <NUM_LIT> ; ( ( ( long ) b & ( <NUM_LIT> << tmp ) ) == <NUM_LIT> ) ; tmp -- ) ; tmp = <NUM_LIT> - tmp ; if ( ( b << tmp ) > a ) { a -= b << ( tmp - <NUM_LIT> ) ; } else { a -= b << tmp ;


<s> if ( b == <NUM_LIT> ) return a ; tmp = LZ ( b ) ; for ( tmp = <NUM_LIT> ; ( ( ( long ) b & ( <NUM_LIT> << tmp ) ) == <NUM_LIT> ) ; tmp -- ) ; tmp = <NUM_LIT> - tmp ; if ( ( b << tmp ) > a ) { a -= b << ( tmp - <NUM_LIT> ) ;


<s> long sign ; long result ; sign = a ^ b ; result = __Udiv ( __builtin_labs ( a ) , __builtin_labs ( b ) ) ;

return ( sign < <NUM_LIT> ) ? - result : result ;


<s> long __Div ( long a , long b ) { long sign ; long result ;


<s> long result ; result = __Umod ( __builtin_labs ( a ) , __builtin_labs ( b ) ) ; return ( a < <NUM_LIT> ) ? - result : result ;


<s> for ( unsigned i = <NUM_LIT> , n = constraints . length ( ) ; i < n ; ++ i ) if ( strchr ( constraints [ i ] , 'h' ) != NULL ) return NULL ; rtx mof_reg = gen_rtx_REG ( SImode , CRIS_MOF_REGNUM ) ;

for ( unsigned i = <NUM_LIT> , n = outputs . length ( ) ; i < n ; ++ i ) if ( reg_overlap_mentioned_p ( mof_reg , outputs [ i ] ) ) return NULL ;


<s> clobbers . safe_push ( gen_rtx_REG ( CCmode , CRIS_CC0_REGNUM ) ) ; SET_HARD_REG_BIT ( clobbered_regs , CRIS_CC0_REGNUM ) ; for ( unsigned i = <NUM_LIT> , n = constraints . length ( ) ; i < n ; ++ i ) if ( strchr ( constraints [ i ] , 'h' ) != NULL ) return NULL ; rtx mof_reg = gen_rtx_REG ( SImode , CRIS_MOF_REGNUM ) ;


<s> else if ( TARGET_ETRAX4_ADD && cris_cpu_version < CRIS_CPU_ETRAX4 ) cris_cpu_version = CRIS_CPU_ETRAX4 ; if ( cris_cpu_str ) { cris_cpu_version = ( * cris_cpu_str == 'v' ? atoi ( cris_cpu_str + <NUM_LIT> ) : - <NUM_LIT> ) ; if ( strcmp ( <STR_LIT> , cris_cpu_str ) == <NUM_LIT> ) cris_cpu_version = <NUM_LIT> ; if ( strcmp ( <STR_LIT> , cris_cpu_str ) == <NUM_LIT> || strcmp ( <STR_LIT> , cris_cpu_str ) == <NUM_LIT> ) cris_cpu_version = <NUM_LIT> ; if ( strcmp ( <STR_LIT> , cris_cpu_str ) == <NUM_LIT> || strcmp ( <STR_LIT> , cris_cpu_str ) == <NUM_LIT> ) cris_cpu_version = <NUM_LIT> ; if ( cris_cpu_version < <NUM_LIT> || cris_cpu_version > <NUM_LIT> ) error ( <STR_LIT> <STR_LIT> , cris_cpu_str ) ; if ( cris_cpu_version >= CRIS_CPU_ETRAX4 ) target_flags |= MASK_ETRAX4_ADD ; if ( cris_cpu_version >= CRIS_CPU_SVINTO ) target_flags |= ( MASK_SVINTO | MASK_ALIGN_BY_32 | MASK_STACK_ALIGN | MASK_CONST_ALIGN | MASK_DATA_ALIGN ) ; } if ( cris_tune_str ) { int cris_tune = ( * cris_tune_str == 'v' ? atoi ( cris_tune_str + <NUM_LIT> ) : - <NUM_LIT> ) ; if ( strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> ) cris_tune = <NUM_LIT> ; if ( strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> || strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> ) cris_tune = <NUM_LIT> ; if ( strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> || strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> ) cris_tune = <NUM_LIT> ;


<s> if ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ) { * total = <NUM_LIT> ; break ; } default : * total = <NUM_LIT> ; break ; } else if ( val <= <NUM_LIT> && val >= - <NUM_LIT> ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; } case LABEL_REF : * total = <NUM_LIT> ; return true ; case CONST : case SYMBOL_REF : * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : if ( x != CONST0_RTX ( mode == VOIDmode ? DImode : mode ) ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; case MULT : if ( outer_code == PLUS && cris_biap_index_p ( x , false ) ) { * total = <NUM_LIT> ; return true ; } if ( ! CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) || exact_log2 ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) ) { if ( TARGET_HAS_MUL_INSNS ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) + COSTS_N_INSNS ( <NUM_LIT> ) / <NUM_LIT> ; return true ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return false ; case UDIV : case MOD : case UMOD : case DIV : if ( ! CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) || exact_log2 ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return false ; case AND : if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ! CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ! satisfies_constraint_I ( XEXP ( x , <NUM_LIT> ) ) ) { * total = ( rtx_cost ( XEXP ( x , <NUM_LIT> ) , mode , ( enum rtx_code ) outer_code , opno , speed ) + <NUM_LIT> + <NUM_LIT> * GET_MODE_NUNITS ( mode ) ) ; return true ;


<s> mult = INTVAL ( XEXP ( val_rtx , <NUM_LIT> ) ) ; val_rtx = XEXP ( val_rtx , <NUM_LIT> ) ; code = MULT ; } if ( other_op >= <NUM_LIT> ) { if ( GET_MODE_SIZE ( GET_MODE ( ops [ other_op ] ) ) > UNITS_PER_WORD ) return <NUM_LIT> ; if ( ( cris_base_p ( ops [ lreg ] , reload_in_progress || reload_completed ) && cris_base_p ( ops [ other_op ] , reload_in_progress || reload_completed ) && REGNO ( ops [ lreg ] ) == REGNO ( ops [ other_op ] ) ) || rtx_equal_p ( ops [ other_op ] , ops [ lreg ] ) ) return <NUM_LIT> ; } if ( ops [ lreg ] == frame_pointer_rtx || ops [ rreg ] == frame_pointer_rtx || ops [ rval ] == frame_pointer_rtx || ( other_op >= <NUM_LIT> && ops [ other_op ] == frame_pointer_rtx ) ) return <NUM_LIT> ; if ( code == PLUS && ! cris_base_p ( val_rtx , reload_in_progress || reload_completed ) ) { if ( rtx_equal_p ( ops [ lreg ] , reg_rtx ) && CONST_INT_P ( val_rtx ) && ( INTVAL ( val_rtx ) <= <NUM_LIT> && INTVAL ( val_rtx ) >= - <NUM_LIT> ) ) return <NUM_LIT> ; if ( CONSTANT_P ( val_rtx ) ) return <NUM_LIT> ; if ( MEM_P ( val_rtx ) && cris_base_or_autoincr_p ( XEXP ( val_rtx , <NUM_LIT> ) , reload_in_progress || reload_completed ) ) return <NUM_LIT> ; if ( GET_CODE ( val_rtx ) == SIGN_EXTEND && MEM_P ( XEXP ( val_rtx , <NUM_LIT> ) ) && cris_base_or_autoincr_p ( XEXP ( XEXP ( val_rtx , <NUM_LIT> ) , <NUM_LIT> ) , reload_in_progress || reload_completed ) ) return <NUM_LIT> ; return <NUM_LIT> ; } else if ( code == MULT || ( code == PLUS && cris_base_p ( val_rtx , reload_in_progress || reload_completed ) ) ) { if ( rtx_equal_p ( ops [ lreg ] , reg_rtx ) || ( mult == <NUM_LIT> && rtx_equal_p ( ops [ lreg ] , val_rtx ) ) ) return <NUM_LIT> ; if ( mult != <NUM_LIT> && mult != <NUM_LIT> && mult != <NUM_LIT> ) return <NUM_LIT> ; if ( ! cris_base_p ( reg_rtx , reload_in_progress || reload_completed ) ) return <NUM_LIT> ; return <NUM_LIT> ; } internal_error ( <STR_LIT> ) ;


<s> int cris_cfun_uses_pic_table ( ) { return current_function_uses_pic_offset_table ;


<s> void cris_conditional_register_usage ( ) {


<s> if ( regs_ever_live [ CRIS_SRP_REGNUM ] || cfun -> machine -> needs_return_address_on_stack != <NUM_LIT> ) return <NUM_LIT> ; cris_target_asm_function_epilogue ( NULL , get_frame_size ( ) ) ; if ( * save_last ) return <NUM_LIT> ; return <NUM_LIT> ;


for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( ( ( ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) || ( regno == ( int ) PIC_OFFSET_TABLE_REGNUM && ( current_function_uses_pic_offset_table || ( flag_pic && regs_ever_live [ regno + <NUM_LIT> ] && ! call_used_regs [ regno + <NUM_LIT> ] ) ) ) ) && ( regno != FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && regno != CRIS_SRP_REGNUM ) || ( current_function_calls_eh_return && ( regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) || regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) || regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) || regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) ) ) ) offs += <NUM_LIT> ;


<s> if ( strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> || strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> ) cris_tune = <NUM_LIT> ; if ( strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> || strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> ) cris_tune = <NUM_LIT> ; if ( cris_tune < <NUM_LIT> || cris_tune > <NUM_LIT> ) error ( <STR_LIT> , cris_tune_str ) ; if ( cris_tune >= CRIS_CPU_SVINTO ) target_flags |= ( TARGET_MASK_STACK_ALIGN | TARGET_MASK_CONST_ALIGN | TARGET_MASK_DATA_ALIGN | TARGET_MASK_ALIGN_BY_32 ) ; } if ( flag_pic ) { if ( ! TARGET_LINUX ) { error ( <STR_LIT> ) ; flag_pic = <NUM_LIT> ; } flag_no_function_cse = <NUM_LIT> ; } if ( ( write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG ) && ! TARGET_ELF ) { warning ( <STR_LIT> ) ;


<s> int regno ; int reglimit = STACK_POINTER_REGNUM ; int lastreg = - <NUM_LIT> ; if ( ! reload_completed || frame_pointer_needed || get_frame_size ( ) != <NUM_LIT> || current_function_pretend_args_size || current_function_args_size || current_function_outgoing_args_size || current_function_calls_eh_return || ! TARGET_PROLOGUE_EPILOGUE ) return <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < reglimit ; regno ++ ) if ( ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) || ( regno == ( int ) PIC_OFFSET_TABLE_REGNUM && ( current_function_uses_pic_offset_table || ( flag_pic && regs_ever_live [ regno + <NUM_LIT> ] && ! call_used_regs [ regno + <NUM_LIT> ] ) ) ) ) { if ( lastreg != regno - <NUM_LIT> ) return <NUM_LIT> ; lastreg = regno ; } return <NUM_LIT> ;


<s> int regno ; int reglimit = STACK_POINTER_REGNUM ; int lastreg = - <NUM_LIT> ;


<s> if ( ( GET_CODE ( tem1 ) == MULT && BIAP_INDEX_P ( tem1 ) ) || REG_P ( tem1 ) ) return <NUM_LIT> / <NUM_LIT> ; if ( GET_CODE ( tem2 ) == CONST_INT && INTVAL ( tem2 ) < <NUM_LIT> && INTVAL ( tem2 ) >= - <NUM_LIT> ) return <NUM_LIT> / <NUM_LIT> ; if ( GET_CODE ( tem2 ) == CONST_INT && CONST_OK_FOR_LETTER_P ( INTVAL ( tem2 ) , 'L' ) ) return ( <NUM_LIT> + <NUM_LIT> ) / <NUM_LIT> ;

if ( CONSTANT_P ( tem2 ) ) return ( <NUM_LIT> + <NUM_LIT> + <NUM_LIT> ) / <NUM_LIT> ;


<s> if ( BASE_OR_AUTOINCR_P ( x ) ) return <NUM_LIT> ; if ( GET_CODE ( x ) == MEM ) return ( <NUM_LIT> + <NUM_LIT> ) / <NUM_LIT> ; if ( CONSTANT_P ( x ) ) return ( <NUM_LIT> + <NUM_LIT> ) / <NUM_LIT> ; if ( GET_CODE ( x ) == PLUS ) {


<s> if ( ca -> regs == CRIS_MAX_ARGS_IN_REGS - <NUM_LIT> && ! targetm . calls . must_pass_in_stack ( mode , type ) && CRIS_FUNCTION_ARG_SIZE ( mode , type ) > <NUM_LIT> && CRIS_FUNCTION_ARG_SIZE ( mode , type ) <= <NUM_LIT> ) return UNITS_PER_WORD ;


<s> if ( ! current_function_uses_pic_offset_table ) internal_error ( <STR_LIT> ) ; } else assemble_name ( file , buf ) ;


<s> fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> , CRIS_PLT_PCOFFSET_SUFFIX ) ; } else { fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , XSTR ( XEXP ( DECL_RTL ( funcdecl ) , <NUM_LIT> ) , <NUM_LIT> ) ) ; fprintf ( stream , <STR_LIT> ) ;


<s> const char * origstr = XSTR ( x , <NUM_LIT> ) ; const char * str ; str = ( * targetm . strip_name_encoding ) ( origstr ) ; assemble_name ( file , str ) ; if ( ! current_function_uses_pic_offset_table ) output_operand_lossage ( <STR_LIT> ) ;


<s> const char * origstr = XSTR ( x , <NUM_LIT> ) ; const char * str ; str = ( * targetm . strip_name_encoding ) ( origstr ) ;


<s> return current_function_uses_pic_offset_table ;


<s> void cris_conditional_register_usage ( void ) { if ( flag_pic ) fixed_regs [ PIC_OFFSET_TABLE_REGNUM ] = call_used_regs [ PIC_OFFSET_TABLE_REGNUM ] = <NUM_LIT> ; if ( TARGET_HAS_MUL_INSNS ) fixed_regs [ CRIS_MOF_REGNUM ] = <NUM_LIT> ;


<s> int regno_inc = - <NUM_LIT> ; if ( GET_CODE ( destreg ) == POST_INC ) increment += nregs * <NUM_LIT> ; if ( GET_CODE ( destreg ) == POST_INC || GET_CODE ( destreg ) == PLUS ) destreg = XEXP ( destreg , <NUM_LIT> ) ; CRIS_ASSERT ( REG_P ( destreg ) ) ; if ( nregs == <NUM_LIT> ) { rtx mov = gen_rtx_SET ( VOIDmode , dest , gen_rtx_REG ( SImode , <NUM_LIT> ) ) ; if ( increment == <NUM_LIT> ) { insn = emit_insn ( mov ) ; if ( frame_related ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return insn ; } vec = rtvec_alloc ( <NUM_LIT> ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = mov ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , destreg , plus_constant ( destreg , increment ) ) ; if ( frame_related ) { RTX_FRAME_RELATED_P ( mov ) = <NUM_LIT> ; RTX_FRAME_RELATED_P ( RTVEC_ELT ( vec , <NUM_LIT> ) ) = <NUM_LIT> ; } } else { vec = rtvec_alloc ( nregs + ( increment != <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , replace_equiv_address ( dest , plus_constant ( destreg , increment ) ) , gen_rtx_REG ( SImode , regno ) ) ;


<s> rtx mem ; rtx insn ; rtx srpreg = gen_rtx_raw_REG ( SImode , CRIS_SRP_REGNUM ) ; mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( srpreg , mem ) ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , gen_rtx_raw_REG ( SImode , CRIS_STACKADJ_REG ) ) ) ; cris_expand_return ( false ) ; } else cris_expand_return ( true ) ; return ; } if ( pretend != <NUM_LIT> ) { if ( return_address_on_stack ) { rtx mem ; rtx srpreg = gen_rtx_raw_REG ( SImode , CRIS_SRP_REGNUM ) ; rtx insn ; mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( srpreg , mem ) ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; } emit_insn ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( stack_pointer_rtx , pretend ) ) ) ; } if ( current_function_calls_eh_return ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , gen_rtx_raw_REG ( SImode , CRIS_STACKADJ_REG ) ) ) ; cris_expand_return ( false ) ;


<s> op = ro ; } else { rtx tem , mem , rm , ro ; gcc_assert ( ! no_new_pseudos ) ; current_function_uses_pic_offset_table = <NUM_LIT> ; tem = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , op ) , CRIS_UNSPEC_PLTGOTREAD ) ; rm = gen_reg_rtx ( Pmode ) ; emit_move_insn ( rm , gen_rtx_CONST ( Pmode , tem ) ) ; ro = gen_reg_rtx ( Pmode ) ; if ( expand_binop ( Pmode , add_optab , rm , pic_offset_table_rtx , ro , <NUM_LIT> , OPTAB_LIB_WIDEN ) != ro ) internal_error ( <STR_LIT> ) ;


<s> insn = cris_emit_movem_store ( mem , GEN_INT ( n_saved ) , <NUM_LIT> , true ) ; } framesize += n_saved * <NUM_LIT> + size ; last_movem_reg = - <NUM_LIT> ; size = <NUM_LIT> ; } insn = emit_insn ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( stack_pointer_rtx , - <NUM_LIT> - size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; mem = gen_rtx_MEM ( SImode , stack_pointer_rtx ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( mem , gen_rtx_raw_REG ( SImode , regno ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; framesize += <NUM_LIT> + size ; size = <NUM_LIT> ; } } } if ( last_movem_reg != - <NUM_LIT> ) { int n_saved = ( n_movem_regs == <NUM_LIT> ) ? <NUM_LIT> : last_movem_reg + <NUM_LIT> ; if ( ( last_movem_reg + <NUM_LIT> ) * <NUM_LIT> + size >= <NUM_LIT> && ( last_movem_reg + <NUM_LIT> ) * <NUM_LIT> + size <= <NUM_LIT> && ( cris_cpu_version >= CRIS_CPU_SVINTO || n_saved == <NUM_LIT> ) && TARGET_SIDE_EFFECT_PREFIXES ) { mem = gen_rtx_MEM ( SImode , plus_constant ( stack_pointer_rtx , - ( n_saved * <NUM_LIT> + size ) ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = cris_emit_movem_store ( mem , GEN_INT ( n_saved ) , - ( n_saved * <NUM_LIT> + size ) , true ) ; } else { insn = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( stack_pointer_rtx , - ( n_saved * <NUM_LIT> + size ) ) ) ; insn = emit_insn ( insn ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; mem = gen_rtx_MEM ( SImode , stack_pointer_rtx ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = cris_emit_movem_store ( mem , GEN_INT ( n_saved ) , <NUM_LIT> , true ) ; } framesize += n_saved * <NUM_LIT> + size ; if ( cfoa_size ) { insn = emit_insn ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( stack_pointer_rtx , - cfoa_size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; framesize += cfoa_size ; } } else if ( ( size + cfoa_size ) > <NUM_LIT> ) { insn = emit_insn ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( stack_pointer_rtx , - ( cfoa_size + size ) ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; framesize += size + cfoa_size ; } if ( got_really_used ) { rtx got = gen_rtx_UNSPEC ( SImode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , CRIS_UNSPEC_GOT ) ; emit_move_insn ( pic_offset_table_rtx , got ) ; emit_insn ( gen_rtx_USE ( VOIDmode , pic_offset_table_rtx ) ) ; } if ( cris_max_stackframe && framesize > cris_max_stackframe ) warning ( <NUM_LIT> , <STR_LIT> , framesize ) ;


<s> void cris_expand_return ( bool on_stack ) { emit_jump_insn ( gen_rtx_RETURN ( VOIDmode ) ) ; CRIS_ASSERT ( cfun -> machine -> return_type != CRIS_RETINSN_RET || ! on_stack ) ; CRIS_ASSERT ( cfun -> machine -> return_type != CRIS_RETINSN_JUMP || on_stack ) ;


<s> targetm . file_start_file_directive = TARGET_ELF ;


<s> vec = rtvec_alloc ( nprefix + nregs + ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == POST_INC ) ) ; if ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == POST_INC ) { RTVEC_ELT ( vec , nprefix + <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , srcreg , plus_constant ( srcreg , nregs * <NUM_LIT> ) ) ; eltno ++ ; } src = replace_equiv_address ( src , srcreg ) ; RTVEC_ELT ( vec , nprefix ) = gen_rtx_SET ( VOIDmode , gen_rtx_REG ( SImode , regno ) , src ) ; regno += regno_inc ; for ( i = <NUM_LIT> ; i < nregs ; i ++ , eltno ++ ) { RTVEC_ELT ( vec , nprefix + eltno ) = gen_rtx_SET ( VOIDmode , gen_rtx_REG ( SImode , regno ) , adjust_address_nv ( src , SImode , i * <NUM_LIT> ) ) ; regno += regno_inc ; } return gen_rtx_PARALLEL ( VOIDmode , vec ) ;


<s> case OPT_metrax100 : target_flags |= ( MASK_SVINTO + MASK_ETRAX4_ADD + MASK_ALIGN_BY_32 ) ; break ; case OPT_mno_etrax100 : target_flags &= ~ ( MASK_SVINTO + MASK_ETRAX4_ADD + MASK_ALIGN_BY_32 ) ; break ; case OPT_m32_bit : case OPT_m32bit : target_flags |= ( MASK_STACK_ALIGN + MASK_CONST_ALIGN + MASK_DATA_ALIGN + MASK_ALIGN_BY_32 ) ; break ; case OPT_m16_bit : case OPT_m16bit : target_flags |= ( MASK_STACK_ALIGN + MASK_CONST_ALIGN + MASK_DATA_ALIGN ) ; break ; case OPT_m8_bit : case OPT_m8bit : target_flags &= ~ ( MASK_STACK_ALIGN + MASK_CONST_ALIGN + MASK_DATA_ALIGN ) ; break ; default : break ; } CRIS_SUBTARGET_HANDLE_OPTION ( code , arg , value ) ;


<s> if ( current_function_uses_pic_offset_table ) { push_topmost_sequence ( ) ; got_really_used = reg_used_between_p ( pic_offset_table_rtx , get_insns ( ) , NULL_RTX ) ; pop_topmost_sequence ( ) ; }

for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( cris_reg_saved_in_regsave_area ( regno , got_really_used ) ) offs += <NUM_LIT> ;


<s> got_really_used = reg_used_between_p ( pic_offset_table_rtx , get_insns ( ) , NULL_RTX ) ; pop_topmost_sequence ( ) ; } for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( cris_reg_saved_in_regsave_area ( regno , got_really_used ) ) offs += <NUM_LIT> ; offs += get_frame_size ( ) ; offs += current_function_outgoing_args_size ;

if ( TARGET_STACK_ALIGN ) offs = TARGET_ALIGN_BY_32 ? ( offs + <NUM_LIT> ) & ~ <NUM_LIT> : ( offs + <NUM_LIT> ) & ~ <NUM_LIT> ;


<s> set_optab_libfunc ( smul_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , SImode , <STR_LIT> ) ;

set_optab_libfunc ( udiv_optab , SImode , <STR_LIT> ) ;


<s> int cris_legitimate_pic_operand ( rtx x ) {


<s> for ( t = outputs ; t != NULL ; t = TREE_CHAIN ( t ) ) { tree val = TREE_VALUE ( t ) ; if ( strchr ( TREE_STRING_POINTER ( TREE_VALUE ( TREE_PURPOSE ( t ) ) ) , 'h' ) != NULL || tree_overlaps_hard_reg_set ( val , & mof_set ) != NULL_TREE ) return clobbers ; } for ( t = inputs ; t != NULL ; t = TREE_CHAIN ( t ) ) { tree val = TREE_VALUE ( t ) ; if ( strchr ( TREE_STRING_POINTER ( TREE_VALUE ( TREE_PURPOSE ( t ) ) ) , 'h' ) != NULL || tree_overlaps_hard_reg_set ( val , & mof_set ) != NULL_TREE ) return clobbers ; } return tree_cons ( NULL_TREE , build_string ( strlen ( reg_names [ CRIS_MOF_REGNUM ] ) , reg_names [ CRIS_MOF_REGNUM ] ) , clobbers ) ;


<s> HARD_REG_SET mof_set ; tree clobbers ; tree t ; CLEAR_HARD_REG_SET ( mof_set ) ; SET_HARD_REG_BIT ( mof_set , CRIS_MOF_REGNUM ) ; clobbers = tree_cons ( NULL_TREE , build_string ( strlen ( reg_names [ CRIS_CC0_REGNUM ] ) , reg_names [ CRIS_CC0_REGNUM ] ) , in_clobbers ) ; for ( t = outputs ; t != NULL ; t = TREE_CHAIN ( t ) ) { tree val = TREE_VALUE ( t ) ; if ( strchr ( TREE_STRING_POINTER ( TREE_VALUE ( TREE_PURPOSE ( t ) ) ) , 'h' ) != NULL || tree_overlaps_hard_reg_set ( val , & mof_set ) != NULL_TREE ) return clobbers ; } for ( t = inputs ; t != NULL ; t = TREE_CHAIN ( t ) ) {


<s> if ( SET_DEST ( exp ) == pc_rtx ) return ; if ( SET_DEST ( exp ) == cc0_rtx ) { cc_status . value1 = SET_SRC ( exp ) ; cc_status . value2 = <NUM_LIT> ; if ( GET_CODE ( SET_SRC ( exp ) ) == ZERO_EXTRACT && XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) == const1_rtx ) { if ( GET_CODE ( XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) ) == CONST_INT ) cc_status . flags = CC_INVERTED ; else cc_status . flags = CC_Z_IN_NOT_N ; } else cc_status . flags = <NUM_LIT> ; if ( GET_CODE ( SET_SRC ( exp ) ) == COMPARE ) { if ( ! REG_P ( XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) ) && XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) != const0_rtx ) cc_status . flags = CC_REVERSED ; cc_status . value2 = gen_rtx_MINUS ( GET_MODE ( SET_SRC ( exp ) ) , XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) , XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) ) ; } return ; } else if ( REG_P ( SET_DEST ( exp ) ) || ( GET_CODE ( SET_DEST ( exp ) ) == STRICT_LOW_PART && REG_P ( XEXP ( SET_DEST ( exp ) , <NUM_LIT> ) ) ) ) { if ( GET_MODE_SIZE ( GET_MODE ( SET_DEST ( exp ) ) ) > UNITS_PER_WORD || GET_MODE_CLASS ( GET_MODE ( SET_DEST ( exp ) ) ) == MODE_FLOAT ) { if ( GET_MODE ( SET_DEST ( exp ) ) == DImode && ( GET_CODE ( SET_SRC ( exp ) ) == PLUS || GET_CODE ( SET_SRC ( exp ) ) == MINUS ) ) { cc_status . flags = <NUM_LIT> ; cc_status . value1 = SET_DEST ( exp ) ; cc_status . value2 = SET_SRC ( exp ) ; if ( cris_reg_overlap_mentioned_p ( cc_status . value1 , cc_status . value2 ) ) cc_status . value2 = <NUM_LIT> ; cc_status . flags |= CC_NO_OVERFLOW ; return ; } } else if ( SET_SRC ( exp ) == const0_rtx ) { if ( cc_status . value1 && modified_in_p ( cc_status . value1 , insn ) ) cc_status . value1 = <NUM_LIT> ; if ( cc_status . value2 && modified_in_p ( cc_status . value2 , insn ) ) cc_status . value2 = <NUM_LIT> ; return ; } else { cc_status . flags = <NUM_LIT> ; cc_status . value1 = SET_DEST ( exp ) ; cc_status . value2 = SET_SRC ( exp ) ; if ( cris_reg_overlap_mentioned_p ( cc_status . value1 , cc_status . value2 ) ) cc_status . value2 = <NUM_LIT> ;

if ( GET_CODE ( SET_SRC ( exp ) ) == PLUS || GET_CODE ( SET_SRC ( exp ) ) == MINUS || GET_CODE ( SET_SRC ( exp ) ) == NEG ) cc_status . flags |= CC_NO_OVERFLOW ;


<s> case PLUS : return <STR_LIT> ; break ; case MINUS : return <STR_LIT> ; break ; case MULT : internal_error ( <STR_LIT> ) ; break ; case DIV : return <STR_LIT> ; break ; case AND : return <STR_LIT> ; break ; case IOR : return <STR_LIT> ; break ; case XOR : return <STR_LIT> ; break ;


<s> break ; case MINUS : return <STR_LIT> ; break ; case MULT : internal_error ( <STR_LIT> ) ; break ; case DIV : return <STR_LIT> ; break ; case AND : return <STR_LIT> ; break ; case IOR : return <STR_LIT> ; break ; case XOR : return <STR_LIT> ; break ; case NOT : return <STR_LIT> ; break ; case ASHIFT : return <STR_LIT> ; break ; case LSHIFTRT : return <STR_LIT> ; break ; case ASHIFTRT : return <STR_LIT> ; break ; case UMIN : cris_output_insn_is_bound = <NUM_LIT> ; return <STR_LIT> ;


<s> operands [ n ] = operands [ n + <NUM_LIT> ] ; operands [ n + <NUM_LIT> ] = tem ;


<s> if ( MEM_P ( operands [ n ] ) ) { rtx tem = operands [ n ] ;

operands [ n ] = operands [ n + <NUM_LIT> ] ;


<s> bool cris_output_addr_const_extra ( FILE * file , rtx xconst ) { switch ( GET_CODE ( xconst ) ) { rtx x ; case UNSPEC : x = XVECEXP ( xconst , <NUM_LIT> , <NUM_LIT> ) ; CRIS_ASSERT ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF || GET_CODE ( x ) == CONST ) ; output_addr_const ( file , x ) ; switch ( XINT ( xconst , <NUM_LIT> ) ) { case CRIS_UNSPEC_PLT : fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_GOTREL : fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_GOTREAD : if ( flag_pic == <NUM_LIT> ) fprintf ( file , <STR_LIT> ) ; else fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_PLTGOTREAD : if ( flag_pic == <NUM_LIT> ) fprintf ( file , CRIS_GOTPLT_SUFFIX <STR_LIT> ) ; else fprintf ( file , CRIS_GOTPLT_SUFFIX ) ; break ; default : gcc_unreachable ( ) ; } return true ;


<s> case CRIS_UNSPEC_PLT : fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_GOTREL : fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_GOTREAD : if ( flag_pic == <NUM_LIT> ) fprintf ( file , <STR_LIT> ) ; else fprintf ( file , <STR_LIT> ) ; break ;


<s> if ( t1 == cris_got_symbol || t1 == cris_got_symbol ) return cris_got_symbol_needing_fixup ; return t1 != cris_no_symbol ? t1 : t2 ; } case CONST_INT : case CONST_DOUBLE : return cris_no_symbol ; case UNSPEC : return cris_invalid_pic_symbol ; default : fatal_insn ( <STR_LIT> , x ) ; }


<s> putc ( INTVAL ( XEXP ( index , <NUM_LIT> ) ) == <NUM_LIT> ? 'w' : 'd' , file ) ; } else if ( GET_CODE ( index ) == SIGN_EXTEND && GET_CODE ( inner ) == MEM ) { rtx inner_inner = XEXP ( inner , <NUM_LIT> ) ; if ( GET_CODE ( inner_inner ) == POST_INC ) { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( inner_inner , <NUM_LIT> ) ) ] ) ; putc ( GET_MODE ( inner ) == HImode ? 'w' : 'b' , file ) ; } else { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( inner_inner ) ] ) ; putc ( GET_MODE ( inner ) == HImode ? 'w' : 'b' , file ) ; } } else if ( GET_CODE ( index ) == MEM ) { if ( GET_CODE ( inner ) == POST_INC ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( inner , <NUM_LIT> ) ) ] ) ;

else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( inner ) ] ) ;


<s> rtx x1 , x2 ; x1 = XEXP ( x , <NUM_LIT> ) ; x2 = XEXP ( x , <NUM_LIT> ) ; if ( BASE_P ( x1 ) ) { cris_print_base ( x1 , file ) ; cris_print_index ( x2 , file ) ; } else if ( BASE_P ( x2 ) ) { cris_print_base ( x2 , file ) ;


<s> static int cris_reg_saved_in_regsave_area ( unsigned int regno , bool got_really_used ) { return ( ( ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) || ( regno == PIC_OFFSET_TABLE_REGNUM && ( got_really_used || ( flag_pic && regs_ever_live [ regno + <NUM_LIT> ] && ! call_used_regs [ regno + <NUM_LIT> ] ) ) ) ) && ( regno != FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && regno != CRIS_SRP_REGNUM ) || ( current_function_calls_eh_return && ( regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) || regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) || regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) || regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) ) ) ;


<s> rtx op00 = XEXP ( op0 , <NUM_LIT> ) ; rtx op000 = XEXP ( op00 , <NUM_LIT> ) ; rtx * op000p = & XEXP ( op00 , <NUM_LIT> ) ; if ( ( GET_MODE ( op00 ) == HImode || GET_MODE ( op00 ) == QImode ) && ( REG_P ( op000 ) || ( GET_CODE ( op000 ) == POST_INC && REG_P ( XEXP ( op000 , <NUM_LIT> ) ) ) ) ) { bool something_reloaded = false ; if ( GET_CODE ( op000 ) == POST_INC && REG_P ( XEXP ( op000 , <NUM_LIT> ) ) && REGNO ( XEXP ( op000 , <NUM_LIT> ) ) > CRIS_LAST_GENERAL_REGISTER ) return false ; if ( ( REG_P ( op000 ) && REGNO ( op000 ) > CRIS_LAST_GENERAL_REGISTER ) ) { push_reload ( op000 , NULL_RTX , op000p , NULL , GENERAL_REGS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , type ) ; something_reloaded = true ; } if ( REGNO ( op1 ) > CRIS_LAST_GENERAL_REGISTER ) { push_reload ( op1 , NULL_RTX , op1p , NULL , GENERAL_REGS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , type ) ; something_reloaded = true ; }


<s> if ( ! REG_P ( op1 ) ) return false ; if ( GET_CODE ( op0 ) == SIGN_EXTEND && GET_CODE ( XEXP ( op0 , <NUM_LIT> ) ) == MEM ) { rtx op00 = XEXP ( op0 , <NUM_LIT> ) ; rtx op000 = XEXP ( op00 , <NUM_LIT> ) ; rtx * op000p = & XEXP ( op00 , <NUM_LIT> ) ; if ( ( GET_MODE ( op00 ) == HImode || GET_MODE ( op00 ) == QImode ) && ( REG_P ( op000 ) || ( GET_CODE ( op000 ) == POST_INC && REG_P ( XEXP ( op000 , <NUM_LIT> ) ) ) ) ) { bool something_reloaded = false ; if ( GET_CODE ( op000 ) == POST_INC && REG_P ( XEXP ( op000 , <NUM_LIT> ) ) && REGNO ( XEXP ( op000 , <NUM_LIT> ) ) > CRIS_LAST_GENERAL_REGISTER ) return false ; if ( ( REG_P ( op000 ) && REGNO ( op000 ) > CRIS_LAST_GENERAL_REGISTER ) ) { push_reload ( op000 , NULL_RTX , op000p , NULL , GENERAL_REGS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , type ) ; something_reloaded = true ; } if ( REGNO ( op1 ) > CRIS_LAST_GENERAL_REGISTER ) { push_reload ( op1 , NULL_RTX , op1p , NULL , GENERAL_REGS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , type ) ; something_reloaded = true ; } gcc_assert ( something_reloaded ) ; return true ; } }


<s> bool cris_return_address_on_stack ( void ) { return regs_ever_live [ CRIS_SRP_REGNUM ] || cfun -> machine -> needs_return_address_on_stack ;


<s> cfun -> machine -> needs_return_address_on_stack = <NUM_LIT> ; return count == <NUM_LIT> ? gen_rtx_MEM ( Pmode , plus_constant ( virtual_incoming_args_rtx , - <NUM_LIT> ) ) : NULL_RTX ;


<s> } case LABEL_REF : * total = <NUM_LIT> ; return true ; case CONST : case SYMBOL_REF : * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : if ( x != CONST0_RTX ( GET_MODE ( x ) == VOIDmode ? DImode : GET_MODE ( x ) ) ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; case MULT : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT || exact_log2 ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) ) { if ( TARGET_HAS_MUL_INSNS ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) + COSTS_N_INSNS ( <NUM_LIT> ) / <NUM_LIT> ; return true ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return false ; case UDIV : case MOD : case UMOD : case DIV : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT || exact_log2 ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return false ; case AND : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT && ! CONST_OK_FOR_LETTER_P ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) , 'I' ) ) { * total = ( rtx_cost ( XEXP ( x , <NUM_LIT> ) , outer_code ) + <NUM_LIT> + <NUM_LIT> * GET_MODE_NUNITS ( GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ) ) ; return true ; } return false ; case ZERO_EXTEND : case SIGN_EXTEND :

* total = rtx_cost ( XEXP ( x , <NUM_LIT> ) , outer_code ) ;


<s> static void cris_setup_incoming_varargs ( CUMULATIVE_ARGS * ca , enum machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED , int * pretend_arg_size , int second_time ) { if ( ca -> regs < CRIS_MAX_ARGS_IN_REGS ) { int stdarg_regs = CRIS_MAX_ARGS_IN_REGS - ca -> regs ; cfun -> machine -> stdarg_regs = stdarg_regs ; * pretend_arg_size = stdarg_regs * <NUM_LIT> ; }

if ( TARGET_PDEBUG ) fprintf ( asm_out_file , <STR_LIT> , ca -> regs , * pretend_arg_size , second_time ) ;


<s> } if ( ops [ lreg ] == frame_pointer_rtx || ops [ rreg ] == frame_pointer_rtx || ops [ rval ] == frame_pointer_rtx || ( other_op >= <NUM_LIT> && ops [ other_op ] == frame_pointer_rtx ) ) return <NUM_LIT> ; if ( code == PLUS && ! BASE_P ( val_rtx ) ) { if ( rtx_equal_p ( ops [ lreg ] , reg_rtx ) && GET_CODE ( val_rtx ) == CONST_INT && ( INTVAL ( val_rtx ) <= <NUM_LIT> && INTVAL ( val_rtx ) >= - <NUM_LIT> ) ) return <NUM_LIT> ; if ( CONSTANT_P ( val_rtx ) ) return <NUM_LIT> ; if ( GET_CODE ( val_rtx ) == MEM && BASE_OR_AUTOINCR_P ( XEXP ( val_rtx , <NUM_LIT> ) ) ) return <NUM_LIT> ; if ( GET_CODE ( val_rtx ) == SIGN_EXTEND && GET_CODE ( XEXP ( val_rtx , <NUM_LIT> ) ) == MEM && BASE_OR_AUTOINCR_P ( XEXP ( XEXP ( val_rtx , <NUM_LIT> ) , <NUM_LIT> ) ) ) return <NUM_LIT> ; return <NUM_LIT> ; } else if ( code == MULT || ( code == PLUS && BASE_P ( val_rtx ) ) ) {

if ( rtx_equal_p ( ops [ lreg ] , reg_rtx ) || ( mult == <NUM_LIT> && rtx_equal_p ( ops [ lreg ] , val_rtx ) ) ) return <NUM_LIT> ;


<s> bool got_really_used = false ; if ( ! reload_completed || frame_pointer_needed || get_frame_size ( ) != <NUM_LIT> || current_function_pretend_args_size || current_function_args_size || current_function_outgoing_args_size || current_function_calls_eh_return || ! TARGET_PROLOGUE_EPILOGUE ) return false ; if ( current_function_uses_pic_offset_table ) { push_topmost_sequence ( ) ; got_really_used = reg_used_between_p ( pic_offset_table_rtx , get_insns ( ) , NULL_RTX ) ; pop_topmost_sequence ( ) ; }

for ( regno = <NUM_LIT> ; regno < reglimit ; regno ++ ) if ( cris_reg_saved_in_regsave_area ( regno , got_really_used ) ) return false ;


<s> if ( GET_CODE ( x ) != CONST ) return false ; x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == CRIS_UNSPEC_GOTREL && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == UNSPEC ) switch ( XINT ( x , <NUM_LIT> ) ) { case CRIS_UNSPEC_PLT : case CRIS_UNSPEC_PLTGOTREAD : case CRIS_UNSPEC_GOTREAD :


<s> else if ( fmt [ i ] == 'E' ) { int j ; for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( saved_regs_mentioned ( XEXP ( x , i ) ) ) return <NUM_LIT> ; } }


<s> static int cris_arg_partial_bytes ( cumulative_args_t ca , machine_mode mode , tree type , bool named ATTRIBUTE_UNUSED ) { if ( get_cumulative_args ( ca ) -> regs == CRIS_MAX_ARGS_IN_REGS - <NUM_LIT> && ! targetm . calls . must_pass_in_stack ( mode , type ) && CRIS_FUNCTION_ARG_SIZE ( mode , type ) > <NUM_LIT> && CRIS_FUNCTION_ARG_SIZE ( mode , type ) <= <NUM_LIT> ) return UNITS_PER_WORD ; else return <NUM_LIT> ;


<s> if ( get_cumulative_args ( ca ) -> regs == CRIS_MAX_ARGS_IN_REGS - <NUM_LIT> && ! targetm . calls . must_pass_in_stack ( mode , type ) && CRIS_FUNCTION_ARG_SIZE ( mode , type ) > <NUM_LIT> && CRIS_FUNCTION_ARG_SIZE ( mode , type ) <= <NUM_LIT> ) return UNITS_PER_WORD ; else return <NUM_LIT> ;


<s> gcc_assert ( whole_jump_insn != NULL_RTX && LABEL_P ( whole_jump_insn ) ) ; whole_jump_insn = prev_nonnote_nondebug_insn ( whole_jump_insn ) ; gcc_assert ( whole_jump_insn != NULL_RTX && ( JUMP_P ( whole_jump_insn ) || ( TARGET_V32 && INSN_P ( whole_jump_insn ) && GET_CODE ( PATTERN ( whole_jump_insn ) ) == SEQUENCE ) ) ) ; whole_jump_insn = PATTERN ( whole_jump_insn ) ; if ( TARGET_V32 ) {

rtx parallel_jump = ( GET_CODE ( whole_jump_insn ) == SEQUENCE ? PATTERN ( XVECEXP ( whole_jump_insn , <NUM_LIT> , <NUM_LIT> ) ) : whole_jump_insn ) ;


<s> fprintf ( stream , <STR_LIT> , CRIS_PLT_PCOFFSET_SUFFIX ) ; } else { fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> , CRIS_PLT_PCOFFSET_SUFFIX ) ; } } else { fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , XSTR ( XEXP ( DECL_RTL ( funcdecl ) , <NUM_LIT> ) , <NUM_LIT> ) ) ; fprintf ( stream , <STR_LIT> ) ; if ( TARGET_V32 ) fprintf ( stream , <STR_LIT> ) ;


<s> set = single_set ( cc0_user ) ; if ( JUMP_P ( cc0_user ) && GET_CODE ( body ) == SET && SET_DEST ( body ) == pc_rtx && GET_CODE ( SET_SRC ( body ) ) == IF_THEN_ELSE && XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) == cc0_rtx ) { return GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == GT || GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == LE ; } else if ( set ) { return GET_CODE ( SET_SRC ( body ) ) == GT || GET_CODE ( SET_SRC ( body ) ) == LE ; }


<s> rtx_insn * cc0_user = NULL ; rtx body ; rtx set ; gcc_assert ( insn != NULL ) ; if ( ! TARGET_V32 ) return false ; cc0_user = next_cc0_user ( insn ) ; if ( cc0_user == NULL ) return false ; body = PATTERN ( cc0_user ) ; set = single_set ( cc0_user ) ; if ( JUMP_P ( cc0_user ) && GET_CODE ( body ) == SET && SET_DEST ( body ) == pc_rtx && GET_CODE ( SET_SRC ( body ) ) == IF_THEN_ELSE && XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) == cc0_rtx ) { return GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == GT || GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == LE ; } else if ( set ) { return GET_CODE ( SET_SRC ( body ) ) == GT || GET_CODE ( SET_SRC ( body ) ) == LE ; }


<s> vec = rtvec_alloc ( <NUM_LIT> ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = mov ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , destreg , plus_constant ( Pmode , destreg , increment ) ) ; if ( frame_related ) { RTX_FRAME_RELATED_P ( mov ) = <NUM_LIT> ; RTX_FRAME_RELATED_P ( RTVEC_ELT ( vec , <NUM_LIT> ) ) = <NUM_LIT> ; } } else { vec = rtvec_alloc ( nregs + ( increment != <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , replace_equiv_address ( dest , plus_constant ( Pmode , destreg , increment ) ) , gen_rtx_REG ( SImode , regno ) ) ; regno += regno_inc ; if ( frame_related ) RTX_FRAME_RELATED_P ( RTVEC_ELT ( vec , <NUM_LIT> ) ) = <NUM_LIT> ; if ( increment != <NUM_LIT> ) { RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , destreg , plus_constant ( Pmode , destreg , increment != <NUM_LIT> ? increment : nregs * <NUM_LIT> ) ) ; eltno ++ ; if ( frame_related ) RTX_FRAME_RELATED_P ( RTVEC_ELT ( vec , <NUM_LIT> ) ) = <NUM_LIT> ; if ( GET_CODE ( XEXP ( dest , <NUM_LIT> ) ) == POST_INC ) dest = replace_equiv_address ( dest , destreg ) ; } for ( i = <NUM_LIT> ; i < nregs ; i ++ , eltno ++ ) {

RTVEC_ELT ( vec , eltno ) = gen_rtx_SET ( VOIDmode , adjust_address_nv ( dest , SImode , i * <NUM_LIT> ) , gen_rtx_REG ( SImode , regno ) ) ;


<s> return cris_function_arg_1 ( ca , mode , type , named , false ) ;


<s> const CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ;

if ( ( ! incoming || named ) && ca -> regs < CRIS_MAX_ARGS_IN_REGS ) return gen_rtx_REG ( mode , CRIS_FIRST_ARG_REG + ca -> regs ) ;


<s> ca -> regs += ( <NUM_LIT> + CRIS_FUNCTION_ARG_SIZE ( mode , type ) ) / <NUM_LIT> ;


<s> static void cris_function_arg_advance ( cumulative_args_t ca_v , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) {

CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ;


<s> static rtx cris_function_incoming_arg ( cumulative_args_t ca , machine_mode mode , const_tree type , bool named ) {

return cris_function_arg_1 ( ca , mode , type , named , true ) ;


<s> static rtx cris_function_incoming_arg ( cumulative_args_t ca , machine_mode mode , const_tree type , bool named ) { return cris_function_arg_1 ( ca , mode , type , named , true ) ;


<s> eltno ++ ; } src = replace_equiv_address ( src , srcreg ) ; RTVEC_ELT ( vec , nprefix ) = gen_rtx_SET ( VOIDmode , gen_rtx_REG ( SImode , regno ) , src ) ; regno += regno_inc ; for ( i = <NUM_LIT> ; i < nregs ; i ++ , eltno ++ ) { RTVEC_ELT ( vec , nprefix + eltno ) = gen_rtx_SET ( VOIDmode , gen_rtx_REG ( SImode , regno ) , adjust_address_nv ( src , SImode , i * <NUM_LIT> ) ) ;


if ( strcmp ( <STR_LIT> , cris_cpu_str ) == <NUM_LIT> || strcmp ( <STR_LIT> , cris_cpu_str ) == <NUM_LIT> ) cris_cpu_version = <NUM_LIT> ;


<s> if ( strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> ) cris_tune = <NUM_LIT> ; if ( strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> || strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> ) cris_tune = <NUM_LIT> ; if ( strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> || strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> ) cris_tune = <NUM_LIT> ; if ( cris_tune < <NUM_LIT> || cris_tune > <NUM_LIT> ) error ( <STR_LIT> , cris_tune_str ) ; if ( cris_tune >= CRIS_CPU_SVINTO ) target_flags |= ( MASK_STACK_ALIGN | MASK_CONST_ALIGN | MASK_DATA_ALIGN | MASK_ALIGN_BY_32 ) ; } if ( cris_cpu_version >= CRIS_CPU_V32 ) target_flags &= ~ ( MASK_SIDE_EFFECT_PREFIXES | MASK_MUL_BUG ) ; if ( flag_pic ) { if ( ! TARGET_LINUX ) { error ( <STR_LIT> ) ; flag_pic = <NUM_LIT> ; } flag_no_function_cse = <NUM_LIT> ; } init_machine_status = cris_init_machine_status ;


<s> return ( targetm . calls . must_pass_in_stack ( mode , type ) || CRIS_FUNCTION_ARG_SIZE ( mode , type ) > <NUM_LIT> ) ;


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

if ( rclass != ACR_REGS && rclass != MOF_REGS && rclass != MOF_SRP_REGS && rclass != SRP_REGS && rclass != CC0_REGS && rclass != SPECIAL_REGS ) return GENERAL_REGS ;


<s> static void cris_print_operand_address ( FILE * file , rtx x ) { putc ( '[' , file ) ; if ( CONSTANT_ADDRESS_P ( x ) ) cris_output_addr_const ( file , x ) ; else if ( cris_base_or_autoincr_p ( x , true ) ) cris_print_base ( x , file ) ; else if ( GET_CODE ( x ) == PLUS ) { rtx x1 , x2 ; x1 = XEXP ( x , <NUM_LIT> ) ; x2 = XEXP ( x , <NUM_LIT> ) ; if ( cris_base_p ( x1 , true ) ) { cris_print_base ( x1 , file ) ; cris_print_index ( x2 , file ) ; } else if ( cris_base_p ( x2 , true ) ) { cris_print_base ( x2 , file ) ; cris_print_index ( x1 , file ) ; } else LOSE_AND_RETURN ( <STR_LIT> , x ) ; } else if ( MEM_P ( x ) ) { putc ( '[' , file ) ;

cris_print_base ( XEXP ( x , <NUM_LIT> ) , file ) ;


<s> x1 = XEXP ( x , <NUM_LIT> ) ; x2 = XEXP ( x , <NUM_LIT> ) ; if ( cris_base_p ( x1 , true ) ) { cris_print_base ( x1 , file ) ; cris_print_index ( x2 , file ) ; } else if ( cris_base_p ( x2 , true ) ) { cris_print_base ( x2 , file ) ; cris_print_index ( x1 , file ) ; } else LOSE_AND_RETURN ( <STR_LIT> , x ) ; }


<s> else if ( val <= <NUM_LIT> && val >= - <NUM_LIT> ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; } case LABEL_REF : * total = <NUM_LIT> ; return true ; case CONST : case SYMBOL_REF : * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : if ( x != CONST0_RTX ( GET_MODE ( x ) == VOIDmode ? DImode : GET_MODE ( x ) ) ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; case MULT : if ( outer_code == PLUS && cris_biap_index_p ( x , false ) ) { * total = <NUM_LIT> ; return true ; } if ( ! CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) || exact_log2 ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) ) { if ( TARGET_HAS_MUL_INSNS ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) + COSTS_N_INSNS ( <NUM_LIT> ) / <NUM_LIT> ; return true ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return false ; case UDIV : case MOD : case UMOD : case DIV : if ( ! CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) || exact_log2 ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return false ; case AND : if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ! CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ! satisfies_constraint_I ( XEXP ( x , <NUM_LIT> ) ) ) { * total = ( rtx_cost ( XEXP ( x , <NUM_LIT> ) , ( enum rtx_code ) outer_code , opno , speed ) + <NUM_LIT> + <NUM_LIT> * GET_MODE_NUNITS ( GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ) ) ; return true ; } return false ; case ZERO_EXTRACT : if ( outer_code != COMPARE ) return false ;


<s> int stdarg_regs = CRIS_MAX_ARGS_IN_REGS - ca -> regs ; cfun -> machine -> stdarg_regs = stdarg_regs ; * pretend_arg_size = stdarg_regs * <NUM_LIT> ; }


<s> else if ( MEM_P ( src ) ) { rtx addr = XEXP ( src , <NUM_LIT> ) ; int reverse = ( refers_to_regno_p ( dregno , addr ) != <NUM_LIT> ) ; if ( GET_CODE ( addr ) == POST_INC ) { rtx mem ; rtx insn ; mem = change_address ( src , SImode , addr ) ; insn = gen_rtx_SET ( VOIDmode , operand_subword ( dest , <NUM_LIT> , TRUE , mode ) , mem ) ; insn = emit_insn ( insn ) ; if ( GET_CODE ( XEXP ( mem , <NUM_LIT> ) ) == POST_INC ) REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) , REG_NOTES ( insn ) ) ; mem = copy_rtx ( mem ) ; insn = gen_rtx_SET ( VOIDmode , operand_subword ( dest , <NUM_LIT> , TRUE , mode ) , mem ) ; insn = emit_insn ( insn ) ; if ( GET_CODE ( XEXP ( mem , <NUM_LIT> ) ) == POST_INC ) REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) , REG_NOTES ( insn ) ) ; } else { if ( side_effects_p ( addr ) ) fatal_insn ( <STR_LIT> , addr ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operand_subword ( dest , reverse , TRUE , mode ) , change_address ( src , SImode , plus_constant ( Pmode , addr , reverse * UNITS_PER_WORD ) ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operand_subword ( dest , ! reverse , TRUE , mode ) , change_address ( src , SImode , plus_constant ( Pmode , addr , ( ! reverse ) * UNITS_PER_WORD ) ) ) ) ; } } else internal_error ( <STR_LIT> ) ; } else if ( MEM_P ( dest ) && ( REG_P ( src ) || src == const0_rtx || src == CONST0_RTX ( DFmode ) ) ) { rtx addr = XEXP ( dest , <NUM_LIT> ) ;


<s> else { if ( side_effects_p ( addr ) ) fatal_insn ( <STR_LIT> , addr ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operand_subword ( dest , reverse , TRUE , mode ) , change_address ( src , SImode , plus_constant ( Pmode , addr , reverse * UNITS_PER_WORD ) ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operand_subword ( dest , ! reverse , TRUE , mode ) , change_address ( src , SImode , plus_constant ( Pmode , addr , ( ! reverse ) * UNITS_PER_WORD ) ) ) ) ; } } else internal_error ( <STR_LIT> ) ; } else if ( MEM_P ( dest ) && ( REG_P ( src ) || src == const0_rtx || src == CONST0_RTX ( DFmode ) ) ) { rtx addr = XEXP ( dest , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == POST_INC ) { rtx mem ; rtx insn ; mem = change_address ( dest , SImode , addr ) ; insn = gen_rtx_SET ( VOIDmode , mem , operand_subword ( src , <NUM_LIT> , TRUE , mode ) ) ; insn = emit_insn ( insn ) ; if ( GET_CODE ( XEXP ( mem , <NUM_LIT> ) ) == POST_INC ) REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) , REG_NOTES ( insn ) ) ; mem = copy_rtx ( mem ) ; insn = gen_rtx_SET ( VOIDmode , mem , operand_subword ( src , <NUM_LIT> , TRUE , mode ) ) ; insn = emit_insn ( insn ) ; if ( GET_CODE ( XEXP ( mem , <NUM_LIT> ) ) == POST_INC ) REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) , REG_NOTES ( insn ) ) ; } else { if ( side_effects_p ( addr ) ) fatal_insn ( <STR_LIT> , addr ) ; emit_insn ( gen_rtx_SET ( VOIDmode , change_address ( dest , SImode , addr ) , operand_subword ( src , <NUM_LIT> , TRUE , mode ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , change_address ( dest , SImode , plus_constant ( Pmode , addr , UNITS_PER_WORD ) ) , operand_subword ( src , <NUM_LIT> , TRUE , mode ) ) ) ; }


return MAX ( cris_preferred_mininum_alignment ( ) , basic_align ) ;


<s> if ( ! TARGET_CONST_ALIGN ) return <NUM_LIT> ; if ( TARGET_ALIGN_BY_32 ) return <NUM_LIT> ; return <NUM_LIT> ;


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


<s> return MAX ( cris_preferred_mininum_alignment ( ) , GET_MODE_ALIGNMENT ( mode ) ) ;


<s> static HOST_WIDE_INT cris_static_rtx_alignment ( machine_mode mode ) { return MAX ( cris_preferred_mininum_alignment ( ) , GET_MODE_ALIGNMENT ( mode ) ) ;


<s> gcc_assert ( REG_P ( tem1 ) || GET_CODE ( tem1 ) == MULT ) ; if ( ( GET_CODE ( tem1 ) == MULT && cris_biap_index_p ( tem1 , false ) ) || REG_P ( tem2 ) ) return <NUM_LIT> / <NUM_LIT> ; if ( CONST_INT_P ( tem2 ) && INTVAL ( tem2 ) < <NUM_LIT> && INTVAL ( tem2 ) >= - <NUM_LIT> ) return <NUM_LIT> / <NUM_LIT> ; if ( satisfies_constraint_L ( tem2 ) ) return ( <NUM_LIT> + <NUM_LIT> ) / <NUM_LIT> ;

if ( CONSTANT_P ( tem2 ) ) return ( <NUM_LIT> + <NUM_LIT> + <NUM_LIT> ) / <NUM_LIT> ;


<s> if ( ! REG_P ( tem1 ) && GET_CODE ( tem1 ) != MULT ) tem1 = tem2 , tem2 = XEXP ( x , <NUM_LIT> ) ; gcc_assert ( REG_P ( tem1 ) || GET_CODE ( tem1 ) == MULT ) ; if ( ( GET_CODE ( tem1 ) == MULT && cris_biap_index_p ( tem1 , false ) ) || REG_P ( tem2 ) ) return <NUM_LIT> / <NUM_LIT> ; if ( CONST_INT_P ( tem2 ) && INTVAL ( tem2 ) < <NUM_LIT> && INTVAL ( tem2 ) >= - <NUM_LIT> ) return <NUM_LIT> / <NUM_LIT> ; if ( satisfies_constraint_L ( tem2 ) ) return ( <NUM_LIT> + <NUM_LIT> ) / <NUM_LIT> ; if ( CONSTANT_P ( tem2 ) ) return ( <NUM_LIT> + <NUM_LIT> + <NUM_LIT> ) / <NUM_LIT> ; return ( <NUM_LIT> + <NUM_LIT> + <NUM_LIT> ) / <NUM_LIT> ;


<s> if ( get_cumulative_args ( ca ) -> regs == CRIS_MAX_ARGS_IN_REGS - <NUM_LIT> && ! targetm . calls . must_pass_in_stack ( arg ) && CRIS_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) > <NUM_LIT> && CRIS_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) <= <NUM_LIT> ) return UNITS_PER_WORD ;


<s> if ( get_cumulative_args ( ca ) -> regs == CRIS_MAX_ARGS_IN_REGS - <NUM_LIT> && ! targetm . calls . must_pass_in_stack ( arg ) && CRIS_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) > <NUM_LIT> && CRIS_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) <= <NUM_LIT> ) return UNITS_PER_WORD ; else return <NUM_LIT> ;


<s> if ( symtab -> state != PARSING ) return ;

default_asm_output_ident_directive ( string ) ;


<s> final_start_function ( emit_barrier ( ) , stream , <NUM_LIT> ) ; if ( delta > <NUM_LIT> ) fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , ADDITIVE_SIZE_MODIFIER ( delta ) , delta , reg_names [ CRIS_FIRST_ARG_REG ] ) ; else if ( delta < <NUM_LIT> ) fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , ADDITIVE_SIZE_MODIFIER ( - delta ) , - delta , reg_names [ CRIS_FIRST_ARG_REG ] ) ; fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , XSTR ( XEXP ( DECL_RTL ( funcdecl ) , <NUM_LIT> ) , <NUM_LIT> ) ) ; fprintf ( stream , <STR_LIT> ) ;


<s> else if ( delta < <NUM_LIT> ) fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , ADDITIVE_SIZE_MODIFIER ( - delta ) , - delta , reg_names [ CRIS_FIRST_ARG_REG ] ) ; fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , XSTR ( XEXP ( DECL_RTL ( funcdecl ) , <NUM_LIT> ) , <NUM_LIT> ) ) ; fprintf ( stream , <STR_LIT> ) ;


<s> fprintf ( f , <STR_LIT> , reg_names [ STATIC_CHAIN_REGNUM ] ) ; fprintf ( f , <STR_LIT> ) ; fprintf ( f , <STR_LIT> , reg_names [ STATIC_CHAIN_REGNUM ] ) ;


<s> fprintf ( f , <STR_LIT> ) ; fprintf ( f , <STR_LIT> , reg_names [ STATIC_CHAIN_REGNUM ] ) ; fprintf ( f , <STR_LIT> ) ; fprintf ( f , <STR_LIT> , reg_names [ STATIC_CHAIN_REGNUM ] ) ; fprintf ( f , <STR_LIT> ) ;


<s> static unsigned int cris_atomic_align_for_mode ( machine_mode mode ) {


<s> static unsigned int cris_atomic_align_for_mode ( machine_mode mode ) { return GET_MODE_BITSIZE ( mode ) ;


<s> bool cris_base_or_autoincr_p ( const_rtx x , bool strict ) {

return ( cris_base_p ( x , strict ) || ( GET_CODE ( x ) == POST_INC && cris_base_p ( XEXP ( x , <NUM_LIT> ) , strict ) ) ) ;


<s> return ( cris_base_p ( x , strict ) || ( GET_CODE ( x ) == POST_INC && cris_base_p ( XEXP ( x , <NUM_LIT> ) , strict ) ) ) ;


<s> bool cris_base_p ( const_rtx x , bool strict ) { return ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) ) ;


<s> bool cris_bdap_index_p ( const_rtx x , bool strict ) { return ( ( MEM_P ( x ) && GET_MODE ( x ) == SImode && cris_base_or_autoincr_p ( XEXP ( x , <NUM_LIT> ) , strict ) ) || ( GET_CODE ( x ) == SIGN_EXTEND && MEM_P ( XEXP ( x , <NUM_LIT> ) ) && ( GET_MODE ( XEXP ( x , <NUM_LIT> ) ) == HImode || GET_MODE ( XEXP ( x , <NUM_LIT> ) ) == QImode ) && cris_base_or_autoincr_p ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , strict ) ) ) ;


<s> return t == cris_unspec || t == cris_got_symbol || t == cris_rel_symbol ;


<s> enum cris_symbol_type t = cris_symbol_type_of ( x ) ; return t == cris_unspec || t == cris_got_symbol || t == cris_rel_symbol ;


<s> cc0_user = next_cc0_user ( insn ) ; if ( cc0_user == NULL ) return false ; body = PATTERN ( cc0_user ) ; set = single_set ( cc0_user ) ;

if ( JUMP_P ( cc0_user ) && GET_CODE ( body ) == SET && SET_DEST ( body ) == pc_rtx && GET_CODE ( SET_SRC ( body ) ) == IF_THEN_ELSE && XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) == cc0_rtx ) {


<s> rtx body ; rtx set ; gcc_assert ( insn != NULL ) ; if ( ! TARGET_V32 ) return false ; cc0_user = next_cc0_user ( insn ) ; if ( cc0_user == NULL ) return false ; body = PATTERN ( cc0_user ) ; set = single_set ( cc0_user ) ; if ( JUMP_P ( cc0_user ) && GET_CODE ( body ) == SET && SET_DEST ( body ) == pc_rtx && GET_CODE ( SET_SRC ( body ) ) == IF_THEN_ELSE && XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) == cc0_rtx ) { return GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == GT || GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == LE ; }


<s> if ( m2 == CC_NZVCmode ) { if ( m1 == CC_NZVCmode || m1 == CCmode ) return CC_NZVCmode ; return VOIDmode ; }


<s> return crtl -> uses_pic_offset_table ;


<s> static void cris_conditional_register_usage ( void ) {


return MAX ( cris_preferred_minimum_alignment ( ) , basic_align ) ;


<s> return MAX ( cris_preferred_minimum_alignment ( ) , basic_align ) ;


<s> return ( CRIS_CONSTANT_P ( x ) && ( ! flag_pic || cris_valid_pic_const ( x , true ) ) ) ;


<s> bool cris_constant_index_p ( const_rtx x ) { return ( CRIS_CONSTANT_P ( x ) && ( ! flag_pic || cris_valid_pic_const ( x , true ) ) ) ;


<s> RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , CRIS_CC0_REGNUM ) ) ;

return emit_insn ( gen_rtx_PARALLEL ( VOIDmode , vec ) ) ;


<s> insn = emit_move_insn ( dest , gen_rtx_REG ( SImode , <NUM_LIT> ) ) ; if ( frame_related ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return insn ; } vec = rtvec_alloc ( <NUM_LIT> ) ; rtx mov = gen_rtx_SET ( dest , gen_rtx_REG ( SImode , <NUM_LIT> ) ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = mov ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( destreg , plus_constant ( Pmode , destreg , increment ) ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , CRIS_CC0_REGNUM ) ) ; if ( frame_related ) { RTX_FRAME_RELATED_P ( mov ) = <NUM_LIT> ; RTX_FRAME_RELATED_P ( RTVEC_ELT ( vec , <NUM_LIT> ) ) = <NUM_LIT> ; } } else { vec = rtvec_alloc ( nregs + ( increment != <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( replace_equiv_address ( dest , plus_constant ( Pmode , destreg , increment ) ) , gen_rtx_REG ( SImode , regno ) ) ; regno += regno_inc ; if ( frame_related ) RTX_FRAME_RELATED_P ( RTVEC_ELT ( vec , <NUM_LIT> ) ) = <NUM_LIT> ; if ( increment != <NUM_LIT> ) { RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( destreg , plus_constant ( Pmode , destreg , increment != <NUM_LIT> ? increment : nregs * <NUM_LIT> ) ) ; eltno ++ ;


<s> reg = force_reg ( Pmode , addr ) ; ok_label = gen_label_rtx ( ) ; andop = gen_rtx_AND ( Pmode , reg , GEN_INT ( natural_alignment - <NUM_LIT> ) ) ; emit_cmp_and_jump_insns ( force_reg ( SImode , andop ) , const0_rtx , EQ , NULL_RTX , Pmode , <NUM_LIT> , ok_label ) ; jmp = get_last_insn ( ) ; gcc_assert ( JUMP_P ( jmp ) ) ;

predict_insn_def ( jmp , PRED_NORETURN , TAKEN ) ;


<s> if ( argspace_offset ) { emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( argspace_offset ) ) ) ; argspace_offset = <NUM_LIT> ; } mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( gen_raw_REG ( SImode , regno ) , mem ) ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; } if ( last_movem_reg != - <NUM_LIT> ) { rtx insn ; if ( argspace_offset ) { emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( argspace_offset ) ) ) ; argspace_offset = <NUM_LIT> ; } mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_insn ( cris_gen_movem_load ( mem , GEN_INT ( last_movem_reg + <NUM_LIT> ) ) ) ; if ( side_effects_p ( PATTERN ( insn ) ) ) REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; } if ( frame_pointer_needed ) { rtx insn ; emit_insn ( gen_cris_frame_deallocated_barrier ( ) ) ; emit_move_insn ( stack_pointer_rtx , hard_frame_pointer_rtx ) ; mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( hard_frame_pointer_rtx , mem ) ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; } else if ( ( size + argspace_offset ) != <NUM_LIT> ) { emit_insn ( gen_cris_frame_deallocated_barrier ( ) ) ; size += argspace_offset ; emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( size ) ) ) ; } if ( return_address_on_stack && pretend == <NUM_LIT> ) { if ( crtl -> calls_eh_return ) { rtx mem ; rtx insn ; rtx srpreg = gen_raw_REG ( SImode , CRIS_SRP_REGNUM ) ; mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( srpreg , mem ) ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; if ( crtl -> calls_eh_return ) emit_insn ( gen_add2_insn ( stack_pointer_rtx , gen_raw_REG ( SImode , CRIS_STACKADJ_REG ) ) ) ; cris_expand_return ( false ) ; } else cris_expand_return ( true ) ; return ; } if ( pretend != <NUM_LIT> ) { if ( return_address_on_stack ) { rtx mem ; rtx srpreg = gen_raw_REG ( SImode , CRIS_SRP_REGNUM ) ; rtx insn ; mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( srpreg , mem ) ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ;


<s> if ( argspace_offset ) { emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( argspace_offset ) ) ) ; argspace_offset = <NUM_LIT> ; } mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( gen_raw_REG ( SImode , regno ) , mem ) ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; } if ( last_movem_reg != - <NUM_LIT> ) { rtx insn ; if ( argspace_offset ) { emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( argspace_offset ) ) ) ; argspace_offset = <NUM_LIT> ; } mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_insn ( cris_gen_movem_load ( mem , GEN_INT ( last_movem_reg + <NUM_LIT> ) ) ) ; if ( side_effects_p ( PATTERN ( insn ) ) ) REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; } if ( frame_pointer_needed ) { rtx insn ; emit_insn ( gen_cris_frame_deallocated_barrier ( ) ) ; emit_move_insn ( stack_pointer_rtx , hard_frame_pointer_rtx ) ; mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( hard_frame_pointer_rtx , mem ) ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; } else if ( ( size + argspace_offset ) != <NUM_LIT> ) { emit_insn ( gen_cris_frame_deallocated_barrier ( ) ) ; size += argspace_offset ; emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( size ) ) ) ; } if ( return_address_on_stack && pretend == <NUM_LIT> ) { if ( crtl -> calls_eh_return ) { rtx mem ; rtx insn ; rtx srpreg = gen_raw_REG ( SImode , CRIS_SRP_REGNUM ) ; mem = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( srpreg , mem ) ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , stack_pointer_rtx , REG_NOTES ( insn ) ) ; if ( crtl -> calls_eh_return ) emit_insn ( gen_add2_insn ( stack_pointer_rtx , gen_raw_REG ( SImode , CRIS_STACKADJ_REG ) ) ) ; cris_expand_return ( false ) ; } else cris_expand_return ( true ) ; return ; } if ( pretend != <NUM_LIT> ) { if ( return_address_on_stack ) {


<s> CRIS_ASSERT ( can_create_pseudo_p ( ) ) ; if ( t == cris_rel_symbol ) { if ( TARGET_V32 ) { rtx sym = GET_CODE ( op ) != CONST ? op : get_related_value ( op ) ; HOST_WIDE_INT offs = get_integer_term ( op ) ; gcc_assert ( offs == <NUM_LIT> ) ; op = gen_rtx_CONST ( Pmode , gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , sym ) , CRIS_UNSPEC_PCREL ) ) ; } else op = force_reg ( Pmode , op ) ; * markerp = const0_rtx ; } else if ( t == cris_got_symbol ) { if ( TARGET_AVOID_GOTPLT ) { rtx tem , rm , ro ; crtl -> uses_pic_offset_table = <NUM_LIT> ; tem = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , op ) , TARGET_V32 ? CRIS_UNSPEC_PLT_PCREL : CRIS_UNSPEC_PLT_GOTREL ) ; tem = gen_rtx_CONST ( Pmode , tem ) ; if ( TARGET_V32 ) op = tem ; else { rm = gen_reg_rtx ( Pmode ) ; emit_move_insn ( rm , tem ) ; ro = gen_reg_rtx ( Pmode ) ;

if ( expand_binop ( Pmode , add_optab , rm , pic_offset_table_rtx , ro , <NUM_LIT> , OPTAB_LIB_WIDEN ) != ro ) internal_error ( <STR_LIT> ) ;


<s> else { rtx tem , mem , rm , ro ; gcc_assert ( can_create_pseudo_p ( ) ) ; crtl -> uses_pic_offset_table = <NUM_LIT> ; tem = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , op ) , CRIS_UNSPEC_PLTGOTREAD ) ; rm = gen_reg_rtx ( Pmode ) ; emit_move_insn ( rm , gen_rtx_CONST ( Pmode , tem ) ) ; ro = gen_reg_rtx ( Pmode ) ; if ( expand_binop ( Pmode , add_optab , rm , pic_offset_table_rtx , ro , <NUM_LIT> , OPTAB_LIB_WIDEN ) != ro ) internal_error ( <STR_LIT> ) ; mem = gen_rtx_MEM ( Pmode , ro ) ; set_mem_alias_set ( mem , new_alias_set ( ) ) ; MEM_NOTRAP_P ( mem ) = <NUM_LIT> ; op = mem ; }


<s> if ( return_address_on_stack ) { insn = emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( - <NUM_LIT> - pretend ) ) ) ; pretend = <NUM_LIT> ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; mem = gen_rtx_MEM ( SImode , stack_pointer_rtx ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( mem , gen_raw_REG ( SImode , CRIS_SRP_REGNUM ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; framesize += <NUM_LIT> ; } if ( frame_pointer_needed ) { insn = emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( - <NUM_LIT> - pretend ) ) ) ; pretend = <NUM_LIT> ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; mem = gen_rtx_MEM ( SImode , stack_pointer_rtx ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( mem , hard_frame_pointer_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; framesize += <NUM_LIT> ; } size += pretend ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( cris_reg_saved_in_regsave_area ( regno ) ) { n_movem_regs ++ ; if ( regno == last_movem_reg + <NUM_LIT> ) last_movem_reg = regno ; else { if ( last_movem_reg != - <NUM_LIT> ) { int n_saved = ( n_movem_regs == <NUM_LIT> ) ? <NUM_LIT> : last_movem_reg + <NUM_LIT> ; if ( ( last_movem_reg + <NUM_LIT> ) * <NUM_LIT> + size >= <NUM_LIT> && ( last_movem_reg + <NUM_LIT> ) * <NUM_LIT> + size <= <NUM_LIT> && cris_cpu_version >= CRIS_CPU_SVINTO && n_saved > <NUM_LIT> && TARGET_SIDE_EFFECT_PREFIXES ) { mem = gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , - ( n_saved * <NUM_LIT> + size ) ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = cris_emit_movem_store ( mem , GEN_INT ( n_saved ) , - ( n_saved * <NUM_LIT> + size ) , true ) ; } else { insn = emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( - ( n_saved * <NUM_LIT> + size ) ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; mem = gen_rtx_MEM ( SImode , stack_pointer_rtx ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = cris_emit_movem_store ( mem , GEN_INT ( n_saved ) , <NUM_LIT> , true ) ; } framesize += n_saved * <NUM_LIT> + size ; last_movem_reg = - <NUM_LIT> ; size = <NUM_LIT> ; } insn = emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( - <NUM_LIT> - size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> last_movem_reg = - <NUM_LIT> ; size = <NUM_LIT> ; } insn = emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( - <NUM_LIT> - size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; mem = gen_rtx_MEM ( SImode , stack_pointer_rtx ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = emit_move_insn ( mem , gen_raw_REG ( SImode , regno ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; framesize += <NUM_LIT> + size ; size = <NUM_LIT> ; } } } if ( last_movem_reg != - <NUM_LIT> ) { int n_saved = ( n_movem_regs == <NUM_LIT> ) ? <NUM_LIT> : last_movem_reg + <NUM_LIT> ; if ( ( last_movem_reg + <NUM_LIT> ) * <NUM_LIT> + size >= <NUM_LIT> && ( last_movem_reg + <NUM_LIT> ) * <NUM_LIT> + size <= <NUM_LIT> && cris_cpu_version >= CRIS_CPU_SVINTO && n_saved > <NUM_LIT> && TARGET_SIDE_EFFECT_PREFIXES ) { mem = gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , - ( n_saved * <NUM_LIT> + size ) ) ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = cris_emit_movem_store ( mem , GEN_INT ( n_saved ) , - ( n_saved * <NUM_LIT> + size ) , true ) ; } else { insn = emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( - ( n_saved * <NUM_LIT> + size ) ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; mem = gen_rtx_MEM ( SImode , stack_pointer_rtx ) ; set_mem_alias_set ( mem , get_frame_alias_set ( ) ) ; insn = cris_emit_movem_store ( mem , GEN_INT ( n_saved ) , <NUM_LIT> , true ) ; } framesize += n_saved * <NUM_LIT> + size ; if ( cfoa_size ) { insn = emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( - cfoa_size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; framesize += cfoa_size ; } } else if ( ( size + cfoa_size ) > <NUM_LIT> ) { insn = emit_insn ( gen_add2_insn ( stack_pointer_rtx , GEN_INT ( - ( cfoa_size + size ) ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; framesize += size + cfoa_size ; } if ( cris_max_stackframe && framesize > cris_max_stackframe ) warning ( <NUM_LIT> , <STR_LIT> , framesize ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = framesize ;


<s> CRIS_ASSERT ( cfun -> machine -> return_type != CRIS_RETINSN_JUMP || on_stack ) ;


<s> int cris_fatal ( char * arg ) { internal_error ( arg ) ; return <NUM_LIT> ;


<s> static void cris_file_end ( void ) {

if ( TARGET_LINUX && trampolines_created ) file_end_indicate_exec_stack ( ) ;


<s> targetm . asm_file_start_app_off = ! ( TARGET_PDEBUG || flag_print_asm_name ) ; default_file_start ( ) ;


<s> static void cris_file_start ( void ) {

targetm . asm_file_start_app_off = ! ( TARGET_PDEBUG || flag_print_asm_name ) ;


<s> bool cris_frame_pointer_required ( void ) { return ! crtl -> sp_is_unchanging ;


<s> static rtx cris_function_arg ( cumulative_args_t ca , const function_arg_info & arg ) {

return cris_function_arg_1 ( ca , arg , false ) ;


<s> const CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ; if ( ( ! incoming || arg . named ) && ca -> regs < CRIS_MAX_ARGS_IN_REGS ) return gen_rtx_REG ( arg . mode , CRIS_FIRST_ARG_REG + ca -> regs ) ; else return NULL_RTX ;


<s> static rtx cris_function_arg_1 ( cumulative_args_t ca_v , const function_arg_info & arg , bool incoming ) { const CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ;

if ( ( ! incoming || arg . named ) && ca -> regs < CRIS_MAX_ARGS_IN_REGS ) return gen_rtx_REG ( arg . mode , CRIS_FIRST_ARG_REG + ca -> regs ) ;


<s> static void cris_function_arg_advance ( cumulative_args_t ca_v , const function_arg_info & arg ) {

CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ;


<s> static rtx cris_function_incoming_arg ( cumulative_args_t ca , const function_arg_info & arg ) { return cris_function_arg_1 ( ca , arg , true ) ;


<s> int regno_inc = - <NUM_LIT> ; if ( GET_CODE ( srcreg ) == POST_INC ) srcreg = XEXP ( srcreg , <NUM_LIT> ) ; CRIS_ASSERT ( REG_P ( srcreg ) ) ; if ( nregs == <NUM_LIT> ) return gen_movsi ( gen_rtx_REG ( SImode , <NUM_LIT> ) , src ) ; vec = rtvec_alloc ( nregs + ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == POST_INC ) ) ; if ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == POST_INC ) { RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( srcreg , plus_constant ( Pmode , srcreg , nregs * <NUM_LIT> ) ) ; eltno ++ ; } src = replace_equiv_address ( src , srcreg ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_SET ( gen_rtx_REG ( SImode , regno ) , src ) ; regno += regno_inc ; for ( i = <NUM_LIT> ; i < nregs ; i ++ , eltno ++ ) { RTVEC_ELT ( vec , eltno ) = gen_rtx_SET ( gen_rtx_REG ( SImode , regno ) , adjust_address_nv ( src , SImode , i * <NUM_LIT> ) ) ; regno += regno_inc ; }

return gen_rtx_PARALLEL ( VOIDmode , vec ) ;


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

return ( ( mode == CCmode || regno != CRIS_CC0_REGNUM ) && ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD || regno != CRIS_MOF_REGNUM ) ) ;


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

return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ;


<s> static inline bool cris_index_p ( const_rtx x , bool strict ) { return ( REG_P ( x ) && reg_ok_for_index_p ( x , strict ) ) ;


<s> static inline bool cris_index_p ( const_rtx x , bool strict ) {

return ( REG_P ( x ) && reg_ok_for_index_p ( x , strict ) ) ;


<s> bool return_address_on_stack = cris_return_address_on_stack ( ) ; int ap_fp_offset = <NUM_LIT> + ( return_address_on_stack ? <NUM_LIT> : <NUM_LIT> ) ; if ( fromreg == ARG_POINTER_REGNUM && toreg == HARD_FRAME_POINTER_REGNUM ) return ap_fp_offset ;

if ( fromreg == FRAME_POINTER_REGNUM && toreg == STACK_POINTER_REGNUM ) return fp_sp_offset ;


<s> static int cris_initial_frame_pointer_offset ( void ) { int regno ; int offs = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( cris_reg_saved_in_regsave_area ( regno ) ) offs += <NUM_LIT> ; offs += get_frame_size ( ) ; offs += crtl -> outgoing_args_size ; if ( TARGET_STACK_ALIGN ) offs = TARGET_ALIGN_BY_32 ? ( offs + <NUM_LIT> ) & ~ <NUM_LIT> : ( offs + <NUM_LIT> ) & ~ <NUM_LIT> ; return offs ;


<s> set_optab_libfunc ( umod_optab , SImode , <STR_LIT> ) ; if ( TARGET_ATOMICS_MAY_CALL_LIBFUNCS ) { set_optab_libfunc ( sync_compare_and_swap_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( sync_compare_and_swap_optab , HImode , <STR_LIT> ) ;


<s> return ggc_cleared_alloc < machine_function > ( ) ;


<s> else if ( CONSTANT_P ( x ) ) return true ; else if ( GET_CODE ( x ) == PLUS ) { x1 = XEXP ( x , <NUM_LIT> ) ; x2 = XEXP ( x , <NUM_LIT> ) ; if ( ( cris_base_p ( x1 , strict ) && CONSTANT_P ( x2 ) ) || ( cris_base_p ( x2 , strict ) && CONSTANT_P ( x1 ) ) || ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD && ( ( cris_base_p ( x1 , strict ) && cris_bdap_index_p ( x2 , strict ) ) || ( cris_base_p ( x2 , strict ) && cris_bdap_index_p ( x1 , strict ) ) || ( cris_base_p ( x1 , strict ) && cris_biap_index_p ( x2 , strict ) ) || ( cris_base_p ( x2 , strict ) && cris_biap_index_p ( x1 , strict ) ) ) ) ) return true ;


<s> bool cris_legitimate_address_p ( machine_mode mode , rtx x , bool strict ) { const_rtx x1 , x2 ; if ( cris_base_or_autoincr_p ( x , strict ) ) return true ; else if ( CONSTANT_P ( x ) ) return true ; else if ( GET_CODE ( x ) == PLUS ) { x1 = XEXP ( x , <NUM_LIT> ) ; x2 = XEXP ( x , <NUM_LIT> ) ; if ( ( cris_base_p ( x1 , strict ) && CONSTANT_P ( x2 ) ) || ( cris_base_p ( x2 , strict ) && CONSTANT_P ( x1 ) ) || ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD && ( ( cris_base_p ( x1 , strict ) && cris_bdap_index_p ( x2 , strict ) ) || ( cris_base_p ( x2 , strict ) && cris_bdap_index_p ( x1 , strict ) ) || ( cris_base_p ( x1 , strict ) && cris_biap_index_p ( x2 , strict ) ) || ( cris_base_p ( x2 , strict ) && cris_biap_index_p ( x1 , strict ) ) ) ) ) return true ; } else if ( MEM_P ( x ) ) { if ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD && cris_base_or_autoincr_p ( XEXP ( x , <NUM_LIT> ) , strict ) ) return true ;


<s> t = cris_symbol_type_of ( x ) ; return t == cris_no_symbol || t == cris_offsettable_symbol || t == cris_unspec ;


<s> return t == cris_no_symbol || t == cris_offsettable_symbol || t == cris_unspec ;


<s> int cris_legitimate_pic_operand ( rtx x ) { return cris_valid_pic_const ( x , true ) ;


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

return gen_rtx_REG ( mode , CRIS_FIRST_ARG_REG ) ;


<s> for ( unsigned i = <NUM_LIT> , n = outputs . length ( ) ; i < n ; ++ i ) if ( reg_overlap_mentioned_p ( mof_reg , outputs [ i ] ) ) return NULL ; for ( unsigned i = <NUM_LIT> , n = inputs . length ( ) ; i < n ; ++ i ) if ( reg_overlap_mentioned_p ( mof_reg , inputs [ i ] ) ) return NULL ;


<s> static int cris_memory_move_cost ( machine_mode mode , reg_class_t rclass ATTRIBUTE_UNUSED , bool in ATTRIBUTE_UNUSED ) { if ( mode == QImode || mode == HImode ) return <NUM_LIT> ; else return <NUM_LIT> ;


<s> src_addr = XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ; if ( GET_CODE ( elt ) != SET || ! REG_P ( SET_DEST ( elt ) ) || GET_MODE ( SET_DEST ( elt ) ) != SImode || REGNO ( SET_DEST ( elt ) ) != regno || ! MEM_P ( SET_SRC ( elt ) ) || GET_MODE ( SET_SRC ( elt ) ) != SImode || ! memory_address_p ( SImode , src_addr ) ) return false ; for ( setno = <NUM_LIT> ; i < XVECLEN ( op , <NUM_LIT> ) ; setno ++ , i ++ ) { rtx elt = XVECEXP ( op , <NUM_LIT> , i ) ; regno += regno_dir ; if ( GET_CODE ( elt ) != SET || ! REG_P ( SET_DEST ( elt ) ) || GET_MODE ( SET_DEST ( elt ) ) != SImode || REGNO ( SET_DEST ( elt ) ) != regno || ! MEM_P ( SET_SRC ( elt ) ) || GET_MODE ( SET_SRC ( elt ) ) != SImode || GET_CODE ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ) != PLUS || ! rtx_equal_p ( XEXP ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) , <NUM_LIT> ) , src_addr ) || ! CONST_INT_P ( XEXP ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) , <NUM_LIT> ) ) || INTVAL ( XEXP ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) , <NUM_LIT> ) ) != setno * <NUM_LIT> ) return false ; } return true ;


<s> else cc_status . flags = CC_Z_IN_NOT_N ; } else if ( GET_CODE ( SET_SRC ( exp ) ) == COMPARE ) { if ( ! REG_P ( XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) ) && XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) != const0_rtx ) cc_status . flags = CC_REVERSED ; cc_status . value2 = gen_rtx_MINUS ( GET_MODE ( SET_SRC ( exp ) ) , XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) , XEXP ( SET_SRC ( exp ) , <NUM_LIT> ) ) ; } return ; } else if ( REG_P ( SET_DEST ( exp ) ) || ( GET_CODE ( SET_DEST ( exp ) ) == STRICT_LOW_PART && REG_P ( XEXP ( SET_DEST ( exp ) , <NUM_LIT> ) ) ) ) { if ( GET_MODE_SIZE ( GET_MODE ( SET_DEST ( exp ) ) ) > UNITS_PER_WORD || GET_MODE_CLASS ( GET_MODE ( SET_DEST ( exp ) ) ) == MODE_FLOAT ) { if ( GET_MODE ( SET_DEST ( exp ) ) == DImode && ( GET_CODE ( SET_SRC ( exp ) ) == PLUS || GET_CODE ( SET_SRC ( exp ) ) == MINUS ) ) { CC_STATUS_INIT ; cc_status . value1 = SET_DEST ( exp ) ; cc_status . value2 = SET_SRC ( exp ) ; if ( cris_reg_overlap_mentioned_p ( cc_status . value1 , cc_status . value2 ) ) cc_status . value2 = <NUM_LIT> ; cc_status . flags |= CC_NO_OVERFLOW ; return ; } } else if ( SET_SRC ( exp ) == const0_rtx || ( REG_P ( SET_SRC ( exp ) ) && ( REGNO ( SET_SRC ( exp ) ) > CRIS_LAST_GENERAL_REGISTER ) ) || ( TARGET_V32 && REG_P ( SET_DEST ( exp ) ) && satisfies_constraint_I ( SET_SRC ( exp ) ) ) ) { if ( cc_status . value1 && modified_in_p ( cc_status . value1 , insn ) ) cc_status . value1 = <NUM_LIT> ; if ( cc_status . value2 && modified_in_p ( cc_status . value2 , insn ) ) cc_status . value2 = <NUM_LIT> ; return ; } else { CC_STATUS_INIT ; cc_status . value1 = SET_DEST ( exp ) ; cc_status . value2 = SET_SRC ( exp ) ; if ( cris_reg_overlap_mentioned_p ( cc_status . value1 , cc_status . value2 ) ) cc_status . value2 = <NUM_LIT> ;

if ( GET_CODE ( SET_SRC ( exp ) ) == PLUS || GET_CODE ( SET_SRC ( exp ) ) == MINUS || GET_CODE ( SET_SRC ( exp ) ) == NEG ) cc_status . flags |= CC_NO_OVERFLOW ;


<s> } return ; case CC_CLOBBER : CC_STATUS_INIT ; return ; case CC_REV : case CC_NOOV32 : case CC_NORMAL : cris_normal_notice_update_cc ( exp , insn ) ; if ( attrval == CC_NOOV32 && TARGET_V32 ) cc_status . flags |= CC_NO_OVERFLOW ; return ; default : internal_error ( <STR_LIT> ) ; }


<s> static void cris_operand_lossage ( const char * msgid , rtx op ) { debug_rtx ( op ) ;

output_operand_lossage ( <STR_LIT> , msgid ) ;


if ( strcmp ( <STR_LIT> , cris_tune_str ) == <NUM_LIT> ) cris_tune = <NUM_LIT> ;


<s> return <STR_LIT> ; case IOR : return <STR_LIT> ; case XOR : return <STR_LIT> ; case NOT : return <STR_LIT> ; case ASHIFT : return <STR_LIT> ; case LSHIFTRT : return <STR_LIT> ; case ASHIFTRT : return <STR_LIT> ; case UMIN : cris_output_insn_is_bound = <NUM_LIT> ; return <STR_LIT> ;


operands [ n ] = operands [ n + <NUM_LIT> ] ;


<s> operands [ n ] = operands [ n + <NUM_LIT> ] ; operands [ n + <NUM_LIT> ] = tem ; }


<s> in_code ++ ; output_addr_const ( file , x ) ; in_code -- ;


<s> case CRIS_UNSPEC_PLT_GOTREL : gcc_assert ( ! TARGET_V32 ) ; fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_GOTREL : gcc_assert ( ! TARGET_V32 ) ; fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_GOTREAD : if ( flag_pic == <NUM_LIT> ) fprintf ( file , <STR_LIT> ) ; else fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_PLTGOTREAD : if ( flag_pic == <NUM_LIT> ) fprintf ( file , CRIS_GOTPLT_SUFFIX <STR_LIT> ) ; else fprintf ( file , CRIS_GOTPLT_SUFFIX ) ;


<s> fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_GOTREL : gcc_assert ( ! TARGET_V32 ) ; fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_GOTREAD : if ( flag_pic == <NUM_LIT> ) fprintf ( file , <STR_LIT> ) ; else fprintf ( file , <STR_LIT> ) ; break ; case CRIS_UNSPEC_PLTGOTREAD : if ( flag_pic == <NUM_LIT> ) fprintf ( file , CRIS_GOTPLT_SUFFIX <STR_LIT> ) ; else fprintf ( file , CRIS_GOTPLT_SUFFIX ) ; break ; default : gcc_unreachable ( ) ; } return true ; default :


<s> return ( targetm . calls . must_pass_in_stack ( arg ) || CRIS_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) > <NUM_LIT> ) ;


<s> static bool cris_pass_by_reference ( cumulative_args_t , const function_arg_info & arg ) { return ( targetm . calls . must_pass_in_stack ( arg ) || CRIS_FUNCTION_ARG_SIZE ( arg . mode , arg . type ) > <NUM_LIT> ) ;


<s> rtx reg = XEXP ( src , <NUM_LIT> ) ; rtx prev_dest = SET_DEST ( prev_set ) ; rtx prev_src = SET_SRC ( prev_set ) ; bool src_same = rtx_equal_p ( prev_src , reg ) ; if ( REG_P ( prev_dest ) && ! reg_set_p ( reg , prev_src ) && ! reg_set_between_p ( reg , prev_cc_outer , outer_insn ) && ( src_same || rtx_equal_p ( prev_dest , reg ) ) ) { machine_mode ccmode = GET_MODE ( src ) ; rtx modeadjusted_dccr = ( ccmode == CCmode ? dccr : gen_rtx_REG ( CCmode , CRIS_CC0_REGNUM ) ) ; rtx compare = ( src_same ? pat : gen_rtx_SET ( modeadjusted_dccr , gen_rtx_COMPARE ( ccmode , copy_rtx ( prev_src ) , const0_rtx ) ) ) ;

validate_change ( prev_cc_setter , & XVECEXP ( PATTERN ( prev_cc_setter ) , <NUM_LIT> , <NUM_LIT> ) , compare , true ) ;


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


<s> static HOST_WIDE_INT cris_preferred_minimum_alignment ( void ) { if ( ! TARGET_CONST_ALIGN ) return <NUM_LIT> ; if ( TARGET_ALIGN_BY_32 ) return <NUM_LIT> ;


<s> static reg_class_t cris_preferred_reload_class ( rtx x , reg_class_t rclass ) { if ( rclass != MOF_REGS && rclass != MOF_SRP_REGS && rclass != SRP_REGS && rclass != CC0_REGS && rclass != SPECIAL_REGS ) return GENERAL_REGS ; if ( GET_CODE ( x ) == PLUS && ! reg_class_subset_p ( rclass , GENERAL_REGS ) ) return NO_REGS ;

if ( satisfies_constraint_P ( x ) && ! reg_class_subset_p ( rclass , GENERAL_REGS ) ) return NO_REGS ;


<s> static void cris_print_index ( rtx index , FILE * file ) { if ( ! CONST_INT_P ( index ) || INTVAL ( index ) >= <NUM_LIT> ) putc ( '+' , file ) ; if ( REG_P ( index ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( index ) ] ) ; else if ( CONSTANT_P ( index ) ) cris_output_addr_const ( file , index ) ; else if ( GET_CODE ( index ) == MULT ) { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( index , <NUM_LIT> ) ) ] ) ; putc ( INTVAL ( XEXP ( index , <NUM_LIT> ) ) == <NUM_LIT> ? 'w' : 'd' , file ) ; } else if ( GET_CODE ( index ) == SIGN_EXTEND && MEM_P ( XEXP ( index , <NUM_LIT> ) ) ) { rtx inner = XEXP ( index , <NUM_LIT> ) ; rtx inner_inner = XEXP ( inner , <NUM_LIT> ) ; if ( GET_CODE ( inner_inner ) == POST_INC ) { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( inner_inner , <NUM_LIT> ) ) ] ) ; putc ( GET_MODE ( inner ) == HImode ? 'w' : 'b' , file ) ;


<s> if ( GET_CODE ( inner_inner ) == POST_INC ) { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( inner_inner , <NUM_LIT> ) ) ] ) ; putc ( GET_MODE ( inner ) == HImode ? 'w' : 'b' , file ) ; } else { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( inner_inner ) ] ) ; putc ( GET_MODE ( inner ) == HImode ? 'w' : 'b' , file ) ; } } else if ( MEM_P ( index ) ) { rtx inner = XEXP ( index , <NUM_LIT> ) ; if ( GET_CODE ( inner ) == POST_INC ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( inner , <NUM_LIT> ) ) ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( inner ) ] ) ; }

else cris_operand_lossage ( <STR_LIT> , index ) ;


<s> cris_print_index ( x1 , file ) ; } else LOSE_AND_RETURN ( <STR_LIT> , x ) ; } else if ( MEM_P ( x ) ) { putc ( '[' , file ) ; cris_print_base ( XEXP ( x , <NUM_LIT> ) , file ) ; putc ( ']' , file ) ; } else LOSE_AND_RETURN ( <STR_LIT> , x ) ; putc ( ']' , file ) ;


<s> machine_mode cris_promote_function_mode ( const_tree type ATTRIBUTE_UNUSED , machine_mode mode , int * punsignedp ATTRIBUTE_UNUSED , const_tree fntype ATTRIBUTE_UNUSED , int for_return ) { if ( for_return == <NUM_LIT> ) return mode ;

return CRIS_PROMOTED_MODE ( mode , * punsignedp , type ) ;


<s> break ; case GT : if ( op1 == constm1_rtx ) code = GE ; break ; case GEU : if ( op1 == const1_rtx ) code = NE ; break ; case LTU : if ( op1 == const1_rtx ) code = EQ ; break ; case GTU : if ( op1 == const0_rtx ) code = NE ; break ; case LEU : if ( op1 == const0_rtx ) code = EQ ; break ; default : break ; }


<s> static int cris_register_move_cost ( machine_mode mode ATTRIBUTE_UNUSED , reg_class_t from , reg_class_t to ) { if ( reg_classes_intersect_p ( from , SPECIAL_REGS ) && reg_classes_intersect_p ( to , SPECIAL_REGS ) ) return <NUM_LIT> ;

if ( reg_classes_intersect_p ( from , SPECIAL_REGS ) || reg_classes_intersect_p ( to , SPECIAL_REGS ) ) return <NUM_LIT> ;


<s> if ( GET_CODE ( in ) == STRICT_LOW_PART ) in = XEXP ( in , <NUM_LIT> ) ;

return reg_overlap_mentioned_p ( x , in ) ;


<s> static int cris_reg_overlap_mentioned_p ( rtx x , rtx in ) { if ( GET_CODE ( in ) == STRICT_LOW_PART ) in = XEXP ( in , <NUM_LIT> ) ; return reg_overlap_mentioned_p ( x , in ) ;


<s> return ( ( ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) ) && ( regno != HARD_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) && regno != CRIS_SRP_REGNUM ) || ( crtl -> calls_eh_return && ( regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) || regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) || regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) || regno == EH_RETURN_DATA_REGNO ( <NUM_LIT> ) ) ) ;


<s> op1p = & XEXP ( x , <NUM_LIT> ) ; if ( ! REG_P ( op1 ) ) return false ; if ( GET_CODE ( op0 ) == SIGN_EXTEND && MEM_P ( XEXP ( op0 , <NUM_LIT> ) ) ) { rtx op00 = XEXP ( op0 , <NUM_LIT> ) ; rtx op000 = XEXP ( op00 , <NUM_LIT> ) ; rtx * op000p = & XEXP ( op00 , <NUM_LIT> ) ;

if ( ( GET_MODE ( op00 ) == HImode || GET_MODE ( op00 ) == QImode ) && ( REG_P ( op000 ) || ( GET_CODE ( op000 ) == POST_INC && REG_P ( XEXP ( op000 , <NUM_LIT> ) ) ) ) ) {


<s> return df_regs_ever_live_p ( CRIS_SRP_REGNUM ) || cfun -> machine -> needs_return_address_on_stack ;


<s> bool cris_return_address_on_stack ( void ) {

return df_regs_ever_live_p ( CRIS_SRP_REGNUM ) || cfun -> machine -> needs_return_address_on_stack ;


<s> bool cris_return_address_on_stack_for_return ( void ) { return cfun -> machine -> return_type == CRIS_RETINSN_RET ? false : cris_return_address_on_stack ( ) ;


<s> return cfun -> machine -> return_type == CRIS_RETINSN_RET ? false : cris_return_address_on_stack ( ) ;


<s> rtx cris_return_addr_rtx ( int count , rtx frameaddr ATTRIBUTE_UNUSED ) { cfun -> machine -> needs_return_address_on_stack = <NUM_LIT> ;

return count == <NUM_LIT> ? gen_rtx_MEM ( Pmode , plus_constant ( Pmode , virtual_incoming_args_rtx , - <NUM_LIT> ) ) : NULL_RTX ;


<s> case UMOD : case DIV : if ( ! CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) || exact_log2 ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return false ; case AND : if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ! CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ! satisfies_constraint_I ( XEXP ( x , <NUM_LIT> ) ) ) { * total = ( rtx_cost ( XEXP ( x , <NUM_LIT> ) , mode , ( enum rtx_code ) outer_code , opno , speed ) + <NUM_LIT> + <NUM_LIT> * GET_MODE_NUNITS ( mode ) ) ; return true ; } return false ; case ZERO_EXTRACT : if ( reload_completed ) { if ( outer_code != COMPARE ) return false ; } else switch ( outer_code ) { case EQ : case NE : case LT : case LTU : case LE : case LEU : case GT : case GTU : case GE : case GEU : break ; default : return false ; } case ZERO_EXTEND : case SIGN_EXTEND : * total = rtx_cost ( XEXP ( x , <NUM_LIT> ) , VOIDmode , ( enum rtx_code ) outer_code , opno , speed ) ; return true ; default : return false ; }


<s> gcc_assert ( reload_completed ) ; if ( GET_MODE_CLASS ( GET_MODE ( x ) ) != MODE_INT || y != const0_rtx ) return CCmode ;

if ( op == EQ || op == NE || op == GTU || op == LEU || op == LT || op == GE ) return CC_NZmode ;


<s> if ( op == EQ || op == NE || op == GTU || op == LEU || op == LT || op == GE ) return CC_NZmode ; gcc_assert ( op == GEU || op == LTU || op == GT || op == LE ) ;


<s> static void cris_setup_incoming_varargs ( cumulative_args_t ca_v , const function_arg_info & , int * pretend_arg_size , int second_time ) { CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ; if ( ca -> regs < CRIS_MAX_ARGS_IN_REGS ) { int stdarg_regs = CRIS_MAX_ARGS_IN_REGS - ca -> regs ; cfun -> machine -> stdarg_regs = stdarg_regs ; * pretend_arg_size = stdarg_regs * <NUM_LIT> ; } if ( TARGET_PDEBUG ) fprintf ( asm_out_file , <STR_LIT> , ca -> regs , * pretend_arg_size , second_time ) ;


<s> static void cris_setup_incoming_varargs ( cumulative_args_t ca_v , const function_arg_info & , int * pretend_arg_size , int second_time ) { CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ; if ( ca -> regs < CRIS_MAX_ARGS_IN_REGS ) { int stdarg_regs = CRIS_MAX_ARGS_IN_REGS - ca -> regs ; cfun -> machine -> stdarg_regs = stdarg_regs ; * pretend_arg_size = stdarg_regs * <NUM_LIT> ;


<s> if ( rtx_equal_p ( ops [ lreg ] , reg_rtx ) && CONST_INT_P ( val_rtx ) && ( INTVAL ( val_rtx ) <= <NUM_LIT> && INTVAL ( val_rtx ) >= - <NUM_LIT> ) ) return <NUM_LIT> ; if ( CONSTANT_P ( val_rtx ) ) return <NUM_LIT> ; if ( MEM_P ( val_rtx ) && cris_base_or_autoincr_p ( XEXP ( val_rtx , <NUM_LIT> ) , reload_in_progress || reload_completed ) ) return <NUM_LIT> ; if ( GET_CODE ( val_rtx ) == SIGN_EXTEND && MEM_P ( XEXP ( val_rtx , <NUM_LIT> ) ) && cris_base_or_autoincr_p ( XEXP ( XEXP ( val_rtx , <NUM_LIT> ) , <NUM_LIT> ) , reload_in_progress || reload_completed ) ) return <NUM_LIT> ; return <NUM_LIT> ; } else if ( code == MULT || ( code == PLUS && cris_base_p ( val_rtx , reload_in_progress || reload_completed ) ) ) { if ( rtx_equal_p ( ops [ lreg ] , reg_rtx ) || ( mult == <NUM_LIT> && rtx_equal_p ( ops [ lreg ] , val_rtx ) ) ) return <NUM_LIT> ; if ( mult != <NUM_LIT> && mult != <NUM_LIT> && mult != <NUM_LIT> ) return <NUM_LIT> ; if ( ! cris_base_p ( reg_rtx , reload_in_progress || reload_completed ) ) return <NUM_LIT> ;


<s> unsigned int regno ; unsigned int reglimit = STACK_POINTER_REGNUM ;

if ( ! reload_completed || frame_pointer_needed || get_frame_size ( ) != <NUM_LIT> || crtl -> args . pretend_args_size || crtl -> args . size || crtl -> outgoing_args_size || crtl -> calls_eh_return || ! TARGET_PROLOGUE_EPILOGUE ) return false ;


<s> rtx words [ <NUM_LIT> ] ; split_double ( src , & words [ <NUM_LIT> ] , & words [ <NUM_LIT> ] ) ; emit_move_insn ( operand_subword ( dest , <NUM_LIT> , TRUE , mode ) , words [ <NUM_LIT> ] ) ; emit_move_insn ( operand_subword ( dest , <NUM_LIT> , TRUE , mode ) , words [ <NUM_LIT> ] ) ; } else if ( MEM_P ( src ) ) { rtx addr = XEXP ( src , <NUM_LIT> ) ; int reverse = ( refers_to_regno_p ( dregno , addr ) != <NUM_LIT> ) ; if ( GET_CODE ( addr ) == POST_INC ) { rtx mem ; rtx insn ; mem = change_address ( src , SImode , addr ) ; insn = emit_move_insn ( operand_subword ( dest , <NUM_LIT> , TRUE , mode ) , mem ) ; if ( GET_CODE ( XEXP ( mem , <NUM_LIT> ) ) == POST_INC ) REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) , REG_NOTES ( insn ) ) ; mem = copy_rtx ( mem ) ; insn = emit_move_insn ( operand_subword ( dest , <NUM_LIT> , TRUE , mode ) , mem ) ; if ( GET_CODE ( XEXP ( mem , <NUM_LIT> ) ) == POST_INC ) REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) , REG_NOTES ( insn ) ) ; } else { if ( side_effects_p ( addr ) ) fatal_insn ( <STR_LIT> , addr ) ; emit_move_insn ( operand_subword ( dest , reverse , TRUE , mode ) , change_address ( src , SImode , plus_constant ( Pmode , addr , reverse * UNITS_PER_WORD ) ) ) ; emit_move_insn ( operand_subword ( dest , ! reverse , TRUE , mode ) , change_address ( src , SImode , plus_constant ( Pmode , addr , ( ! reverse ) * UNITS_PER_WORD ) ) ) ; } }


<s> static HOST_WIDE_INT cris_static_rtx_alignment ( machine_mode mode ) { return MAX ( cris_preferred_minimum_alignment ( ) , GET_MODE_ALIGNMENT ( mode ) ) ;


<s> static rtx cris_struct_value_rtx ( tree fntype ATTRIBUTE_UNUSED , int incoming ATTRIBUTE_UNUSED ) {

return gen_rtx_REG ( Pmode , CRIS_STRUCT_VALUE_REGNUM ) ;


<s> case LABEL_REF : return flag_pic ? cris_rel_symbol : cris_offsettable_symbol ; case CONST : return cris_symbol_type_of ( XEXP ( x , <NUM_LIT> ) ) ; case PLUS : case MINUS : { enum cris_symbol_type t1 = cris_symbol_type_of ( XEXP ( x , <NUM_LIT> ) ) ; enum cris_symbol_type t2 = cris_symbol_type_of ( XEXP ( x , <NUM_LIT> ) ) ; gcc_assert ( t1 == cris_no_symbol || t2 == cris_no_symbol ) ;


<s> rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; rtx mem ; emit_block_move ( m_tramp , assemble_trampoline_template ( ) , GEN_INT ( TRAMPOLINE_SIZE ) , BLOCK_OP_NORMAL ) ;

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


<s> emit_move_insn ( mem , chain_value ) ; mem = adjust_address ( m_tramp , SImode , <NUM_LIT> ) ;


<s> x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC && ( XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == CRIS_UNSPEC_GOTREL || XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == CRIS_UNSPEC_PCREL ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == UNSPEC ) switch ( XINT ( x , <NUM_LIT> ) ) { case CRIS_UNSPEC_PLT_PCREL : case CRIS_UNSPEC_PCREL : return ! any_operand ; case CRIS_UNSPEC_PLT_GOTREL :


<s> return optimize > <NUM_LIT> && flag_delayed_branch && flag_compare_elim_after_reload ;


<s> const char * Get_mode ( rtx x ) { return GET_MODE_NAME ( GET_MODE ( x ) ) ;


return GET_RTX_LENGTH ( GET_CODE ( x ) ) ;


<s> rtl_opt_pass * make_pass_cris_postdbr_cmpelim ( gcc :: context * ctxt ) {

return new pass_cris_postdbr_cmpelim ( ctxt ) ;


<s> return new pass_cris_postdbr_cmpelim ( ctxt ) ;


<s> rtx Next_insn ( rtx insn ) { return NEXT_INSN ( insn ) ;


<s> pass_cris_postdbr_cmpelim ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_cris_postdbr_cmpelim , ctxt ) {


<s> static inline bool reg_ok_for_base_p ( const_rtx x , bool strict ) { return ( ( ! strict && ! HARD_REGISTER_P ( x ) ) || REGNO_OK_FOR_BASE_P ( REGNO ( x ) ) ) ;


<s> static inline bool reg_ok_for_index_p ( const_rtx x , bool strict ) { return reg_ok_for_base_p ( x , strict ) ;


<s> static inline bool reg_ok_for_index_p ( const_rtx x , bool strict ) {

return reg_ok_for_base_p ( x , strict ) ;


<s> rtx Xvecexp ( rtx x , int n , int m ) {