Template_token: <s> int named_size = <NUM_LIT> ; if ( ! TYPE_NO_NAMED_ARGS_STDARG_P ( TREE_TYPE ( current_function_decl ) ) ) named_size = GET_MODE_SIZE ( SImode ) * ( * cum - FT32_R0 ) + GET_MODE_SIZE ( arg . mode ) ; if ( named_size < <NUM_LIT> ) * pretend_size =

Target_Clf: MPU

Compiler_Type: GCC


Template_token: <s> op2 = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( op1 ) == REG && CONST_INT_P ( op2 ) && INTVAL ( op2 ) >= - <NUM_LIT> && INTVAL ( op2 ) < <NUM_LIT> && reg_ok_for_base_p ( op1 , strict ) ) goto yes ; if ( GET_CODE ( op1 ) == SYMBOL_REF && CONST_INT_P ( op2 ) ) goto yes ; } if ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) ) goto yes ; if ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF || CONST_INT_P ( x ) ) goto yes ; } else { if ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) ) goto yes ; } return <NUM_LIT> ; yes : return


Template_token: <s> if ( GET_CODE ( op1 ) == SYMBOL_REF && CONST_INT_P ( op2 ) ) goto yes ; } if ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) ) goto yes ; if ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF || CONST_INT_P ( x ) ) goto yes ; } else { if ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) )

ground_truth: goto yes ;


