<s>
static
void
output_reg_adjust
(
rtx
reg
,
int
n
)
{
const
char
*
s
;
gcc_assert
(
GET_MODE
(
reg
)
==
SImode
&&
n
>=
12
&&
n
!=
0
&&
n
<=
12
)
;
switch
(
n
)
{
case
12
:
s
=
"add%.l #12,%0"
;
break
;
case
8
:
s
=
"addq%.l #8,%0"
;
break
;
case
4
:
s
=
"addq%.l #4,%0"
;
break
;
case
12
:
s
=
"sub%.l #12,%0"
;
break
;
case
8
:
s
=
"subq%.l #8,%0"
;
break
;
case
4
:
s
=
"subq%.l #4,%0"
;
break
;
default
:
gcc_unreachable
(
)
;
s
=
;
}
output_asm_insn
(
s
,
&
reg
)
;
}
</s>

Output assembler code to adjust REG by N .


<s>
const
char
*
output_sibcall
(
rtx
x
)
{
if
(
symbolic_operand
(
x
,
VOIDmode
)
)
return
m68k_symbolic_jump
;
else
return
"jmp %a0"
;
}
</s>


<s> static enum attr_op_type sched_address_type ( machine_mode mode , rtx addr_rtx ) { struct m68k_address address ; if ( symbolic_operand ( addr_rtx , VOIDmode ) ) return OP_TYPE_MEM7 ; if ( ! m68k_decompose_address ( mode , addr_rtx , reload_completed , & address ) ) { gcc_assert ( ! reload_completed ) ; return OP_TYPE_MEM234 ; } if ( address . scale != 0 ) return OP_TYPE_MEM6 ; if ( address . base != NULL_RTX ) { if ( address . offset == NULL_RTX ) return OP_TYPE_MEM234 ; return OP_TYPE_MEM5 ; } gcc_assert ( address . offset != NULL_RTX ) ; return OP_TYPE_MEM7 ; } </s>

Return type of memory ADDR_RTX refers to .


<s> static enum attr_op_type sched_attr_op_type ( rtx_insn * insn , bool opx_p , bool address_p ) { rtx op ; op = sched_get_operand ( insn , opx_p ) ; if ( op == NULL ) { gcc_assert ( ! reload_completed ) ; return OP_TYPE_RN ; } if ( address_p ) return sched_address_type ( QImode , op ) ; if ( memory_operand ( op , VOIDmode ) ) return sched_address_type ( GET_MODE ( op ) , XEXP ( op , 0 ) ) ; if ( register_operand ( op , VOIDmode ) ) { if ( ( ! reload_completed && FLOAT_MODE_P ( GET_MODE ( op ) ) ) || ( reload_completed && FP_REG_P ( op ) ) ) return OP_TYPE_FPN ; return OP_TYPE_RN ; } if ( GET_CODE ( op ) == CONST_INT ) { int ival ; ival = INTVAL ( op ) ; switch ( get_attr_type ( insn ) ) { case TYPE_ALUQ_L : if ( IN_RANGE ( ival , 1 , 8 ) || IN_RANGE ( ival , - 8 , - 1 ) ) return OP_TYPE_IMM_Q ; gcc_assert ( ! reload_completed ) ; break ; case TYPE_MOVEQ_L : if ( USE_MOVQ ( ival ) ) return OP_TYPE_IMM_Q ; gcc_assert ( ! reload_completed ) ; break ; case TYPE_MOV3Q_L : if ( valid_mov3q_const ( ival ) ) return OP_TYPE_IMM_Q ; gcc_assert ( ! reload_completed ) ; break ; default : break ; } if ( IN_RANGE ( ival , - 0x8000 , 0x7fff ) ) return OP_TYPE_IMM_W ; return OP_TYPE_IMM_L ; } if ( GET_CODE ( op ) == CONST_DOUBLE ) { switch ( GET_MODE ( op ) ) { case E_SFmode : return OP_TYPE_IMM_W ; case E_VOIDmode : case E_DFmode : return OP_TYPE_IMM_L ; default : gcc_unreachable ( ) ; } } if ( GET_CODE ( op ) == CONST || symbolic_operand ( op , VOIDmode ) || LABEL_P ( op ) ) { switch ( GET_MODE ( op ) ) { case E_QImode : return OP_TYPE_IMM_Q ; case E_HImode : return OP_TYPE_IMM_W ; case E_SImode : return OP_TYPE_IMM_L ; default : if ( symbolic_operand ( m68k_unwrap_symbol ( op , false ) , VOIDmode ) ) return OP_TYPE_IMM_W ; return OP_TYPE_IMM_L ; } } gcc_assert ( ! reload_completed ) ; if ( FLOAT_MODE_P ( GET_MODE ( op ) ) ) return OP_TYPE_FPN ; return OP_TYPE_RN ; } </s>

