Template_token: <s> USItype bit = <NUM_LIT> ; USItype res = <NUM_LIT> ; while ( den < num && bit && ! ( den & ( <NUM_LIT> << <NUM_LIT> ) ) ) { den <<= <NUM_LIT> ; bit <<= <NUM_LIT> ; } while ( bit ) { if ( num >= den ) { num -= den ; res |= bit ; } bit >>= <NUM_LIT> ; den >>=

Target: mt

Target_Clf: CPU

Compiler_Type: GCC


Template_token: <s> bit <<= <NUM_LIT> ; } while ( bit ) { if ( num >= den ) { num -= den ; res |= bit ; } bit >>=


Template_token: <s> neg = ! neg ; } res = udivmodsi4 ( a , b , <NUM_LIT> ) ; if ( neg ) res = - res ; return res


Template_token: <s> word_type neg = <NUM_LIT> ; SItype res ; if ( a < <NUM_LIT> ) { a = - a ; neg = ! neg ; } if ( b < <NUM_LIT> ) { b = - b ; neg = ! neg ; } res = udivmodsi4 ( a

ground_truth: , b , <NUM_LIT> ) ;


Template_token: <s> USItype c = <NUM_LIT> ; while ( a != <NUM_LIT> ) { if ( a & <NUM_LIT>


Template_token: <s> return udivmodsi4 ( a , b ,

ground_truth: <NUM_LIT> ) ;


Template_token: <s> SItype __umodsi3 ( SItype a , SItype b


Template_token: <s> if ( GET_CODE ( op ) == CONST_INT && SMALL_INT ( op ) ) return <NUM_LIT> ; return register_operand ( op

ground_truth: , mode ) ;

File: mt


Template_token: <s> int arith_operand ( rtx op , enum machine_mode mode ) { if ( GET_CODE ( op ) == CONST_INT && SMALL_INT ( op ) ) return <NUM_LIT> ; return register_operand ( op ,

ground_truth: mode ) ;


Template_token: <s> if ( GET_CODE ( op ) == CONST_INT && CONST_OK_FOR_LETTER_P ( INTVAL ( op ) , 'M'

ground_truth: ) ) return <NUM_LIT> ;


Template_token: <s> rtx tmp ; if ( ! INSN_P ( x ) || ! INSN_P ( y ) ) return <NUM_LIT> ; tmp = PATTERN ( y ) ; note_stores ( PATTERN ( x ) , insn_dependent_p_1 , & tmp ) ; if ( tmp == NULL_RTX

ground_truth: ) return true ;


Template_token: <s> static void insn_dependent_p_1 ( rtx x , rtx pat

ground_truth: ATTRIBUTE_UNUSED , void * data ) {


Template_token: <s> rtx * pinsn = ( rtx * ) data ; if ( * pinsn && reg_mentioned_p ( x , * pinsn

ground_truth: ) ) * pinsn = NULL_RTX ;


Template_token: <s> tmp = PATTERN ( y ) ; note_stores ( PATTERN ( x ) , insn_dependent_p_1


Template_token: <s> if ( mode == BLKmode ) words = ( ( int_size_in_bytes ( type ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; else words = ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; if ( ! targetm . calls . pass_by_reference ( & cum , mode , type , named ) && cum < MT_NUM_ARG_REGS && ( cum + words ) > MT_NUM_ARG_REGS ) { int bytes = ( MT_NUM_ARG_REGS - cum )

ground_truth: * UNITS_PER_WORD ;


Template_token: <s> static int mt_arg_partial_bytes ( CUMULATIVE_ARGS * pcum , enum machine_mode mode , tree type , bool named ATTRIBUTE_UNUSED ) { int cum = * pcum ; int words ; if ( mode == BLKmode ) words = ( ( int_size_in_bytes ( type ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; else words = ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; if ( ! targetm . calls . pass_by_reference ( & cum , mode , type , named ) && cum < MT_NUM_ARG_REGS &&

ground_truth: ( cum + words ) > MT_NUM_ARG_REGS ) {


Template_token: <s> if ( mt_nops_required ) fprintf ( f , <STR_LIT> , mt_nops_required , mt_nop_reasons ) ; while ( mt_nops_required ) { fprintf ( f ,

ground_truth: <STR_LIT> ) ;


Template_token: <s> rtx tmp ; rtx p ; rtx jmp ; gcc_assert ( GET_CODE ( PATTERN ( branch ) ) == SEQUENCE ) ; if ( INSN_DELETED_P ( branch ) ) return NULL_RTX ; slot = XVECEXP ( PATTERN ( branch ) , <NUM_LIT> , <NUM_LIT> ) ; tmp = PATTERN ( insn ) ; note_stores ( PATTERN ( slot ) , insn_dependent_p_1 , & tmp ) ; if ( tmp ) return NULL_RTX ; jmp = XVECEXP ( PATTERN ( branch ) , <NUM_LIT> , <NUM_LIT> ) ; tmp = PATTERN ( jmp ) ; note_stores ( PATTERN ( slot ) , insn_dependent_p_1 , & tmp ) ; if ( ! tmp ) return branch ; p = PREV_INSN ( branch ) ; NEXT_INSN ( p ) = slot ; PREV_INSN ( slot ) = p ; NEXT_INSN ( slot ) = jmp ; PREV_INSN ( jmp

ground_truth: ) = slot ;


ground_truth: ] || profile_flag || interrupt_handler ) ;


Template_token: <s> } fprintf ( stderr , <STR_LIT> , ( ( current_function_decl && DECL_NAME ( current_function_decl ) ) ? IDENTIFIER_POINTER ( DECL_NAME ( current_function_decl ) ) : <STR_LIT> ) ) ; fprintf ( stderr , <STR_LIT> , info -> total_size ) ; fprintf ( stderr , <STR_LIT> , info -> pretend_size ) ; fprintf ( stderr , <STR_LIT> , info -> args_size ) ; fprintf ( stderr , <STR_LIT> , info -> extra_size ) ; fprintf ( stderr , <STR_LIT> , info -> reg_size ) ; fprintf ( stderr , <STR_LIT> , info -> var_size ) ; fprintf ( stderr , <STR_LIT> , info -> frame_size ) ; fprintf ( stderr , <STR_LIT> , info -> reg_mask ) ; fprintf ( stderr , <STR_LIT> , info -> save_fp ) ; fprintf ( stderr , <STR_LIT> , info -> save_lr ) ; fprintf ( stderr , <STR_LIT> , info -> initialized ) ; fprintf ( stderr , <STR_LIT> ) ; for ( regno = GPR_R0 ; regno <= GPR_LAST ; regno ++ ) if ( ( <NUM_LIT> << regno ) & info -> reg_mask

ground_truth: ) fprintf ( stderr , <STR_LIT> , reg_names [ regno ] ) ;


Template_token: <s> if ( ! info ) { error ( <STR_LIT> ) ; gcc_unreachable ( ) ; } fprintf ( stderr , <STR_LIT> , ( ( current_function_decl && DECL_NAME ( current_function_decl ) ) ? IDENTIFIER_POINTER ( DECL_NAME ( current_function_decl ) ) : <STR_LIT> ) ) ; fprintf ( stderr , <STR_LIT> , info -> total_size ) ; fprintf ( stderr , <STR_LIT> , info -> pretend_size ) ; fprintf ( stderr , <STR_LIT> , info -> args_size ) ; fprintf ( stderr , <STR_LIT> , info -> extra_size ) ; fprintf ( stderr , <STR_LIT> , info -> reg_size ) ; fprintf ( stderr , <STR_LIT> , info -> var_size ) ; fprintf ( stderr , <STR_LIT> , info -> frame_size ) ; fprintf ( stderr , <STR_LIT> , info -> reg_mask ) ; fprintf ( stderr , <STR_LIT> , info -> save_fp ) ; fprintf ( stderr , <STR_LIT> ,

ground_truth: info -> save_lr ) ;


Template_token: <s> rtx condition_rtx , loc_ref ; if ( ! reg_or_0_operand ( op0 , SImode ) ) op0 = copy_to_mode_reg ( SImode , op0 ) ; if ( ! reg_or_0_operand ( op1 , SImode ) ) op1 = copy_to_mode_reg ( SImode , op1 ) ; condition_rtx = mt_generate_compare ( code , op0 , op1


Template_token: <s> offset = <NUM_LIT> ; } if ( info . save_fp ) { offset -= UNITS_PER_WORD ; stack_offset -= UNITS_PER_WORD ; mt_emit_save_restore ( direction , gen_rtx_REG ( SImode , GPR_FP ) , gen_rtx_MEM ( SImode , gen_rtx_PLUS (

ground_truth: SImode , base_reg , GEN_INT ( offset ) ) ) , stack_offset ) ;


Template_token: <s> int offset = info . total_size ; int stack_offset = info . total_size ; if ( ! info . save_fp && ! info . save_lr && ! reg_mask ) return ; if ( CONST_OK_FOR_LETTER_P ( offset , 'O' ) ) base_reg = stack_pointer_rtx ; else { base_reg = gen_rtx_REG ( SImode , GPR_R9 ) ; offset = <NUM_LIT> ; } if ( info . save_fp ) { offset -= UNITS_PER_WORD ; stack_offset -= UNITS_PER_WORD ; mt_emit_save_restore ( direction , gen_rtx_REG ( SImode , GPR_FP ) , gen_rtx_MEM ( SImode , gen_rtx_PLUS ( SImode , base_reg , GEN_INT ( offset ) )

ground_truth: ) , stack_offset ) ;


Template_token: <s> if ( CONST_OK_FOR_LETTER_P ( offset , 'O' ) ) base_reg = stack_pointer_rtx ; else { base_reg = gen_rtx_REG ( SImode , GPR_R9 ) ; offset = <NUM_LIT> ; } if ( info . save_fp ) { offset -= UNITS_PER_WORD ; stack_offset -= UNITS_PER_WORD ; } if ( info . save_lr ) { offset -= UNITS_PER_WORD ; stack_offset -= UNITS_PER_WORD ; mt_emit_save_restore ( direction , gen_rtx_REG ( SImode , GPR_LINK ) , gen_rtx_MEM ( SImode , gen_rtx_PLUS ( SImode , base_reg , GEN_INT ( offset ) ) ) , stack_offset ) ; } for ( regno = GPR_R0 ; regno <= GPR_LAST ; regno ++ ) { if ( ( reg_mask & ( <NUM_LIT> << regno )


Template_token: <s> mt_emit_save_restore ( direction , gen_rtx_REG ( SImode , GPR_LINK ) , gen_rtx_MEM ( SImode , gen_rtx_PLUS ( SImode , base_reg , GEN_INT ( offset ) ) ) , stack_offset ) ; } for ( regno = GPR_R0 ; regno <= GPR_LAST ; regno ++ ) { if ( ( reg_mask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) { offset -= UNITS_PER_WORD ; stack_offset -= UNITS_PER_WORD ; mt_emit_save_restore ( direction , gen_rtx_REG ( SImode , regno ) , gen_rtx_MEM ( SImode , gen_rtx_PLUS ( SImode , base_reg , GEN_INT ( offset )

ground_truth: ) ) , stack_offset ) ;


Template_token: <s> insn = emit_move_insn ( mem , reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( SImode , gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( stack_offset ) ) ) , reg ) , REG_NOTES ( insn ) ) ; } else emit_move_insn ( reg ,

ground_truth: mem ) ;


Template_token: <s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) != REG || REGNO ( operands [ <NUM_LIT> ] ) != EH_RETURN_STACKADJ_REGNO ) { rtx sp

ground_truth: = EH_RETURN_STACKADJ_RTX ;


Template_token: <s> frame_size = current_frame_info . total_size ; if ( CONST_OK_FOR_LETTER_P ( frame_size , 'O' ) ) size_rtx = GEN_INT ( frame_size ) ; else { gcc_assert ( ! interrupt_handler ) ; size_rtx = gen_rtx_REG ( SImode , GPR_R9 ) ; insn = emit_move_insn ( size_rtx , GEN_INT ( frame_size & <NUM_LIT> ) ) ; insn = emit_insn ( gen_iorsi3 ( size_rtx , size_rtx , GEN_INT ( frame_size & <NUM_LIT> ) ) ) ; emit_insn ( gen_addsi3 ( size_rtx , size_rtx , stack_pointer_rtx ) ) ; } if ( frame_pointer_needed ) insn = emit_move_insn ( stack_pointer_rtx , frame_pointer_rtx ) ; mt_emit_save_fp ( FROM_MEM_TO_PROCESSOR , current_frame_info ) ; mt_emit_save_regs ( FROM_MEM_TO_PROCESSOR , current_frame_info ) ; if ( frame_size ) { if ( CONST_OK_FOR_LETTER_P ( frame_size , 'O' ) ) insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , size_rtx ) ) ; else insn = emit_move_insn ( stack_pointer_rtx , gen_rtx_REG ( SImode , GPR_R9 ) ) ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( SImode , stack_pointer_rtx ,

ground_truth: GEN_INT ( frame_size ) ) ) , REG_NOTES ( insn ) ) ;


Template_token: <s> rtx reg ; slotno = mt_function_arg_slotno ( cum , mode , type , named , incoming_p , & regno ) ; if ( slotno == - <NUM_LIT> ) reg = NULL_RTX ; else reg = gen_rtx_REG ( mode , regno ) ; return

ground_truth: reg ;


Template_token: <s> rtx mt_function_arg ( const CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , int named , int incoming_p ) { int slotno , regno ; rtx reg ; slotno = mt_function_arg_slotno ( cum , mode , type , named , incoming_p , &

ground_truth: regno ) ;


Template_token: <s> int mt_function_arg_boundary ( enum machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED


Template_token: <s> static int mt_function_arg_slotno ( const CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , int named ATTRIBUTE_UNUSED , int incoming_p ATTRIBUTE_UNUSED , int * pregno ) { int regbase =


Template_token: <s> if ( ( mode ) == DImode || ( mode ) == DFmode ) return gen_rtx_MEM ( mode , gen_rtx_REG ( mode , RETURN_VALUE_REGNUM ) ) ; if ( valtype ) mode = TYPE_MODE

ground_truth: ( valtype ) ;


Template_token: <s> case LEU : scratch0 = gen_reg_rtx ( SImode ) ; scratch1 = gen_reg_rtx ( SImode ) ; const_scratch = force_reg ( SImode , GEN_INT ( MT_MIN_INT ) ) ; emit_insn ( gen_addsi3 ( scratch0 , const_scratch , op0 ) ) ; emit_insn ( gen_addsi3 ( scratch1 , const_scratch , op1 ) ) ; break ; default : scratch0 = op0 ; scratch1 = op1 ; break ; } switch ( code ) { case GTU : code = GT ; break ; case LTU


Template_token: <s> if ( CALL_P ( complete_insn ) ) return TYPE_BRANCH ; if ( GET_CODE ( insn ) != SET ) return TYPE_ARITH ; if ( SET_DEST ( insn ) == pc_rtx ) return


Template_token: <s> mt_compute_frame_size ( get_frame_size ( ) ) ; if ( from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) return <NUM_LIT> ; else if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) return current_frame_info

ground_truth: . total_size ;


Template_token: <s> if ( incoming ) fputs ( <STR_LIT> , stderr ) ; if ( fntype ) { tree ret_type = TREE_TYPE ( fntype ) ; fprintf ( stderr , <STR_LIT> , tree_code_name [ ( int )

ground_truth: TREE_CODE ( ret_type ) ] ) ;


Template_token: <s> static struct machine_function * mt_init_machine_status ( void ) { struct machine_function * f ; f = ggc_alloc_cleared ( sizeof (

ground_truth: struct machine_function ) ) ;


Template_token: <s> static struct machine_function * mt_init_machine_status ( void ) { struct machine_function *

ground_truth: f ;


Template_token: <s> static bool mt_interrupt_function_p ( tree func ) { tree a ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return false ; a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func


Template_token: <s> if ( GET_CODE ( xinsn ) == REG && mt_reg_ok_for_base_p ( xinsn , strict ) ) return true ; if ( GET_CODE ( xinsn ) == PLUS && GET_CODE ( XEXP ( xinsn , <NUM_LIT> ) ) == REG && mt_reg_ok_for_base_p ( XEXP ( xinsn , <NUM_LIT> ) , strict ) &&

ground_truth: GET_CODE ( XEXP ( xinsn , <NUM_LIT> ) ) == CONST_INT && SMALL_INT ( XEXP ( xinsn , <NUM_LIT> ) ) ) return true ;


Template_token: <s> static bool mt_pass_in_stack ( enum machine_mode mode ATTRIBUTE_UNUSED , tree type ) { return ( ( ( type ) != <NUM_LIT> && ( TREE_CODE ( TYPE_SIZE ( type ) ) != INTEGER_CST ||

ground_truth: TREE_ADDRESSABLE ( type ) ) ) ) ;


Template_token: <s> static void mt_print_operand_simple_address ( FILE * file , rtx addr ) { if ( ! addr ) error ( <STR_LIT> ) ; else switch ( GET_CODE ( addr ) ) { case REG : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( addr ) ] ) ; break ; case PLUS : { rtx reg = <NUM_LIT> ; rtx offset = <NUM_LIT> ; rtx arg0 = XEXP ( addr , <NUM_LIT> ) ; rtx arg1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( arg0 ) == REG ) { reg = arg0 ; offset = arg1 ; if ( GET_CODE ( offset ) == REG ) fatal_insn ( <STR_LIT> , addr ) ; } else if ( GET_CODE ( arg1 ) == REG ) reg = arg1 , offset = arg0 ; else if ( CONSTANT_P ( arg0 ) && CONSTANT_P ( arg1 ) ) { fprintf ( file , <STR_LIT> , reg_names [ GPR_R0 ] ) ; output_addr_const ( file , addr ) ; break ; } fprintf ( file , <STR_LIT> , reg_names [ REGNO ( reg ) ] ) ; output_addr_const ( file , offset ) ; break ; } case LABEL_REF : case SYMBOL_REF : case CONST_INT : case CONST : output_addr_const ( file , addr )


Template_token: <s> int mt_reg_ok_for_base_p ( rtx x , int strict ) { if ( strict ) return ( ( ( unsigned ) REGNO (

ground_truth: x ) ) < FIRST_PSEUDO_REGISTER ) ;


Template_token: <s> rtx jmp , tmp ; enum attr_type attr ; gcc_assert ( INSN_P ( insn ) && ! INSN_DELETED_P ( insn ) ) ; for ( next = NEXT_INSN ( insn ) ; next ; next = NEXT_INSN ( next ) ) { if ( ! INSN_P ( next ) ) continue ; if ( GET_CODE ( PATTERN ( next ) ) != USE ) break ; } jmp = insn ; if ( GET_CODE ( PATTERN ( insn ) ) == SEQUENCE ) jmp = XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ; attr = recog_memoized ( jmp ) >= <NUM_LIT> ? get_attr_type ( jmp ) : TYPE_UNKNOWN ; if ( next && attr == TYPE_LOAD ) { tmp = PATTERN ( next ) ; if ( GET_CODE ( tmp ) == SEQUENCE ) tmp = PATTERN ( XVECEXP ( tmp , <NUM_LIT> , <NUM_LIT> ) ) ; note_stores ( PATTERN ( insn ) , insn_dependent_p_1 , & tmp ) ; if ( ! tmp ) emit_insn_after ( gen_nop ( ) , insn ) ; } if ( attr == TYPE_CALL ) { int nops = <NUM_LIT> ; int count ; rtx prev = insn ; rtx rescan = NULL_RTX ; for ( count = <NUM_LIT> ; count && ! nops ; ) { int type ; prev = PREV_INSN ( prev ) ; if ( ! prev ) { nops = count ; break ; } if ( BARRIER_P ( prev ) ) break ; if ( LABEL_P ( prev ) ) { label_info * label ; branch_info * branch ; for ( label = mt_labels ; label ; label = label -> next ) if ( label -> label == prev ) { for ( branch = label -> branches ; branch ; branch = branch -> next


Template_token: <s> if ( count != <NUM_LIT> ) return NULL_RTX ; return get_hard_reg_initial_val ( Pmode

ground_truth: , GPR_LINK ) ;


Template_token: <s> int regs = MT_NUM_ARG_REGS - * cum ; * pretend_size = regs < <NUM_LIT> ? <NUM_LIT> : GET_MODE_SIZE ( SImode ) * regs ; if ( no_rtl ) return ; for ( regno = * cum ; regno < MT_NUM_ARG_REGS ; regno ++ ) { rtx reg = gen_rtx_REG ( SImode , FIRST_ARG_REGNUM

ground_truth: + regno ) ;


Template_token: <s> int in_struct_p , volatile_p ; if ( GET_CODE ( ref ) != MEM ) return ; in_struct_p = MEM_IN_STRUCT_P ( ref ) ; volatile_p = MEM_VOLATILE_P

ground_truth: ( ref ) ;


Template_token: <s> } break ; default : gcc_unreachable ( ) ; } switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { case REG : if ( ! IS_PSEUDO_P ( operands [ <NUM_LIT> ] ) ) { int r = REGNO ( operands [ <NUM_LIT> ] ) ; sh = gen_rtx_REG ( nmode , r ) ; sl = gen_rtx_REG ( nmode , r + HARD_REGNO_NREGS ( r , nmode ) ) ; } else { sh = gen_rtx_SUBREG ( nmode , operands [ <NUM_LIT> ] , <NUM_LIT> ) ; sl = gen_rtx_SUBREG ( nmode , operands [ <NUM_LIT> ] , GET_MODE_SIZE ( nmode ) ) ; } break ; case CONST_DOUBLE : if ( operands [ <NUM_LIT> ] == const0_rtx ) sh = sl = const0_rtx ; else split_double ( operands [ <NUM_LIT> ] , & sh , & sl ) ; break ; case CONST_INT : if ( operands [ <NUM_LIT> ] == const0_rtx ) sh = sl = const0_rtx ; else { int vl , vh ; switch ( nmode ) { default : gcc_unreachable ( ) ; } sl = GEN_INT ( vl ) ; sh = GEN_INT ( vh ) ; } break ; case SUBREG : sl = gen_rtx_SUBREG ( nmode , SUBREG_REG ( operands [ <NUM_LIT> ] ) , SUBREG_BYTE ( operands [ <NUM_LIT> ] ) + GET_MODE_SIZE ( nmode ) ) ; sh = gen_rtx_SUBREG ( nmode , SUBREG_REG ( operands [ <NUM_LIT> ] ) , SUBREG_BYTE

ground_truth: ( operands [ <NUM_LIT> ] ) ) ;


Template_token: <s> dl = gen_rtx_REG ( nmode , r + HARD_REGNO_NREGS ( r , nmode ) ) ; } else { dh = gen_rtx_SUBREG ( nmode , operands [ <NUM_LIT> ] , <NUM_LIT> ) ; dl = gen_rtx_SUBREG ( nmode , operands [ <NUM_LIT> ] , GET_MODE_SIZE ( nmode ) ) ; } break ; case MEM : switch ( GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ) { case POST_INC : case POST_DEC : gcc_unreachable ( ) ; default : dl = operand_subword ( operands [ <NUM_LIT> ] , GET_MODE_SIZE ( nmode ) / UNITS_PER_WORD , <NUM_LIT> , omode ) ; dh = operand_subword ( operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> , omode ) ; } break ; default : gcc_unreachable ( ) ; } switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { case REG : if ( ! IS_PSEUDO_P ( operands [ <NUM_LIT> ] ) ) { int r = REGNO ( operands [ <NUM_LIT> ] ) ; sh = gen_rtx_REG ( nmode , r ) ; sl = gen_rtx_REG ( nmode , r + HARD_REGNO_NREGS ( r , nmode ) ) ; } else { sh = gen_rtx_SUBREG ( nmode , operands [ <NUM_LIT> ] , <NUM_LIT> ) ; sl = gen_rtx_SUBREG ( nmode , operands [ <NUM_LIT> ] , GET_MODE_SIZE ( nmode ) ) ; } break ; case CONST_DOUBLE : if ( operands [ <NUM_LIT> ] == const0_rtx ) sh = sl = const0_rtx ; else split_double ( operands [ <NUM_LIT> ] , & sh , & sl ) ; break ; case CONST_INT : if ( operands [ <NUM_LIT> ] == const0_rtx ) sh = sl = const0_rtx ; else { int vl , vh ; switch ( nmode ) { default : gcc_unreachable ( ) ; } sl = GEN_INT ( vl ) ; sh = GEN_INT ( vh ) ; } break ; case SUBREG : sl = gen_rtx_SUBREG ( nmode , SUBREG_REG ( operands [ <NUM_LIT> ] ) , SUBREG_BYTE ( operands [ <NUM_LIT> ] ) + GET_MODE_SIZE ( nmode ) ) ; sh = gen_rtx_SUBREG ( nmode , SUBREG_REG ( operands [ <NUM_LIT> ] ) , SUBREG_BYTE ( operands [ <NUM_LIT> ] ) ) ; break ; case MEM : switch ( GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ) { case POST_DEC : case POST_INC : gcc_unreachable ( ) ; break ; default : sl = operand_subword ( operands [ <NUM_LIT> ] , GET_MODE_SIZE ( nmode ) / UNITS_PER_WORD , <NUM_LIT> , omode ) ; sh = operand_subword ( operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> , omode ) ; if ( GET_CODE ( dl ) == REG && true_regnum ( dl ) == true_regnum ( XEXP ( XEXP ( sl , <NUM_LIT> ) , <NUM_LIT> ) ) )


Template_token: <s> return gen_rtx_REG ( Pmode

ground_truth: , RETVAL_REGNUM ) ;


Template_token: <s> case CONST_INT : return INTVAL ( op ) == <NUM_LIT> ; case REG : case

ground_truth: SUBREG :


Template_token: <s> int single_const_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { if ( big_const_operand ( op , mode ) || GET_CODE ( op ) == CONST || GET_CODE ( op ) == LABEL_REF || GET_CODE ( op ) == SYMBOL_REF ) return <NUM_LIT> ; return <NUM_LIT>


Template_token: <s> int single_const_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { if ( big_const_operand ( op , mode ) || GET_CODE ( op ) == CONST || GET_CODE ( op ) ==

ground_truth: LABEL_REF || GET_CODE ( op ) == SYMBOL_REF ) return <NUM_LIT> ;