Template_token: <s> static enum machine_mode ft32_addr_space_pointer_mode ( addr_space_t addrspace ATTRIBUTE_UNUSED ) { return Pmode


Template_token: <s> if ( * cum >= <NUM_LIT> ) return <NUM_LIT> ; if ( ft32_pass_by_reference ( cum_v , mode , type , named ) ) size = <NUM_LIT> ; else if ( type ) { if ( AGGREGATE_TYPE_P ( type

ground_truth: ) ) return <NUM_LIT> ;


Template_token: <s> if ( ft32_pass_by_reference ( cum_v , mode , type , named ) ) size = <NUM_LIT> ; else if ( type ) { if ( AGGREGATE_TYPE_P ( type ) ) return <NUM_LIT> ; size = int_size_in_bytes

ground_truth: ( type ) ;


Template_token: <s> int padding_locals ; int regno ; cfun -> machine -> local_vars_size = get_frame_size ( ) ; padding_locals = cfun -> machine -> local_vars_size % stack_alignment ; if ( padding_locals ) padding_locals = stack_alignment - padding_locals ; cfun -> machine -> local_vars_size += padding_locals ; cfun -> machine -> callee_saved_reg_size = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ( ! call_used_regs [ regno ] ) ) cfun -> machine -> callee_saved_reg_size += <NUM_LIT> ; cfun -> machine -> size_for_adjusting_sp = crtl -> args . pretend_args_size + cfun -> machine -> local_vars_size + ( ACCUMULATE_OUTGOING_ARGS

ground_truth: ? crtl -> outgoing_args_size : <NUM_LIT> ) ;


Template_token: <s> int regno ; rtx insn ; ft32_compute_frame ( ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = cfun -> machine -> size_for_adjusting_sp ; if ( ! must_link ( ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_R13 ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ; } if ( optimize_size ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; emit_insn ( gen_call_prolog ( preg ) ) ; break ; } } } else { for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( ! fixed_regs [ regno ] && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno


Template_token: <s> static void ft32_function_arg_advance ( cumulative_args_t cum_v , enum machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; * cum = ( * cum < FT32_R6 ? * cum + ( ( <NUM_LIT> + FT32_FUNCTION_ARG_SIZE ( mode

ground_truth: , type ) ) / <NUM_LIT> ) : * cum ) ;


Template_token: <s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; * cum = ( * cum < FT32_R6 ? * cum + ( ( <NUM_LIT> + FT32_FUNCTION_ARG_SIZE (

ground_truth: mode , type ) ) / <NUM_LIT> ) : * cum ) ;


Template_token: <s> static rtx ft32_libcall_value ( enum machine_mode mode

ground_truth: , const_rtx fun ATTRIBUTE_UNUSED ) {


Template_token: <s> for ( rd = <NUM_LIT> ; rd < <NUM_LIT> ; rd ++ ) { u = ( ( u >> <NUM_LIT> ) & <NUM_LIT> ) | ( u << <NUM_LIT> ) ; if ( ( - <NUM_LIT> <= ( int32_t ) u ) && ( ( int32_t ) u <= <NUM_LIT> ) ) { ft32_load_immediate ( dst , ( int32_t ) u ) ; sprintf ( pattern , <STR_LIT> , rd ) ; output_asm_insn ( pattern , & dst ) ; return <STR_LIT> ; } } ft32_load_immediate ( dst , i >> <NUM_LIT> ) ; sprintf ( pattern , <STR_LIT> , i & <NUM_LIT>


Template_token: <s> else { int rd ; uint32_t u = i ; for ( rd = <NUM_LIT> ; rd < <NUM_LIT> ; rd ++ ) { u = ( ( u >> <NUM_LIT> ) & <NUM_LIT> ) | ( u << <NUM_LIT> ) ; if ( ( - <NUM_LIT> <= ( int32_t ) u ) && ( ( int32_t ) u <= <NUM_LIT> ) ) { ft32_load_immediate ( dst , ( int32_t ) u ) ; sprintf ( pattern , <STR_LIT> , rd ) ; output_asm_insn ( pattern , & dst ) ; return <STR_LIT> ; } } ft32_load_immediate ( dst , i >> <NUM_LIT> ) ; sprintf ( pattern , <STR_LIT> , i & <NUM_LIT> ) ; output_asm_insn ( pattern , &

ground_truth: dst ) ;


Template_token: <s> static bool ft32_pass_by_reference ( cumulative_args_t cum ATTRIBUTE_UNUSED , enum machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { unsigned HOST_WIDE_INT size ; if ( type ) { if ( AGGREGATE_TYPE_P ( type ) ) return true ; size = int_size_in_bytes ( type ) ; } else size = GET_MODE_SIZE (

ground_truth: mode ) ;


Template_token: <s> fprintf ( file , <STR_LIT> , dwspec ) ; return ; } case 'f' : { int bf = ft32_as_bitfield ( INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >> <NUM_LIT> , bf & <NUM_LIT> ) ; return ; } case 'g' : { int bf = ft32_as_bitfield ( <NUM_LIT> ^ INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >> <NUM_LIT> , bf & <NUM_LIT> ) ; return ; } case 'b' : { ft32_print_operand ( file , XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; return ; } default : LOSE_AND_RETURN ( <STR_LIT> , x ) ; } switch ( GET_CODE ( operand ) ) { case REG : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( operand ) ] ) ; return ; case MEM : output_address ( GET_MODE ( XEXP ( operand , <NUM_LIT> )

ground_truth: ) , XEXP ( operand , <NUM_LIT> ) ) ;


Template_token: <s> rtx operand = x ; switch ( code ) { case <NUM_LIT> : break ; case 'h' : if ( GET_CODE ( operand ) != REG ) internal_error ( <STR_LIT> ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( operand ) + <NUM_LIT> ] ) ; return ; case 'm' : fprintf ( file , <STR_LIT> , ( long ) ( - INTVAL ( x ) ) ) ; return ; case 'd' : { int i = INTVAL ( x ) ; char dwspec ; switch ( i ) { case <NUM_LIT> : dwspec = 'b' ; break ; case <NUM_LIT> : dwspec = 's' ; break ; case <NUM_LIT> : dwspec = 'l' ; break ; default : if ( ( i % <NUM_LIT> ) != <NUM_LIT> ) internal_error ( <STR_LIT> , i ) ; else dwspec = 'l' ; break ; } fprintf ( file , <STR_LIT> , dwspec ) ; return ; } case 'f' : { int bf = ft32_as_bitfield ( INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >> <NUM_LIT> , bf & <NUM_LIT> ) ; return ; } case 'g' : { int bf = ft32_as_bitfield ( <NUM_LIT> ^ INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >>

ground_truth: <NUM_LIT> , bf & <NUM_LIT> ) ;


Template_token: <s> if ( mode == SImode ) return <NUM_LIT> ; return <NUM_LIT>


Template_token: <s> int pretend = crtl -> args . pretend_args_size ; if ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { emit_jump_insn ( gen_returner24 ( ) ) ; return ; } int epilog24 = ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && optimize_size ) ; if ( must_link ( ) ) { emit_insn ( gen_unlink ( ) ) ; } else if ( ! epilog24 && ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) ) { emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , FT32_SP ) , gen_rtx_REG ( SImode , FT32_SP ) , GEN_INT ( cfun -> machine -> size_for_adjusting_sp ) ) ) ; } if ( cfun -> machine -> callee_saved_reg_size != <NUM_LIT> ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; if ( optimize_size && ( pretend == <NUM_LIT> ) ) { if ( epilog24 ) emit_insn ( gen_jump_epilog24 ( preg ) ) ; else emit_insn ( gen_jump_epilog ( preg ) ) ; return ; } emit_insn ( gen_movsi_pop ( preg ) ) ; } } } if ( pretend != <NUM_LIT> ) emit_jump_insn ( gen_pretend_returner ( GEN_INT ( pretend ) ) ) ; else emit_jump_insn ( gen_returner


Template_token: <s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int named_size = GET_MODE_SIZE ( SImode ) * ( * cum - FT32_R0 )

ground_truth: + GET_MODE_SIZE ( mode ) ;


Template_token: <s> static void ft32_setup_incoming_varargs ( cumulative_args_t cum_v , enum machine_mode mode , tree type ATTRIBUTE_UNUSED , int * pretend_size , int no_rtl ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int named_size = GET_MODE_SIZE ( SImode ) * ( * cum - FT32_R0 ) + GET_MODE_SIZE (


Template_token: <s> int bytes_left , size ; if ( * cum >= <NUM_LIT> ) return <NUM_LIT> ; if ( ft32_pass_by_reference ( cum_v , mode , type , named ) ) size = <NUM_LIT> ; else if ( type ) { if ( AGGREGATE_TYPE_P ( type ) ) return <NUM_LIT> ; size = int_size_in_bytes ( type ) ; } else size = GET_MODE_SIZE ( mode ) ; bytes_left = ( <NUM_LIT> * <NUM_LIT> ) - ( ( * cum - <NUM_LIT> ) * <NUM_LIT> ) ; if ( size > bytes_left

ground_truth: ) return bytes_left ;


Template_token: <s> cfun -> machine -> local_vars_size += padding_locals ; cfun -> machine -> callee_saved_reg_size = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno ) &&

ground_truth: ( ! call_used_regs [ regno ] ) ) cfun -> machine -> callee_saved_reg_size += <NUM_LIT> ;


Template_token: <s> } if ( optimize_size ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; emit_insn ( gen_call_prolog ( preg ) ) ; break ; } } } else { for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( ! fixed_regs [ regno ] && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) { insn = emit_insn ( gen_movsi_push ( gen_rtx_REG ( Pmode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } if ( cfun -> machine -> size_for_adjusting_sp >= <NUM_LIT> ) { error ( <STR_LIT> ) ; return ; } if ( must_link ( ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_FP ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else if ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) { int adj = cfun -> machine -> size_for_adjusting_sp ; insn = emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , FT32_SP ) , gen_rtx_REG ( SImode , FT32_SP ) , GEN_INT ( - adj


Template_token: <s> if ( ! must_link ( ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_R13 ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ; } if ( optimize_size ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; emit_insn ( gen_call_prolog ( preg ) ) ; break ; } } } else { for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( ! fixed_regs [ regno ] && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) { insn = emit_insn ( gen_movsi_push ( gen_rtx_REG ( Pmode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } if ( cfun -> machine -> size_for_adjusting_sp >= <NUM_LIT> ) { error ( <STR_LIT> ) ; return ; } if ( must_link ( ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_FP ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else if ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) { int adj = cfun

ground_truth: -> machine -> size_for_adjusting_sp ;


Template_token: <s> static rtx ft32_function_arg ( cumulative_args_t cum_v , machine_mode mode , const_tree type ATTRIBUTE_UNUSED , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( * cum < <NUM_LIT> ) return gen_rtx_REG ( mode , * cum ) ; else return


ground_truth: mode , const_tree type , bool named ATTRIBUTE_UNUSED ) {


Template_token: <s> size = int_size_in_bytes ( type ) ; } else size = GET_MODE_SIZE ( mode ) ; return size > <NUM_LIT> *


Template_token: <s> int bytes_left , size ; if ( * cum >= <NUM_LIT> ) return <NUM_LIT> ; if ( ft32_pass_by_reference ( cum_v , arg ) ) size = <NUM_LIT> ; else if ( arg . type ) { if ( AGGREGATE_TYPE_P ( arg . type ) ) return <NUM_LIT> ; size = int_size_in_bytes ( arg . type ) ; } else size = GET_MODE_SIZE ( arg . mode ) ; bytes_left = ( <NUM_LIT> * <NUM_LIT> ) - ( ( * cum - <NUM_LIT> ) * <NUM_LIT> ) ; if ( size > bytes_left ) return bytes_left ; else return


Template_token: <s> int bytes_left , size ; if ( * cum >= <NUM_LIT> ) return <NUM_LIT> ; if ( ft32_pass_by_reference ( cum_v , arg ) ) size = <NUM_LIT> ; else if ( arg . type ) { if ( AGGREGATE_TYPE_P ( arg . type ) )

ground_truth: return <NUM_LIT> ;


Template_token: <s> int ft32_as_bitfield ( unsigned int x ) { int lobit , hibit ; if ( x == <NUM_LIT> ) return - <NUM_LIT> ; for ( lobit = <NUM_LIT> ; lobit < <NUM_LIT> ; lobit ++ ) if ( x & ( <NUM_LIT> << lobit ) ) break ; for ( hibit = <NUM_LIT> ; hibit >= <NUM_LIT> ; hibit -- ) if ( x & ( <NUM_LIT> << hibit ) ) break ; int width = <NUM_LIT> + hibit

ground_truth: - lobit ;


Template_token: <s> cfun -> machine -> callee_saved_reg_size = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno )

ground_truth: && ! call_used_or_fixed_reg_p ( regno ) ) cfun -> machine -> callee_saved_reg_size += <NUM_LIT> ;


Template_token: <s> int is_flash = ( type && TYPE_P ( type ) && ! ADDR_SPACE_GENERIC_P ( TYPE_ADDR_SPACE ( type ) ) ) ; if ( ( code == VAR_DECL ) && ! is_flash ) SYMBOL_REF_FLAGS ( symbol ) |= <NUM_LIT> ; } break ; case tcc_constant : case tcc_exceptional : if ( code == STRING_CST ) SYMBOL_REF_FLAGS ( symbol


Template_token: <s> void ft32_expand_epilogue ( void ) { int regno ; int pretend = crtl -> args . pretend_args_size ; if ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { emit_jump_insn ( gen_returner24 ( ) ) ; return ; } int epilog24 = ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && optimize_size ) ; if ( must_link ( ) ) { emit_insn ( gen_unlink ( ) ) ; } else if ( ! epilog24 && ( cfun

ground_truth: -> machine -> size_for_adjusting_sp > <NUM_LIT> ) ) {


Template_token: <s> insn = emit_insn ( gen_movsi_push ( ( gen_rtx_REG ( Pmode , FT32_R5 - i ) ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } insn = emit_insn ( gen_movsi_push ( ( gen_rtx_REG ( Pmode , FT32_R29 ) ) ) ) ; } if ( flag_stack_usage_info ) current_function_static_stack_size = cfun -> machine -> size_for_adjusting_sp ; if ( ! must_link ( ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_R13 ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ; } if ( optimize_size ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! call_used_or_fixed_reg_p ( regno ) && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; emit_insn ( gen_call_prolog ( preg ) ) ; break ; } } } else { for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) { insn = emit_insn ( gen_movsi_push ( gen_rtx_REG ( Pmode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } if ( cfun -> machine -> size_for_adjusting_sp >= <NUM_LIT> ) { error ( <STR_LIT> ) ; return ; } if ( must_link ( ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_FP ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) =


Template_token: <s> static bool ft32_fixed_condition_code_regs ( unsigned int * p1 , unsigned int *


Template_token: <s> static bool ft32_frame_pointer_required ( void ) { return cfun -> calls_alloca


Template_token: <s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( * cum < <NUM_LIT> ) return gen_rtx_REG ( arg . mode , * cum ) ; else return


Template_token: <s> * cum = ( * cum < FT32_R6 ? * cum + ( ( <NUM_LIT> + FT32_FUNCTION_ARG_SIZE ( arg . mode , arg

ground_truth: . type ) ) / <NUM_LIT> ) : * cum ) ;


Template_token: <s> return gen_rtx_REG ( TYPE_MODE ( valtype ) ,


Template_token: <s> static bool ft32_function_value_regno_p ( const unsigned int regno ) { return ( regno ==


Template_token: <s> if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) { int arg_offset ; arg_offset = must_link ( ) ? <NUM_LIT> : <NUM_LIT> ; return ( ( cfun -> machine -> callee_saved_reg_size + arg_offset * UNITS_PER_WORD ) + cfun -> machine ->

ground_truth: size_for_adjusting_sp ) ;


Template_token: <s> return gen_rtx_REG ( mode , FT32_R0


Template_token: <s> sprintf ( pattern , <STR_LIT> , i ) ; output_asm_insn ( pattern , & dst ) ; } else if ( i >= - <NUM_LIT> && i <= <NUM_LIT> ) { ft32_load_immediate ( dst , i >> <NUM_LIT> ) ; sprintf ( pattern , <STR_LIT> , i & <NUM_LIT> ) ; output_asm_insn ( pattern , & dst ) ; } else { int rd ; uint32_t u


Template_token: <s> switch ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) ) { case CONST_INT : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( x , <NUM_LIT> ) ) ] , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ; break ; case SYMBOL_REF : output_addr_const ( file , XEXP ( x , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( x , <NUM_LIT> ) ) ] ) ; break ; case CONST : { rtx plus = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( plus , <NUM_LIT> ) ) == SYMBOL_REF && CONST_INT_P ( XEXP ( plus , <NUM_LIT> ) ) ) { output_addr_const ( file , XEXP ( plus , <NUM_LIT>


Template_token: <s> if ( TREE_TYPE ( decl ) != error_mark_node && TYPE_ADDR_SPACE ( TREE_TYPE ( decl ) ) == ADDR_SPACE_PM ) { if ( ! DECL_P ( decl ) ) return get_section ( <STR_LIT> , SECTION_WRITE | SECTION_DEBUG , NULL ) ; return get_named_section ( decl , <STR_LIT> , reloc ) ; } return default_elf_select_section ( decl ,

ground_truth: reloc , align ) ;


Template_token: <s> int named_size = GET_MODE_SIZE ( SImode ) * ( * cum - FT32_R0 ) + GET_MODE_SIZE ( arg . mode ) ; if ( named_size < <NUM_LIT> ) *


Template_token: <s> static int must_link ( void ) { int bigframe = ( cfun -> machine -> size_for_adjusting_sp


Template_token: <s> static bool reg_ok_for_base_p ( rtx r , bool strict ) { int NUM = REGNO