<s> } else { builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( ! TARGET_SOFT_MUL ) { if ( ! flag_iso ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( TARGET_MULTIPLY_HIGH ) { if ( ! flag_iso ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( ! TARGET_SOFT_DIV ) { if ( ! flag_iso ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ;


<s> if ( ! flag_iso ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( TARGET_BARREL_SHIFT ) { if ( ! flag_iso ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( TARGET_PATTERN_COMPARE ) { if ( ! flag_iso ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( TARGET_HARD_FLOAT ) { if ( ! flag_iso ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( TARGET_FLOAT_CONVERT ) {


<s> if ( CALL_P ( branch ) ) { rtx call ; call = XVECEXP ( PATTERN ( branch ) , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ; if ( GET_CODE ( call ) != CALL ) gcc_unreachable ( ) ; return XEXP ( XEXP ( call , <NUM_LIT> ) , <NUM_LIT> ) ; }


<s> call = XVECEXP ( PATTERN ( branch ) , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ;

if ( GET_CODE ( call ) != CALL ) gcc_unreachable ( ) ;


<s> else return <NUM_LIT> ; case ADDRESS_CONST_INT : if ( SMALL_INT ( x ) ) return <NUM_LIT> ; else return <NUM_LIT> ; case ADDRESS_REG_INDEX : return <NUM_LIT> ; case ADDRESS_SYMBOLIC : case ADDRESS_SYMBOLIC_TXT_REL : case ADDRESS_GOTOFF : return <NUM_LIT> ; case ADDRESS_TLS :


<s> case ADDRESS_SYMBOLIC_TXT_REL : case ADDRESS_GOTOFF : return <NUM_LIT> ; case ADDRESS_TLS : switch ( addr . tls_type ) { case TLS_GD : return <NUM_LIT> ; case TLS_LDM : return <NUM_LIT> ; case TLS_DTPREL : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } default :


<s> emit_move_insn ( op0 , result ) ; return true ; } else if ( flag_pic ) { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; result = expand_pic_symbol_ref ( mode , op1 ) ; if ( TARGET_PIC_DATA_TEXT_REL && GET_CODE ( op0 ) == REG && REGNO ( op0 ) >= FIRST_PSEUDO_REGISTER ) result = force_reg ( SImode , result ) ; emit_move_insn ( op0 , result ) ; return true ; } } if ( GET_CODE ( op1 ) == PLUS && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == CONST ) { rtx p0 , p1 = NULL , result , temp ; p0 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( p0 ) == PLUS ) { p1 = XEXP ( p0 , <NUM_LIT> ) ; p0 = XEXP ( p0 , <NUM_LIT> ) ; }


<s> } if ( GET_CODE ( op1 ) == SYMBOL_REF || GET_CODE ( op1 ) == LABEL_REF ) { rtx result ; if ( microblaze_tls_symbol_p ( op1 ) ) { result = microblaze_legitimize_tls_address ( op1 , NULL_RTX ) ; emit_move_insn ( op0 , result ) ; return true ; } else if ( flag_pic ) { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; result = expand_pic_symbol_ref ( mode , op1 ) ; if ( TARGET_PIC_DATA_TEXT_REL && GET_CODE ( op0 ) == REG && REGNO ( op0 ) >= FIRST_PSEUDO_REGISTER ) result = force_reg ( SImode , result ) ; emit_move_insn ( op0 , result ) ; return true ; } } if ( GET_CODE ( op1 ) == PLUS && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == CONST ) { rtx p0 , p1 = NULL , result , temp ; p0 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( p0 ) == PLUS ) { p1 = XEXP ( p0 , <NUM_LIT> ) ; p0 = XEXP ( p0 , <NUM_LIT> ) ; } if ( p1 == NULL ) gcc_unreachable ( ) ; if ( GET_CODE ( p0 ) == UNSPEC && GET_CODE ( p1 ) == CONST_INT && flag_pic && TARGET_PIC_DATA_TEXT_REL ) { result = gen_rtx_CONST ( Pmode , p0 ) ; result = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , result ) ; temp = force_reg ( SImode , result ) ; emit_move_insn ( op0 , gen_rtx_PLUS ( SImode , temp , p1 ) ) ; return true ; } }

if ( GET_CODE ( op1 ) == CONST && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == PLUS ) {


<s> break ; case ADDRESS_CONST_INT : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regA ) ] ) ; output_addr_const ( file , info . offset ) ; break ; case ADDRESS_SYMBOLIC : case ADDRESS_SYMBOLIC_TXT_REL : case ADDRESS_GOTOFF : case ADDRESS_PLT : case ADDRESS_TLS : if ( info . regA ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regA ) ] ) ; output_addr_const ( file , info . symbol ) ; if ( type == ADDRESS_GOTOFF ) { fputs ( <STR_LIT> , file ) ; } else if ( type == ADDRESS_PLT ) { fputs ( <STR_LIT> , file ) ; } else if ( type == ADDRESS_SYMBOLIC_TXT_REL ) { if ( info . offset != NULL && CONST_INT_P ( info . offset ) && INTVAL ( info . offset ) > <NUM_LIT> ) { fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , info . offset ) ; } fputs ( <STR_LIT> , file ) ; }


<s> case ADDRESS_REG : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regA ) ] ) ; output_addr_const ( file , info . offset ) ; break ; case ADDRESS_REG_INDEX : if ( REGNO ( info . regA ) == <NUM_LIT> ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regB ) ] , reg_names [ REGNO ( info . regA ) ] ) ; else if ( REGNO ( info . regB ) != <NUM_LIT> ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regB ) ] , reg_names [ REGNO ( info . regA ) ] ) ; break ; case ADDRESS_CONST_INT : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regA ) ] ) ; output_addr_const ( file , info . offset ) ; break ; case ADDRESS_SYMBOLIC : case ADDRESS_SYMBOLIC_TXT_REL : case ADDRESS_GOTOFF : case ADDRESS_PLT : case ADDRESS_TLS : if ( info . regA ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regA ) ] ) ; output_addr_const ( file , info . symbol ) ; if ( type == ADDRESS_GOTOFF ) { fputs ( <STR_LIT> , file ) ; } else if ( type == ADDRESS_PLT ) { fputs ( <STR_LIT> , file ) ; } else if ( type == ADDRESS_SYMBOLIC_TXT_REL ) { if ( info . offset != NULL && CONST_INT_P ( info . offset ) && INTVAL ( info . offset ) > <NUM_LIT> ) { fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , info . offset ) ; } fputs ( <STR_LIT> , file ) ;


<s> gp_reg_size = <NUM_LIT> ; mask = <NUM_LIT> ; var_size = size ; args_size = crtl -> outgoing_args_size ; if ( ( args_size == <NUM_LIT> ) && cfun -> calls_alloca ) args_size = NUM_OF_ARGS * UNITS_PER_WORD ; total_size = var_size + args_size ; if ( flag_pic == <NUM_LIT> ) df_set_regs_ever_live ( MB_ABI_PIC_ADDR_REGNUM , true ) ; for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) { if ( microblaze_must_save_register ( regno ) ) { if ( regno != MB_ABI_SUB_RETURN_ADDR_REGNUM ) gp_reg_size += GET_MODE_SIZE ( SImode ) ; mask |= ( <NUM_LIT> << ( regno - GP_REG_FIRST ) ) ; } } total_size += gp_reg_size ; if ( microblaze_is_interrupt_variant ( ) ) total_size += <NUM_LIT> ; if ( total_size == <NUM_LIT> && crtl -> is_leaf ) link_debug_size = <NUM_LIT> ; else link_debug_size = UNITS_PER_WORD ; total_size += link_debug_size ; current_frame_info . total_size = total_size ; current_frame_info . var_size = var_size ; current_frame_info . args_size = args_size ; current_frame_info . gp_reg_size = gp_reg_size ; current_frame_info . mask = mask ; current_frame_info . initialized = reload_completed ; current_frame_info . num_gp = gp_reg_size / UNITS_PER_WORD ; current_frame_info . link_debug_size = link_debug_size ; if ( mask ) current_frame_info . gp_offset = ( total_size - gp_reg_size ) ; else current_frame_info . gp_offset = <NUM_LIT> ; return total_size ;


<s> addr = XEXP ( op , <NUM_LIT> ) ; if ( CONSTANT_ADDRESS_P ( addr ) ) return <NUM_LIT> ;

return memory_address_p ( ( GET_MODE_CLASS ( mode ) == MODE_INT ? SImode : SFmode ) , plus_constant ( Pmode , addr , <NUM_LIT> ) ) ;


<s> result = gen_rtx_CONST ( Pmode , result ) ; result = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , result ) ; result = gen_const_mem ( Pmode , result ) ;


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( ( mode == BLKmode || GET_MODE_CLASS ( mode ) != MODE_COMPLEX_INT || GET_MODE_CLASS ( mode ) != MODE_COMPLEX_FLOAT ) && cum -> arg_words < MAX_ARGS_IN_REGISTERS ) { 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 ( words + cum -> arg_words <= MAX_ARGS_IN_REGISTERS ) return <NUM_LIT> ; return ( MAX_ARGS_IN_REGISTERS - cum -> arg_words ) * UNITS_PER_WORD ; } else if ( mode == DImode && cum -> arg_words == MAX_ARGS_IN_REGISTERS - <NUM_LIT> ) return UNITS_PER_WORD ; return <NUM_LIT> ;


<s> tmp = gen_rtx_CONST ( Pmode , x ) ; emit_insn ( gen_rtx_SET ( VOIDmode , reg , gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , tmp ) ) ) ; return reg ;


<s> rtx tmp ; if ( reg == NULL_RTX ) reg = gen_reg_rtx ( Pmode ) ; tmp = gen_rtx_CONST ( Pmode , x ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , reg , gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , tmp ) ) ) ;