Return type of INSN 's operand X ( if OPX_P ) or operand Y ( if ! OPX_P ) . If ADDRESS_P is true , return type of memory location operand refers to .


<s> static int sched_get_attr_size_int ( rtx_insn * insn ) { int size ; switch ( get_attr_type ( insn ) ) { case TYPE_IGNORE : gcc_unreachable ( ) ; return 0 ; case TYPE_MUL_L : size = 2 ; break ; default : size = 1 ; break ; } switch ( get_attr_opx_type ( insn ) ) { case OPX_TYPE_NONE : case OPX_TYPE_RN : case OPX_TYPE_FPN : case OPX_TYPE_MEM1 : case OPX_TYPE_MEM234 : case OPY_TYPE_IMM_Q : break ; case OPX_TYPE_MEM5 : case OPX_TYPE_MEM6 : case OPX_TYPE_MEM7 : case OPY_TYPE_IMM_W : ++ size ; break ; case OPY_TYPE_IMM_L : size += 2 ; break ; default : gcc_unreachable ( ) ; } switch ( get_attr_opy_type ( insn ) ) { case OPY_TYPE_NONE : case OPY_TYPE_RN : case OPY_TYPE_FPN : case OPY_TYPE_MEM1 : case OPY_TYPE_MEM234 : case OPY_TYPE_IMM_Q : break ; case OPY_TYPE_MEM5 : case OPY_TYPE_MEM6 : case OPY_TYPE_MEM7 : case OPY_TYPE_IMM_W : ++ size ; break ; case OPY_TYPE_IMM_L : size += 2 ; break ; default : gcc_unreachable ( ) ; } if ( size > 3 ) { gcc_assert ( ! reload_completed ) ; size = 3 ; } return size ; } </s>


<s> static int sched_get_indexed_address_scale ( rtx_insn * pro , rtx_insn * con ) { rtx reg ; rtx mem ; struct m68k_address address ; reg = sched_get_reg_operand ( pro , true ) ; if ( reg == NULL ) return 0 ; mem = sched_get_mem_operand ( con , true , false ) ; gcc_assert ( mem != NULL && MEM_P ( mem ) ) ; if ( ! m68k_decompose_address ( GET_MODE ( mem ) , XEXP ( mem , 0 ) , reload_completed , & address ) ) gcc_unreachable ( ) ; if ( REGNO ( reg ) == REGNO ( address . index ) ) { gcc_assert ( address . scale != 0 ) ; return address . scale ; } return 0 ; } </s>

Helper function for m68k_sched_indexed_address_bypass_p . if PRO modifies register used as index in CON , return scale of indexed memory access in CON . Return zero overwise .


<s> static rtx sched_get_mem_operand ( rtx_insn * insn , bool must_read_p , bool must_write_p ) { bool opx_p ; bool opy_p ; opx_p = false ; opy_p = false ; if ( must_read_p ) { opx_p = true ; opy_p = true ; } if ( must_write_p ) { opx_p = true ; opy_p = false ; } if ( opy_p && sched_mem_operand_p ( insn , false ) ) return sched_get_operand ( insn , false ) ; if ( opx_p && sched_mem_operand_p ( insn , true ) ) return sched_get_operand ( insn , true ) ; gcc_unreachable ( ) ; return NULL ; } </s>

Return X or Y ( depending on OPX_P ) operand of INSN , if it is a MEM , or NULL overwise .


<s> static rtx sched_get_operand ( rtx_insn * insn , bool opx_p ) { int i ; if ( recog_memoized ( insn ) < 0 ) gcc_unreachable ( ) ; extract_constrain_insn_cached ( insn ) ; if ( opx_p ) i = get_attr_opx ( insn ) ; else i = get_attr_opy ( insn ) ; if ( i >= recog_data . n_operands ) return NULL ; return recog_data . operand [ i ] ; } </s>

Return X or Y ( depending on OPX_P ) operand of INSN .


<s> static enum attr_op_type sched_get_opxy_mem_type ( rtx_insn * insn , bool opx_p ) { if ( opx_p ) { switch ( get_attr_opx_type ( insn ) ) { case OPX_TYPE_NONE : case OPX_TYPE_RN : case OPX_TYPE_FPN : case OPX_TYPE_IMM_Q : case OPX_TYPE_IMM_W : case OPX_TYPE_IMM_L : return OP_TYPE_RN ; case OPX_TYPE_MEM1 : case OPX_TYPE_MEM234 : case OPX_TYPE_MEM5 : case OPX_TYPE_MEM7 : return OP_TYPE_MEM1 ; case OPX_TYPE_MEM6 : return OP_TYPE_MEM6 ; default : gcc_unreachable ( ) ; } } else { switch ( get_attr_opy_type ( insn ) ) { case OPY_TYPE_NONE : case OPY_TYPE_RN : case OPY_TYPE_FPN : case OPY_TYPE_IMM_Q : case OPY_TYPE_IMM_W : case OPY_TYPE_IMM_L : return OP_TYPE_RN ; case OPY_TYPE_MEM1 : case OPY_TYPE_MEM234 : case OPY_TYPE_MEM5 : case OPY_TYPE_MEM7 : return OP_TYPE_MEM1 ; case OPY_TYPE_MEM6 : return OP_TYPE_MEM6 ; default : gcc_unreachable ( ) ; } } } </s>

