<s> static int c6x_adjust_cost ( rtx_insn * insn , rtx link , rtx_insn * dep_insn , int cost ) { enum attr_type insn_type = TYPE_UNKNOWN , dep_insn_type = TYPE_UNKNOWN ; int dep_insn_code_number , insn_code_number ; int shadow_bonus = <NUM_LIT> ; enum reg_note kind ; dep_insn_code_number = recog_memoized ( dep_insn ) ; insn_code_number = recog_memoized ( insn ) ; if ( dep_insn_code_number >= <NUM_LIT> ) dep_insn_type = get_attr_type ( dep_insn ) ; if ( insn_code_number >= <NUM_LIT> ) insn_type = get_attr_type ( insn ) ; kind = REG_NOTE_KIND ( link ) ; if ( kind == <NUM_LIT> ) { if ( dep_insn_type == TYPE_LOAD ) { rtx set = PATTERN ( dep_insn ) ; if ( GET_CODE ( set ) == COND_EXEC ) set = COND_EXEC_CODE ( set ) ; if ( GET_CODE ( set ) == UNSPEC ) cost = <NUM_LIT> ; else { gcc_assert ( GET_CODE ( set ) == SET ) ; if ( ! reg_overlap_mentioned_p ( SET_DEST ( set ) , PATTERN ( insn ) ) ) cost = <NUM_LIT> ; } } } if ( shadow_type_p ( insn_type ) ) shadow_bonus = <NUM_LIT> ; if ( kind != <NUM_LIT>


<s> cumulative_args_t cum ; HARD_REG_SET call_saved_regset ; tree parameter ; machine_mode mode ; tree type ; rtx parm_rtx ; int i ; INIT_CUMULATIVE_ARGS ( cum_v , NULL , NULL , <NUM_LIT> , <NUM_LIT> ) ; cum = pack_cumulative_args ( & cum_v ) ; COMPL_HARD_REG_SET ( call_saved_regset , call_used_reg_set ) ; for ( i = <NUM_LIT> ; i < call_expr_nargs ( call_expr ) ; i ++ ) { parameter = CALL_EXPR_ARG ( call_expr , i ) ; gcc_assert ( parameter ) ; if ( TREE_CODE ( parameter ) == ERROR_MARK ) return true ; type = TREE_TYPE ( parameter ) ; gcc_assert ( type ) ; mode = TYPE_MODE ( type ) ; gcc_assert ( mode ) ; if ( pass_by_reference ( & cum_v , mode , type , true )


<s> if ( TARGET_BIG_ENDIAN ) real_regno = regno + nregs - ( i + <NUM_LIT> ) ; else real_regno = regno + i ; XVECEXP ( p , <NUM_LIT> , i ) = gen_rtx_REG ( SImode , real_regno ) ; } return p


<s> call_insn = emit_call_insn ( call_insn ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( call_insn ) , gen_rtx_REG ( Pmode , REG_B3 ) ) ; } else { if ( retval == NULL_RTX ) call_insn = emit_call_insn ( call_insn ) ; else call_insn = emit_call_insn ( gen_rtx_SET ( GET_MODE ( retval ) , retval , call_insn ) ) ; } if ( flag_pic ) use_reg ( & CALL_INSN_FUNCTION_USAGE ( call_insn )


<s> off = - initial_offset + <NUM_LIT> - frame . padding0 ; mem = gen_frame_mem ( Pmode , stack_pointer_rtx ) ; added_already = <NUM_LIT> ; if ( frame_pointer_needed ) { rtx fp_reg = gen_rtx_REG ( SImode , REG_A15 ) ; rtx addr = gen_rtx_POST_MODIFY ( Pmode , stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) ; insn = emit_move_insn ( gen_frame_mem ( Pmode , addr ) , fp_reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; nsaved ++ ; insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; off -= <NUM_LIT> ; added_already = - <NUM_LIT> ; } emit_add_sp_const ( initial_offset - added_already , true ) ; if ( nsaved < frame . nregs ) { unsigned i ; for ( i = <NUM_LIT> ; i < N_SAVE_ORDER ; i ++ ) { int idx = N_SAVE_ORDER - i - <NUM_LIT> ; unsigned regno = reg_save_order [ idx ] ; rtx reg ; machine_mode save_mode = SImode ; if ( regno == REG_A15 && frame_pointer_needed ) continue ; if ( ! c6x_save_reg ( regno ) ) continue ; if ( TARGET_STDW && ( off & <NUM_LIT> ) == <NUM_LIT> && off <= <NUM_LIT> && ( regno & <NUM_LIT> ) == <NUM_LIT> && i + <NUM_LIT> < N_SAVE_ORDER && reg_save_order [ idx - <NUM_LIT> ] == regno - <NUM_LIT> && c6x_save_reg ( regno - <NUM_LIT> ) ) { save_mode = DImode ; regno -- ; i ++ ; } reg = gen_rtx_REG ( save_mode , regno ) ; off -= GET_MODE_SIZE ( save_mode ) ; insn = emit_move_insn ( adjust_address ( mem , save_mode , off ) , reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; nsaved += HARD_REGNO_NREGS ( regno , save_mode ) ; } } gcc_assert ( nsaved == frame . nregs ) ; emit_add_sp_const ( - frame . to_allocate - initial_offset , true ) ; if ( must_reload_pic_reg_p ( ) ) { if ( dsbt_decl == NULL ) { tree t ; t = build_index_type ( integer_one_node ) ; t = build_array_type ( integer_type_node ,


<s> if ( initial_offset < - <NUM_LIT> ) initial_offset = - frame . frame_pointer_offset - <NUM_LIT> ; if ( frame . to_allocate > <NUM_LIT> ) gcc_assert ( initial_offset != <NUM_LIT> ) ; off = - initial_offset + <NUM_LIT> - frame . padding0 ; mem = gen_frame_mem ( Pmode , stack_pointer_rtx ) ; added_already = <NUM_LIT> ; if ( frame_pointer_needed ) { rtx fp_reg = gen_rtx_REG ( SImode , REG_A15 ) ; rtx addr = gen_rtx_POST_MODIFY ( Pmode , stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) ; insn = emit_move_insn ( gen_frame_mem ( Pmode , addr ) , fp_reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; nsaved ++ ; insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; off -= <NUM_LIT> ; added_already = - <NUM_LIT> ; } emit_add_sp_const ( initial_offset - added_already , true ) ; if ( nsaved < frame . nregs ) { unsigned i ; for ( i = <NUM_LIT> ; i < N_SAVE_ORDER ; i ++ ) { int idx = N_SAVE_ORDER - i - <NUM_LIT> ; unsigned regno = reg_save_order [ idx ] ; rtx reg ; machine_mode save_mode = SImode ; if ( regno == REG_A15 && frame_pointer_needed ) continue ; if ( ! c6x_save_reg ( regno ) ) continue ; if ( TARGET_STDW && ( off & <NUM_LIT> ) == <NUM_LIT> && off <= <NUM_LIT> && ( regno & <NUM_LIT> ) == <NUM_LIT> && i + <NUM_LIT> < N_SAVE_ORDER && reg_save_order [ idx - <NUM_LIT> ] == regno - <NUM_LIT> && c6x_save_reg ( regno - <NUM_LIT> ) ) { save_mode = DImode ; regno -- ; i ++ ; } reg = gen_rtx_REG ( save_mode , regno ) ; off -= GET_MODE_SIZE ( save_mode ) ; insn = emit_move_insn ( adjust_address ( mem , save_mode , off ) , reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; nsaved += HARD_REGNO_NREGS ( regno , save_mode ) ; } } gcc_assert ( nsaved == frame . nregs ) ; emit_add_sp_const ( - frame . to_allocate - initial_offset , true ) ; if ( must_reload_pic_reg_p ( ) ) { if ( dsbt_decl == NULL ) { tree


<s> static rtx c6x_function_arg ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( cum -> count >= cum -> nregs ) return NULL_RTX ; if ( type ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( TARGET_BIG_ENDIAN && AGGREGATE_TYPE_P ( type ) ) { if ( size > <NUM_LIT> ) { rtx reg1 = gen_rtx_REG ( SImode , argument_registers [ cum -> count ] + <NUM_LIT> ) ; rtx reg2 = gen_rtx_REG ( SImode , argument_registers [ cum -> count ] ) ; rtvec vec = gen_rtvec ( <NUM_LIT> , gen_rtx_EXPR_LIST ( VOIDmode , reg1 , const0_rtx ) , gen_rtx_EXPR_LIST ( VOIDmode , reg2 , GEN_INT ( <NUM_LIT>


<s> if ( type ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( TARGET_BIG_ENDIAN && AGGREGATE_TYPE_P ( type ) ) { if ( size > <NUM_LIT> ) { rtx reg1 = gen_rtx_REG ( SImode , argument_registers [ cum -> count ] + <NUM_LIT> ) ; rtx reg2 = gen_rtx_REG ( SImode , argument_registers [ cum -> count ] ) ; rtvec vec = gen_rtvec ( <NUM_LIT> , gen_rtx_EXPR_LIST ( VOIDmode , reg1 , const0_rtx ) , gen_rtx_EXPR_LIST ( VOIDmode , reg2 , GEN_INT ( <NUM_LIT> ) ) ) ; return gen_rtx_PARALLEL ( mode , vec


<s> if ( TARGET_DSBT ) { struct cgraph_local_info * this_func ; if ( ! decl ) return false ; this_func = cgraph_node :: local_info ( current_function_decl ) ; return this_func -> local ; } return true


<s> } units = get_attr_units ( insn ) ; switch ( units ) { case UNITS_D : case UNITS_DL : case UNITS_DS : case UNITS_DLS : case UNITS_D_ADDR : return 'd' ; break ; case UNITS_L : case UNITS_LS : return


<s> rtx t = ( i & <NUM_LIT> ) ? t2 : t1 ; rtx v1 = gen_reg_rtx ( SImode ) ; rtx v2 = gen_reg_rtx ( SImode ) ; emit_move_insn ( v1 , mem ) ; if ( i < <NUM_LIT> ) emit_insn ( gen_ashlsi3 ( v2 , t , GEN_INT ( <NUM_LIT> ) ) ) ; else emit_insn ( gen_lshrsi3 ( v2 , t , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_andsi3 ( v2 , v2 , mask ) ) ; emit_insn ( gen_iorsi3 ( v2 , v2 , v1 ) ) ; emit_move_insn ( mem , v2 ) ; } tramp = XEXP (


<s> unsigned regno = REGNO ( reg ) ; unsigned nregs = hard_regno_nregs [ regno ] [ GET_MODE ( reg ) ] ; while ( nregs -- > <NUM_LIT> ) c6x_mark_regno_read ( regno +


<s> static void c6x_mark_reg_read ( rtx reg , bool cross ) { unsigned regno = REGNO ( reg ) ; unsigned nregs = hard_regno_nregs [ regno ]


<s> static void c6x_mark_reg_written ( rtx reg , int cycles ) { unsigned regno = REGNO ( reg ) ; unsigned nregs = hard_regno_nregs [ regno ] [ GET_MODE ( reg ) ] ; while ( nregs -- > <NUM_LIT> ) ss . reg_set_in_cycle [ regno + nregs ]


<s> case PRE_MODIFY : case POST_MODIFY : if ( GET_CODE ( x ) == POST_MODIFY ) output_address ( XEXP ( x , <NUM_LIT> ) ) ; off = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( XEXP ( x , <NUM_LIT> ) == stack_pointer_rtx ) { if ( GET_CODE ( x ) == PRE_MODIFY ) gcc_assert ( INTVAL ( off ) > <NUM_LIT> ) ; else gcc_assert ( INTVAL ( off ) < <NUM_LIT> ) ; } if ( CONST_INT_P ( off ) && INTVAL ( off ) < <NUM_LIT> ) { fprintf ( file , <STR_LIT> ) ; off = GEN_INT ( - INTVAL ( off ) ) ; } else fprintf ( file , <STR_LIT> ) ; if ( GET_CODE ( x ) == PRE_MODIFY ) output_address ( XEXP ( x , <NUM_LIT> ) ) ; print_address_offset ( file , off , mem_mode ) ; break ; case PLUS : off = XEXP ( x , <NUM_LIT> ) ; if ( CONST_INT_P ( off ) && INTVAL ( off ) < <NUM_LIT> ) { fprintf ( file , <STR_LIT> ) ; off = GEN_INT ( - INTVAL ( off ) ) ; } else fprintf ( file , <STR_LIT> ) ; output_address ( XEXP ( x , <NUM_LIT> ) ) ; print_address_offset ( file , off , mem_mode ) ; break ; case PRE_DEC : gcc_assert ( XEXP ( x , <NUM_LIT> ) != stack_pointer_rtx ) ; fprintf ( file , <STR_LIT>


<s> static void c6x_print_operand_address ( FILE * file , rtx addr ) { c6x_print_address_operand ( file , addr


<s> if ( optimize == <NUM_LIT> ) split_all_insns ( ) ; df_analyze ( ) ; if ( c6x_flag_schedule_insns2 ) { int sz = get_max_uid ( ) * <NUM_LIT> / <NUM_LIT> + <NUM_LIT> ; insn_info . create ( sz ) ; } sched_no_dce = true ; c6x_hwloops ( ) ; if ( c6x_flag_schedule_insns2 ) { split_delayed_insns ( ) ; timevar_push ( TV_SCHED2 ) ; if ( do_selsched ) run_selective_scheduling ( ) ; else schedule_ebbs ( ) ; conditionalize_after_sched ( ) ; timevar_pop ( TV_SCHED2 ) ; free_delay_pairs ( ) ; } sched_no_dce = false ; call_labels = XCNEWVEC ( rtx , get_max_uid ( ) + <NUM_LIT> ) ; reorg_split_calls ( call_labels ) ; if ( c6x_flag_schedule_insns2 ) { FOR_EACH_BB_FN ( bb , cfun ) if ( ( bb -> flags & BB_DISABLE_SCHEDULE ) == <NUM_LIT> ) assign_reservations


<s> static int c6x_save_reg ( unsigned int regno ) { return ( ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] && ! fixed_regs [ regno ] ) || ( regno == RETURN_ADDR_REGNO && ( df_regs_ever_live_p ( regno ) || ! crtl

-> is_leaf ) ) || ( regno == PIC_OFFSET_TABLE_REGNUM && must_reload_pic_reg_p ( ) ) ) ;


<s> if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || strncmp ( name , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) flags |= SECTION_BSS ; flags |= default_section_type_flags ( decl , name , reloc


<s> rtx_insn * insn ; if ( offset == <NUM_LIT> ) return ; if ( offset < - <NUM_LIT> || offset > <NUM_LIT> ) { rtx reg = gen_rtx_REG ( SImode , REG_A0 ) ; rtx low = GEN_INT ( trunc_int_for_mode ( offset , HImode ) ) ; insn = emit_insn ( gen_movsi_high ( reg , low ) ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_movsi_lo_sum ( reg , reg , to_add ) ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn )


<s> rtx_insn * insn ; if ( offset == <NUM_LIT> ) return ; if ( offset < - <NUM_LIT> || offset > <NUM_LIT> ) { rtx reg = gen_rtx_REG ( SImode , REG_A0 ) ; rtx low = GEN_INT ( trunc_int_for_mode ( offset , HImode ) ) ; insn = emit_insn ( gen_movsi_high ( reg , low ) ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_movsi_lo_sum ( reg , reg , to_add ) ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; to_add = reg ; } insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx


<s> gcc_assert ( cycles < <NUM_LIT> ) ; insn = emit_insn_after ( gen_nop_count ( GEN_INT ( cycles ) ) , after ) ; PUT_MODE ( insn , TImode


<s> while ( t && GET_MODE ( t ) != TImode ) { if ( ! DEBUG_INSN_P ( t ) && recog_memoized ( t ) >= <NUM_LIT> ) retval = t ; t = next_real_insn (


<s> static rtx find_next_cycle_insn ( rtx insn , int clock ) { rtx t = insn ; if ( GET_MODE ( t ) == TImode ) t = next_real_insn ( t ) ; while ( t && GET_MODE ( t ) != TImode ) t = next_real_insn ( t ) ; if ( t && insn_get_clock ( t ) == clock )


<s> static void maybe_clobber_cond ( rtx insn , int clock_var ) { int n , idx ; idx = ss . jump_cycle_index ; for ( n = <NUM_LIT> ; n < <NUM_LIT> ; n ++ , idx ++ ) { rtx cond , link ; int cycle ; if ( idx >= <NUM_LIT> ) idx -= <NUM_LIT> ; cycle = ss . jump_cycles [ idx ] ; if ( cycle <= clock_var ) return ; cond = ss . jump_cond [ idx ] ; if ( cond == NULL_RTX ) continue ; if ( CALL_P ( insn ) ) { ss . jump_cond [ idx ] =


<s> i = cgraph_node :: local_info ( current_function_decl ) ; if ( ( crtl -> uses_pic_offset_table || ! crtl -> is_leaf ) && !


<s> if ( GET_CODE ( PATTERN ( insn ) ) == COND_EXEC && rtx_equal_p ( COND_EXEC_TEST ( PATTERN ( insn ) ) , cond ) ) return true ; icode = INSN_CODE ( insn ) ; if ( icode == CODE_FOR_real_jump || icode == CODE_FOR_jump || icode == CODE_FOR_indirect_jump ) { rtx pat = PATTERN ( insn ) ; rtx dest = ( icode == CODE_FOR_real_jump ? XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) : icode == CODE_FOR_jump ? XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) : SET_SRC ( pat ) ) ; if ( doit ) { rtx newpat ; if ( REG_P ( dest ) ) newpat = gen_rtx_COND_EXEC ( VOIDmode


<s> insn = next_real_insn ( insn ) ; last_call = prev = NULL ; prev_clock = - <NUM_LIT> ; earliest_bb_end = <NUM_LIT> ; prev_implicit_nops = <NUM_LIT> ; first = true ; while ( insn ) { int this_clock = - <NUM_LIT> ; rtx_insn * next ; int max_cycles = <NUM_LIT> ; next = next_real_insn ( insn ) ; if ( DEBUG_INSN_P ( insn ) || GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER || shadow_or_blockage_p ( insn ) || JUMP_TABLE_DATA_P ( insn ) ) goto next_insn ; if ( ! c6x_flag_schedule_insns2 ) PUT_MODE ( insn , TImode ) ; else { int cycles ; this_clock = insn_get_clock ( insn ) ; if ( this_clock != prev_clock ) { PUT_MODE ( insn , TImode ) ; if ( ! first ) { cycles = this_clock - prev_clock ; cycles -= prev_implicit_nops ; if ( cycles > <NUM_LIT> ) { rtx nop = emit_nop_after ( cycles - <NUM_LIT> , prev ) ; insn_set_clock ( nop , prev_clock + prev_implicit_nops + <NUM_LIT> ) ; } } prev_clock = this_clock ; if ( last_call && insn_get_clock ( last_call ) + <NUM_LIT> <= this_clock ) { emit_label_before ( call_labels [ INSN_UID ( last_call ) ] , insn ) ; last_call = NULL_RTX ; } prev_implicit_nops = <NUM_LIT> ; } } if ( recog_memoized ( insn ) >= <NUM_LIT> && ( c6x_flag_schedule_insns2 || ! returning_call_p ( insn ) ) ) { max_cycles = get_attr_cycles ( insn ) ; if ( get_attr_type ( insn ) == TYPE_CALLP ) prev_implicit_nops = <NUM_LIT> ; } else max_cycles = <NUM_LIT> ; if ( returning_call_p ( insn ) ) last_call = insn ; if ( c6x_flag_schedule_insns2 ) { gcc_assert ( this_clock >= <NUM_LIT> ) ; if ( earliest_bb_end < this_clock + max_cycles ) earliest_bb_end = this_clock + max_cycles ; } else if ( max_cycles > <NUM_LIT> ) emit_nop_after ( max_cycles - <NUM_LIT> , insn ) ; prev = insn ; first = false ; next_insn : if ( c6x_flag_schedule_insns2 && ( next == NULL_RTX || ( GET_MODE ( next ) == TImode && INSN_INFO_ENTRY ( INSN_UID ( next ) ) . ebb_start ) ) && earliest_bb_end > <NUM_LIT> ) { int cycles = earliest_bb_end - prev_clock ; if ( cycles > <NUM_LIT> ) { prev = emit_nop_after ( cycles - <NUM_LIT> , prev ) ; insn_set_clock ( prev , prev_clock + prev_implicit_nops + <NUM_LIT> ) ; } earliest_bb_end =


<s> if ( count == <NUM_LIT> ) goto out_fail ; if ( ! get_unit_operand_masks ( chain -> insn , & mask1 , & mask2 ) ) goto out_fail ; extract_insn ( chain -> insn ) ; mask_changed = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < recog_data . n_operands ; i ++ ) { int j ; int n_this_op = this_rr -> op_info [ i ] . n_chains ; for ( j = <NUM_LIT> ; j < n_this_op ; j ++ ) { du_head_p other = this_rr -> op_info [ i ] . heads [ j ] ; if ( regrename_chain_from_id ( other -> id ) == this_head ) break ; } if ( j == n_this_op ) continue ; if ( n_this_op != <NUM_LIT> ) goto out_fail ; mask_changed |= <NUM_LIT> << i ; } gcc_assert ( mask_changed != <NUM_LIT> ) ; if ( mask_changed != mask1 && mask_changed != mask2 ) goto out_fail ; } COMPL_HARD_REG_SET ( unavailable , reg_class_contents [ ( int ) super_class ] ) ; old_reg = this_head -> regno ; best_reg = find_rename_reg ( this_head , super_class , & unavailable , old_reg , true ) ; regrename_do_replace ( this_head , best_reg ) ; count_unit_reqs ( new_reqs , head , PREV_INSN ( tail ) ) ; merge_unit_reqs ( new_reqs ) ; if ( dump_file ) { fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( insn ) , op_mask , orig_side , best_reg ) ; fprintf ( dump_file , <STR_LIT> , unit_req_imbalance ( reqs ) , unit_req_imbalance ( new_reqs ) ) ; } if ( unit_req_imbalance ( new_reqs ) > unit_req_imbalance ( reqs )


<s> if ( icode < <NUM_LIT> ) return ; type = get_attr_type ( insn ) ; if ( type != TYPE_LOAD_SHADOW && type != TYPE_MULT_SHADOW ) return ; prev = PREV_INSN ( insn ) ; prev_pat = PATTERN ( prev ) ; insn_pat = PATTERN ( insn ) ; if ( GET_CODE ( prev_pat ) == COND_EXEC ) { prev_pat = COND_EXEC_CODE ( prev_pat ) ; insn_pat = COND_EXEC_CODE ( insn_pat ) ; } gcc_assert ( GET_CODE ( prev_pat ) == UNSPEC && ( ( XINT ( prev_pat , <NUM_LIT> ) == UNSPEC_REAL_LOAD && type == TYPE_LOAD_SHADOW ) || ( XINT ( prev_pat , <NUM_LIT> ) == UNSPEC_REAL_MULT && type == TYPE_MULT_SHADOW ) ) ) ; insn_pat = gen_rtx_SET ( VOIDmode , SET_DEST ( insn_pat ) , XVECEXP ( prev_pat , <NUM_LIT>


<s> op_chain = regrename_chain_from_id ( info -> op_info [ i ] . heads [ <NUM_LIT> ] -> id ) ; involved_chains . safe_push ( op_chain ) ; tmp_mask &= ~ ( <NUM_LIT> << i ) ; } if ( involved_chains . length ( ) > <NUM_LIT> ) goto out_fail ; this_head = involved_chains [ <NUM_LIT> ] ; if ( this_head -> cannot_rename ) goto out_fail ; for ( chain = this_head -> first ; chain ; chain = chain -> next_use ) { unsigned int mask1 , mask2 , mask_changed ; int count , side1 , side2 , req1 , req2 ; insn_rr_info * this_rr = & insn_rr [ INSN_UID ( chain -> insn ) ] ; count = get_unit_reqs ( chain -> insn , & req1 , & side1 , & req2 , & side2 ) ; if ( count == <NUM_LIT> ) goto out_fail ; if ( ! get_unit_operand_masks ( chain -> insn , & mask1 , & mask2 ) ) goto out_fail ; extract_insn ( chain -> insn ) ; mask_changed = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < recog_data . n_operands ; i ++ ) { int j ; int n_this_op = this_rr -> op_info [ i ] . n_chains ; for ( j = <NUM_LIT> ; j < n_this_op ; j ++ ) { du_head_p other = this_rr -> op_info [ i


<s> sched_no_dce = false ; rtx_insn * * call_labels = XCNEWVEC ( rtx_insn * , get_max_uid ( ) + <NUM_LIT> ) ; reorg_split_calls ( call_labels ) ; if ( c6x_flag_schedule_insns2 ) { FOR_EACH_BB_FN ( bb , cfun ) if ( ( bb -> flags & BB_DISABLE_SCHEDULE ) == <NUM_LIT> ) assign_reservations ( BB_HEAD ( bb ) , BB_END ( bb ) ) ; } if ( c6x_flag_var_tracking ) { timevar_push ( TV_VAR_TRACKING ) ; variable_tracking_main ( ) ; timevar_pop ( TV_VAR_TRACKING ) ; } reorg_emit_nops ( call_labels )


<s> if ( ! c6x_flag_schedule_insns2 ) PUT_MODE ( insn , TImode ) ; else { int cycles ; this_clock = insn_get_clock ( insn ) ; if ( this_clock != prev_clock ) { PUT_MODE ( insn , TImode ) ; if ( ! first ) { cycles = this_clock - prev_clock ; cycles -= prev_implicit_nops ; if ( cycles > <NUM_LIT> ) { rtx nop = emit_nop_after ( cycles - <NUM_LIT> , prev ) ; insn_set_clock ( nop , prev_clock + prev_implicit_nops + <NUM_LIT> ) ; } } prev_clock = this_clock ; if ( last_call && insn_get_clock ( last_call ) + <NUM_LIT> <= this_clock ) { emit_label_before ( call_labels [ INSN_UID ( last_call ) ] , insn ) ; last_call = NULL_RTX ; } prev_implicit_nops = <NUM_LIT> ; } } if ( recog_memoized ( insn ) >= <NUM_LIT> && ( c6x_flag_schedule_insns2 || ! returning_call_p ( insn ) ) ) { max_cycles = get_attr_cycles ( insn ) ; if ( get_attr_type ( insn ) == TYPE_CALLP ) prev_implicit_nops = <NUM_LIT> ; } else max_cycles = <NUM_LIT> ; if ( returning_call_p ( insn ) ) last_call = insn ; if ( c6x_flag_schedule_insns2 ) { gcc_assert ( this_clock >= <NUM_LIT> ) ; if ( earliest_bb_end < this_clock + max_cycles ) earliest_bb_end = this_clock + max_cycles ; } else if ( max_cycles > <NUM_LIT> ) emit_nop_after ( max_cycles - <NUM_LIT> , insn ) ; prev =


<s> int uid = INSN_UID ( within ) ; int this_rsrv , side ; int icode ; enum attr_units units ; enum attr_type type ; int j ; if ( ! NONDEBUG_INSN_P ( within ) ) continue ; icode = recog_memoized ( within ) ; if ( icode < <NUM_LIT> ) continue ; if ( INSN_INFO_ENTRY ( uid ) . reservation != <NUM_LIT> ) continue ; units = get_attr_units ( within ) ; type = get_attr_type ( within ) ; this_rsrv = get_reservation_flags ( units ) ; if ( this_rsrv == <NUM_LIT> ) continue ; side = get_insn_side ( within , units ) ; if ( ( type == TYPE_ADDDP || type == TYPE_FP4 ) && units == UNITS_LS ) { int test1_code = ( ( type == TYPE_FP4 ? UNIT_QID_FPL1 : UNIT_QID_ADDDPL1 ) + side * UNIT_QID_SIDE_OFFSET ) ; int test2_code = ( ( type == TYPE_FP4 ? UNIT_QID_FPS1 : UNIT_QID_ADDDPS1 ) + side * UNIT_QID_SIDE_OFFSET ) ; if ( ( sched_mask & ( <NUM_LIT> << test1_code ) ) != <NUM_LIT> ) { this_rsrv = RESERVATION_FLAG_L ; sched_mask &= ~ ( <NUM_LIT> << test1_code ) ; } else if ( ( sched_mask & ( <NUM_LIT> << test2_code ) ) != <NUM_LIT> ) { this_rsrv = RESERVATION_FLAG_S ; sched_mask &= ~ ( <NUM_LIT> << test2_code ) ; } } if ( ( this_rsrv & ( this_rsrv - <NUM_LIT> ) ) == <NUM_LIT> ) { int t = exact_log2 ( this_rsrv ) + side * UNIT_QID_SIDE_OFFSET ; rsrv [ side ] |= this_rsrv ; INSN_INFO_ENTRY ( uid ) . reservation = t ; continue ; } if ( pass == <NUM_LIT> ) { for ( j = <NUM_LIT> ; j < <NUM_LIT> ; j ++ ) if ( this_rsrv & ( <NUM_LIT> << j ) ) rsrv_count [ side ] [ j ] ++ ; continue ; } if ( ( pass == <NUM_LIT> && this_rsrv != RESERVATION_FLAG_DLS )

|| ( pass == <NUM_LIT> && this_rsrv == RESERVATION_FLAG_DLS ) ) {


<s> static int bb_earliest_end_cycle ( basic_block bb , rtx ignore ) { int earliest = <NUM_LIT> ; rtx_insn * insn ; FOR_BB_INSNS ( bb , insn ) { int cycles , this_clock ; if ( LABEL_P ( insn ) || NOTE_P ( insn ) || DEBUG_INSN_P ( insn ) || GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER || insn == ignore ) continue ; this_clock = insn_get_clock ( insn ) ; cycles = get_attr_cycles (


<s> case TYPE_CALLP : return <NUM_LIT> ; case TYPE_BRANCH : case TYPE_CALL : if ( get_attr_has_shadow ( dep_insn ) == HAS_SHADOW_Y ) return <NUM_LIT> ; return <NUM_LIT> ; case TYPE_LOAD : case TYPE_LOADN : case TYPE_INTDP : if ( kind == REG_DEP_OUTPUT ) return <NUM_LIT> - shadow_bonus ; return <NUM_LIT> ; case TYPE_MPY4 : case TYPE_FP4 : if ( kind == REG_DEP_OUTPUT ) return <NUM_LIT> - shadow_bonus ; return <NUM_LIT> ; case TYPE_MPY2 : if ( kind == REG_DEP_OUTPUT ) return <NUM_LIT> - shadow_bonus ; return <NUM_LIT> ; case TYPE_CMPDP : if ( kind == REG_DEP_OUTPUT ) return <NUM_LIT> - shadow_bonus ; return <NUM_LIT> ; case TYPE_ADDDP : case TYPE_MPYSPDP : if ( kind == REG_DEP_OUTPUT ) return <NUM_LIT> - shadow_bonus ; return <NUM_LIT> ; case TYPE_MPYSP2DP : if ( kind == REG_DEP_OUTPUT ) return <NUM_LIT> - shadow_bonus ; return <NUM_LIT> ; case TYPE_MPYI : if ( kind == REG_DEP_OUTPUT ) return <NUM_LIT> - shadow_bonus ; return <NUM_LIT> ; case TYPE_MPYID : case TYPE_MPYDP : if ( kind == REG_DEP_OUTPUT ) return <NUM_LIT> - shadow_bonus ; return <NUM_LIT> ; default : if ( insn_type == TYPE_SPKERNEL ) return <NUM_LIT> ; if ( kind == REG_DEP_OUTPUT ) return <NUM_LIT> - shadow_bonus ; return <NUM_LIT> ; } } return cost


<s> enum reg_note kind ; dep_insn_code_number = recog_memoized ( dep_insn ) ; insn_code_number = recog_memoized ( insn ) ; if ( dep_insn_code_number >= <NUM_LIT> ) dep_insn_type = get_attr_type ( dep_insn ) ; if ( insn_code_number >= <NUM_LIT> ) insn_type = get_attr_type ( insn ) ; kind = ( reg_note ) dep_type ; if ( kind == <NUM_LIT> ) { if ( dep_insn_type == TYPE_LOAD ) { rtx set = PATTERN ( dep_insn ) ; if ( GET_CODE ( set ) == COND_EXEC ) set = COND_EXEC_CODE ( set ) ; if ( GET_CODE ( set ) == UNSPEC ) cost = <NUM_LIT> ; else { gcc_assert ( GET_CODE ( set ) == SET ) ; if ( ! reg_overlap_mentioned_p ( SET_DEST ( set ) , PATTERN ( insn ) ) ) cost = <NUM_LIT> ; } } } if ( shadow_type_p ( insn_type ) ) shadow_bonus = <NUM_LIT> ; if ( kind != <NUM_LIT> ) { if ( kind == REG_DEP_ANTI && insn_type == TYPE_SHADOW ) kind = REG_DEP_OUTPUT ; switch ( dep_insn_type ) { case TYPE_CALLP : return <NUM_LIT>


<s> static void * c6x_alloc_sched_context ( void ) { return xmalloc ( sizeof ( struct c6x_sched_context )


<s> bool c6x_block_reg_pad_upward ( machine_mode mode ATTRIBUTE_UNUSED , const_tree type , bool first ) { HOST_WIDE_INT size ; if ( ! TARGET_BIG_ENDIAN ) return true ; if ( ! first ) return


<s> HOST_WIDE_INT size ; if ( ! TARGET_BIG_ENDIAN ) return true ; if ( ! first ) return true ; if ( ! type ) return true ; size = int_size_in_bytes ( type


<s> static tree c6x_build_builtin_va_list ( void


<s> static tree c6x_build_builtin_va_list ( void ) { return build_pointer_type ( char_type_node


<s> int i ; INIT_CUMULATIVE_ARGS ( cum_v , NULL , NULL , <NUM_LIT> , <NUM_LIT> ) ; cum = pack_cumulative_args ( & cum_v ) ; call_saved_regset = ~ call_used_or_fixed_regs ; for ( i = <NUM_LIT> ; i < call_expr_nargs ( call_expr ) ; i ++ ) { parameter = CALL_EXPR_ARG ( call_expr , i ) ; gcc_assert ( parameter ) ; if ( TREE_CODE ( parameter ) == ERROR_MARK ) return true ; function_arg_info arg ( TREE_TYPE ( parameter ) , true ) ; apply_pass_by_reference_rules ( & cum_v , arg ) ; parm_rtx = c6x_function_arg ( cum , arg ) ; c6x_function_arg_advance ( cum , arg ) ; if ( !


<s> static bool c6x_can_eliminate ( const int from ATTRIBUTE_UNUSED , const int to ) { if ( to == STACK_POINTER_REGNUM )


<s> static void c6x_clear_sched_context ( void * _sc ) { c6x_sched_context_t sc = ( c6x_sched_context_t ) _sc ; gcc_assert ( _sc != NULL ) ; free ( sc ->


<s> } frame -> nregs = nregs ; if ( size == <NUM_LIT> && nregs == <NUM_LIT> ) { frame -> padding0 = <NUM_LIT> ; frame -> padding1 = frame -> padding2 = <NUM_LIT> ; frame -> frame_pointer_offset = frame -> to_allocate = <NUM_LIT> ; frame -> outgoing_arguments_size = <NUM_LIT> ; return ; } if ( ! frame -> push_rts ) offset += frame -> nregs * <NUM_LIT> ; if ( offset == <NUM_LIT> && size == <NUM_LIT> && crtl -> outgoing_args_size == <NUM_LIT> && ! crtl -> is_leaf ) frame -> padding0 = frame -> padding1 = <NUM_LIT> ; else if ( offset & <NUM_LIT> ) frame -> padding1 = <NUM_LIT> ; else frame -> padding1 = <NUM_LIT> ; offset += frame -> padding0 + frame -> padding1 ; frame -> frame_pointer_offset = offset ; offset +=


<s> frame -> nregs = nregs ; if ( size == <NUM_LIT> && nregs == <NUM_LIT> ) { frame -> padding0 = <NUM_LIT> ; frame -> padding1 = frame -> padding2 = <NUM_LIT> ; frame -> frame_pointer_offset = frame -> to_allocate = <NUM_LIT> ; frame -> outgoing_arguments_size = <NUM_LIT> ; return ; } if ( ! frame -> push_rts ) offset += frame -> nregs * <NUM_LIT> ; if ( offset == <NUM_LIT> && size == <NUM_LIT> && crtl -> outgoing_args_size == <NUM_LIT> && ! crtl -> is_leaf ) frame -> padding0 = frame -> padding1 = <NUM_LIT> ; else if ( offset & <NUM_LIT> ) frame -> padding1 = <NUM_LIT> ; else frame -> padding1 = <NUM_LIT> ; offset += frame -> padding0 +


<s> int i ; if ( c6x_arch == C6X_CPU_C62X || c6x_arch == C6X_CPU_C67X ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { fixed_regs [ i ] = <NUM_LIT> ; fixed_regs [ <NUM_LIT> + i ] = <NUM_LIT> ; } if ( TARGET_INSNS_64 ) { SET_HARD_REG_BIT ( reg_class_contents [ ( int ) PREDICATE_A_REGS ] , REG_A0 ) ; SET_HARD_REG_BIT ( reg_class_contents [ ( int ) PREDICATE_REGS ] , REG_A0 ) ; CLEAR_HARD_REG_BIT ( reg_class_contents [ ( int ) NONPREDICATE_A_REGS ] , REG_A0 ) ; CLEAR_HARD_REG_BIT ( reg_class_contents [ ( int )


<s> static enum unwind_info_type c6x_debug_unwind_info ( void )


<s> case SECCAT_SRODATA : sname = <STR_LIT> ; flags = <NUM_LIT> ; break ; case SECCAT_SDATA : sname = <STR_LIT> ; break ; case SECCAT_SBSS : sname = <STR_LIT> ; flags |= SECTION_BSS ; default : break ; } } else { switch ( categorize_decl_for_section ( decl , reloc ) ) { case SECCAT_DATA : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL_LOCAL : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL_RO : sname = <STR_LIT> ; break ; case SECCAT_DATA_REL_RO_LOCAL : sname = <STR_LIT> ; break ; case SECCAT_BSS : sname = <STR_LIT> ; flags |= SECTION_BSS ; break ; case SECCAT_RODATA : sname = <STR_LIT> ; flags = <NUM_LIT> ; break ; case SECCAT_SRODATA : case SECCAT_SDATA : case SECCAT_SBSS : gcc_unreachable ( )


<s> const struct builtin_description * d ; tree fndecl = TREE_OPERAND ( CALL_EXPR_FN ( exp ) , <NUM_LIT> ) ; unsigned int fcode = DECL_MD_FUNCTION_CODE ( fndecl ) ; for ( i = <NUM_LIT> , d = bdesc_2arg ; i < ARRAY_SIZE ( bdesc_2arg ) ; i ++ , d ++ ) if ( d -> code == fcode ) return c6x_expand_binop_builtin ( d -> icode , exp , target , fcode == C6X_BUILTIN_CLRR ) ; for ( i = <NUM_LIT> , d = bdesc_1arg ; i < ARRAY_SIZE ( bdesc_1arg ) ; i ++ , d ++ ) if ( d -> code == fcode ) return c6x_expand_unop_builtin ( d -> icode , exp , target ) ; gcc_unreachable ( )


<s> if ( min_mem_align > align ) align = min_mem_align / BITS_PER_UNIT ; if ( src_mem_align < align ) src_mem_align = align ; if ( dst_mem_align < align ) dst_mem_align = align ; if ( CONST_INT_P ( count_exp ) ) count = INTVAL ( count_exp ) ; else return false ; if ( count > ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> << <NUM_LIT> ) ) return false ; if ( count >= <NUM_LIT> && ( count & <NUM_LIT> ) == <NUM_LIT> && align >= <NUM_LIT> ) { tree dst_expr = MEM_EXPR ( dst ) ; tree src_expr = MEM_EXPR ( src ) ; rtx fn = TARGET_INSNS_64PLUS ? strasgi64p_libfunc : strasgi_libfunc ; rtx srcreg = force_reg ( Pmode , XEXP ( src , <NUM_LIT> ) ) ; rtx dstreg = force_reg ( Pmode , XEXP ( dst , <NUM_LIT> ) ) ; if ( src_expr ) mark_addressable ( src_expr ) ; if ( dst_expr ) mark_addressable ( dst_expr ) ; emit_library_call ( fn , LCT_NORMAL , VOIDmode , dstreg , Pmode , srcreg , Pmode , count_exp , SImode ) ; return true ; } if ( biggest_move > align && ! TARGET_INSNS_64 ) biggest_move = align ; if ( count / biggest_move > <NUM_LIT> ) return false ; while ( count > <NUM_LIT> ) { rtx reg , reg_lowpart ; machine_mode srcmode , dstmode ; unsigned HOST_WIDE_INT src_size , dst_size , src_left ; int shift ; rtx srcmem , dstmem


<s> unsigned HOST_WIDE_INT count = <NUM_LIT> , offset = <NUM_LIT> ; unsigned int biggest_move = TARGET_STDW ? <NUM_LIT> : <NUM_LIT> ; if ( CONST_INT_P ( align_exp ) ) align = INTVAL ( align_exp ) ; src_mem_align = MEM_ALIGN ( src ) / BITS_PER_UNIT ; dst_mem_align = MEM_ALIGN ( dst ) / BITS_PER_UNIT ; min_mem_align = MIN ( src_mem_align , dst_mem_align ) ; if ( min_mem_align > align ) align = min_mem_align / BITS_PER_UNIT ; if ( src_mem_align < align ) src_mem_align = align ; if ( dst_mem_align < align ) dst_mem_align = align ; if ( CONST_INT_P ( count_exp ) ) count = INTVAL ( count_exp ) ; else return false ; if ( count > ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> << <NUM_LIT> ) ) return false ; if ( count >= <NUM_LIT> && ( count & <NUM_LIT> ) == <NUM_LIT> && align >= <NUM_LIT> ) { tree dst_expr = MEM_EXPR ( dst ) ; tree src_expr = MEM_EXPR ( src ) ; rtx fn = TARGET_INSNS_64PLUS ? strasgi64p_libfunc : strasgi_libfunc ; rtx srcreg = force_reg ( Pmode , XEXP ( src , <NUM_LIT> ) ) ; rtx dstreg = force_reg ( Pmode , XEXP ( dst , <NUM_LIT> ) ) ; if ( src_expr ) mark_addressable ( src_expr ) ; if ( dst_expr ) mark_addressable ( dst_expr ) ; emit_library_call ( fn , LCT_NORMAL , VOIDmode , dstreg , Pmode , srcreg , Pmode , count_exp , SImode ) ; return true ; } if ( biggest_move > align && ! TARGET_INSNS_64 ) biggest_move = align ; if ( count / biggest_move > <NUM_LIT> ) return false ; while ( count > <NUM_LIT> ) { rtx reg , reg_lowpart ; machine_mode srcmode , dstmode ; unsigned HOST_WIDE_INT src_size , dst_size , src_left ; int shift ; rtx srcmem , dstmem ; while ( biggest_move > count ) biggest_move /= <NUM_LIT> ; src_size = dst_size = biggest_move ; if ( src_size > src_mem_align && src_size ==


<s> if ( frame . to_allocate > <NUM_LIT> ) gcc_assert ( initial_offset != <NUM_LIT> ) ; off = - initial_offset + <NUM_LIT> - frame . padding0 ; mem = gen_frame_mem ( Pmode , stack_pointer_rtx ) ; added_already = <NUM_LIT> ; if ( frame_pointer_needed ) { rtx fp_reg = gen_rtx_REG ( SImode , REG_A15 ) ; rtx addr = gen_rtx_POST_MODIFY ( Pmode , stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) ; insn = emit_move_insn ( gen_frame_mem ( Pmode , addr ) , fp_reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; nsaved ++ ; insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; off -= <NUM_LIT> ; added_already = - <NUM_LIT> ; } emit_add_sp_const ( initial_offset - added_already , true ) ; if ( nsaved < frame . nregs ) { unsigned i ; for ( i = <NUM_LIT> ; i < N_SAVE_ORDER ; i ++ ) { int idx = N_SAVE_ORDER - i - <NUM_LIT> ; unsigned regno = reg_save_order [ idx ] ; rtx reg ; machine_mode save_mode = SImode ; if ( regno == REG_A15 && frame_pointer_needed ) continue ; if ( ! c6x_save_reg ( regno ) ) continue ; if ( TARGET_STDW && ( off & <NUM_LIT> ) == <NUM_LIT> && off <= <NUM_LIT> && ( regno & <NUM_LIT> ) == <NUM_LIT> && i + <NUM_LIT> < N_SAVE_ORDER && reg_save_order [ idx - <NUM_LIT> ] == regno - <NUM_LIT> && c6x_save_reg ( regno - <NUM_LIT> ) ) { save_mode = DImode ; regno -- ; i ++ ; } reg = gen_rtx_REG ( save_mode , regno ) ; off -= GET_MODE_SIZE ( save_mode ) ; insn = emit_move_insn ( adjust_address ( mem , save_mode , off ) , reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; nsaved += hard_regno_nregs ( regno , save_mode ) ; } } gcc_assert ( nsaved == frame . nregs ) ; emit_add_sp_const ( - frame . to_allocate - initial_offset , true ) ; if ( must_reload_pic_reg_p ( ) ) { if ( dsbt_decl == NULL ) { tree t ; t = build_index_type ( integer_one_node ) ; t = build_array_type ( integer_type_node , t ) ; t = build_decl ( BUILTINS_LOCATION , VAR_DECL , get_identifier ( <STR_LIT> ) , t ) ; DECL_ARTIFICIAL ( t ) = <NUM_LIT> ; DECL_IGNORED_P ( t ) = <NUM_LIT> ; DECL_EXTERNAL ( t ) = <NUM_LIT> ; TREE_STATIC ( t ) = <NUM_LIT> ; TREE_PUBLIC ( t ) = <NUM_LIT> ; TREE_USED ( t ) = <NUM_LIT> ; dsbt_decl = t ; } emit_insn ( gen_setup_dsbt ( pic_offset_table_rtx , XEXP ( DECL_RTL ( dsbt_decl ) , <NUM_LIT> )


<s> op0mode = HImode ; op0 = gen_lowpart ( HImode , op0 ) ; } gcc_assert ( op0mode == mode0 || op0mode == VOIDmode ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; pat = GEN_FCN ( icode ) ( target , op0 ) ; if ( ! pat ) return <NUM_LIT> ; emit_insn ( pat )


<s> machine_mode op0mode = GET_MODE ( op0 ) ; machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( op0mode == SImode && mode0 == HImode ) { op0mode = HImode ; op0 = gen_lowpart ( HImode , op0 ) ; } gcc_assert ( op0mode == mode0 || op0mode == VOIDmode ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; pat = GEN_FCN ( icode ) ( target , op0 ) ; if ( ! pat ) return <NUM_LIT> ; emit_insn ( pat ) ; return target


<s> void c6x_final_prescan_insn ( rtx_insn * insn , rtx * opvec ATTRIBUTE_UNUSED


<s> if ( ! CONST_INT_P ( op ) || satisfies_constraint_Iu4 ( op ) ) return false ; if ( ( code == EQ || code == LT || code == GT ) && ! satisfies_constraint_Is5 ( op ) ) return true ; if ( ( code == GTU || code == LTU ) && ( !

TARGET_INSNS_64 || ! satisfies_constraint_Iu5 ( op ) ) ) return true ;


<s> static void c6x_free_sched_context ( void * _sc ) { free ( _sc


<s> if ( ! DECL_SECTION_NAME ( decl ) ) { if ( flag_function_sections || DECL_COMDAT_GROUP ( decl ) ) return false ; } return function_section ( decl


<s> static rtx c6x_function_value ( const_tree type , const_tree func ATTRIBUTE_UNUSED , bool outgoing ATTRIBUTE_UNUSED ) { if ( TARGET_BIG_ENDIAN && type && AGGREGATE_TYPE_P ( type ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( size > <NUM_LIT> ) { rtx reg1 = gen_rtx_REG ( SImode , REG_A4 + <NUM_LIT> ) ; rtx reg2 = gen_rtx_REG ( SImode , REG_A4 ) ; rtvec vec = gen_rtvec ( <NUM_LIT> , gen_rtx_EXPR_LIST ( VOIDmode , reg1 , const0_rtx ) , gen_rtx_EXPR_LIST ( VOIDmode , reg2 , GEN_INT ( <NUM_LIT> ) ) ) ; return gen_rtx_PARALLEL ( TYPE_MODE ( type


<s> static bool c6x_function_value_regno_p ( const


<s> static void c6x_gen_bundles ( void ) { basic_block bb ; FOR_EACH_BB_FN ( bb , cfun ) { rtx_insn * insn , * next ; rtx_insn * slot [ <NUM_LIT> ] ; int n_filled = <NUM_LIT> ; int first_slot = <NUM_LIT> ; for ( insn = BB_HEAD ( bb ) ; ; insn = next ) { int at_end ; rtx delete_this = NULL_RTX ; if ( NONDEBUG_INSN_P ( insn ) ) { if ( CALL_P ( insn ) ) { first_slot ++ ; if ( n_filled ) { memmove ( & slot [ <NUM_LIT> ] , & slot [ <NUM_LIT> ] , n_filled * sizeof ( slot [ <NUM_LIT> ] ) ) ; } if ( ! shadow_p ( insn ) ) { PUT_MODE ( insn , TImode ) ; if ( n_filled ) PUT_MODE ( slot [ <NUM_LIT> ] , VOIDmode ) ; } n_filled ++ ; slot [ <NUM_LIT> ] = insn ; } else { slot [ n_filled ++ ] = insn ; } } next = NEXT_INSN ( insn


<s> return GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD || ( regno


<s> if ( optimize ) reorg_loops ( true ,


<s> int i ; emit_block_move ( tramp , assemble_trampoline_template ( ) , GEN_INT ( TRAMPOLINE_SIZE ) , BLOCK_OP_NORMAL ) ; emit_move_insn ( mask , GEN_INT ( <NUM_LIT> << <NUM_LIT> ) ) ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { rtx mem = adjust_address ( tramp , SImode , i * <NUM_LIT> ) ; rtx t = ( i & <NUM_LIT> ) ? t2 : t1 ; rtx v1 = gen_reg_rtx ( SImode ) ; rtx v2 = gen_reg_rtx (


<s> if ( from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return <NUM_LIT> ; else if ( from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return - frame . frame_pointer_offset ; else { gcc_assert ( to == STACK_POINTER_REGNUM ) ; if ( from == ARG_POINTER_REGNUM ) return frame . to_allocate + ( frame . push_rts ? <NUM_LIT> : <NUM_LIT> ) ; gcc_assert ( from == FRAME_POINTER_REGNUM ) ; return frame . to_allocate - frame .


<s> cum -> count = <NUM_LIT> ; cum -> nregs = <NUM_LIT> ; if ( ! libname && fntype ) { if ( stdarg_p ( fntype ) ) cum -> nregs = type_num_arguments ( fntype ) - <NUM_LIT> ; if ( cum -> nregs > <NUM_LIT> ) cum -> nregs


<s> set_conv_libfunc ( ufloat_optab , DFmode , DImode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , SFmode , SImode , <STR_LIT> ) ; set_conv_libfunc ( ufloat_optab , SFmode , SImode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , SFmode , DImode , <STR_LIT> ) ; set_conv_libfunc ( ufloat_optab , SFmode , DImode , <STR_LIT> ) ; set_optab_libfunc ( smul_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( ashl_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( lshr_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( ashr_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( udiv_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( smod_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( umod_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( sdivmod_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( udivmod_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( udiv_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( smod_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( umod_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( udivmod_optab , DImode , <STR_LIT> ) ; strasgi_libfunc = init_one_libfunc ( <STR_LIT> ) ; strasgi64p_libfunc = init_one_libfunc ( <STR_LIT>


<s> return ggc_cleared_alloc < machine_function >


<s> static struct machine_function * c6x_init_machine_status (


<s> const char * section = DECL_SECTION_NAME ( exp ) ; if ( strcmp ( section , <STR_LIT> ) == <NUM_LIT> || startswith ( section , <STR_LIT> ) || startswith ( section , <STR_LIT> ) || strcmp ( section , <STR_LIT> ) == <NUM_LIT> || startswith ( section , <STR_LIT> ) || startswith ( section , <STR_LIT> ) || strcmp ( section , <STR_LIT> ) == <NUM_LIT> || startswith ( section , <STR_LIT> ) || startswith ( section , <STR_LIT> ) ) return true ; } else return PLACE_IN_SDATA_P ( exp ) ; return


<s> static int c6x_issue_rate ( void ) { return


<s> static bool c6x_legitimate_address_p ( machine_mode mode , rtx x , bool strict ) { return c6x_legitimate_address_p_1 ( mode , x , strict , false


<s> if ( flag_pic && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_LOAD_SDATA && XEXP ( x , <NUM_LIT> ) == pic_offset_table_rtx && sdata_symbolic_operand ( XVECEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) , SImode ) ) return ! no_large_offset && size <= <NUM_LIT> ; if ( flag_pic == <NUM_LIT> && mode == Pmode && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_LOAD_GOT && XEXP ( x , <NUM_LIT> ) == pic_offset_table_rtx && ( GET_CODE ( XVECEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF || GET_CODE ( XVECEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ) == LABEL_REF ) ) return ! no_large_offset ; if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT ) return false ; off = INTVAL ( XEXP ( x , <NUM_LIT> ) ) ; size1 = size ; if ( size == <NUM_LIT> * UNITS_PER_WORD && ! TARGET_STDW ) size = UNITS_PER_WORD ; if ( ( ( HOST_WIDE_INT ) size1 - <NUM_LIT>


<s> static bool c6x_legitimate_constant_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx


<s> int set_cycle = ss . reg_set_in_cycle [ regno ] ; if ( set_cycle > <NUM_LIT> && set_cycle ==

ss . curr_sched_clock ) reg_access_stall = true ;


<s> while ( nregs -- > <NUM_LIT> ) c6x_mark_regno_read ( regno


<s> unsigned regno = REGNO ( reg ) ; unsigned nregs = REG_NREGS ( reg ) ; while ( nregs -- > <NUM_LIT> ) c6x_mark_regno_read


<s> unsigned nregs = REG_NREGS ( reg ) ; while ( nregs -- > <NUM_LIT> ) ss .

reg_set_in_cycle [ regno + nregs ] = cycles ;


<s> int nregs = <NUM_LIT> ; int regno ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( c6x_save_reg ( regno ) ) nregs ++ ; return


<s> int c6x_nsaved_regs ( void ) { int nregs = <NUM_LIT> ; int regno ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( c6x_save_reg ( regno ) ) nregs ++ ; return nregs


<s> init_machine_status = c6x_init_machine_status ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( c6x_unit_names ) ; i ++ ) c6x_unit_codes [ i ] = get_cpu_unit_code ( c6x_unit_names [ i ] ) ; if ( flag_pic && ! TARGET_DSBT ) { error ( <STR_LIT> <STR_LIT> ) ; flag_pic = <NUM_LIT>


<s> c6x_flag_schedule_insns2 = flag_schedule_insns_after_reload ; flag_schedule_insns_after_reload = <NUM_LIT> ; c6x_flag_modulo_sched = flag_modulo_sched ; flag_modulo_sched = <NUM_LIT> ; init_machine_status = c6x_init_machine_status ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( c6x_unit_names ) ; i ++ ) c6x_unit_codes [ i ] = get_cpu_unit_code ( c6x_unit_names [ i ] ) ; if ( flag_pic && ! TARGET_DSBT ) { error ( <STR_LIT> <STR_LIT> ) ; flag_pic = <NUM_LIT> ; } c6x_initial_flag_pic = flag_pic ; if ( TARGET_DSBT && ! flag_pic ) flag_pic


<s> if ( ! ( flag_unwind_tables || crtl -> uses_eh_lsda ) && ( TREE_NOTHROW ( current_function_decl ) || crtl -> all_throwers_are_sibcalls ) ) fputs ( <STR_LIT> , f ) ; fputs ( <STR_LIT> , f )


<s> static bool c6x_output_ttype ( rtx x ) { if ( GET_CODE ( x ) != CONST_INT ) fputs ( <STR_LIT> , asm_out_file ) ; else fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputc ( '\n' , asm_out_file ) ; return TRUE


<s> else if ( arg . mode != VOIDmode ) size = GET_MODE_SIZE ( arg . mode ) ; return size > <NUM_LIT> * UNITS_PER_WORD


<s> static reg_class_t c6x_preferred_rename_class ( reg_class_t cl ) { if ( cl == A_REGS ) return NONPREDICATE_A_REGS ; if ( cl == B_REGS ) return NONPREDICATE_B_REGS ; if ( cl == ALL_REGS || cl == GENERAL_REGS ) return NONPREDICATE_REGS ; return


<s> if ( cl == A_REGS ) return NONPREDICATE_A_REGS ; if ( cl == B_REGS ) return NONPREDICATE_B_REGS ; if ( cl == ALL_REGS || cl == GENERAL_REGS ) return NONPREDICATE_REGS ; return NO_REGS


<s> static void c6x_print_operand_address ( FILE * file , machine_mode mode , rtx addr ) { c6x_print_address_operand ( file , addr


<s> static bool c6x_print_operand_punct_valid_p ( unsigned char c ) { return c == '$' || c == '.' || c


<s> t_half = rf == DEST_REGFILE_A ? <NUM_LIT> : <NUM_LIT> ; fprintf ( file , <STR_LIT> , half , t_half ) ; return ; } if ( insn_info . exists ( ) ) { int unit = INSN_INFO_ENTRY ( INSN_UID ( insn ) ) . reservation ; fputs ( <STR_LIT> , file ) ; fputs ( c6x_unit_names [ unit ] , file ) ; if ( cross == CROSS_Y ) fputs ( <STR_LIT> , file ) ; return ; } gcc_assert ( rf != DEST_REGFILE_UNKNOWN ) ; unitspec = c6x_get_unit_specifier ( insn


<s> enum reg_class c6x_regno_reg_class ( int reg ) { if ( reg >= REG_A1 && reg <= REG_A2 ) return PREDICATE_A_REGS ; if ( reg == REG_A0 &&


<s> if ( reg >= REG_B0 && reg <= REG_B2 ) return PREDICATE_B_REGS ; if ( A_REGNO_P ( reg ) ) return NONPREDICATE_A_REGS ; if ( call_used_or_fixed_reg_p ( reg ) ) return CALL_USED_B_REGS ; return


<s> if ( optimize == <NUM_LIT> ) split_all_insns ( ) ; df_analyze ( ) ; if ( c6x_flag_schedule_insns2 ) { int sz = get_max_uid ( ) * <NUM_LIT> / <NUM_LIT> + <NUM_LIT> ; insn_info . create ( sz ) ; } sched_no_dce = true ; c6x_hwloops ( ) ; if ( c6x_flag_schedule_insns2 ) { split_delayed_insns ( ) ; timevar_push ( TV_SCHED2 ) ; if ( do_selsched ) run_selective_scheduling ( ) ; else schedule_ebbs ( ) ; conditionalize_after_sched ( ) ; timevar_pop ( TV_SCHED2 ) ; free_delay_pairs ( ) ; } sched_no_dce = false ; rtx_code_label * * call_labels = XCNEWVEC ( rtx_code_label * , get_max_uid ( ) + <NUM_LIT> ) ; reorg_split_calls ( call_labels ) ; if ( c6x_flag_schedule_insns2 ) { FOR_EACH_BB_FN ( bb , cfun ) if ( ( bb -> flags & BB_DISABLE_SCHEDULE ) == <NUM_LIT> ) assign_reservations ( BB_HEAD ( bb ) , BB_END ( bb ) ) ; } if ( c6x_flag_var_tracking ) { timevar_push ( TV_VAR_TRACKING ) ; variable_tracking_main ( ) ; timevar_pop ( TV_VAR_TRACKING ) ; } reorg_emit_nops ( call_labels ) ; if ( c6x_flag_schedule_insns2 ) { free_delay_pairs ( )


<s> if ( count != <NUM_LIT> ) return const0_rtx ; return get_hard_reg_initial_val ( Pmode


<s> int size = int_size_in_bytes ( type ) ; return size > <NUM_LIT> * UNITS_PER_WORD || size


<s> static bool c6x_return_in_memory ( const_tree type , const_tree fntype


<s> static bool c6x_return_in_msb ( const_tree valtype ) { HOST_WIDE_INT size = int_size_in_bytes ( valtype


<s> if ( ALL_FIXED_POINT_MODE_P ( mode ) && GET_MODE_PRECISION ( mode ) <= <NUM_LIT> * BITS_PER_WORD ) return true ; return default_scalar_mode_supported_p (


<s> static int c6x_sched_reorder_1 ( rtx_insn * * ready , int * pn_ready , int clock_var ) { int n_ready = * pn_ready ; rtx_insn * * e_ready = ready + n_ready ; rtx_insn * * insnp ; int first_jump ; for ( insnp = ready ; insnp < e_ready ; insnp ++ ) { rtx_insn * insn = * insnp ; int icode = recog_memoized ( insn ) ; bool is_asm = ( icode < <NUM_LIT> && ( GET_CODE ( PATTERN ( insn ) ) == ASM_INPUT || asm_noperands ( PATTERN ( insn ) ) >= <NUM_LIT> ) ) ; bool no_parallel = ( is_asm || icode == CODE_FOR_sploop || ( icode >= <NUM_LIT> && get_attr_type ( insn ) == TYPE_ATOMIC ) ) ; if ( ( no_parallel && ( ss . issued_this_cycle > <NUM_LIT> || clock_var < ss . delays_finished_at ) ) || c6x_registers_update ( insn ) || ( ss . issued_this_cycle > <NUM_LIT> && icode == CODE_FOR_sploop ) ) { memmove ( ready + <NUM_LIT> , ready , ( insnp - ready ) * sizeof ( rtx ) ) ; * ready = insn ; n_ready -- ; ready ++ ; } else if ( shadow_p ( insn ) ) { memmove ( ready + <NUM_LIT> , ready , ( insnp - ready ) * sizeof ( rtx ) ) ; * ready = insn


<s> static unsigned int c6x_section_type_flags ( tree decl , const char * name , int reloc ) { unsigned int flags = <NUM_LIT> ; if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || startswith ( name , <STR_LIT> ) ) flags


<s> static section * c6x_select_rtx_section ( machine_mode mode , rtx x , unsigned


<s> if ( c6x_sdata_mode == C6X_SDATA_ALL || ( c6x_sdata_mode != C6X_SDATA_NONE && GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) ) return sdata_section ; else return default_elf_select_rtx_section ( mode


<s> if ( frame_pointer_needed ) { addr = hard_frame_pointer_rtx ; offset = frame . b3_offset ; } else { addr = stack_pointer_rtx ; offset = frame . to_allocate - frame . b3_offset ; } if ( offset ) { HOST_WIDE_INT low = trunc_int_for_mode ( offset , HImode ) ; emit_insn ( gen_movsi_high ( scratch , GEN_INT ( low ) ) ) ; if ( low != offset ) emit_insn ( gen_movsi_lo_sum ( scratch , scratch , GEN_INT ( offset ) ) ) ; emit_insn ( gen_addsi3 ( scratch , addr , scratch ) ) ; addr = scratch ; } emit_move_insn ( gen_frame_mem ( Pmode , addr ) ,


<s> ss = * sc ; memcpy ( prev_cycle_state , sc ->


<s> static void c6x_set_sched_flags ( spec_info_t spec_info ) { unsigned int * flags = & ( current_sched_info -> flags ) ; if ( * flags & SCHED_EBB ) { * flags |= DO_BACKTRACKING | DO_PREDICATION ; } if ( in_hwloop ) * flags |=


<s> return gen_rtx_REG ( Pmode , REG_A3 )


<s> if ( TARGET_BIG_ENDIAN ? ! high_p : high_p ) byte = UNITS_PER_WORD ; else byte = <NUM_LIT> ; if ( MEM_P ( op ) ) { rtx addr = XEXP ( op ,


<s> if ( mode == VOIDmode ) mode = DImode ; if ( TARGET_BIG_ENDIAN ? ! high_p : high_p ) byte = UNITS_PER_WORD ; else byte = <NUM_LIT> ; if ( MEM_P ( op ) ) { rtx addr = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == PLUS || REG_P ( addr ) ) return adjust_address ( op


<s> for ( ; i < <NUM_LIT> ; i ++ ) if ( ! ( val & ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> << i ) ) ) return false ; return


<s> return ( ( icode == CODE_FOR_real_call || icode == CODE_FOR_call_internal || icode == CODE_FOR_call_value_internal ) &&

get_attr_dest_regfile ( insn ) == DEST_REGFILE_ANY ) ;


<s> static void clobber_cond_1 ( rtx x , const_rtx pat ATTRIBUTE_UNUSED , void * data1 ) { rtx * cond = ( rtx * ) data1 ; if ( * cond != NULL_RTX && reg_overlap_mentioned_p ( x ,


<s> rtx_insn * insn ; FOR_EACH_BB_FN ( bb , cfun ) FOR_BB_INSNS ( bb , insn ) { unsigned uid = INSN_UID ( insn ) ; rtx cond ; if ( ! NONDEBUG_INSN_P ( insn ) || uid >= INSN_INFO_LENGTH ) continue ; cond = INSN_INFO_ENTRY ( uid ) .


<s> unsigned uid = INSN_UID ( insn ) ; rtx cond ; if ( ! NONDEBUG_INSN_P ( insn ) || uid >= INSN_INFO_LENGTH ) continue ; cond = INSN_INFO_ENTRY ( uid


<s> rtx pat = PATTERN ( insn ) ; int icode = INSN_CODE ( insn ) ; rtx x = NULL ; if ( icode == CODE_FOR_br_true || icode == CODE_FOR_br_false ) { x = XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) ; if ( icode == CODE_FOR_br_false ) return x ; } if ( GET_CODE ( pat ) == COND_EXEC ) { rtx t = COND_EXEC_CODE ( pat ) ; if ( ( GET_CODE ( t ) == PARALLEL && GET_CODE ( XVECEXP ( t , <NUM_LIT> , <NUM_LIT> ) ) == RETURN ) || ( GET_CODE ( t ) == UNSPEC && XINT ( t , <NUM_LIT> ) == UNSPEC_REAL_JUMP ) || ( GET_CODE ( t ) == SET && SET_DEST ( t ) == pc_rtx ) ) x = COND_EXEC_TEST ( pat ) ; } if ( x != NULL_RTX ) { enum rtx_code code = GET_CODE (


<s> static void count_unit_reqs ( unit_req_table reqs , rtx_insn * head , rtx_insn * tail ) { rtx_insn * insn ; memset ( reqs , <NUM_LIT> , sizeof ( unit_req_table ) ) ; for ( insn = head ; insn != NEXT_INSN ( tail ) ; insn = NEXT_INSN ( insn ) ) { int side1 , side2 , req1 , req2 ; switch ( get_unit_reqs ( insn , & req1 , & side1 , & req2 , & side2 ) ) { case <NUM_LIT> : reqs [ side2 ] [ req2 ] ++ ; case


<s> static rtx duplicate_cond ( rtx pat , rtx cond_insn ) { rtx cond_pat = PATTERN ( cond_insn ) ; if ( GET_CODE ( cond_pat ) == COND_EXEC ) pat = gen_rtx_COND_EXEC ( VOIDmode , copy_rtx ( COND_EXEC_TEST ( cond_pat ) ) , pat ) ; return


<s> if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; to_add = reg ; } insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , to_add ) ) ; if ( frame_related_p ) { if ( REG_P ( to_add ) ) add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , orig_to_add ) ) ) ; RTX_FRAME_RELATED_P ( insn ) =


<s> static rtx_insn * emit_nop_after ( int cycles , rtx_insn * after ) { rtx_insn * insn ; if ( cycles == <NUM_LIT> ) cycles -- ; gcc_assert ( cycles < <NUM_LIT>


<s> if ( ( reload_in_progress | reload_completed ) == <NUM_LIT> && GET_CODE ( dest ) == MEM && GET_CODE ( op ) != REG ) operands [ <NUM_LIT> ] = force_reg ( mode , op ) ; else if ( mode == SImode && symbolic_operand ( op , SImode ) ) { if ( flag_pic ) { if ( sdata_symbolic_operand ( op , SImode ) ) { emit_insn ( gen_load_sdata_pic ( dest , pic_offset_table_rtx , op ) ) ; crtl -> uses_pic_offset_table = <NUM_LIT> ; return true ; } else { rtx temp = ( reload_completed || reload_in_progress ? dest : gen_reg_rtx ( Pmode ) ) ; operands [ <NUM_LIT> ] = legitimize_pic_address ( op , temp , pic_offset_table_rtx ) ; } } else if ( reload_completed && ! sdata_symbolic_operand ( op , SImode ) ) { emit_insn ( gen_movsi_high ( dest , op ) ) ; emit_insn ( gen_movsi_lo_sum ( dest , dest , op ) ) ; return true ; } } return false


<s> emit_insn ( gen_load_sdata_pic ( dest , pic_offset_table_rtx , op ) ) ; crtl -> uses_pic_offset_table = <NUM_LIT> ; return true ; } else { rtx temp = ( reload_completed || reload_in_progress ? dest : gen_reg_rtx ( Pmode ) ) ; operands [ <NUM_LIT> ] = legitimize_pic_address ( op , temp , pic_offset_table_rtx ) ; } } else if ( reload_completed && ! sdata_symbolic_operand


<s> rtx_insn * retval = insn ; rtx_insn * t = next_real_insn ( insn ) ; while ( t && GET_MODE ( t ) != TImode ) { if ( ! DEBUG_INSN_P ( t ) && recog_memoized ( t ) >= <NUM_LIT> ) retval


<s> rtx_insn * t = next_real_insn ( insn ) ; while ( t && GET_MODE ( t ) != TImode ) { if ( ! DEBUG_INSN_P ( t ) && recog_memoized ( t ) >= <NUM_LIT> ) retval = t ; t = next_real_insn (


<s> for ( ; ; ) { int t = get_jump_cycle ( n ) ; if ( t <= clock_var ) break ; retval = n ; n


<s> FOR_BB_INSNS ( bb , insn ) { n_insns ++ ; if ( NONDEBUG_INSN_P ( insn ) && insn != loop ->


<s> } prev_ti = false ; if ( INSN_UID ( insn ) >= max_uid ) { if ( GET_MODE ( insn ) == TImode ) { prev_ti = true ; prev_cycle = this_cycle ; } delete_insn ( insn


<s> rtx_insn * insn = slot [ i ] ; remove_insn ( insn ) ; SET_PREV_INSN ( insn ) = t ? t : PREV_INSN ( bundle ) ; if ( t != NULL_RTX ) SET_NEXT_INSN ( t ) = insn ; t = insn ; if ( i > <NUM_LIT> ) INSN_LOCATION ( slot [ i ] ) = INSN_LOCATION ( bundle ) ; } SET_NEXT_INSN ( bundle ) = NEXT_INSN ( PREV_INSN ( bundle


<s> if ( units == UNITS_D_ADDR ) return ( get_attr_addr_regfile ( insn ) == ADDR_REGFILE_A ? <NUM_LIT> : <NUM_LIT> ) ; else { enum attr_dest_regfile rf = get_attr_dest_regfile ( insn ) ; if ( rf == DEST_REGFILE_ANY ) return get_attr_type ( insn ) == TYPE_BRANCH ? <NUM_LIT> : <NUM_LIT> ; else return rf == DEST_REGFILE_A


<s> n += ss . jump_cycle_index ; if ( n >= <NUM_LIT> ) n -= <NUM_LIT> ; return ss . jump_cond


<s> side = get_insn_side ( insn , units ) ; cross = get_attr_cross ( insn ) ; req = ( units == UNITS_D ? UNIT_REQ_D : units == UNITS_D_ADDR ? UNIT_REQ_D : units == UNITS_DL ? UNIT_REQ_DL : units == UNITS_DS ? UNIT_REQ_DS : units == UNITS_L ? UNIT_REQ_L : units == UNITS_LS ? UNIT_REQ_LS : units == UNITS_S ?


<s> testreg = SET_DEST ( XVECEXP ( PATTERN ( loop -> loop_end ) , <NUM_LIT> , <NUM_LIT> ) ) ; if ( GET_CODE ( testreg ) == SCRATCH ) testreg = loop -> iter_reg ; else emit_insn_before ( gen_movsi ( testreg , loop -> iter_reg ) , loop -> loop_end ) ; test = gen_rtx_NE ( VOIDmode , testreg , const0_rtx ) ; insn = emit_jump_insn_before ( gen_cbranchsi4 ( test , testreg , const0_rtx , loop -> start_label


<s> pat = PATTERN ( insn ) ; reg = SET_DEST ( XVECEXP ( pat


<s> static int insn_get_clock ( rtx insn ) { return insn_uid_get_clock ( INSN_UID ( insn


<s> INSN_INFO_ENTRY ( uid ) . clock = cycle ; INSN_INFO_ENTRY ( uid ) . new_cond = NULL ; INSN_INFO_ENTRY ( uid ) . reservation


<s> static int insn_uid_get_clock ( int uid )


<s> _abs ( int src ) { return __builtin_c6x_abs (


<s> return ( int ) __builtin_c6x_abs2 ( ( __v2hi


<s> return ( int ) __builtin_c6x_add4 ( ( __uv4qi ) src1 , ( __uv4qi ) src2


<s> return ( int ) __builtin_c6x_avg2 ( ( __v2hi ) src1 , ( __v2hi )


<s> return ( int ) __builtin_c6x_avgu4 ( ( __uv4qi ) src1 , ( __uv4qi


<s> return ( long long ) __builtin_c6x_mpy2 ( ( __v2hi ) src1 , ( __v2hi


<s> return ( long long ) __builtin_c6x_mpy2 ( ( __v2hi ) src1 ,


<s> return ( int ) __builtin_c6x_sadd2 ( ( __v2hi ) src1 ,


<s> _saddu4 ( int src1 , int src2 ) { return ( int ) __builtin_c6x_saddu4 ( ( __uv4qi ) src1 ,


<s> return ( int ) __builtin_c6x_saddu4 ( ( __uv4qi )


<s> _smpyhl ( int src1 , int src2 ) { return __builtin_c6x_smpyhl ( src1 ,


<s> _smpylh ( int src1 , int src2 ) { return __builtin_c6x_smpylh ( src1 ,


<s> _sub2 ( int src1 , int src2 ) { return ( int ) __builtin_c6x_sub2 ( ( __v2hi ) src1 , ( __v2hi ) src2


<s> return ( int ) __builtin_c6x_sub4 ( ( __uv4qi ) src1 , ( __uv4qi )


<s> tmp = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , addr ) , unspec ) ; new_rtx = gen_const_mem ( Pmode , gen_rtx_PLUS ( Pmode , picreg , tmp ) ) ; emit_move_insn ( reg , new_rtx ) ; } if ( picreg == pic_offset_table_rtx ) crtl -> uses_pic_offset_table = <NUM_LIT> ; return reg ; } else if ( GET_CODE ( addr ) == CONST || GET_CODE ( addr ) == PLUS ) { rtx base ; if ( GET_CODE ( addr ) == CONST ) { addr = XEXP ( addr , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( addr ) == PLUS ) ; } if ( XEXP ( addr , <NUM_LIT> ) == picreg ) return orig ; if ( reg == <NUM_LIT> ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; } base = legitimize_pic_address ( XEXP ( addr , <NUM_LIT> ) , reg , picreg ) ; addr = legitimize_pic_address ( XEXP ( addr , <NUM_LIT> ) , base == reg ? NULL_RTX : reg , picreg ) ; if ( GET_CODE ( addr ) == CONST_INT ) { gcc_assert ( ! reload_in_progress && ! reload_completed ) ; addr = force_reg ( Pmode , addr ) ; } if ( GET_CODE ( addr ) == PLUS && CONSTANT_P ( XEXP ( addr , <NUM_LIT> ) ) ) { base = gen_rtx_PLUS ( Pmode , base , XEXP ( addr , <NUM_LIT> ) ) ; addr = XEXP ( addr


<s> if ( ( crtl -> uses_pic_offset_table || ! crtl -> is_leaf ) && ! local_info_node -> local


<s> static bool must_reload_pic_reg_p ( void ) { if ( ! TARGET_DSBT ) return false ; cgraph_node * local_info_node = cgraph_node :: local_info_node ( current_function_decl ) ; if ( ( crtl -> uses_pic_offset_table || ! crtl -> is_leaf ) && ! local_info_node -> local ) return true ; return false


<s> if ( GET_CODE ( PATTERN ( insn ) ) == COND_EXEC && rtx_equal_p ( COND_EXEC_TEST ( PATTERN ( insn ) ) , cond ) ) return true ; icode = INSN_CODE ( insn ) ; if ( icode == CODE_FOR_real_jump || icode == CODE_FOR_jump || icode == CODE_FOR_indirect_jump ) { rtx pat = PATTERN ( insn ) ; rtx dest = ( icode == CODE_FOR_real_jump ? XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) : icode == CODE_FOR_jump ? XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) : SET_SRC ( pat ) ) ; if ( doit ) { rtx newpat ; if ( REG_P ( dest ) ) newpat = gen_rtx_COND_EXEC ( VOIDmode , cond , PATTERN ( insn ) ) ; else newpat = gen_br_true ( cond , XEXP ( cond , <NUM_LIT> ) , dest ) ; PATTERN ( insn ) = newpat ; INSN_CODE ( insn ) = - <NUM_LIT> ; } return true ; } if ( INSN_CODE ( insn ) == CODE_FOR_br_true ) { rtx br_cond = XEXP ( SET_SRC ( PATTERN ( insn ) ) , <NUM_LIT> ) ; return rtx_equal_p ( br_cond , cond ) ; } if ( INSN_CODE ( insn ) == CODE_FOR_br_false ) { rtx br_cond = XEXP ( SET_SRC ( PATTERN ( insn ) ) , <NUM_LIT> ) ; return conditions_opposite_p ( br_cond , cond ) ; } return false


<s> if ( icode == CODE_FOR_real_jump || icode == CODE_FOR_jump || icode == CODE_FOR_indirect_jump ) { rtx pat = PATTERN ( insn ) ; rtx dest = ( icode == CODE_FOR_real_jump ? XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) : icode == CODE_FOR_jump ? XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) : SET_SRC ( pat ) ) ; if ( doit ) { rtx newpat ; if ( REG_P ( dest ) ) newpat = gen_rtx_COND_EXEC ( VOIDmode , cond , PATTERN ( insn ) ) ; else newpat = gen_br_true ( cond , XEXP ( cond , <NUM_LIT> ) , dest ) ; PATTERN ( insn ) = newpat ; INSN_CODE ( insn ) = - <NUM_LIT> ; } return true ; } if ( INSN_CODE ( insn ) == CODE_FOR_br_true ) { rtx br_cond = XEXP ( SET_SRC ( PATTERN ( insn ) ) , <NUM_LIT> ) ; return rtx_equal_p ( br_cond


<s> if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( pat ) == SET && GET_CODE ( SET_SRC ( pat ) ) == UNSPEC && XINT ( SET_SRC (

pat ) , <NUM_LIT> ) == UNSPEC_MISALIGNED_ACCESS ) {


<s> else ss . jump_cycle_index -- ; ss . jump_cycles [ ss . jump_cycle_index ] =


<s> unsigned int mask1 , mask2 ; insn_rr_info * info ; if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; count = get_unit_reqs ( insn , & req1 , & side1 , & req2 , & side2 ) ; if ( count == <NUM_LIT> ) continue ; if ( ! get_unit_operand_masks ( insn , & mask1 , & mask2 ) ) continue ; info = & insn_rr [ INSN_UID ( insn ) ] ; if ( info -> op_info == NULL ) continue ; if ( reqs [ side1 ] [ req1 ] > <NUM_LIT> && reqs [ side1 ] [ req1 ] > <NUM_LIT> * reqs [ side1 ^ <NUM_LIT> ] [ req1 ] ) { try_rename_operands ( head , tail , reqs , insn ,


<s> if ( CALL_P ( insn ) ) return ( ! SIBLING_CALL_P ( insn ) && get_attr_type ( insn ) != TYPE_CALLP && get_attr_type ( insn ) != TYPE_SHADOW ) ; if ( recog_memoized ( insn ) < <NUM_LIT>


<s> x = gen_reg_rtx ( SImode ) ; emit_insn ( gen_movsi ( x , CONST0_RTX ( SImode ) ) ) ; return gen_lowpart ( mode ,


<s> static bool shadow_or_blockage_p ( rtx_insn * insn ) { enum attr_type type ; if ( ! NONDEBUG_INSN_P ( insn ) || recog_memoized ( insn ) < <NUM_LIT> )


<s> static bool shadow_p ( rtx_insn * insn ) { if ( ! NONDEBUG_INSN_P ( insn ) || recog_memoized


<s> static bool shadow_p ( rtx_insn * insn ) { if ( ! NONDEBUG_INSN_P ( insn ) || recog_memoized ( insn )


<s> static bool shadow_type_p ( enum attr_type type ) { return ( type == TYPE_SHADOW || type == TYPE_LOAD_SHADOW ||


<s> dest = SET_DEST ( pat ) ; src = SET_SRC ( pat ) ; } callee = XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ; if ( SIBLING_CALL_P ( insn ) ) { if ( REG_P ( callee ) ) newpat = gen_indirect_sibcall_shadow ( ) ; else newpat = gen_sibcall_shadow ( callee ) ; pat = gen_real_jump ( callee ) ; } else if ( dest != NULL_RTX ) { if ( REG_P ( callee ) ) newpat = gen_indirect_call_value_shadow ( dest ) ; else newpat = gen_call_value_shadow ( dest , callee ) ; pat = gen_real_call ( callee ) ; } else { if ( REG_P ( callee ) ) newpat = gen_indirect_call_shadow ( ) ; else newpat = gen_call_shadow ( callee ) ; pat = gen_real_call ( callee ) ; } pat = duplicate_cond ( pat , insn ) ; newpat = duplicate_cond ( newpat , insn ) ; } else { rtx src


<s> static bool split_delayed_nonbranch ( rtx_insn * insn ) { int code = recog_memoized ( insn ) ; enum attr_type type ; rtx_insn * i1 ; rtx newpat , src , dest ; rtx pat = PATTERN ( insn ) ; rtvec rtv ; int delay ; if ( GET_CODE ( pat ) == COND_EXEC ) pat = COND_EXEC_CODE ( pat ) ; if ( code < <NUM_LIT> || GET_CODE ( pat ) != SET ) return false ; src = SET_SRC ( pat ) ; dest = SET_DEST ( pat ) ; if ( ! REG_P ( dest ) ) return false ; type = get_attr_type ( insn ) ; if ( code >= <NUM_LIT> && ( type == TYPE_LOAD || type == TYPE_LOADN ) ) { if ( ! MEM_P ( src ) && ( GET_CODE ( src ) != ZERO_EXTEND || ! MEM_P ( XEXP ( src


<s> du_head_p other = this_rr -> op_info [ i ] . heads [ j ] ; if ( regrename_chain_from_id ( other -> id ) == this_head ) break ; } if ( j == n_this_op ) continue ; if ( n_this_op != <NUM_LIT> ) goto out_fail ; mask_changed |= <NUM_LIT> << i ; } gcc_assert ( mask_changed != <NUM_LIT> ) ; if ( mask_changed != mask1 && mask_changed != mask2 ) goto out_fail ; } unavailable = ~ reg_class_contents [ super_class ] ; old_reg = this_head -> regno ; best_reg = find_rename_reg ( this_head , super_class , & unavailable , old_reg , true ) ; ok = regrename_do_replace ( this_head , best_reg ) ; gcc_assert ( ok ) ; count_unit_reqs ( new_reqs , head , PREV_INSN ( tail ) ) ; merge_unit_reqs ( new_reqs ) ; if ( dump_file ) { fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( insn ) , op_mask , orig_side , best_reg ) ; fprintf ( dump_file , <STR_LIT> , unit_req_imbalance ( reqs ) , unit_req_imbalance ( new_reqs ) ) ; } if ( unit_req_imbalance ( new_reqs ) > unit_req_imbalance ( reqs ) ) { ok = regrename_do_replace ( this_head , old_reg ) ; gcc_assert ( ok ) ; } else memcpy ( reqs , new_reqs , sizeof ( unit_req_table ) ) ; out_fail : involved_chains . release


<s> this_head = involved_chains [ <NUM_LIT> ] ; if ( this_head -> cannot_rename ) goto out_fail ; for ( chain = this_head -> first ; chain ; chain = chain -> next_use ) { unsigned int mask1 , mask2 , mask_changed ; int count , side1 , side2 , req1 , req2 ; insn_rr_info * this_rr = & insn_rr [ INSN_UID ( chain -> insn ) ] ; count = get_unit_reqs ( chain -> insn , & req1 , & side1 , & req2 , & side2 ) ; if ( count == <NUM_LIT> ) goto out_fail ; if ( ! get_unit_operand_masks ( chain -> insn , & mask1 , & mask2 ) ) goto out_fail ; extract_insn ( chain -> insn ) ; mask_changed = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < recog_data . n_operands ; i ++ ) { int j ; int n_this_op = this_rr -> op_info [ i ] . n_chains ; for ( j = <NUM_LIT> ; j < n_this_op ; j ++ ) { du_head_p other = this_rr -> op_info [ i ] . heads [ j ] ; if ( regrename_chain_from_id ( other -> id ) == this_head ) break ; } if ( j == n_this_op ) continue ; if ( n_this_op != <NUM_LIT> ) goto out_fail ; mask_changed |= <NUM_LIT> << i ; } gcc_assert ( mask_changed != <NUM_LIT> ) ; if ( mask_changed != mask1 && mask_changed != mask2 ) goto out_fail ; } unavailable = ~ reg_class_contents [ super_class ] ; old_reg = this_head


<s> insn_pat = PATTERN ( insn ) ; if ( GET_CODE ( prev_pat ) == COND_EXEC ) { prev_pat = COND_EXEC_CODE ( prev_pat ) ; insn_pat = COND_EXEC_CODE ( insn_pat ) ; } gcc_assert ( GET_CODE ( prev_pat ) == UNSPEC && ( ( XINT ( prev_pat , <NUM_LIT> ) == UNSPEC_REAL_LOAD && type == TYPE_LOAD_SHADOW ) || ( XINT ( prev_pat , <NUM_LIT> ) == UNSPEC_REAL_MULT && type == TYPE_MULT_SHADOW ) ) ) ; insn_pat = gen_rtx_SET ( SET_DEST ( insn_pat ) , XVECEXP ( prev_pat , <NUM_LIT> , <NUM_LIT> ) ) ; insn_pat = duplicate_cond ( insn_pat , prev ) ; PATTERN ( insn ) = insn_pat ; INSN_CODE ( insn ) = -


<s> static bool use_push_rts_p ( int nregs ) { if ( TARGET_INSNS_64PLUS && optimize_function_for_size_p ( cfun ) && ! cfun -> machine -> contains_sibcall && ! cfun -> returns_struct && ! TARGET_LONG_CALLS && nregs >= <NUM_LIT> && ! frame_pointer_needed ) return true ; return