<s> if ( microblaze_classify_address ( & addr , x , mode , false ) ) { switch ( addr . type ) { case ADDRESS_REG : if ( SMALL_INT ( addr . offset ) ) return <NUM_LIT> ; else return <NUM_LIT> ; case ADDRESS_CONST_INT : if ( SMALL_INT ( x ) ) return <NUM_LIT> ; else return <NUM_LIT> ; case ADDRESS_REG_INDEX : return <NUM_LIT> ; case ADDRESS_SYMBOLIC : case ADDRESS_GOTOFF : return <NUM_LIT> ; case ADDRESS_TLS : switch ( addr . tls_type ) { case TLS_GD : return <NUM_LIT> ; case TLS_LDM : return <NUM_LIT> ; case TLS_DTPREL : return <NUM_LIT> ;


<s> int size ; char * buf ; if ( symtab -> state != PARSING ) return ; size = strlen ( string ) + <NUM_LIT> ; if ( size <= microblaze_section_threshold ) section_asm_op = SDATA2_SECTION_ASM_OP ; else section_asm_op = READONLY_DATA_SECTION_ASM_OP ;

buf = ACONCAT ( ( section_asm_op , <STR_LIT> , string , <STR_LIT> , NULL ) ) ;


<s> char * buf ; if ( symtab -> state != PARSING ) return ; size = strlen ( string ) + <NUM_LIT> ; if ( size <= microblaze_section_threshold ) section_asm_op = SDATA2_SECTION_ASM_OP ; else section_asm_op = READONLY_DATA_SECTION_ASM_OP ; buf = ACONCAT ( ( section_asm_op , <STR_LIT> , string , <STR_LIT> , NULL ) ) ;

symtab -> finalize_toplevel_asm ( build_string ( strlen ( buf ) , buf ) ) ;


<s> static void microblaze_asm_output_mi_thunk ( FILE * file , tree thunk_fndecl ATTRIBUTE_UNUSED , HOST_WIDE_INT delta , HOST_WIDE_INT vcall_offset , tree function ) { rtx this_rtx , funexp ; rtx_insn * insn ; reload_completed = <NUM_LIT> ; epilogue_completed = <NUM_LIT> ; emit_note ( NOTE_INSN_PROLOGUE_END ) ; if ( aggregate_value_p ( TREE_TYPE ( TREE_TYPE ( function ) ) , function ) ) this_rtx = gen_rtx_REG ( Pmode , ( MB_ABI_FIRST_ARG_REGNUM + <NUM_LIT> ) ) ; else this_rtx = gen_rtx_REG ( Pmode , MB_ABI_FIRST_ARG_REGNUM ) ; if ( delta ) emit_insn ( gen_addsi3 ( this_rtx , this_rtx , GEN_INT ( delta ) ) ) ; if ( vcall_offset ) { rtx vcall_offset_rtx = GEN_INT ( vcall_offset ) ; rtx temp1 = gen_rtx_REG ( Pmode , MB_ABI_TEMP1_REGNUM ) ; emit_move_insn ( temp1 , gen_rtx_MEM ( Pmode , this_rtx ) ) ; rtx loc = gen_rtx_PLUS ( Pmode , temp1 , vcall_offset_rtx ) ; emit_move_insn ( temp1 , gen_rtx_MEM ( Pmode , loc ) ) ; emit_insn ( gen_addsi3 ( this_rtx , this_rtx , temp1 ) ) ; } if ( ! TREE_USED ( function ) ) { assemble_external ( function ) ; TREE_USED ( function ) = <NUM_LIT> ; } funexp = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; rtx temp2 = gen_rtx_REG ( Pmode , MB_ABI_TEMP2_REGNUM ) ; if ( flag_pic ) emit_move_insn ( temp2 , expand_pic_symbol_ref ( Pmode , funexp ) ) ; else emit_move_insn ( temp2 , funexp ) ; emit_insn ( gen_indirect_jump ( temp2 ) ) ; insn = get_insns ( ) ; shorten_branches ( insn ) ; final_start_function ( insn , file , <NUM_LIT> ) ; final ( insn , file , <NUM_LIT> ) ;


<s> if ( aggregate_value_p ( TREE_TYPE ( TREE_TYPE ( function ) ) , function ) ) this_rtx = gen_rtx_REG ( Pmode , ( MB_ABI_FIRST_ARG_REGNUM + <NUM_LIT> ) ) ; else this_rtx = gen_rtx_REG ( Pmode , MB_ABI_FIRST_ARG_REGNUM ) ; if ( delta ) emit_insn ( gen_addsi3 ( this_rtx , this_rtx , GEN_INT ( delta ) ) ) ; if ( vcall_offset ) { rtx vcall_offset_rtx = GEN_INT ( vcall_offset ) ; rtx temp1 = gen_rtx_REG ( Pmode , MB_ABI_TEMP1_REGNUM ) ; emit_move_insn ( temp1 , gen_rtx_MEM ( Pmode , this_rtx ) ) ;

rtx loc = gen_rtx_PLUS ( Pmode , temp1 , vcall_offset_rtx ) ;


<s> bits = BITS_PER_WORD ; mode = mode_for_size ( bits , MODE_INT , <NUM_LIT> ) ; delta = bits / BITS_PER_UNIT ; regs = XALLOCAVEC ( rtx , length / delta ) ; for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) { regs [ i ] = gen_reg_rtx ( mode ) ; emit_move_insn ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; } for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) emit_move_insn ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; if ( offset < length ) { src = adjust_address ( src , BLKmode , offset ) ; dest = adjust_address ( dest , BLKmode , offset ) ; move_by_pieces ( dest , src , length - offset , MIN ( MEM_ALIGN ( src ) , MEM_ALIGN ( dest ) ) , <NUM_LIT> ) ; }


<s> rtx_insn * insns ; rtx tls_entry ; df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; start_sequence ( ) ;

tls_entry = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( reloc ) ) , UNSPEC_TLS ) ;


<s> tls_entry = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( reloc ) ) , UNSPEC_TLS ) ; reg = load_tls_operand ( tls_entry , reg ) ; * valuep = emit_library_call_value ( get_tls_get_addr ( ) , NULL_RTX , LCT_PURE , Pmode , <NUM_LIT> , reg , Pmode ) ; insns = get_insns ( ) ; end_sequence ( ) ;


<s> break ; } case CONST_INT : { info -> regA = gen_rtx_raw_REG ( mode , <NUM_LIT> ) ; info -> type = ADDRESS_CONST_INT ; info -> offset = x ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : { info -> type = ADDRESS_SYMBOLIC ; info -> symbol_type = SYMBOL_TYPE_GENERAL ; info -> symbol = x ; info -> regA = gen_rtx_raw_REG ( mode , get_base_reg ( x ) ) ; if ( GET_CODE ( x ) == CONST ) { if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC ) { info -> regA = gen_rtx_raw_REG ( mode , get_base_reg ( XVECEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ) ) ; return microblaze_classify_unspec ( info , XEXP ( x , <NUM_LIT> ) ) ; } return ! ( flag_pic && pic_address_needs_scratch ( x ) ) ; } if ( flag_pic == <NUM_LIT> ) return false ; else if ( microblaze_tls_symbol_p ( x ) ) return false ; return true ; } case UNSPEC : { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; return microblaze_classify_unspec ( info , x ) ; } default :


<s> info -> symbol_type = SYMBOL_TYPE_GENERAL ; info -> symbol = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; if ( XINT ( x , <NUM_LIT> ) == UNSPEC_GOTOFF ) { info -> regA = gen_rtx_REG ( SImode , PIC_OFFSET_TABLE_REGNUM ) ; info -> type = ADDRESS_GOTOFF ; } else if ( XINT ( x , <NUM_LIT> ) == UNSPEC_PLT ) { info -> type = ADDRESS_PLT ;


<s> static bool microblaze_const_double_ok ( rtx op , machine_mode mode ) { REAL_VALUE_TYPE d ; if ( GET_CODE ( op ) != CONST_DOUBLE ) return <NUM_LIT> ; if ( GET_MODE ( op ) == VOIDmode ) return <NUM_LIT> ; if ( mode != SFmode && mode != DFmode ) return <NUM_LIT> ; if ( op == CONST0_RTX ( mode ) ) return <NUM_LIT> ; REAL_VALUE_FROM_CONST_DOUBLE ( d , op ) ; if ( REAL_VALUE_ISNAN ( d ) ) return FALSE ; if ( REAL_VALUE_NEGATIVE ( d ) ) d = real_value_negate ( & d ) ; if ( mode == DFmode ) { if ( REAL_VALUES_LESS ( d , dfhigh ) && REAL_VALUES_LESS ( dflow , d ) ) return <NUM_LIT> ; } else { if ( REAL_VALUES_LESS ( d , sfhigh ) && REAL_VALUES_LESS ( sflow , d ) ) return <NUM_LIT> ; } return <NUM_LIT> ;


<s> static bool microblaze_const_double_ok ( rtx op , machine_mode mode ) { REAL_VALUE_TYPE d ; if ( GET_CODE ( op ) != CONST_DOUBLE ) return <NUM_LIT> ; if ( GET_MODE ( op ) == VOIDmode ) return <NUM_LIT> ; if ( mode != SFmode && mode != DFmode ) return <NUM_LIT> ; if ( op == CONST0_RTX ( mode ) ) return <NUM_LIT> ;

REAL_VALUE_FROM_CONST_DOUBLE ( d , op ) ;


<s> if ( align > UNITS_PER_WORD ) { align = UNITS_PER_WORD ; } else if ( align < UNITS_PER_WORD ) { if ( INTVAL ( length ) <= MAX_MOVE_BYTES ) { move_by_pieces ( dest , src , bytes , align , <NUM_LIT> ) ; return true ; } else return false ; } if ( INTVAL ( length ) <= <NUM_LIT> * MAX_MOVE_BYTES ) { microblaze_block_move_straight ( dest , src , INTVAL ( length ) ) ; return true ;


<s> insn = emit_insn ( gen_movqi ( regqi , mem_rtx ) ) ; insn = emit_insn ( gen_movsi ( operands [ <NUM_LIT> ] , gen_rtx_SUBREG ( SImode , regqi , <NUM_LIT> ) ) ) ; jump = emit_jump_insn_after ( gen_jump ( div_end_label ) , insn ) ; JUMP_LABEL ( jump ) = div_end_label ; LABEL_NUSES ( div_end_label ) = <NUM_LIT> ; emit_barrier ( ) ; emit_label ( div_label ) ;

ret = emit_library_call_value ( gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) , operands [ <NUM_LIT> ] , LCT_NORMAL , GET_MODE ( operands [ <NUM_LIT> ] ) , <NUM_LIT> , operands [ <NUM_LIT> ] , GET_MODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] , GET_MODE ( operands [ <NUM_LIT> ] ) ) ;


<s> emit_insn ( gen_rtx_CLOBBER ( SImode , reg18 ) ) ; emit_insn ( gen_ashlsi3_bshift ( regt1 , operands [ <NUM_LIT> ] , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_addsi3 ( regt1 , regt1 , operands [ <NUM_LIT> ] ) ) ; mem_rtx = gen_rtx_MEM ( QImode , gen_rtx_PLUS ( Pmode , regt1 , div_table_rtx ) ) ; insn = emit_insn ( gen_movqi ( regqi , mem_rtx ) ) ; insn = emit_insn ( gen_movsi ( operands [ <NUM_LIT> ] , gen_rtx_SUBREG ( SImode , regqi , <NUM_LIT> ) ) ) ; jump = emit_jump_insn_after ( gen_jump ( div_end_label ) , insn ) ; JUMP_LABEL ( jump ) = div_end_label ; LABEL_NUSES ( div_end_label ) = <NUM_LIT> ; emit_barrier ( ) ; emit_label ( div_label ) ; ret = emit_library_call_value ( gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) , operands [ <NUM_LIT> ] , LCT_NORMAL , GET_MODE ( operands [ <NUM_LIT> ] ) , <NUM_LIT> , operands [ <NUM_LIT> ] , GET_MODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] , GET_MODE ( operands [ <NUM_LIT> ] ) ) ; if ( ret != operands [ <NUM_LIT> ] ) emit_move_insn ( operands [ <NUM_LIT> ] , ret ) ; emit_label ( div_end_label ) ;


<s> rtx mem_rtx ; if ( microblaze_can_use_return_insn ( ) ) { emit_jump_insn ( gen_return_internal ( gen_rtx_REG ( Pmode , GP_REG_FIRST + MB_ABI_SUB_RETURN_ADDR_REGNUM ) ) ) ; return ; } if ( fsiz > <NUM_LIT> ) { if ( ! crtl -> is_leaf || interrupt_handler ) { mem_rtx = gen_rtx_MEM ( SImode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , const0_rtx ) ) ; if ( interrupt_handler ) MEM_VOLATILE_P ( mem_rtx ) = <NUM_LIT> ; reg_rtx = gen_rtx_REG ( SImode , MB_ABI_SUB_RETURN_ADDR_REGNUM ) ; emit_move_insn ( reg_rtx , mem_rtx ) ;


<s> rtx p0 , p1 ; p0 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; p1 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ( GET_CODE ( p1 ) == CONST_INT ) && ( ( GET_CODE ( p0 ) == UNSPEC ) || ( ( GET_CODE ( p0 ) == SYMBOL_REF || GET_CODE ( p0 ) == LABEL_REF ) && ( flag_pic == <NUM_LIT> || microblaze_tls_symbol_p ( p0 ) || ! SMALL_INT ( p1 ) ) ) ) ) { rtx temp = force_reg ( SImode , p0 ) ; rtx temp2 = p1 ; if ( flag_pic && reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; emit_move_insn ( op0 , gen_rtx_PLUS ( SImode , temp , temp2 ) ) ; return true ; }


<s> rtx op0 , op1 ; op0 = operands [ <NUM_LIT> ] ; op1 = operands [ <NUM_LIT> ] ; if ( ! register_operand ( op0 , SImode ) && ! register_operand ( op1 , SImode ) && ( GET_CODE ( op1 ) != CONST_INT || INTVAL ( op1 ) != <NUM_LIT> ) ) { rtx temp = force_reg ( SImode , op1 ) ; emit_move_insn ( op0 , temp ) ; return true ; } if ( GET_CODE ( op1 ) == SYMBOL_REF || GET_CODE ( op1 ) == LABEL_REF ) { rtx result ; if ( microblaze_tls_symbol_p ( op1 ) ) { result = microblaze_legitimize_tls_address ( op1 , NULL_RTX ) ; emit_move_insn ( op0 , result ) ; return true ; } else if ( flag_pic ) { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; result = expand_pic_symbol_ref ( mode , op1 ) ; emit_move_insn ( op0 , result ) ; return true ; } } if ( GET_CODE ( op1 ) == CONST && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == PLUS ) { rtx p0 , p1 ; p0 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; p1 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ( GET_CODE ( p1 ) == CONST_INT ) && ( ( GET_CODE ( p0 ) == UNSPEC ) || ( ( GET_CODE ( p0 ) == SYMBOL_REF || GET_CODE ( p0 ) == LABEL_REF ) && ( flag_pic == <NUM_LIT> || microblaze_tls_symbol_p ( p0 ) || ! SMALL_INT ( p1 ) ) ) ) ) {


<s> tree type = build_pointer_type ( fntype ) ; tree function_result_decl = build_decl ( BUILTINS_LOCATION , PARM_DECL , NULL_TREE , type ) ; DECL_ARG_TYPE ( function_result_decl ) = type ; TREE_CHAIN ( function_result_decl ) = fnargs ; fnargs = function_result_decl ; } INIT_CUMULATIVE_ARGS ( args_so_far_v , fntype , NULL_RTX , <NUM_LIT> , <NUM_LIT> ) ; args_so_far = pack_cumulative_args ( & args_so_far_v ) ; regno = GP_ARG_FIRST ; for ( cur_arg = fnargs ; cur_arg != <NUM_LIT> ; cur_arg = next_arg ) { tree passed_type = DECL_ARG_TYPE ( cur_arg ) ; machine_mode passed_mode = TYPE_MODE ( passed_type ) ; rtx entry_parm ; if ( TREE_ADDRESSABLE ( passed_type ) ) { passed_type = build_pointer_type ( passed_type ) ; passed_mode = Pmode ; } entry_parm = targetm . calls . function_arg ( args_so_far , passed_mode , passed_type , true ) ; if ( entry_parm ) { int words ; if ( GET_MODE ( entry_parm ) == BLKmode ) words = ( int_size_in_bytes ( passed_type ) + <NUM_LIT> ) / <NUM_LIT> ; else words = ( GET_MODE_SIZE ( GET_MODE ( entry_parm ) ) + <NUM_LIT> ) / <NUM_LIT> ; regno = REGNO ( entry_parm ) + words - <NUM_LIT> ; } else { regno = GP_ARG_LAST + <NUM_LIT> ; break ; } targetm . calls . function_arg_advance ( args_so_far , passed_mode , passed_type , true ) ; next_arg = TREE_CHAIN ( cur_arg ) ;


<s> for ( i = <NUM_LIT> ; i < num ; i ++ ) { rtx pattern = RTVEC_ELT ( adjust , i ) ; emit_insn ( pattern ) ; } } fsiz = compute_frame_size ( get_frame_size ( ) ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = fsiz ; if ( ( ( TYPE_ARG_TYPES ( fntype ) != <NUM_LIT> && ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( fntype ) ) ) != void_type_node ) ) || ( arg_name != <NUM_LIT> && ( ( arg_name [ <NUM_LIT> ] == '_' && strcmp ( arg_name , <STR_LIT> ) == <NUM_LIT> ) || ( arg_name [ <NUM_LIT> ] == 'v' && strcmp ( arg_name , <STR_LIT> ) == <NUM_LIT> ) ) ) ) ) { int offset = ( regno - GP_ARG_FIRST + <NUM_LIT> ) * UNITS_PER_WORD ; rtx ptr = stack_pointer_rtx ; for ( ; regno <= GP_ARG_LAST ; regno ++ ) { if ( offset != <NUM_LIT> ) ptr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( offset ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , ptr ) , gen_rtx_REG ( SImode , regno ) ) ; offset += GET_MODE_SIZE ( SImode ) ; } } if ( fsiz > <NUM_LIT> ) { rtx fsiz_rtx = GEN_INT ( fsiz ) ; rtx_insn * insn = NULL ; insn = emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , fsiz_rtx ) ) ; if ( insn ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( ! crtl -> is_leaf || interrupt_handler ) { mem_rtx = gen_rtx_MEM ( SImode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , const0_rtx ) ) ; if ( interrupt_handler ) MEM_VOLATILE_P ( mem_rtx ) = <NUM_LIT> ; reg_rtx = gen_rtx_REG ( SImode , MB_ABI_SUB_RETURN_ADDR_REGNUM ) ; insn = emit_move_insn ( mem_rtx , reg_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } save_restore_insns ( <NUM_LIT> ) ; if ( frame_pointer_needed ) { rtx_insn * insn = <NUM_LIT> ; insn = emit_insn ( gen_movsi ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; if ( insn ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; }


<s> gcc_assert ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG ) ) ; if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) && ( INTVAL ( operands [ <NUM_LIT> ] ) == <NUM_LIT> ) ) return <NUM_LIT> ; if ( TARGET_BARREL_SHIFT ) return <NUM_LIT> ;