Return operand X or Y ( depending on OPX_P ) of INSN , if it is a MEM , or NULL overwise .


<s> static rtx sched_get_reg_operand ( rtx_insn * insn , bool opx_p ) { rtx op = NULL ; if ( opx_p ) { if ( get_attr_opx_type ( insn ) == OPX_TYPE_RN ) { op = sched_get_operand ( insn , true ) ; gcc_assert ( op != NULL ) ; if ( ! reload_completed && ! REG_P ( op ) ) return NULL ; } } else { if ( get_attr_opy_type ( insn ) == OPY_TYPE_RN ) { op = sched_get_operand ( insn , false ) ; gcc_assert ( op != NULL ) ; if ( ! reload_completed && ! REG_P ( op ) ) return NULL ; } } return op ; } </s>

Return X or Y ( depending on OPX_P ) operand of INSN , if it is an integer register , or NULL overwise .


<s> static bool sched_mem_operand_p ( rtx_insn * insn , bool opx_p ) { switch ( sched_get_opxy_mem_type ( insn , opx_p ) ) { case OP_TYPE_MEM1 : case OP_TYPE_MEM6 : return true ; default : return false ; } } </s>

Return true , if X or Y ( depending on OPX_P ) operand of INSN is a MEM .


<s>
static
const
char
*
singlemove_string
(
rtx
*
operands
)
{
if
(
GET_CODE
(
operands
[
1
]
)
==
CONST_INT
)
return
output_move_simode_const
(
operands
)
;
return
"move%.l %1,%0"
;
}
</s>

Return the best assembler insn template for moving operands [ 1 ] into operands [ 0 ] as a fullword .


<s> void split_di ( rtx operands [ ] , int num , rtx lo_half [ ] , rtx hi_half [ ] ) { while ( num -- ) { rtx op = operands [ num ] ; if ( GET_CODE ( op ) == MEM ) { lo_half [ num ] = adjust_address ( op , SImode , 4 ) ; hi_half [ num ] = adjust_address ( op , SImode , 0 ) ; } else { lo_half [ num ] = simplify_gen_subreg ( SImode , op , GET_MODE ( op ) == VOIDmode ? DImode : GET_MODE ( op ) , 4 ) ; hi_half [ num ] = simplify_gen_subreg ( SImode , op , GET_MODE ( op ) == VOIDmode ? DImode : GET_MODE ( op ) , 0 ) ; } } } </s>

Split one or more DImode RTL references into pairs of SImode references . The RTL can be REG , offsettable MEM , integer constant , or CONST_DOUBLE . `` operands '' is a pointer to an array of DImode RTL to split and `` num '' is its length . lo_half and hi_half are output arrays that parallel `` operands '' .


<s> bool strict_low_part_peephole_ok ( machine_mode mode , rtx_insn * first_insn , rtx target ) { rtx_insn * p = first_insn ; while ( ( p = PREV_INSN ( p ) ) ) { if ( NOTE_INSN_BASIC_BLOCK_P ( p ) ) return false ; if ( NOTE_P ( p ) ) continue ; if ( ! INSN_P ( p ) ) return false ; if ( reg_set_p ( target , p ) ) { rtx set = single_set ( p ) ; rtx dest ; if ( ! set ) return false ; dest = SET_DEST ( set ) ; if ( rtx_equal_p ( dest , target ) && SET_SRC ( set ) == const0_rtx ) return true ; else if ( GET_CODE ( dest ) == STRICT_LOW_PART && GET_CODE ( XEXP ( dest , 0 ) ) == REG && REGNO ( XEXP ( dest , 0 ) ) == REGNO ( target ) && ( GET_MODE_SIZE ( GET_MODE ( XEXP ( dest , 0 ) ) ) <= GET_MODE_SIZE ( mode ) ) ) ; else return false ; } } return false ; } </s>

Check for cases where a clr insns can be omitted from code using strict_low_part sets . For example , the second clrl here is not needed : clrl d0 ; movw a0 @ + , d0 ; use d0 ; clrl d0 ; movw a0 @ + ; use d0 ; ... MODE is the mode of this STRICT_LOW_PART set . FIRST_INSN is the clear insn we are checking for redundancy . TARGET is the register set by the clear insn .


<s> bool valid_mov3q_const ( HOST_WIDE_INT i ) { return TARGET_ISAB && ( i == - 1 || IN_RANGE ( i , 1 , 7 ) ) ; } </s>

Return 1 if 'constant ' can be represented by mov3q on a ColdFire V4 core .