gcc_assert ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG ) ) ;


<s> int regbase = - <NUM_LIT> ; int * arg_words = & cum -> arg_words ; cum -> last_arg_fp = <NUM_LIT> ; switch ( mode ) { case SFmode : case DFmode : case VOIDmode : case QImode : case HImode : case SImode : case DImode : case TImode : regbase = GP_ARG_FIRST ; break ;


<s> switch ( mode ) { case VOIDmode : break ; default : gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_INT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) ; cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; break ; case BLKmode : cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += ( ( int_size_in_bytes ( type ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ;


<s> long fsiz = current_frame_info . total_size ; fnname = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ! flag_inhibit_size_directive ) { fputs ( <STR_LIT> , file ) ; if ( interrupt_handler && strcmp ( INTERRUPT_HANDLER_NAME , fnname ) ) fputs ( <STR_LIT> , file ) ; else if ( break_handler && strcmp ( BREAK_HANDLER_NAME , fnname ) ) fputs ( <STR_LIT> , file ) ; else if ( fast_interrupt && strcmp ( FAST_INTERRUPT_NAME , fnname ) ) fputs ( <STR_LIT> , file ) ; else assemble_name ( file , fnname ) ; fputs ( <STR_LIT> , file ) ; if ( ! microblaze_is_interrupt_variant ( ) ) ASM_OUTPUT_TYPE_DIRECTIVE ( file , fnname , <STR_LIT> ) ;


<s> if ( flag_pic == <NUM_LIT> && ( symbol_mentioned_p ( x ) || label_mentioned_p ( x ) ) ) return <NUM_LIT> ;

if ( microblaze_tls_referenced_p ( x ) ) return <NUM_LIT> ;


<s> result = gen_rtx_PLUS ( Pmode , ptr_reg , GEN_INT ( INTVAL ( xplus1 ) & <NUM_LIT> ) ) ; return result ; } if ( code0 == REG && REG_OK_FOR_BASE_P ( xplus0 ) ) { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; if ( code1 == CONST ) { xplus1 = XEXP ( xplus1 , <NUM_LIT> ) ; code1 = GET_CODE ( xplus1 ) ; } if ( code1 == SYMBOL_REF ) { if ( microblaze_tls_symbol_p ( xplus1 ) ) { rtx tls_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; tls_ref = microblaze_legitimize_tls_address ( xplus1 , NULL_RTX ) ; emit_move_insn ( reg , tls_ref ) ; result = gen_rtx_PLUS ( Pmode , xplus0 , reg ) ; return result ; } else if ( flag_pic == <NUM_LIT> ) { rtx pic_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; pic_ref = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , xplus1 ) , UNSPEC_GOTOFF ) ; pic_ref = gen_rtx_CONST ( Pmode , pic_ref ) ; pic_ref = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , pic_ref ) ; pic_ref = gen_const_mem ( Pmode , pic_ref ) ;


<s> } if ( code0 == REG && REG_OK_FOR_BASE_P ( xplus0 ) && code1 == CONST_INT && ! SMALL_INT ( xplus1 ) ) { rtx int_reg = gen_reg_rtx ( Pmode ) ; rtx ptr_reg = gen_reg_rtx ( Pmode ) ; emit_move_insn ( int_reg , GEN_INT ( INTVAL ( xplus1 ) & ~ <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , ptr_reg , gen_rtx_PLUS ( Pmode , xplus0 , int_reg ) ) ) ; result = gen_rtx_PLUS ( Pmode , ptr_reg , GEN_INT ( INTVAL ( xplus1 ) & <NUM_LIT> ) ) ; return result ; } if ( code0 == REG && REG_OK_FOR_BASE_P ( xplus0 ) ) { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; if ( code1 == CONST ) { xplus1 = XEXP ( xplus1 , <NUM_LIT> ) ; code1 = GET_CODE ( xplus1 ) ; } if ( code1 == SYMBOL_REF ) { if ( microblaze_tls_symbol_p ( xplus1 ) ) { rtx tls_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; tls_ref = microblaze_legitimize_tls_address ( xplus1 , NULL_RTX ) ; emit_move_insn ( reg , tls_ref ) ; result = gen_rtx_PLUS ( Pmode , xplus0 , reg ) ; return result ; } else if ( flag_pic == <NUM_LIT> ) { rtx pic_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; pic_ref = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , xplus1 ) , UNSPEC_GOTOFF ) ; pic_ref = gen_rtx_CONST ( Pmode , pic_ref ) ; pic_ref = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , pic_ref ) ; pic_ref = gen_const_mem ( Pmode , pic_ref ) ; emit_move_insn ( reg , pic_ref ) ; result = gen_rtx_PLUS ( Pmode , xplus0 , reg ) ; return result ; } } } } if ( GET_CODE ( xinsn ) == SYMBOL_REF ) { rtx reg ; if ( microblaze_tls_symbol_p ( xinsn ) ) { reg = microblaze_legitimize_tls_address ( xinsn , NULL_RTX ) ; } else { rtx pic_ref ; if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; pic_ref = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , xinsn ) , UNSPEC_GOTOFF ) ; pic_ref = gen_rtx_CONST ( Pmode , pic_ref ) ; pic_ref = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , pic_ref ) ; pic_ref = gen_const_mem ( Pmode , pic_ref ) ; reg = pic_ref ; }


<s> } if ( microblaze_is_interrupt_variant ( ) ) { if ( df_regs_ever_live_p ( regno ) || regno == MB_ABI_MSR_SAVE_REG || ( interrupt_handler && ( regno == MB_ABI_ASM_TEMP_REGNUM || regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM ) ) ) return <NUM_LIT> ; } if ( save_volatiles ) {

if ( df_regs_ever_live_p ( regno ) || regno == MB_ABI_ASM_TEMP_REGNUM || regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM ) return <NUM_LIT> ;


<s> if ( ! TARGET_SUPPORTS_PIC ) { error ( <STR_LIT> ) ; flag_pic = <NUM_LIT> ; } } if ( microblaze_select_cpu == NULL ) microblaze_select_cpu = MICROBLAZE_DEFAULT_CPU ; ver = microblaze_version_to_int ( microblaze_select_cpu ) ; if ( ver == - <NUM_LIT> ) { error ( <STR_LIT> , microblaze_select_cpu ) ; } ver = MICROBLAZE_VERSION_COMPARE ( microblaze_select_cpu , <STR_LIT> ) ; if ( ver < <NUM_LIT> ) { microblaze_select_flags &= ~ ( MICROBLAZE_MASK_NO_UNSAFE_DELAY ) ; microblaze_no_unsafe_delay = <NUM_LIT> ; microblaze_pipe = MICROBLAZE_PIPE_3 ; } else if ( ver == <NUM_LIT> || ( MICROBLAZE_VERSION_COMPARE ( microblaze_select_cpu , <STR_LIT> ) == <NUM_LIT> ) ) { microblaze_select_flags |= ( MICROBLAZE_MASK_NO_UNSAFE_DELAY ) ; microblaze_no_unsafe_delay = <NUM_LIT> ; microblaze_pipe = MICROBLAZE_PIPE_3 ; } else { microblaze_select_flags &= ~ ( MICROBLAZE_MASK_NO_UNSAFE_DELAY ) ; microblaze_no_unsafe_delay = <NUM_LIT> ; microblaze_pipe = MICROBLAZE_PIPE_5 ; if ( MICROBLAZE_VERSION_COMPARE ( microblaze_select_cpu , <STR_LIT> ) == <NUM_LIT> || MICROBLAZE_VERSION_COMPARE ( microblaze_select_cpu , <STR_LIT> ) == <NUM_LIT> || MICROBLAZE_VERSION_COMPARE ( microblaze_select_cpu , <STR_LIT> ) == <NUM_LIT> ) { target_flags |= MASK_PATTERN_COMPARE ; } } ver = MICROBLAZE_VERSION_COMPARE ( microblaze_select_cpu , <STR_LIT> ) ; if ( ver < <NUM_LIT> ) { if ( TARGET_MULTIPLY_HIGH ) warning ( <NUM_LIT> , <STR_LIT> ) ; } ver = MICROBLAZE_VERSION_COMPARE ( microblaze_select_cpu , <STR_LIT> ) ; microblaze_has_clz = <NUM_LIT> ; if ( ver < <NUM_LIT> ) { microblaze_has_clz = <NUM_LIT> ; } ver = MICROBLAZE_VERSION_COMPARE ( microblaze_select_cpu , <STR_LIT> ) ; if ( ver < <NUM_LIT> ) {

if ( TARGET_REORDER == <NUM_LIT> ) warning ( <NUM_LIT> , <STR_LIT> ) ;


<s> rtx microblaze_return_addr ( int count , rtx frame ATTRIBUTE_UNUSED ) {

if ( count != <NUM_LIT> ) return NULL_RTX ;


<s> if ( count != <NUM_LIT> ) return NULL_RTX ;

return gen_rtx_PLUS ( Pmode , get_hard_reg_initial_val ( Pmode , MB_ABI_SUB_RETURN_ADDR_REGNUM ) , GEN_INT ( <NUM_LIT> ) ) ;


<s> if ( mode == SFmode || mode == DFmode ) { if ( TARGET_HARD_FLOAT ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } else if ( mode == DImode ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } else { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return false ; } case NEG : { if ( mode == DImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } case MULT : { if ( mode == SFmode ) { if ( TARGET_HARD_FLOAT ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( ! TARGET_SOFT_MUL ) { if ( MICROBLAZE_VERSION_COMPARE ( microblaze_select_cpu , <STR_LIT> ) >= <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; } else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } case DIV : case UDIV : { if ( mode == SFmode ) { if ( TARGET_HARD_FLOAT ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; }


<s> type = info . type ; switch ( info . type ) { case ADDRESS_REG : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regA ) ] ) ; output_addr_const ( file , info . offset ) ; break ; case ADDRESS_REG_INDEX : if ( REGNO ( info . regA ) == <NUM_LIT> ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regB ) ] , reg_names [ REGNO ( info . regA ) ] ) ; else if ( REGNO ( info . regB ) != <NUM_LIT> ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regB ) ] , reg_names [ REGNO ( info . regA ) ] ) ; break ; case ADDRESS_CONST_INT : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regA ) ] ) ; output_addr_const ( file , info . offset ) ; break ; case ADDRESS_SYMBOLIC : case ADDRESS_GOTOFF : case ADDRESS_PLT : case ADDRESS_TLS : if ( info . regA ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regA ) ] ) ; output_addr_const ( file , info . symbol ) ; if ( type == ADDRESS_GOTOFF ) { fputs ( <STR_LIT> , file ) ; } else if ( type == ADDRESS_PLT ) { fputs ( <STR_LIT> , file ) ; } else if ( type == ADDRESS_TLS ) { switch ( info . tls_type ) { case TLS_GD : fputs ( <STR_LIT> , file ) ; break ; case TLS_LDM :


<s> if ( XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) return <NUM_LIT> ; default : return <NUM_LIT> ; }


<s> if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ; if ( GET_CODE ( call ) != CALL ) abort ( ) ; return XEXP ( XEXP ( call , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> rtx call ; call = XVECEXP ( PATTERN ( branch ) , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ; if ( GET_CODE ( call ) != CALL ) abort ( ) ; return XEXP ( XEXP ( call , <NUM_LIT> ) , <NUM_LIT> ) ; }


<s> rtx branch_target = <NUM_LIT> ; shorten_branches ( get_insns ( ) ) ; for ( i = <NUM_LIT> ; i < n_basic_blocks_for_fn ( cfun ) - <NUM_LIT> ; i ++ ) { edge e ; edge_iterator ei ; bool simple_loop = false ; bb = BASIC_BLOCK_FOR_FN ( cfun , i ) ; if ( bb == NULL ) continue ; if ( ( prev != <NUM_LIT> ) && ( prev != bb ) ) continue ; else prev = <NUM_LIT> ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( e -> src == bb ) {


<s> int length ; int wic_addr0 = <NUM_LIT> * <NUM_LIT> ; int wic_addr1 = <NUM_LIT> * <NUM_LIT> ; int first_addr = INSN_ADDRESSES ( INSN_UID ( first ) ) ; for ( insn = first ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) ) { addr_offset = INSN_ADDRESSES ( INSN_UID ( insn ) ) - first_addr ; length = get_attr_length ( insn ) ; if ( before_4 == <NUM_LIT> && addr_offset + length >= <NUM_LIT> * <NUM_LIT> ) before_4 = insn ; if ( JUMP_P ( insn ) ) return ; if ( before_16 == <NUM_LIT> && addr_offset + length >= <NUM_LIT> * <NUM_LIT> ) before_16 = insn ;

if ( CALL_P ( insn ) || tablejump_p ( insn , <NUM_LIT> , <NUM_LIT> ) ) return ;


<s> xconst0 = XEXP ( xconst0 , <NUM_LIT> ) ; } if ( GET_CODE ( xconst0 ) == SYMBOL_REF || GET_CODE ( xconst0 ) == LABEL_REF ) { if ( flag_pic == <NUM_LIT> || microblaze_tls_symbol_p ( xconst0 ) ) return false ; info -> type = ADDRESS_SYMBOLIC ; info -> symbol = xplus1 ; info -> symbol_type = SYMBOL_TYPE_GENERAL ; return true ; } return false ; } else if ( GET_CODE ( xplus1 ) == REG && microblaze_valid_index_register_p ( xplus1 , mode , strict ) && ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ) ) { info -> type = ADDRESS_REG_INDEX ; info -> regB = xplus1 ; return true ; } } break ; } case CONST_INT : { info -> regA = gen_raw_REG ( mode , <NUM_LIT> ) ; info -> type = ADDRESS_CONST_INT ; info -> offset = x ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : { info -> type = ADDRESS_SYMBOLIC ; info -> symbol_type = SYMBOL_TYPE_GENERAL ; info -> symbol = x ; info -> regA = gen_raw_REG ( mode , get_base_reg ( x ) ) ; if ( GET_CODE ( x ) == CONST ) { if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC ) { info -> regA = gen_raw_REG ( mode , get_base_reg ( XVECEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ) ) ; return microblaze_classify_unspec ( info , XEXP ( x , <NUM_LIT> ) ) ; }

return ! ( flag_pic && pic_address_needs_scratch ( x ) ) ;


<s> info -> type = ADDRESS_PLT ; } else if ( XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) { info -> type = ADDRESS_TLS ; info -> tls_type = tls_reloc ( INTVAL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ) ; } else { return false ; }


<s> info -> regA = gen_rtx_REG ( SImode , PIC_OFFSET_TABLE_REGNUM ) ; info -> type = ADDRESS_GOTOFF ; } else if ( XINT ( x , <NUM_LIT> ) == UNSPEC_PLT ) { info -> type = ADDRESS_PLT ; } else if ( XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) { info -> type = ADDRESS_TLS ; info -> tls_type = tls_reloc ( INTVAL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ) ; } else {


<s> rtx cmp_op1 = operands [ <NUM_LIT> ] ; rtx label1 = operands [ <NUM_LIT> ] ; rtx comp_reg = gen_reg_rtx ( SImode ) ; rtx condition ; gcc_assert ( ( GET_CODE ( cmp_op0 ) == REG ) || ( GET_CODE ( cmp_op0 ) == SUBREG ) ) ; if ( cmp_op1 == const0_rtx ) { comp_reg = cmp_op0 ; condition = gen_rtx_fmt_ee ( signed_condition ( code ) , SImode , comp_reg , const0_rtx ) ; emit_jump_insn ( gen_condjump ( condition , label1 ) ) ; } else if ( code == EQ ) { emit_insn ( gen_seq_internal_pat ( comp_reg , cmp_op0 , cmp_op1 ) ) ; condition = gen_rtx_EQ ( SImode , comp_reg , const0_rtx ) ; emit_jump_insn ( gen_condjump ( condition , label1 ) ) ; } else if ( code == NE ) { emit_insn ( gen_sne_internal_pat ( comp_reg , cmp_op0 , cmp_op1 ) ) ; condition = gen_rtx_NE ( SImode , comp_reg , const0_rtx ) ; emit_jump_insn ( gen_condjump ( condition , label1 ) ) ; }


<s> return result ; } if ( code0 == REG && REG_OK_FOR_BASE_P ( xplus0 ) ) { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; if ( code1 == CONST ) { xplus1 = XEXP ( xplus1 , <NUM_LIT> ) ; code1 = GET_CODE ( xplus1 ) ; } if ( code1 == SYMBOL_REF ) { if ( microblaze_tls_symbol_p ( xplus1 ) ) { rtx tls_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; tls_ref = microblaze_legitimize_tls_address ( xplus1 , NULL_RTX ) ; emit_move_insn ( reg , tls_ref ) ; result = gen_rtx_PLUS ( Pmode , xplus0 , reg ) ; return result ; } else if ( flag_pic == <NUM_LIT> ) { rtx pic_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; pic_ref = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , xplus1 ) , UNSPEC_GOTOFF ) ; pic_ref = gen_rtx_CONST ( Pmode , pic_ref ) ; pic_ref = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , pic_ref ) ; pic_ref = gen_const_mem ( Pmode , pic_ref ) ; emit_move_insn ( reg , pic_ref ) ; result = gen_rtx_PLUS ( Pmode , xplus0 , reg ) ; return result ; }


<s> if ( frame_pointer_needed && ( regno == HARD_FRAME_POINTER_REGNUM ) ) return <NUM_LIT> ; if ( crtl -> calls_eh_return && regno == MB_ABI_SUB_RETURN_ADDR_REGNUM ) return <NUM_LIT> ; if ( ! crtl -> is_leaf ) { if ( regno == MB_ABI_SUB_RETURN_ADDR_REGNUM ) return <NUM_LIT> ; if ( ( microblaze_is_interrupt_variant ( ) || save_volatiles ) && ( regno >= <NUM_LIT> && regno <= <NUM_LIT> ) ) return <NUM_LIT> ; } if ( microblaze_is_interrupt_variant ( ) ) { if ( df_regs_ever_live_p ( regno ) || regno == MB_ABI_MSR_SAVE_REG || ( interrupt_handler && ( regno == MB_ABI_ASM_TEMP_REGNUM || regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM ) ) ) return <NUM_LIT> ; } if ( save_volatiles ) { if ( df_regs_ever_live_p ( regno ) || regno == MB_ABI_ASM_TEMP_REGNUM || regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM ) return <NUM_LIT> ;


<s> HOST_WIDE_INT offset , delta ; unsigned HOST_WIDE_INT bits ; int i ; machine_mode mode ; rtx * regs ; bits = BITS_PER_WORD ; mode = int_mode_for_size ( bits , <NUM_LIT> ) . require ( ) ; delta = bits / BITS_PER_UNIT ; regs = XALLOCAVEC ( rtx , length / delta ) ; for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) { regs [ i ] = gen_reg_rtx ( mode ) ; emit_move_insn ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; } for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) emit_move_insn ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; if ( offset < length ) { src = adjust_address ( src , BLKmode , offset ) ; dest = adjust_address ( dest , BLKmode , offset ) ; move_by_pieces ( dest , src , length - offset , MIN ( MEM_ALIGN ( src ) , MEM_ALIGN ( dest ) ) , <NUM_LIT> ) ;


<s> rtx * regs ; bits = BITS_PER_WORD ; mode = int_mode_for_size ( bits , <NUM_LIT> ) . require ( ) ; delta = bits / BITS_PER_UNIT ; regs = XALLOCAVEC ( rtx , length / delta ) ; for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) { regs [ i ] = gen_reg_rtx ( mode ) ; emit_move_insn ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; } for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) emit_move_insn ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; if ( offset < length ) {

src = adjust_address ( src , BLKmode , offset ) ;


<s> cum -> arg_words += ( ( int_size_in_bytes ( type ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; break ; case E_SFmode : cum -> arg_words ++ ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case E_DFmode : cum -> arg_words += <NUM_LIT> ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case E_DImode : cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += <NUM_LIT> ; break ; case E_QImode : case E_HImode : case E_SImode : case E_TImode : cum -> gp_reg_found = <NUM_LIT> ;


<s> cum -> arg_words += ( ( int_size_in_bytes ( type ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; break ; case E_SFmode : cum -> arg_words ++ ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case E_DFmode : cum -> arg_words += <NUM_LIT> ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ;


<s> if ( TARGET_MULTIPLY_HIGH && TARGET_SOFT_MUL ) error ( <STR_LIT> ) ; microblaze_sched_use_dfa = <NUM_LIT> ; microblaze_abicalls = MICROBLAZE_ABICALLS_NO ; real_maxval ( & dfhigh , <NUM_LIT> , DFmode ) ; real_maxval ( & dflow , <NUM_LIT> , DFmode ) ; real_maxval ( & sfhigh , <NUM_LIT> , SFmode ) ; real_maxval ( & sflow , <NUM_LIT> , SFmode ) ; microblaze_print_operand_punct [ '?' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '#' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '&' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '!' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '*' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '@' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '.' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '(' ] = <NUM_LIT> ; microblaze_print_operand_punct [ ')' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '[' ] = <NUM_LIT> ; microblaze_print_operand_punct [ ']' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '<' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '>' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '{' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '}' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '^' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '$' ] = <NUM_LIT> ; microblaze_print_operand_punct [ '+' ] = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) microblaze_dbx_regno [ i ] = - <NUM_LIT> ; start = GP_DBX_FIRST - GP_REG_FIRST ; for ( i = GP_REG_FIRST ; i <= GP_REG_LAST ; i ++ ) microblaze_dbx_regno [ i ] = i + start ; for ( mode = VOIDmode ; mode != MAX_MACHINE_MODE ; mode = ( machine_mode ) ( ( int ) mode + <NUM_LIT> ) ) { register int size = GET_MODE_SIZE ( mode ) ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { register int ok ; if ( mode == CCmode ) {

ok = ( ST_REG_P ( regno ) || GP_REG_P ( regno ) ) ;


<s> break ; } } next_arg_reg = targetm . calls . function_arg ( args_so_far , VOIDmode , void_type_node , true ) ; if ( next_arg_reg != <NUM_LIT> && GET_CODE ( next_arg_reg ) == PARALLEL ) { rtvec adjust = XVEC ( next_arg_reg , <NUM_LIT> ) ; int num = GET_NUM_ELEM ( adjust ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { rtx pattern = RTVEC_ELT ( adjust , i ) ; emit_insn ( pattern ) ; } } fsiz = compute_frame_size ( get_frame_size ( ) ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = fsiz ; if ( ( ( TYPE_ARG_TYPES ( fntype ) != <NUM_LIT> && ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( fntype ) ) ) != void_type_node ) ) || ( arg_name != <NUM_LIT> && ( ( arg_name [ <NUM_LIT> ] == '_' && strcmp ( arg_name , <STR_LIT> ) == <NUM_LIT> ) || ( arg_name [ <NUM_LIT> ] == 'v' && strcmp ( arg_name , <STR_LIT> ) == <NUM_LIT> ) ) ) ) ) { int offset = ( regno - GP_ARG_FIRST + <NUM_LIT> ) * UNITS_PER_WORD ; rtx ptr = stack_pointer_rtx ; for ( ; regno <= GP_ARG_LAST ; regno ++ ) { if ( offset != <NUM_LIT> ) ptr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( offset ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , ptr ) , gen_rtx_REG ( SImode , regno ) ) ; offset += GET_MODE_SIZE ( SImode ) ; } } if ( fsiz > <NUM_LIT> ) { rtx fsiz_rtx = GEN_INT ( fsiz ) ; rtx_insn * insn = NULL ; insn = emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , fsiz_rtx ) ) ; if ( insn ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( ! crtl -> is_leaf || interrupt_handler ) { mem_rtx = gen_rtx_MEM ( SImode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , const0_rtx ) ) ; if ( interrupt_handler ) MEM_VOLATILE_P ( mem_rtx ) = <NUM_LIT> ; reg_rtx = gen_rtx_REG ( SImode , MB_ABI_SUB_RETURN_ADDR_REGNUM ) ; insn = emit_move_insn ( mem_rtx , reg_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } save_restore_insns ( <NUM_LIT> ) ; if ( frame_pointer_needed ) { rtx_insn * insn = <NUM_LIT> ;

insn = emit_insn ( gen_movsi ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ;


if ( mask ) current_frame_info . gp_offset = ( total_size - gp_reg_size ) ;


<s> rtx addr ; if ( GET_CODE ( op ) != MEM || ! memory_operand ( op , mode ) ) { if ( reload_in_progress && GET_CODE ( op ) == REG && REGNO ( op ) >= FIRST_PSEUDO_REGISTER && reg_renumber [ REGNO ( op ) ] < <NUM_LIT> && reg_equiv_mem ( REGNO ( op ) ) != <NUM_LIT> && double_memory_operand ( reg_equiv_mem ( REGNO ( op ) ) , mode ) ) return <NUM_LIT> ; return <NUM_LIT> ; } addr = XEXP ( op , <NUM_LIT> ) ; if ( CONSTANT_ADDRESS_P ( addr ) ) return <NUM_LIT> ;

return memory_address_p ( ( GET_MODE_CLASS ( mode ) == MODE_INT ? E_SImode : E_SFmode ) , plus_constant ( Pmode , addr , <NUM_LIT> ) ) ;


<s> result = gen_rtx_CONST ( Pmode , result ) ; result = ( TARGET_PIC_DATA_TEXT_REL && isFunc ) ? gen_rtx_PLUS ( Pmode , gen_raw_REG ( Pmode , get_base_reg ( op ) ) , result ) : gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , result ) ;

result = ( ! TARGET_PIC_DATA_TEXT_REL ) ? gen_const_mem ( Pmode , result ) : result ;


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( ( arg . mode == BLKmode || GET_MODE_CLASS ( arg . mode ) != MODE_COMPLEX_INT || GET_MODE_CLASS ( arg . mode ) != MODE_COMPLEX_FLOAT ) && cum -> arg_words < MAX_ARGS_IN_REGISTERS ) { int words = ( ( arg . promoted_size_in_bytes ( ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; if ( words + cum -> arg_words <= MAX_ARGS_IN_REGISTERS ) return <NUM_LIT> ;

return ( MAX_ARGS_IN_REGISTERS - cum -> arg_words ) * UNITS_PER_WORD ;


<s> if ( ( arg . mode == BLKmode || GET_MODE_CLASS ( arg . mode ) != MODE_COMPLEX_INT || GET_MODE_CLASS ( arg . mode ) != MODE_COMPLEX_FLOAT ) && cum -> arg_words < MAX_ARGS_IN_REGISTERS ) { int words = ( ( arg . promoted_size_in_bytes ( ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; if ( words + cum -> arg_words <= MAX_ARGS_IN_REGISTERS ) return <NUM_LIT> ; return ( MAX_ARGS_IN_REGISTERS - cum -> arg_words ) * UNITS_PER_WORD ; } else if ( arg . mode == DImode && cum -> arg_words == MAX_ARGS_IN_REGISTERS - <NUM_LIT> ) return UNITS_PER_WORD ;


<s> else if ( flag_pic ) base_reg = MB_ABI_PIC_ADDR_REGNUM ; if ( TARGET_XLGPOPT && GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_SMALL_P ( x ) && ( decl = SYMBOL_REF_DECL ( x ) ) != NULL ) {

if ( TREE_READONLY ( decl ) ) base_reg = MB_ABI_GPRO_REGNUM ;


<s> call = XVECEXP ( PATTERN ( branch ) , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ; if ( GET_CODE ( call ) != CALL ) abort ( ) ;

return XEXP ( XEXP ( call , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> rtx call ; call = XVECEXP ( PATTERN ( branch ) , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ;

if ( GET_CODE ( call ) != CALL ) abort ( ) ;


<s> if ( ! tls_get_addr_libfunc ) tls_get_addr_libfunc = init_one_libfunc ( <STR_LIT> ) ;


<s> for ( param = fntype ? TYPE_ARG_TYPES ( fntype ) : <NUM_LIT> ; param != <NUM_LIT> ; param = next_param ) { next_param = TREE_CHAIN ( param ) ; if ( next_param == <NUM_LIT> && TREE_VALUE ( param ) != void_type_node ) cum -> gp_reg_found = <NUM_LIT> ;


<s> bool simple_loop = false ; bb = BASIC_BLOCK_FOR_FN ( cfun , i ) ; if ( bb == NULL ) continue ; if ( ( prev != <NUM_LIT> ) && ( prev != bb ) ) continue ; else prev = <NUM_LIT> ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( e -> src == bb ) { simple_loop = true ; prev = e -> dest ; break ; } for ( insn = BB_END ( bb ) ; insn ; insn = PREV_INSN ( insn ) ) { if ( INSN_P ( insn ) && ! simple_loop && CALL_P ( insn ) ) { if ( ( branch_target = get_branch_target ( insn ) ) ) insert_wic_for_ilb_runout ( next_active_insn ( next_active_insn ( insn ) ) ) ; } if ( insn == BB_HEAD ( bb ) ) break ; } }


<s> else prev = <NUM_LIT> ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( e -> src == bb ) { simple_loop = true ; prev = e -> dest ; break ; } for ( insn = BB_END ( bb ) ; insn ; insn = PREV_INSN ( insn ) ) { if ( INSN_P ( insn ) && ! simple_loop && CALL_P ( insn ) ) { if ( ( branch_target = get_branch_target ( insn ) ) ) insert_wic_for_ilb_runout ( next_active_insn ( next_active_insn ( insn ) ) ) ;


<s> int length ; int wic_addr0 = <NUM_LIT> * <NUM_LIT> ; int first_addr = INSN_ADDRESSES ( INSN_UID ( first ) ) ; for ( insn = first ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) ) { addr_offset = INSN_ADDRESSES ( INSN_UID ( insn ) ) - first_addr ; length = get_attr_length ( insn ) ; if ( before_4 == <NUM_LIT> && addr_offset + length >= <NUM_LIT> * <NUM_LIT> ) before_4 = insn ; if ( JUMP_P ( insn ) ) return ; if ( before_16 == <NUM_LIT> && addr_offset + length >= <NUM_LIT> * <NUM_LIT> ) before_16 = insn ; if ( CALL_P ( insn ) || tablejump_p ( insn , <NUM_LIT> , <NUM_LIT> ) ) return ; if ( addr_offset + length >= <NUM_LIT> * <NUM_LIT> ) { gcc_assert ( before_4 && before_16 ) ;

if ( wic_addr0 > <NUM_LIT> * <NUM_LIT> ) {


for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( label_mentioned_p ( XVECEXP ( x , i , j ) ) ) return <NUM_LIT> ;


<s> rtx tmp ; if ( reg == NULL_RTX ) reg = gen_reg_rtx ( Pmode ) ; tmp = gen_rtx_CONST ( Pmode , x ) ;

emit_insn ( gen_rtx_SET ( reg , gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , tmp ) ) ) ;


<s> if ( reg == NULL_RTX ) reg = gen_reg_rtx ( Pmode ) ; tmp = gen_rtx_CONST ( Pmode , x ) ; emit_insn ( gen_rtx_SET ( reg , gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , tmp ) ) ) ; return reg ;


<s> static void microblaze_adjust_block_mem ( rtx mem , HOST_WIDE_INT length , rtx * loop_reg , rtx * loop_mem ) { * loop_reg = copy_addr_to_reg ( XEXP ( mem , <NUM_LIT> ) ) ; * loop_mem = change_address ( mem , BLKmode , * loop_reg ) ;

set_mem_align ( * loop_mem , MIN ( ( HOST_WIDE_INT ) MEM_ALIGN ( mem ) , length * BITS_PER_UNIT ) ) ;


<s> * loop_reg = copy_addr_to_reg ( XEXP ( mem , <NUM_LIT> ) ) ; * loop_mem = change_address ( mem , BLKmode , * loop_reg ) ;


<s> void microblaze_asm_output_ident ( const char * string ) { const char * section_asm_op ; int size ; char * buf ; if ( symtab -> state != PARSING ) return ; size = strlen ( string ) + <NUM_LIT> ; if ( size <= microblaze_section_threshold ) section_asm_op = SDATA2_SECTION_ASM_OP ; else section_asm_op = READONLY_DATA_SECTION_ASM_OP ;

buf = ACONCAT ( ( <STR_LIT> , section_asm_op , <STR_LIT> , string , <STR_LIT> , <STR_LIT> , NULL ) ) ;


<s> const char * fnname = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( thunk_fndecl ) ) ; rtx this_rtx , funexp ; rtx_insn * insn ; reload_completed = <NUM_LIT> ; epilogue_completed = <NUM_LIT> ; emit_note ( NOTE_INSN_PROLOGUE_END ) ; if ( aggregate_value_p ( TREE_TYPE ( TREE_TYPE ( function ) ) , function ) ) this_rtx = gen_rtx_REG ( Pmode , ( MB_ABI_FIRST_ARG_REGNUM + <NUM_LIT> ) ) ; else this_rtx = gen_rtx_REG ( Pmode , MB_ABI_FIRST_ARG_REGNUM ) ; if ( delta ) emit_insn ( gen_addsi3 ( this_rtx , this_rtx , GEN_INT ( delta ) ) ) ; if ( vcall_offset ) { rtx vcall_offset_rtx = GEN_INT ( vcall_offset ) ; rtx temp1 = gen_rtx_REG ( Pmode , MB_ABI_TEMP1_REGNUM ) ; emit_move_insn ( temp1 , gen_rtx_MEM ( Pmode , this_rtx ) ) ; rtx loc = gen_rtx_PLUS ( Pmode , temp1 , vcall_offset_rtx ) ; emit_move_insn ( temp1 , gen_rtx_MEM ( Pmode , loc ) ) ; emit_insn ( gen_addsi3 ( this_rtx , this_rtx , temp1 ) ) ; } if ( ! TREE_USED ( function ) ) { assemble_external ( function ) ; TREE_USED ( function ) = <NUM_LIT> ; } funexp = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; rtx temp2 = gen_rtx_REG ( Pmode , MB_ABI_TEMP2_REGNUM ) ; if ( flag_pic ) emit_move_insn ( temp2 , expand_pic_symbol_ref ( Pmode , funexp ) ) ; else emit_move_insn ( temp2 , funexp ) ; emit_insn ( gen_indirect_jump ( temp2 ) ) ; insn = get_insns ( ) ; shorten_branches ( insn ) ; assemble_start_function ( thunk_fndecl , fnname ) ; final_start_function ( insn , file , <NUM_LIT> ) ;


<s> emit_insn ( gen_addsi3 ( this_rtx , this_rtx , temp1 ) ) ; } if ( ! TREE_USED ( function ) ) { assemble_external ( function ) ; TREE_USED ( function ) = <NUM_LIT> ; } funexp = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; rtx temp2 = gen_rtx_REG ( Pmode , MB_ABI_TEMP2_REGNUM ) ; if ( flag_pic ) emit_move_insn ( temp2 , expand_pic_symbol_ref ( Pmode , funexp ) ) ; else emit_move_insn ( temp2 , funexp ) ; emit_insn ( gen_indirect_jump ( temp2 ) ) ; insn = get_insns ( ) ; shorten_branches ( insn ) ; assemble_start_function ( thunk_fndecl , fnname ) ;

final_start_function ( insn , file , <NUM_LIT> ) ;


<s> static void microblaze_asm_trampoline_template ( FILE * f ) { fprintf ( f , <STR_LIT> ) ; fprintf ( f , <STR_LIT> ) ; fprintf ( f , <STR_LIT> ) ;


<s> fprintf ( f , <STR_LIT> ) ; fprintf ( f , <STR_LIT> ) ;


<s> static void microblaze_block_move_loop ( rtx dest , rtx src , HOST_WIDE_INT length ) { rtx_code_label * label ; rtx src_reg , dest_reg , final_src ; HOST_WIDE_INT leftover ; leftover = length % MAX_MOVE_BYTES ; length -= leftover ; microblaze_adjust_block_mem ( src , MAX_MOVE_BYTES , & src_reg , & src ) ; microblaze_adjust_block_mem ( dest , MAX_MOVE_BYTES , & dest_reg , & dest ) ; final_src = expand_simple_binop ( Pmode , PLUS , src_reg , GEN_INT ( length ) , <NUM_LIT> , <NUM_LIT> , OPTAB_WIDEN ) ; label = gen_label_rtx ( ) ; emit_label ( label ) ;

microblaze_block_move_straight ( dest , src , MAX_MOVE_BYTES ) ;


<s> delta = bits / BITS_PER_UNIT ; regs = XALLOCAVEC ( rtx , length / delta ) ; for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) { regs [ i ] = gen_reg_rtx ( mode ) ; emit_move_insn ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; } for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) emit_move_insn ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; if ( offset < length ) {

src = adjust_address ( src , BLKmode , offset ) ;


<s> static rtx_insn * microblaze_call_tls_get_addr ( rtx x , rtx reg , rtx * valuep , int reloc ) { rtx_insn * insns ; rtx tls_entry ; df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ;


<s> bool microblaze_cannot_force_const_mem ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) { return microblaze_tls_referenced_p ( x ) ;


<s> static bool microblaze_can_eliminate ( const int from , const int to ) {

return ( ( from == RETURN_ADDRESS_POINTER_REGNUM && ! leaf_function_p ( ) ) || ( to == MB_ABI_SUB_RETURN_ADDR_REGNUM && leaf_function_p ( ) ) || ( from != RETURN_ADDRESS_POINTER_REGNUM && ( to == HARD_FRAME_POINTER_REGNUM || ( to == STACK_POINTER_REGNUM && ! frame_pointer_needed ) ) ) ) ;


<s> if ( ! reload_completed ) return <NUM_LIT> ; if ( df_regs_ever_live_p ( MB_ABI_SUB_RETURN_ADDR_REGNUM ) || profile_flag ) return <NUM_LIT> ; if ( current_frame_info . initialized ) return current_frame_info . total_size == <NUM_LIT> ;

return compute_frame_size ( get_frame_size ( ) ) == <NUM_LIT> ;


<s> static HOST_WIDE_INT microblaze_constant_alignment ( const_tree exp , HOST_WIDE_INT align ) { if ( TREE_CODE ( exp ) == STRING_CST || TREE_CODE ( exp ) == CONSTRUCTOR ) return MAX ( align , BITS_PER_WORD ) ; return align ;


<s> REAL_VALUE_TYPE d ; if ( GET_CODE ( op ) != CONST_DOUBLE ) return <NUM_LIT> ; if ( GET_MODE ( op ) == VOIDmode ) return <NUM_LIT> ; if ( mode != SFmode && mode != DFmode ) return <NUM_LIT> ; if ( op == CONST0_RTX ( mode ) ) return <NUM_LIT> ; d = * CONST_DOUBLE_REAL_VALUE ( op ) ; if ( REAL_VALUE_ISNAN ( d ) ) return FALSE ;

if ( REAL_VALUE_NEGATIVE ( d ) ) d = real_value_negate ( & d ) ;


<s> void microblaze_declare_object ( FILE * stream , const char * name , const char * section , const char * fmt , int size ) {


<s> void microblaze_declare_object ( FILE * stream , const char * name , const char * section , const char * fmt , int size ) { fputs ( section , stream ) ;


<s> void microblaze_eh_return ( rtx op0 ) { emit_insn ( gen_movsi ( gen_rtx_MEM ( Pmode , stack_pointer_rtx ) , op0 ) ) ;


<s> } else if ( is_ctor ) s = ctors_section ; else s = dtors_section ; switch_to_section ( s ) ; assemble_align ( POINTER_SIZE ) ;


<s> microblaze_elf_asm_cdtor ( symbol , priority , true ) ;


<s> static void microblaze_elf_asm_destructor ( rtx symbol , int priority ) {

microblaze_elf_asm_cdtor ( symbol , priority , false ) ;


<s> static void microblaze_elf_asm_init_sections ( void ) { sdata2_section = get_unnamed_section ( SECTION_WRITE , output_section_asm_op , SDATA2_SECTION_ASM_OP ) ;


<s> static void microblaze_elf_asm_init_sections ( void ) {


<s> if ( strcmp ( section , <STR_LIT> ) == <NUM_LIT> || strcmp ( section , <STR_LIT> ) == <NUM_LIT> || strcmp ( section , <STR_LIT> ) == <NUM_LIT> || strcmp ( section , <STR_LIT> ) == <NUM_LIT> ) return true ;


<s> default_encode_section_info ( decl , rtl , first ) ;


<s> if ( GET_CODE ( length ) == CONST_INT ) { unsigned HOST_WIDE_INT bytes = UINTVAL ( length ) ; unsigned int align = UINTVAL ( align_rtx ) ; if ( align > UNITS_PER_WORD ) { align = UNITS_PER_WORD ; } else if ( align < UNITS_PER_WORD ) { if ( UINTVAL ( length ) <= MAX_MOVE_BYTES ) { move_by_pieces ( dest , src , bytes , align , RETURN_BEGIN ) ; return true ; } else return false ; } if ( UINTVAL ( length ) <= <NUM_LIT> * MAX_MOVE_BYTES ) { microblaze_block_move_straight ( dest , src , UINTVAL ( length ) ) ; return true ; } else if ( optimize ) { microblaze_block_move_loop ( dest , src , UINTVAL ( length ) ) ; return true ; }


<s> comp_reg = cmp_op0 ; condition = gen_rtx_fmt_ee ( signed_condition ( code ) , SImode , comp_reg , const0_rtx ) ; emit_jump_insn ( gen_condjump ( condition , label1 ) ) ; } else if ( code == EQ || code == NE ) { emit_insn ( gen_xorsi3 ( comp_reg , cmp_op0 , cmp_op1 ) ) ; condition = gen_rtx_fmt_ee ( signed_condition ( code ) , SImode , comp_reg , const0_rtx ) ;


<s> comp_reg = cmp_op0 ; condition = gen_rtx_fmt_ee ( signed_condition ( code ) , SImode , comp_reg , const0_rtx ) ; emit_jump_insn ( gen_condjump ( condition , label1 ) ) ; } else if ( code == EQ ) { emit_insn ( gen_seq_internal_pat ( comp_reg , cmp_op0 , cmp_op1 ) ) ; condition = gen_rtx_EQ ( SImode , comp_reg , const0_rtx ) ; emit_jump_insn ( gen_condjump ( condition , label1 ) ) ; } else if ( code == NE ) {


<s> emit_insn ( gen_cstoresf4 ( comp_reg , operands [ <NUM_LIT> ] , cmp_op0 , cmp_op1 ) ) ;

condition = gen_rtx_NE ( SImode , comp_reg , const0_rtx ) ;


<s> rtx cmp_op1 = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; rtx comp_reg = gen_reg_rtx ( SImode ) ; emit_insn ( gen_cstoresf4 ( comp_reg , operands [ <NUM_LIT> ] , cmp_op0 , cmp_op1 ) ) ; condition = gen_rtx_NE ( SImode , comp_reg , const0_rtx ) ; emit_jump_insn ( gen_condjump ( condition , operands [ <NUM_LIT> ] ) ) ;


<s> rtx_insn * jump , * cjump , * insn ; insn = emit_insn ( gen_iorsi3 ( regt1 , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; cjump = emit_jump_insn_after ( gen_cbranchsi4 ( gen_rtx_GTU ( SImode , regt1 , GEN_INT ( <NUM_LIT> ) ) , regt1 , GEN_INT ( <NUM_LIT> ) , div_label ) , insn ) ; LABEL_NUSES ( div_label ) = <NUM_LIT> ; JUMP_LABEL ( cjump ) = div_label ; emit_insn ( gen_rtx_CLOBBER ( SImode , reg18 ) ) ; emit_insn ( gen_ashlsi3_bshift ( regt1 , operands [ <NUM_LIT> ] , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_addsi3 ( regt1 , regt1 , operands [ <NUM_LIT> ] ) ) ; mem_rtx = gen_rtx_MEM ( QImode , gen_rtx_PLUS ( Pmode , regt1 , div_table_rtx ) ) ; insn = emit_insn ( gen_movqi ( regqi , mem_rtx ) ) ; insn = emit_insn ( gen_movsi ( operands [ <NUM_LIT> ] , gen_rtx_SUBREG ( SImode , regqi , <NUM_LIT> ) ) ) ; jump = emit_jump_insn_after ( gen_jump ( div_end_label ) , insn ) ;


<s> if ( GET_CODE ( p0 ) == UNSPEC && GET_CODE ( p1 ) == CONST_INT && flag_pic && TARGET_PIC_DATA_TEXT_REL ) { result = gen_rtx_CONST ( Pmode , p0 ) ; result = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , result ) ; temp = force_reg ( SImode , result ) ; emit_move_insn ( op0 , gen_rtx_PLUS ( SImode , temp , p1 ) ) ; return true ; } } if ( GET_CODE ( op1 ) == CONST && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == PLUS ) { rtx p0 , p1 ; p0 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; p1 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ( GET_CODE ( p1 ) == CONST_INT ) && ( ( GET_CODE ( p0 ) == UNSPEC ) || ( ( GET_CODE ( p0 ) == SYMBOL_REF || GET_CODE ( p0 ) == LABEL_REF ) && ( flag_pic == <NUM_LIT> || microblaze_tls_symbol_p ( p0 ) || ! SMALL_INT ( p1 ) ) ) ) ) { rtx temp = force_reg ( SImode , p0 ) ; rtx temp2 = p1 ; if ( flag_pic && reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; emit_move_insn ( op0 , gen_rtx_PLUS ( SImode , temp , temp2 ) ) ; return true ; } }


<s> else if ( flag_pic ) { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; result = expand_pic_symbol_ref ( mode , op1 ) ; if ( TARGET_PIC_DATA_TEXT_REL && GET_CODE ( op0 ) == REG && REGNO ( op0 ) >= FIRST_PSEUDO_REGISTER ) result = force_reg ( SImode , result ) ; emit_move_insn ( op0 , result ) ; return true ; } } if ( GET_CODE ( op1 ) == PLUS && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == CONST ) { rtx p0 , p1 , result , temp ; p0 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( p0 ) == PLUS ) { p1 = XEXP ( p0 , <NUM_LIT> ) ; p0 = XEXP ( p0 , <NUM_LIT> ) ; } if ( GET_CODE ( p0 ) == UNSPEC && GET_CODE ( p1 ) == CONST_INT && flag_pic && TARGET_PIC_DATA_TEXT_REL ) { result = gen_rtx_CONST ( Pmode , p0 ) ; result = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , result ) ; temp = force_reg ( SImode , result ) ; emit_move_insn ( op0 , gen_rtx_PLUS ( SImode , temp , p1 ) ) ; return true ; } } if ( GET_CODE ( op1 ) == CONST && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == PLUS ) { rtx p0 , p1 ; p0 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; p1 = XEXP ( XEXP ( op1 , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ( GET_CODE ( p1 ) == CONST_INT ) && ( ( GET_CODE ( p0 ) == UNSPEC ) || ( ( GET_CODE ( p0 ) == SYMBOL_REF || GET_CODE ( p0 ) == LABEL_REF ) && ( flag_pic == <NUM_LIT> || microblaze_tls_symbol_p ( p0 ) || ! SMALL_INT ( p1 ) ) ) ) ) { rtx temp = force_reg ( SImode , p0 ) ;


<s> int offset = ( regno - GP_ARG_FIRST + <NUM_LIT> ) * UNITS_PER_WORD ; rtx ptr = stack_pointer_rtx ; for ( ; regno <= GP_ARG_LAST ; regno ++ ) { if ( offset != <NUM_LIT> ) ptr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( offset ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , ptr ) , gen_rtx_REG ( SImode , regno ) ) ; offset += GET_MODE_SIZE ( SImode ) ; } } if ( fsiz > <NUM_LIT> ) { rtx fsiz_rtx = GEN_INT ( fsiz ) ; rtx_insn * insn = NULL ; insn = emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , fsiz_rtx ) ) ; if ( insn ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( ! crtl -> is_leaf || interrupt_handler ) { mem_rtx = gen_rtx_MEM ( SImode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , const0_rtx ) ) ; if ( interrupt_handler ) MEM_VOLATILE_P ( mem_rtx ) = <NUM_LIT> ; reg_rtx = gen_rtx_REG ( SImode , MB_ABI_SUB_RETURN_ADDR_REGNUM ) ; insn = emit_move_insn ( mem_rtx , reg_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } save_restore_insns ( <NUM_LIT> ) ; if ( frame_pointer_needed ) { rtx_insn * insn = <NUM_LIT> ; insn = emit_insn ( gen_movsi ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; if ( insn ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } if ( ( flag_pic == <NUM_LIT> || TLS_NEEDS_GOT ) && df_regs_ever_live_p ( MB_ABI_PIC_ADDR_REGNUM ) ) { if ( ( flag_pic == <NUM_LIT> && ! TARGET_PIC_DATA_TEXT_REL ) || TLS_NEEDS_GOT ) {


<s> if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) && ( INTVAL ( operands [ <NUM_LIT> ] ) == <NUM_LIT> ) ) return <NUM_LIT> ; if ( TARGET_BARREL_SHIFT ) return <NUM_LIT> ; gcc_assert ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG ) ) ; if ( operands [ <NUM_LIT> ] == const0_rtx && ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) { emit_insn ( gen_movsi ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; return <NUM_LIT> ; } return <NUM_LIT> ;


<s> if ( TARGET_BARREL_SHIFT ) return <NUM_LIT> ; gcc_assert ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) == SUBREG ) ) ; if ( operands [ <NUM_LIT> ] == const0_rtx && ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) { emit_insn ( gen_movsi ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; return <NUM_LIT> ;


<s> tree a ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ; a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ; return a != NULL_TREE ;


<s> static bool microblaze_frame_pointer_required ( void ) {

if ( cfun -> calls_alloca ) return true ;


<s> static bool microblaze_frame_pointer_required ( void ) { if ( cfun -> calls_alloca ) return true ;


<s> gcc_assert ( GET_MODE_CLASS ( arg . mode ) == MODE_COMPLEX_INT || GET_MODE_CLASS ( arg . mode ) == MODE_COMPLEX_FLOAT ) ; case E_BLKmode : regbase = GP_ARG_FIRST ; break ; } if ( * arg_words >= MAX_ARGS_IN_REGISTERS ) ret = <NUM_LIT> ; else { gcc_assert ( regbase != - <NUM_LIT> ) ; ret = gen_rtx_REG ( arg . mode , regbase + * arg_words ) ; } if ( arg . end_marker_p ( ) ) {

if ( cum -> num_adjusts > <NUM_LIT> ) ret = gen_rtx_PARALLEL ( ( machine_mode ) cum -> fp_code , gen_rtvec_v ( cum -> num_adjusts , cum -> adjust ) ) ;


<s> break ; case E_DFmode : cum -> arg_words += <NUM_LIT> ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case E_DImode : cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += <NUM_LIT> ; break ; case E_QImode : case E_HImode : case E_SImode : case E_TImode : cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words ++ ;


<s> case E_SFmode : cum -> arg_words ++ ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case E_DFmode : cum -> arg_words += <NUM_LIT> ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case E_DImode : cum -> gp_reg_found = <NUM_LIT> ;


<s> fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ;


<s> fnname = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ! flag_inhibit_size_directive ) { fputs ( <STR_LIT> , file ) ; if ( interrupt_handler && ! break_handler ) fputs ( <STR_LIT> , file ) ;

else if ( break_handler ) fputs ( <STR_LIT> , file ) ;


<s> const char * fnname ; long fsiz = current_frame_info . total_size ; fnname = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ! flag_inhibit_size_directive ) { fputs ( <STR_LIT> , file ) ; if ( interrupt_handler && strcmp ( INTERRUPT_HANDLER_NAME , fnname ) ) fputs ( <STR_LIT> , file ) ; else if ( break_handler && strcmp ( BREAK_HANDLER_NAME , fnname ) ) fputs ( <STR_LIT> , file ) ; else if ( fast_interrupt && strcmp ( FAST_INTERRUPT_NAME , fnname ) ) fputs ( <STR_LIT> , file ) ; else assemble_name ( file , fnname ) ; fputs ( <STR_LIT> , file ) ; if ( ! microblaze_is_interrupt_variant ( ) ) ASM_OUTPUT_TYPE_DIRECTIVE ( file , fnname , <STR_LIT> ) ;


<s> return LIBCALL_VALUE ( TYPE_MODE ( valtype ) ) ;


<s> static rtx microblaze_function_value ( const_tree valtype , const_tree func ATTRIBUTE_UNUSED , bool outgoing ATTRIBUTE_UNUSED ) { return LIBCALL_VALUE ( TYPE_MODE ( valtype ) ) ;


<s> if ( microblaze_is_interrupt_variant ( ) ) { if ( interrupt_handler && strcmp ( name , INTERRUPT_HANDLER_NAME ) ) fputs ( INTERRUPT_HANDLER_NAME , stream ) ; else if ( break_handler && strcmp ( name , BREAK_HANDLER_NAME ) ) fputs ( BREAK_HANDLER_NAME , stream ) ; else if ( fast_interrupt && strcmp ( name , FAST_INTERRUPT_NAME ) ) fputs ( FAST_INTERRUPT_NAME , stream ) ; fputs ( <STR_LIT> , stream ) ; }


<s> static bool microblaze_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { return microblaze_hard_regno_mode_ok_p [ mode ] [ regno ] ;


<s> break ; case RETURN_ADDRESS_POINTER_REGNUM : if ( crtl -> is_leaf ) offset = <NUM_LIT> ; else offset = current_frame_info . gp_offset + ( ( UNITS_PER_WORD - ( POINTER_SIZE / BITS_PER_UNIT ) ) ) ; break ; default : gcc_unreachable ( ) ;


<s> if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ;

a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ;


<s> tree a ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ; a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ;


<s> int microblaze_is_break_handler ( void ) {


<s> int microblaze_is_interrupt_variant ( void ) { return ( interrupt_handler || fast_interrupt ) ;


<s> return ( interrupt_handler || fast_interrupt ) ;


<s> p1 = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( p1 ) == CONST_INT ) { if ( ( GET_CODE ( p0 ) == UNSPEC ) ) return false ;

if ( ( GET_CODE ( p0 ) == SYMBOL_REF || GET_CODE ( p0 ) == LABEL_REF ) && ( microblaze_tls_symbol_p ( p0 ) || ! SMALL_INT ( p1 ) ) ) return false ;


<s> if ( GET_CODE ( p1 ) == CONST_INT ) { if ( ( GET_CODE ( p0 ) == UNSPEC ) ) return false ;


<s> emit_insn ( gen_rtx_SET ( ptr_reg , gen_rtx_PLUS ( Pmode , xplus0 , int_reg ) ) ) ; result = gen_rtx_PLUS ( Pmode , ptr_reg , GEN_INT ( INTVAL ( xplus1 ) & <NUM_LIT> ) ) ; return result ; } if ( code0 == REG && REG_OK_FOR_BASE_P ( xplus0 ) ) { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; if ( code1 == CONST ) { xplus1 = XEXP ( xplus1 , <NUM_LIT> ) ; code1 = GET_CODE ( xplus1 ) ; } if ( code1 == SYMBOL_REF ) { if ( microblaze_tls_symbol_p ( xplus1 ) ) { rtx tls_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; tls_ref = microblaze_legitimize_tls_address ( xplus1 , NULL_RTX ) ; emit_move_insn ( reg , tls_ref ) ; result = gen_rtx_PLUS ( Pmode , xplus0 , reg ) ; return result ; } else if ( flag_pic == <NUM_LIT> ) { if ( ! TARGET_PIC_DATA_TEXT_REL ) { rtx pic_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; pic_ref = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , xplus1 ) , UNSPEC_GOTOFF ) ; pic_ref = gen_rtx_CONST ( Pmode , pic_ref ) ; pic_ref = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , pic_ref ) ; pic_ref = gen_const_mem ( Pmode , pic_ref ) ; emit_move_insn ( reg , pic_ref ) ; result = gen_rtx_PLUS ( Pmode , xplus0 , reg ) ; return result ; } else { rtx pic_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; pic_ref = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , xplus1 ) , UNSPEC_TEXT ) ; pic_ref = gen_rtx_CONST ( Pmode , pic_ref ) ; emit_insn ( gen_addsi3 ( reg , pic_offset_table_rtx , xplus0 ) ) ; result = gen_rtx_PLUS ( Pmode , reg , pic_ref ) ; return result ; } } } } } if ( GET_CODE ( xinsn ) == SYMBOL_REF ) { rtx reg ; if ( microblaze_tls_symbol_p ( xinsn ) ) { reg = microblaze_legitimize_tls_address ( xinsn , NULL_RTX ) ; }


<s> emit_move_insn ( ptr_reg , XEXP ( XEXP ( xinsn , <NUM_LIT> ) , <NUM_LIT> ) ) ; result = gen_rtx_PLUS ( Pmode , ptr_reg , constant ) ; if ( SMALL_INT ( constant ) ) return result ; xinsn = result ; } if ( GET_CODE ( xinsn ) == PLUS ) { rtx xplus0 = XEXP ( xinsn , <NUM_LIT> ) ; rtx xplus1 = XEXP ( xinsn , <NUM_LIT> ) ; enum rtx_code code0 = GET_CODE ( xplus0 ) ; enum rtx_code code1 = GET_CODE ( xplus1 ) ; if ( code0 != REG && code1 == REG ) { xplus0 = XEXP ( xinsn , <NUM_LIT> ) ; xplus1 = XEXP ( xinsn , <NUM_LIT> ) ; code0 = GET_CODE ( xplus0 ) ; code1 = GET_CODE ( xplus1 ) ; } if ( code0 == REG && REG_OK_FOR_BASE_P ( xplus0 ) && code1 == CONST_INT && ! SMALL_INT ( xplus1 ) ) { rtx int_reg = gen_reg_rtx ( Pmode ) ; rtx ptr_reg = gen_reg_rtx ( Pmode ) ; emit_move_insn ( int_reg , GEN_INT ( INTVAL ( xplus1 ) & ~ <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( ptr_reg , gen_rtx_PLUS ( Pmode , xplus0 , int_reg ) ) ) ; result = gen_rtx_PLUS ( Pmode , ptr_reg , GEN_INT ( INTVAL ( xplus1 ) & <NUM_LIT> ) ) ; return result ; } if ( code0 == REG && REG_OK_FOR_BASE_P ( xplus0 ) ) { if ( reload_in_progress ) df_set_regs_ever_live ( PIC_OFFSET_TABLE_REGNUM , true ) ; if ( code1 == CONST ) { xplus1 = XEXP ( xplus1 , <NUM_LIT> ) ; code1 = GET_CODE ( xplus1 ) ; } if ( code1 == SYMBOL_REF ) { if ( microblaze_tls_symbol_p ( xplus1 ) ) { rtx tls_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; tls_ref = microblaze_legitimize_tls_address ( xplus1 , NULL_RTX ) ; emit_move_insn ( reg , tls_ref ) ; result = gen_rtx_PLUS ( Pmode , xplus0 , reg ) ; return result ; } else if ( flag_pic == <NUM_LIT> ) { if ( ! TARGET_PIC_DATA_TEXT_REL ) { rtx pic_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; pic_ref = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , xplus1 ) , UNSPEC_GOTOFF ) ; pic_ref = gen_rtx_CONST ( Pmode , pic_ref ) ; pic_ref = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , pic_ref ) ; pic_ref = gen_const_mem ( Pmode , pic_ref ) ; emit_move_insn ( reg , pic_ref ) ; result = gen_rtx_PLUS ( Pmode , xplus0 , reg ) ; return result ; } else { rtx pic_ref , reg ; reg = gen_reg_rtx ( Pmode ) ; pic_ref = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , xplus1 ) , UNSPEC_TEXT ) ; pic_ref = gen_rtx_CONST ( Pmode , pic_ref ) ; emit_insn ( gen_addsi3 ( reg , pic_offset_table_rtx , xplus0 ) ) ; result = gen_rtx_PLUS ( Pmode , reg , pic_ref ) ; return result ; } }


<s> dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , x ) ; break ; case TLS_MODEL_LOCAL_EXEC : insns = microblaze_call_tls_get_addr ( x , reg , & ret , TLS_LDM ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) , UNSPEC_TLS ) ; dest = gen_reg_rtx ( Pmode ) ;

emit_libcall_block ( insns , dest , ret , eqv ) ;


<s> compute_bb_for_insn ( ) ; loop_optimizer_init ( AVOID_CFG_MODIFICATIONS ) ; shorten_branches ( get_insns ( ) ) ; insert_wic ( ) ;


<s> return ( ( GET_MODE_CLASS ( mode1 ) == MODE_FLOAT || GET_MODE_CLASS ( mode1 ) == MODE_COMPLEX_FLOAT ) == ( GET_MODE_CLASS ( mode2 ) == MODE_FLOAT || GET_MODE_CLASS ( mode2 ) == MODE_COMPLEX_FLOAT ) ) ;


<s> if ( ( microblaze_is_interrupt_variant ( ) || save_volatiles ) && ( regno >= <NUM_LIT> && regno <= <NUM_LIT> ) ) return <NUM_LIT> ; } if ( microblaze_is_interrupt_variant ( ) ) { if ( df_regs_ever_live_p ( regno ) || regno == MB_ABI_MSR_SAVE_REG || ( ( interrupt_handler || fast_interrupt ) && ( regno == MB_ABI_ASM_TEMP_REGNUM || regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM ) ) ) return <NUM_LIT> ; }


<s> if ( crtl -> calls_eh_return && regno == MB_ABI_SUB_RETURN_ADDR_REGNUM ) return <NUM_LIT> ; if ( ! crtl -> is_leaf ) { if ( regno == MB_ABI_SUB_RETURN_ADDR_REGNUM ) return <NUM_LIT> ; if ( ( microblaze_is_interrupt_variant ( ) || save_volatiles ) && ( regno >= <NUM_LIT> && regno <= <NUM_LIT> ) ) return <NUM_LIT> ; }

if ( microblaze_is_interrupt_variant ( ) ) {


<s> if ( regno >= FIRST_PSEUDO_REGISTER ) { if ( ! strict ) return true ;


<s> if ( count != <NUM_LIT> ) return NULL_RTX ; return get_hard_reg_initial_val ( Pmode , MB_ABI_SUB_RETURN_ADDR_REGNUM ) ;


<s> static int microblaze_save_volatiles ( tree func ) { tree a ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ; a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ;


<s> if ( rclass == ST_REGS ) return GR_REGS ;


<s> static section * microblaze_select_section ( tree decl , int reloc , unsigned HOST_WIDE_INT align ) { switch ( categorize_decl_for_section ( decl , reloc ) ) {


<s> if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) return true ; if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) iter . skip_subrtxes ( ) ; }


<s> subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , x , ALL ) { const_rtx x = * iter ; if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) return true ;

if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) iter . skip_subrtxes ( ) ;


<s> if ( GET_CODE ( x ) != SYMBOL_REF ) return false ;

return SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ;


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


<s> static void microblaze_trampoline_init ( rtx m_tramp , tree fndecl , rtx chain_value ) {

rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ;


<s> return ( GET_CODE ( x ) == REG && microblaze_regno_ok_for_base_p ( REGNO ( x ) , strict ) ) ;


<s> if ( ! strict && GET_CODE ( x ) == SUBREG ) x = SUBREG_REG ( x ) ; return ( GET_CODE ( x ) == REG && microblaze_regno_ok_for_base_p ( REGNO ( x ) , strict ) ) ;


<s> static bool microblaze_valid_index_register_p ( rtx x , machine_mode mode ATTRIBUTE_UNUSED , int strict ) {

if ( ! strict && GET_CODE ( x ) == SUBREG ) x = SUBREG_REG ( x ) ;


<s> int microblaze_valid_pic_const ( rtx x ) { switch ( GET_CODE ( x ) ) { case CONST : case CONST_INT : case CONST_DOUBLE : return true ; default : return false ; }


<s> if ( ( GET_CODE ( p0 ) == SYMBOL_REF || GET_CODE ( p0 ) == LABEL_REF ) && ( GET_CODE ( p1 ) == CONST_INT ) && ( flag_pic == <NUM_LIT> || microblaze_tls_symbol_p ( p0 ) || ! SMALL_INT ( p1 ) ) ) return <NUM_LIT> ;


<s> p1 = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ( GET_CODE ( p0 ) == SYMBOL_REF || GET_CODE ( p0 ) == LABEL_REF ) && ( GET_CODE ( p1 ) == CONST_INT ) && ( flag_pic == <NUM_LIT> || microblaze_tls_symbol_p ( p0 ) || ! SMALL_INT ( p1 ) ) ) return <NUM_LIT> ; }


<s> case ADDRESS_GOTOFF : case ADDRESS_PLT : case ADDRESS_TLS : if ( info . regA ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( info . regA ) ] ) ; output_addr_const ( file , info . symbol ) ; if ( type == ADDRESS_GOTOFF ) { fputs ( <STR_LIT> , file ) ; } else if ( type == ADDRESS_PLT ) { fputs ( <STR_LIT> , file ) ; } else if ( type == ADDRESS_SYMBOLIC_TXT_REL ) { if ( info . offset != NULL && CONST_INT_P ( info . offset ) && INTVAL ( info . offset ) > <NUM_LIT> ) { fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , info . offset ) ; } fputs ( <STR_LIT> , file ) ; } else if ( type == ADDRESS_TLS ) { switch ( info . tls_type ) { case TLS_GD : fputs ( <STR_LIT> , file ) ;


<s> emit_move_insn ( isr_reg_rtx , isr_mem_rtx ) ; emit_move_insn ( isr_msr_rtx , isr_reg_rtx ) ; emit_insn ( gen_rtx_USE ( SImode , isr_reg_rtx ) ) ; emit_insn ( gen_rtx_USE ( SImode , isr_msr_rtx ) ) ; } for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) { if ( BITSET_P ( mask , regno - GP_REG_FIRST ) ) { if ( regno == MB_ABI_SUB_RETURN_ADDR_REGNUM ) continue ; reg_rtx = gen_rtx_REG ( SImode , regno ) ; insn = gen_rtx_PLUS ( Pmode , base_reg_rtx , GEN_INT ( gp_offset ) ) ; mem_rtx = gen_rtx_MEM ( SImode , insn ) ; if ( microblaze_is_interrupt_variant ( ) || save_volatiles ) MEM_VOLATILE_P ( mem_rtx ) = <NUM_LIT> ; if ( prologue ) { insn = emit_move_insn ( mem_rtx , reg_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { insn = emit_move_insn ( reg_rtx , mem_rtx ) ; } gp_offset += GET_MODE_SIZE ( SImode ) ; } } if ( microblaze_is_interrupt_variant ( ) && prologue ) {


<s> if ( microblaze_is_interrupt_variant ( ) ) { isr_mem_rtx = gen_rtx_MEM ( SImode , gen_rtx_PLUS ( Pmode , base_reg_rtx , GEN_INT ( current_frame_info . gp_offset - UNITS_PER_WORD ) ) ) ; MEM_VOLATILE_P ( isr_mem_rtx ) = <NUM_LIT> ; isr_reg_rtx = gen_rtx_REG ( SImode , MB_ABI_MSR_SAVE_REG ) ; isr_msr_rtx = gen_rtx_REG ( SImode , ST_REG ) ; } if ( microblaze_is_interrupt_variant ( ) && ! prologue ) { emit_move_insn ( isr_reg_rtx , isr_mem_rtx ) ; emit_move_insn ( isr_msr_rtx , isr_reg_rtx ) ; emit_insn ( gen_rtx_USE ( SImode , isr_reg_rtx ) ) ; emit_insn ( gen_rtx_USE ( SImode , isr_msr_rtx ) ) ; } for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) { if ( BITSET_P ( mask , regno - GP_REG_FIRST ) ) { if ( regno == MB_ABI_SUB_RETURN_ADDR_REGNUM ) continue ; reg_rtx = gen_rtx_REG ( SImode , regno ) ; insn = gen_rtx_PLUS ( Pmode , base_reg_rtx , GEN_INT ( gp_offset ) ) ; mem_rtx = gen_rtx_MEM ( SImode , insn ) ; if ( microblaze_is_interrupt_variant ( ) || save_volatiles ) MEM_VOLATILE_P ( mem_rtx ) = <NUM_LIT> ; if ( prologue ) { insn = emit_move_insn ( mem_rtx , reg_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { insn = emit_move_insn ( reg_rtx , mem_rtx ) ; }


<s> int simple_memory_operand ( rtx op , machine_mode mode ATTRIBUTE_UNUSED ) { rtx addr , plus0 , plus1 ; if ( GET_CODE ( op ) != MEM ) return <NUM_LIT> ; if ( GET_MODE_SIZE ( GET_MODE ( op ) ) > UNITS_PER_WORD ) return <NUM_LIT> ; addr = XEXP ( op , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case REG : return <NUM_LIT> ; case PLUS : plus0 = XEXP ( addr , <NUM_LIT> ) ;


<s> for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( symbol_mentioned_p ( XVECEXP ( x , i , j ) ) ) return <NUM_LIT> ; }

else if ( fmt [ i ] == 'e' && symbol_mentioned_p ( XEXP ( x , i ) ) ) return <NUM_LIT> ;


<s> return tls_mentioned_p ( XEXP ( x , <NUM_LIT> ) ) ; case UNSPEC :

if ( XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) return <NUM_LIT> ;


<s> if ( XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) return <NUM_LIT> ; return <NUM_LIT> ; default : return <NUM_LIT> ;