<s> if ( TREE_PUBLIC ( default_decl ) == <NUM_LIT> ) { char * ifunc_name = make_unique_name ( default_decl , <STR_LIT> , true ) ; symtab -> change_decl_assembler_name ( ifunc_alias_decl , get_identifier ( ifunc_name ) ) ; XDELETEVEC ( ifunc_name ) ; } resolver_name = make_unique_name ( default_decl , <STR_LIT> , false ) ; type = build_function_type_list ( ptr_type_node , NULL_TREE ) ; decl = build_fn_decl ( resolver_name , type ) ; decl_name = get_identifier ( resolver_name ) ; SET_DECL_ASSEMBLER_NAME ( decl , decl_name ) ; DECL_NAME ( decl ) = decl_name ; TREE_USED ( decl ) = <NUM_LIT> ; DECL_ARTIFICIAL ( decl ) = <NUM_LIT> ; DECL_IGNORED_P ( decl ) = <NUM_LIT> ; TREE_PUBLIC ( decl ) = <NUM_LIT> ; DECL_UNINLINABLE ( decl ) = <NUM_LIT> ; DECL_EXTERNAL ( decl ) = <NUM_LIT> ; DECL_EXTERNAL ( ifunc_alias_decl ) = <NUM_LIT> ; DECL_CONTEXT ( decl ) = NULL_TREE ; DECL_INITIAL ( decl ) = make_node ( BLOCK ) ; DECL_STATIC_CONSTRUCTOR ( decl ) = <NUM_LIT> ; if ( DECL_COMDAT_GROUP ( default_decl ) || TREE_PUBLIC ( default_decl ) ) { DECL_COMDAT ( decl ) = <NUM_LIT> ; make_decl_one_only ( decl , DECL_ASSEMBLER_NAME ( decl ) ) ; } t = build_decl ( UNKNOWN_LOCATION , RESULT_DECL , NULL_TREE , ptr_type_node ) ; DECL_ARTIFICIAL ( t ) = <NUM_LIT> ; DECL_IGNORED_P ( t ) = <NUM_LIT> ; DECL_RESULT ( decl ) = t ; gimplify_function_tree ( decl ) ; push_cfun ( DECL_STRUCT_FUNCTION ( decl ) ) ; * empty_bb = init_lowered_empty_function ( decl , false , profile_count :: uninitialized ( ) ) ; cgraph_node :: add_new_function ( decl , true ) ; symtab -> call_cgraph_insertion_hooks ( cgraph_node :: get_create ( decl ) ) ; pop_cfun ( ) ; gcc_assert ( ifunc_alias_decl != NULL ) ; DECL_ATTRIBUTES ( ifunc_alias_decl ) = make_attribute ( <STR_LIT> , resolver_name , DECL_ATTRIBUTES ( ifunc_alias_decl ) ) ; cgraph_node :: create_same_body_alias ( ifunc_alias_decl , decl ) ; XDELETEVEC ( resolver_name ) ;


<s> bool count_reg = false ; df_ref ref ; for ( ref = DF_REG_DEF_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) if ( ! bitmap_bit_p ( insns , DF_REF_INSN_UID ( ref ) ) ) { df_ref use ; for ( use = DF_REG_USE_CHAIN ( regno ) ; use ; use = DF_REF_NEXT_REG ( use ) ) if ( bitmap_bit_p ( insns , DF_REF_INSN_UID ( use ) ) ) { rtx_insn * insn = DF_REF_INSN ( use ) ; rtx def_set = single_set ( insn ) ; gcc_assert ( def_set ) ; rtx src = SET_SRC ( def_set ) ; if ( ( GET_CODE ( src ) == ASHIFT || GET_CODE ( src ) == ASHIFTRT || GET_CODE ( src ) == LSHIFTRT ) && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) && reg_or_subregno ( XEXP ( src , <NUM_LIT> ) ) == regno ) count_reg = true ; } start_sequence ( ) ; if ( count_reg ) { rtx qreg = gen_lowpart ( QImode , reg ) ; rtx tmp = gen_reg_rtx ( SImode ) ; if ( TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p ( cfun ) ) { emit_move_insn ( tmp , const0_rtx ) ; emit_insn ( gen_movstrictqi ( gen_lowpart ( QImode , tmp ) , qreg ) ) ; } else emit_insn ( gen_rtx_SET ( tmp , gen_rtx_ZERO_EXTEND ( SImode , qreg ) ) ) ; if ( ! TARGET_INTER_UNIT_MOVES_TO_VEC ) { rtx slot = assign_386_stack_local ( SImode , SLOT_STV_TEMP ) ; emit_move_insn ( slot , tmp ) ; tmp = copy_rtx ( slot ) ; } emit_insn ( gen_zero_extendsidi2 ( vreg , tmp ) ) ; } else if ( ! TARGET_INTER_UNIT_MOVES_TO_VEC ) { rtx tmp = assign_386_stack_local ( DImode , SLOT_STV_TEMP ) ; emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ;


<s> if ( count_reg ) { rtx qreg = gen_lowpart ( QImode , reg ) ; rtx tmp = gen_reg_rtx ( SImode ) ; if ( TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p ( cfun ) ) { emit_move_insn ( tmp , const0_rtx ) ; emit_insn ( gen_movstrictqi ( gen_lowpart ( QImode , tmp ) , qreg ) ) ; } else emit_insn ( gen_rtx_SET ( tmp , gen_rtx_ZERO_EXTEND ( SImode , qreg ) ) ) ; if ( ! TARGET_INTER_UNIT_MOVES_TO_VEC ) { rtx slot = assign_386_stack_local ( SImode , SLOT_STV_TEMP ) ; emit_move_insn ( slot , tmp ) ; tmp = copy_rtx ( slot ) ; } emit_insn ( gen_zero_extendsidi2 ( vreg , tmp ) ) ; } else if ( ! TARGET_INTER_UNIT_MOVES_TO_VEC ) { rtx tmp = assign_386_stack_local ( DImode , SLOT_STV_TEMP ) ; emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( vreg , tmp ) ; } else if ( TARGET_SSE4_1 ) { emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_sse4_1_pinsrd ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ) ; } else { rtx tmp = gen_reg_rtx ( DImode ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_vec_interleave_lowv4si ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) ) ) ;


<s> ASM_GENERATE_INTERNAL_LABEL ( indirectlabel2 , INDIRECT_LABEL , indirectlabelno ++ ) ; if ( need_prefix == indirect_thunk_prefix_bnd ) fputs ( <STR_LIT> , asm_out_file ) ; else fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , indirectlabel2 ) ; fputc ( '\n' , asm_out_file ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel1 ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , indirectlabel1 ) ; fputc ( '\n' , asm_out_file ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel2 ) ; if ( regno != INVALID_REGNUM ) { rtx xops [ <NUM_LIT> ] ; xops [ <NUM_LIT> ] = gen_rtx_MEM ( word_mode , stack_pointer_rtx ) ;

xops [ <NUM_LIT> ] = gen_rtx_REG ( word_mode , regno ) ;


<s> tree decl ; indirect_thunk_name ( name , regno , need_prefix , ret_p ) ; decl = build_decl ( BUILTINS_LOCATION , FUNCTION_DECL , get_identifier ( name ) , build_function_type_list ( void_type_node , NULL_TREE ) ) ; DECL_RESULT ( decl ) = build_decl ( BUILTINS_LOCATION , RESULT_DECL , NULL_TREE , void_type_node ) ; TREE_PUBLIC ( decl ) = <NUM_LIT> ; TREE_STATIC ( decl ) = <NUM_LIT> ; DECL_IGNORED_P ( decl ) = <NUM_LIT> ; if ( TARGET_MACHO ) { switch_to_section ( darwin_sections [ picbase_thunk_section ] ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; putc ( '\n' , asm_out_file ) ; ASM_OUTPUT_LABEL ( asm_out_file , name ) ; DECL_WEAK ( decl ) = <NUM_LIT> ; } else if ( USE_HIDDEN_LINKONCE ) { cgraph_node :: create ( decl ) -> set_comdat_group ( DECL_ASSEMBLER_NAME ( decl ) ) ; targetm . asm_out . unique_section ( decl , <NUM_LIT> ) ; switch_to_section ( get_named_section ( decl , NULL , <NUM_LIT> ) ) ; targetm . asm_out . globalize_label ( asm_out_file , name ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; putc ( '\n' , asm_out_file ) ; ASM_DECLARE_FUNCTION_NAME ( asm_out_file , name , decl ) ; } else { switch_to_section ( text_section ) ; ASM_OUTPUT_LABEL ( asm_out_file , name ) ; }

DECL_INITIAL ( decl ) = make_node ( BLOCK ) ;


<s> case LABEL_REF : x = XEXP ( x , <NUM_LIT> ) ; case CODE_LABEL : ASM_GENERATE_INTERNAL_LABEL ( buf , <STR_LIT> , CODE_LABEL_NUMBER ( x ) ) ; assemble_name ( asm_out_file , buf ) ; break ; case CONST_INT : fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( x ) ) ; break ; case CONST : output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; break ; case CONST_DOUBLE : output_operand_lossage ( <STR_LIT> ) ; break ; case PLUS : if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; putc ( '+' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; } else { gcc_assert ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; putc ( '+' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; } break ; case MINUS : if ( ! TARGET_MACHO ) putc ( ASSEMBLER_DIALECT == ASM_INTEL ? '(' : '[' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; putc ( '-' , file ) ; output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; if ( ! TARGET_MACHO ) putc ( ASSEMBLER_DIALECT == ASM_INTEL ? ')' : ']' , file ) ; break ; case UNSPEC : gcc_assert ( XVECLEN ( x , <NUM_LIT> ) == <NUM_LIT> ) ; output_pic_addr_const ( file , XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , code ) ; switch ( XINT ( x , <NUM_LIT> ) ) { case UNSPEC_GOT : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_GOTOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_PLTOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_PCREL : fputs ( ASSEMBLER_DIALECT == ASM_ATT ? <STR_LIT> : <STR_LIT> , file ) ; break ; case UNSPEC_GOTPCREL : fputs ( ASSEMBLER_DIALECT == ASM_ATT ? <STR_LIT> : <STR_LIT> , file ) ; break ; case UNSPEC_GOTTPOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_TPOFF : fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_NTPOFF : if ( TARGET_64BIT ) fputs ( <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_DTPOFF : fputs ( <STR_LIT> , file ) ;


<s> next_feature_string = strchr ( curr_feature_string , ',' ) ; if ( next_feature_string ) * next_feature_string ++ = '\0' ; if ( * curr_feature_string == '^' ) { curr_feature_string ++ ; clear = true ; } for ( i = <NUM_LIT> ; i < X86_TUNE_LAST ; i ++ ) { if ( ! strcmp ( curr_feature_string , ix86_tune_feature_names [ i ] ) ) {


<s> if ( code == 'V' ) { if ( GENERAL_REGNO_P ( regno ) ) msize = GET_MODE_SIZE ( word_mode ) ; else error ( <STR_LIT> ) ; } duplicated = code == 'd' && TARGET_AVX ; switch ( msize ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : if ( GENERAL_REGNO_P ( regno ) && msize > GET_MODE_SIZE ( word_mode ) ) warning ( <NUM_LIT> , <STR_LIT> ) ; case <NUM_LIT> : if ( LEGACY_INT_REGNO_P ( regno ) ) putc ( msize > <NUM_LIT> && TARGET_64BIT ? 'r' : 'e' , file ) ; case <NUM_LIT> : normal : reg = hi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_reg_name ) ) goto normal ; if ( ! ANY_QI_REGNO_P ( regno ) ) error ( <STR_LIT> ) ; reg = qi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_high_reg_name ) ) goto normal ; reg = qi_high_reg_name [ regno ] ; break ; case <NUM_LIT> : case <NUM_LIT> : if ( SSE_REGNO_P ( regno ) ) { gcc_assert ( ! duplicated ) ;

putc ( msize == <NUM_LIT> ? 'y' : 'z' , file ) ;


<s> switch ( msize ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : if ( GENERAL_REGNO_P ( regno ) && msize > GET_MODE_SIZE ( word_mode ) ) warning ( <NUM_LIT> , <STR_LIT> ) ; case <NUM_LIT> : if ( LEGACY_INT_REGNO_P ( regno ) ) putc ( msize > <NUM_LIT> && TARGET_64BIT ? 'r' : 'e' , file ) ; case <NUM_LIT> : normal : reg = hi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_reg_name ) ) goto normal ; if ( ! ANY_QI_REGNO_P ( regno ) ) error ( <STR_LIT> ) ; reg = qi_reg_name [ regno ] ; break ; case <NUM_LIT> : if ( regno >= ARRAY_SIZE ( qi_high_reg_name ) ) goto normal ; reg = qi_high_reg_name [ regno ] ; break ; case <NUM_LIT> : case <NUM_LIT> : if ( SSE_REGNO_P ( regno ) ) { gcc_assert ( ! duplicated ) ; putc ( msize == <NUM_LIT> ? 'y' : 'z' , file ) ; reg = hi_reg_name [ regno ] + <NUM_LIT> ; break ; } goto normal ; default : gcc_unreachable ( ) ; } fputs ( reg , file ) ; if ( REX_INT_REGNO_P ( regno ) ) { gcc_assert ( TARGET_64BIT ) ; switch ( msize ) { case <NUM_LIT> : error ( <STR_LIT> ) ; break ; case <NUM_LIT> : putc ( 'b' , file ) ; break ; case <NUM_LIT> : putc ( 'w' , file ) ; break ;


<s> insn = emit_insn ( insn ) ; if ( style >= <NUM_LIT> ) ix86_add_queued_cfa_restore_notes ( insn ) ; if ( set_cfa ) { rtx r ; gcc_assert ( m -> fs . cfa_reg == src ) ; m -> fs . cfa_offset += INTVAL ( offset ) ; m -> fs . cfa_reg = dest ; r = gen_rtx_PLUS ( Pmode , src , offset ) ; r = gen_rtx_SET ( dest , r ) ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , r ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else if ( style < <NUM_LIT> ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( add_frame_related_expr ) { rtx r = gen_rtx_PLUS ( Pmode , src , offset ) ; r = gen_rtx_SET ( dest , r ) ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , r ) ; } } if ( dest == stack_pointer_rtx ) { HOST_WIDE_INT ooffset = m -> fs . sp_offset ; bool valid = m -> fs . sp_valid ; bool realigned = m -> fs . sp_realigned ; if ( src == hard_frame_pointer_rtx ) { valid = m -> fs . fp_valid ; realigned = false ; ooffset = m -> fs . fp_offset ; } else if ( src == crtl -> drap_reg ) { valid = m -> fs . drap_valid ; realigned = false ; ooffset = <NUM_LIT> ;


<s> static unsigned int rest_of_insert_endbranch ( void ) { timevar_push ( TV_MACH_DEP ) ; rtx cet_eb ; rtx_insn * insn ; basic_block bb ; if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( cfun -> decl ) ) ) && ! cgraph_node :: get ( cfun -> decl ) -> only_called_directly_p ( ) ) { cet_eb = gen_nop_endbr ( ) ; bb = ENTRY_BLOCK_PTR_FOR_FN ( cfun ) -> next_bb ; insn = BB_HEAD ( bb ) ; emit_insn_before ( cet_eb , insn ) ; } bb = <NUM_LIT> ; FOR_EACH_BB_FN ( bb , cfun ) { for ( insn = BB_HEAD ( bb ) ; insn != NEXT_INSN ( BB_END ( bb ) ) ; insn = NEXT_INSN ( insn ) ) { if ( CALL_P ( insn ) ) { if ( find_reg_note ( insn , REG_SETJMP , NULL ) == NULL ) continue ; cet_eb = gen_nop_endbr ( ) ; emit_insn_after_setloc ( cet_eb , insn , INSN_LOCATION ( insn ) ) ; continue ; } if ( JUMP_P ( insn ) && flag_cet_switch ) { rtx target = JUMP_LABEL ( insn ) ; if ( target == NULL_RTX || ANY_RETURN_P ( target ) ) continue ; rtx_insn * label = as_a < rtx_insn * > ( target ) ; rtx_insn * table = next_insn ( label ) ; if ( table == NULL_RTX || ! JUMP_TABLE_DATA_P ( table ) ) continue ; edge_iterator ei ; edge e ; basic_block dest_blk ; FOR_EACH_EDGE ( e , ei , bb -> succs ) { rtx_insn * insn ; dest_blk = e -> dest ; insn = BB_HEAD ( dest_blk ) ; gcc_assert ( LABEL_P ( insn ) ) ; cet_eb = gen_nop_endbr ( ) ;


<s> else ix86_tune_features [ i ] = ! ! ( initial_ix86_tune_features [ i ] & ix86_tune_mask ) ; } if ( dump ) { fprintf ( stderr , <STR_LIT> ) ;

for ( i = <NUM_LIT> ; i < X86_TUNE_LAST ; i ++ ) fprintf ( stderr , <STR_LIT> , ix86_tune_feature_names [ i ] , ix86_tune_features [ i ] ? <STR_LIT> : <STR_LIT> ) ;


<s> byte = GET_MODE_SIZE ( half_mode ) ; while ( num -- ) { rtx op = operands [ num ] ; if ( MEM_P ( op ) ) { lo_half [ num ] = adjust_address ( op , half_mode , <NUM_LIT> ) ; hi_half [ num ] = adjust_address ( op , half_mode , byte ) ;


<s> hi_half [ num ] = adjust_address ( op , half_mode , byte ) ; } else { lo_half [ num ] = simplify_gen_subreg ( half_mode , op , GET_MODE ( op ) == VOIDmode ? mode : GET_MODE ( op ) , <NUM_LIT> ) ; hi_half [ num ] = simplify_gen_subreg ( half_mode , op , GET_MODE ( op ) == VOIDmode ? mode : GET_MODE ( op ) , byte ) ; } }


<s> warning ( <NUM_LIT> , <STR_LIT> , feature ) ;


<s> emit_move_insn ( this_reg , this_param ) ; } else this_reg = NULL_RTX ; if ( delta ) { rtx delta_rtx = GEN_INT ( delta ) ; rtx delta_dst = this_reg ? this_reg : this_param ; if ( TARGET_64BIT ) { if ( ! x86_64_general_operand ( delta_rtx , Pmode ) ) { tmp = gen_rtx_REG ( Pmode , tmp_regno ) ; emit_move_insn ( tmp , delta_rtx ) ; delta_rtx = tmp ; } } ix86_emit_binop ( PLUS , Pmode , delta_dst , delta_rtx ) ; } if ( vcall_offset ) { rtx vcall_addr , vcall_mem , this_mem ; tmp = gen_rtx_REG ( Pmode , tmp_regno ) ; this_mem = gen_rtx_MEM ( ptr_mode , this_reg ) ; if ( Pmode != ptr_mode ) this_mem = gen_rtx_ZERO_EXTEND ( Pmode , this_mem ) ; emit_move_insn ( tmp , this_mem ) ; vcall_addr = plus_constant ( Pmode , tmp , vcall_offset ) ; if ( TARGET_64BIT && ! ix86_legitimate_address_p ( ptr_mode , vcall_addr , true ) ) { rtx tmp2 = gen_rtx_REG ( Pmode , R11_REG ) ; emit_move_insn ( tmp2 , GEN_INT ( vcall_offset ) ) ; vcall_addr = gen_rtx_PLUS ( Pmode , tmp , tmp2 ) ; } vcall_mem = gen_rtx_MEM ( ptr_mode , vcall_addr ) ; if ( Pmode != ptr_mode ) emit_insn ( gen_addsi_1_zext ( this_reg , gen_rtx_REG ( ptr_mode , REGNO ( this_reg ) ) , vcall_mem ) ) ; else ix86_emit_binop ( PLUS , Pmode , this_reg , vcall_mem ) ; } if ( this_reg && this_reg != this_param ) emit_move_insn ( this_param , this_reg ) ; fnaddr = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; if ( TARGET_64BIT ) { if ( ! flag_pic || targetm . binds_local_p ( function ) || TARGET_PECOFF ) ; else { tmp = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , fnaddr ) , UNSPEC_GOTPCREL ) ; tmp = gen_rtx_CONST ( Pmode , tmp ) ; fnaddr = gen_const_mem ( Pmode , tmp ) ; } } else { if ( ! flag_pic || targetm . binds_local_p ( function ) ) ; else if ( TARGET_MACHO ) { fnaddr = machopic_indirect_call_target ( DECL_RTL ( function ) ) ; fnaddr = XEXP ( fnaddr , <NUM_LIT> ) ; } else { tmp = gen_rtx_REG ( Pmode , CX_REG ) ; output_set_got ( tmp , NULL_RTX ) ; fnaddr = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , fnaddr ) , UNSPEC_GOT ) ; fnaddr = gen_rtx_CONST ( Pmode , fnaddr ) ; fnaddr = gen_rtx_PLUS ( Pmode , tmp , fnaddr ) ; fnaddr = gen_const_mem ( Pmode , fnaddr ) ; } } if ( MEM_P ( fnaddr ) ) { if ( sibcall_insn_operand ( fnaddr , word_mode ) ) { fnaddr = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; tmp = gen_rtx_MEM ( QImode , fnaddr ) ; tmp = gen_rtx_CALL ( VOIDmode , tmp , const0_rtx ) ; tmp = emit_call_insn ( tmp ) ; SIBLING_CALL_P ( tmp ) = <NUM_LIT> ; } else emit_jump_insn ( gen_indirect_jump ( fnaddr ) ) ;


<s> static void x86_print_call_or_nop ( FILE * file , const char * target ) { if ( flag_nop_mcount ) fprintf ( file , <STR_LIT> ASM_BYTE <STR_LIT> ) ; else fprintf ( file , <STR_LIT> , target ) ;


<s> rtx_insn * insn = DF_INSN_UID_GET ( insn_uid ) -> insn ; rtx def_set = single_set ( insn ) ; rtx src = SET_SRC ( def_set ) ; rtx dst = SET_DEST ( def_set ) ; if ( REG_P ( src ) && REG_P ( dst ) ) gain += COSTS_N_INSNS ( <NUM_LIT> ) - ix86_cost -> xmm_move ; else if ( REG_P ( src ) && MEM_P ( dst ) ) gain += <NUM_LIT> * ix86_cost -> int_store [ <NUM_LIT> ] - ix86_cost -> sse_store [ <NUM_LIT> ] ; else if ( MEM_P ( src ) && REG_P ( dst ) ) gain += <NUM_LIT> * ix86_cost -> int_load [ <NUM_LIT> ] - ix86_cost -> sse_load [ <NUM_LIT> ] ; else if ( GET_CODE ( src ) == ASHIFT || GET_CODE ( src ) == ASHIFTRT || GET_CODE ( src ) == LSHIFTRT ) { if ( CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) gain -= vector_const_cost ( XEXP ( src , <NUM_LIT> ) ) ; gain += ix86_cost -> shift_const ; if ( INTVAL ( XEXP ( src , <NUM_LIT> ) ) >= <NUM_LIT> ) gain -= COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( GET_CODE ( src ) == PLUS || GET_CODE ( src ) == MINUS || GET_CODE ( src ) == IOR || GET_CODE ( src ) == XOR || GET_CODE ( src ) == AND ) { gain += ix86_cost -> add ; if ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == NOT && ! TARGET_BMI ) gain += <NUM_LIT> * ix86_cost -> add ; if ( CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) gain -= vector_const_cost ( XEXP ( src , <NUM_LIT> ) ) ; if ( CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) gain -= vector_const_cost ( XEXP ( src , <NUM_LIT> ) ) ; } else if ( GET_CODE ( src ) == NEG || GET_CODE ( src ) == NOT ) gain += ix86_cost -> add - COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_CODE ( src ) == COMPARE ) { } else if ( CONST_INT_P ( src ) ) { if ( REG_P ( dst ) ) gain += COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( MEM_P ( dst ) ) gain += <NUM_LIT> * ix86_cost -> int_store [ <NUM_LIT> ] - ix86_cost -> sse_store [ <NUM_LIT> ] ; gain -= vector_const_cost ( src ) ; } else gcc_unreachable ( ) ; } if ( dump_file ) fprintf ( dump_file , <STR_LIT> , gain ) ; EXECUTE_IF_SET_IN_BITMAP ( defs_conv , <NUM_LIT> , insn_uid , bi ) cost += DF_REG_DEF_COUNT ( insn_uid ) * ix86_cost -> mmxsse_to_integer ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , cost ) ; gain -= cost ;


<s> else if ( GET_CODE ( src ) == PLUS || GET_CODE ( src ) == MINUS || GET_CODE ( src ) == IOR || GET_CODE ( src ) == XOR || GET_CODE ( src ) == AND ) { gain += ix86_cost -> add ; if ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == NOT && ! TARGET_BMI ) gain += <NUM_LIT> * ix86_cost -> add ; if ( CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) gain -= vector_const_cost ( XEXP ( src , <NUM_LIT> ) ) ; if ( CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) gain -= vector_const_cost ( XEXP ( src , <NUM_LIT> ) ) ; } else if ( GET_CODE ( src ) == NEG || GET_CODE ( src ) == NOT ) gain += ix86_cost -> add - COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_CODE ( src ) == COMPARE ) { } else if ( CONST_INT_P ( src ) ) { if ( REG_P ( dst ) ) gain += COSTS_N_INSNS ( <NUM_LIT> ) ;

else if ( MEM_P ( dst ) ) gain += <NUM_LIT> * ix86_cost -> int_store [ <NUM_LIT> ] - ix86_cost -> sse_store [ <NUM_LIT> ] ;


<s> emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , adjust_address ( tmp , SImode , <NUM_LIT> ) ) ; } else if ( TARGET_SSE4_1 ) { rtx tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) ) ; emit_insn ( gen_rtx_SET ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_VEC_SELECT ( SImode , gen_rtx_SUBREG ( V4SImode , reg , <NUM_LIT> ) , tmp ) ) ) ; tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) ) ; emit_insn ( gen_rtx_SET ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_VEC_SELECT ( SImode , gen_rtx_SUBREG ( V4SImode , reg , <NUM_LIT> ) , tmp ) ) ) ; } else { rtx vcopy = gen_reg_rtx ( V2DImode ) ; emit_move_insn ( vcopy , gen_rtx_SUBREG ( V2DImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , vcopy , <NUM_LIT> ) ) ; emit_move_insn ( vcopy , gen_rtx_LSHIFTRT ( V2DImode , vcopy , GEN_INT ( <NUM_LIT> ) ) ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , vcopy , <NUM_LIT> ) ) ; } rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; emit_conversion_insns ( seq , insn ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , REGNO ( scopy ) , INSN_UID ( insn ) ) ; } } for ( ref = DF_REG_USE_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) if ( bitmap_bit_p ( insns , DF_REF_INSN_UID ( ref ) ) ) { if ( bitmap_bit_p ( conv , DF_REF_INSN_UID ( ref ) ) ) { rtx_insn * insn = DF_REF_INSN ( ref ) ; rtx def_set = single_set ( insn ) ; gcc_assert ( def_set ) ; rtx src = SET_SRC ( def_set ) ; rtx dst = SET_DEST ( def_set ) ; if ( ! MEM_P ( dst ) || ! REG_P ( src ) ) replace_with_subreg_in_insn ( insn , reg , reg ) ; bitmap_clear_bit ( conv , INSN_UID ( insn ) ) ;


<s> } if ( scalar_copy ) { start_sequence ( ) ; if ( ! TARGET_INTER_UNIT_MOVES_FROM_VEC ) { rtx tmp = assign_386_stack_local ( DImode , SLOT_STV_TEMP ) ; emit_move_insn ( tmp , reg ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , adjust_address ( tmp , SImode , <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , adjust_address ( tmp , SImode , <NUM_LIT> ) ) ; } else if ( TARGET_SSE4_1 ) { rtx tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) ) ; emit_insn ( gen_rtx_SET ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_VEC_SELECT ( SImode , gen_rtx_SUBREG ( V4SImode , reg , <NUM_LIT> ) , tmp ) ) ) ; tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) ) ; emit_insn ( gen_rtx_SET ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_VEC_SELECT ( SImode , gen_rtx_SUBREG ( V4SImode , reg , <NUM_LIT> ) , tmp ) ) ) ; } else { rtx vcopy = gen_reg_rtx ( V2DImode ) ; emit_move_insn ( vcopy , gen_rtx_SUBREG ( V2DImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , vcopy , <NUM_LIT> ) ) ; emit_move_insn ( vcopy , gen_rtx_LSHIFTRT ( V2DImode , vcopy , GEN_INT ( <NUM_LIT> ) ) ) ; emit_move_insn ( gen_rtx_SUBREG ( SImode , scopy , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , vcopy , <NUM_LIT> ) ) ; } rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; emit_conversion_insns ( seq , insn ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , REGNO ( scopy ) , INSN_UID ( insn ) ) ; } } for ( ref = DF_REG_USE_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) if ( bitmap_bit_p ( insns , DF_REF_INSN_UID ( ref ) ) ) { if ( bitmap_bit_p ( conv , DF_REF_INSN_UID ( ref ) ) ) { rtx_insn * insn = DF_REF_INSN ( ref ) ; rtx def_set = single_set ( insn ) ;


<s> if ( ! ( mask & OPTION_MASK_ISA_64BIT ) || TARGET_64BIT ) { ix86_builtins_isa [ ( int ) code ] . isa = mask ; ix86_builtins_isa [ ( int ) code ] . isa2 = mask2 ; mask &= ~ OPTION_MASK_ISA_64BIT ; if ( ( mask & ix86_isa_flags & OPTION_MASK_ISA_AVX512VL ) && mask != OPTION_MASK_ISA_AVX512VL ) mask &= ~ OPTION_MASK_ISA_AVX512VL ; if ( ( mask & ix86_isa_flags & OPTION_MASK_ISA_AVX512BW ) && mask != OPTION_MASK_ISA_AVX512BW ) mask &= ~ OPTION_MASK_ISA_AVX512BW ; if ( ( ( mask2 == <NUM_LIT> || ( mask2 & ix86_isa_flags2 ) != <NUM_LIT> ) && ( mask == <NUM_LIT> || ( mask & ix86_isa_flags ) != <NUM_LIT> ) ) || ( lang_hooks . builtin_function == lang_hooks . builtin_function_ext_scope ) ) { tree type = ix86_get_builtin_func_type ( tcode ) ; decl = add_builtin_function ( name , type , code , BUILT_IN_MD , NULL , NULL_TREE ) ; ix86_builtins [ ( int ) code ] = decl ; ix86_builtins_isa [ ( int ) code ] . set_and_not_built_p = false ; } else { deferred_isa_values |= mask ; deferred_isa_values2 |= mask2 ; ix86_builtins [ ( int ) code ] = NULL_TREE ; ix86_builtins_isa [ ( int ) code ] . tcode = tcode ; ix86_builtins_isa [ ( int ) code ] . name = name ; ix86_builtins_isa [ ( int ) code ] . const_p = false ; ix86_builtins_isa [ ( int ) code ] . pure_p = false ; ix86_builtins_isa [ ( int ) code ] . set_and_not_built_p = true ; } }


<s> case ASHIFT : case LSHIFTRT : if ( ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) || ! IN_RANGE ( INTVAL ( XEXP ( src , <NUM_LIT> ) ) , <NUM_LIT> , <NUM_LIT> ) ) return false ; break ; case PLUS : case MINUS : case IOR : case XOR : case AND : if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; if ( GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != DImode && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; break ; case NEG : case NOT : break ; case REG : return true ; case MEM : case CONST_INT : return REG_P ( dst ) ; default : return false ; } if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) && ( GET_CODE ( src ) != AND || GET_CODE ( XEXP ( src , <NUM_LIT> ) ) != NOT || ! REG_P ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) return false ; if ( GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != DImode && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; return true ;


<s> if ( GET_CODE ( src ) == COMPARE ) return convertible_comparison_p ( insn ) ; if ( ( GET_MODE ( src ) != DImode && ! CONST_INT_P ( src ) ) || GET_MODE ( dst ) != DImode ) return false ; if ( ! REG_P ( dst ) && ! MEM_P ( dst ) ) return false ; switch ( GET_CODE ( src ) ) { case ASHIFTRT : if ( ! TARGET_AVX512VL ) return false ; case ASHIFT : case LSHIFTRT : if ( ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) || ! IN_RANGE ( INTVAL ( XEXP ( src , <NUM_LIT> ) ) , <NUM_LIT> , <NUM_LIT> ) ) return false ; break ; case PLUS : case MINUS : case IOR : case XOR : case AND : if ( ! REG_P ( XEXP ( src , <NUM_LIT> ) ) && ! MEM_P ( XEXP ( src , <NUM_LIT> ) ) && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ; if ( GET_MODE ( XEXP ( src , <NUM_LIT> ) ) != DImode && ! CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) return false ;


<s> emit_insn ( gen_iorhi3 ( reg , reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_TRUNC ; break ; case I387_CW_FLOOR : emit_insn ( gen_andhi3 ( reg , reg , GEN_INT ( ~ <NUM_LIT> ) ) ) ; emit_insn ( gen_iorhi3 ( reg , reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_FLOOR ; break ; case I387_CW_CEIL : emit_insn ( gen_andhi3 ( reg , reg , GEN_INT ( ~ <NUM_LIT> ) ) ) ; emit_insn ( gen_iorhi3 ( reg , reg , GEN_INT ( <NUM_LIT> ) ) ) ; slot = SLOT_CW_CEIL ; break ;


<s> rtx piece_size = GEN_INT ( piece_size_n ) ; rtx piece_size_mask = GEN_INT ( ~ ( ( GET_MODE_SIZE ( mode ) * unroll ) - <NUM_LIT> ) ) ; rtx size ; int i ; top_label = gen_label_rtx ( ) ; out_label = gen_label_rtx ( ) ; iter = gen_reg_rtx ( iter_mode ) ; size = expand_simple_binop ( iter_mode , AND , count , piece_size_mask , NULL , <NUM_LIT> , OPTAB_DIRECT ) ; if ( piece_size == const1_rtx ) { emit_cmp_and_jump_insns ( size , const0_rtx , EQ , NULL_RTX , iter_mode , true , out_label ) ; predict_jump ( REG_BR_PROB_BASE * <NUM_LIT> / <NUM_LIT> ) ; } emit_move_insn ( iter , const0_rtx ) ; emit_label ( top_label ) ; tmp = convert_modes ( Pmode , iter_mode , iter , true ) ; gcc_assert ( ( piece_size_n & ( piece_size_n - <NUM_LIT> ) ) == <NUM_LIT> ) ; destmem = offset_address ( destmem , tmp , piece_size_n ) ; destmem = adjust_address ( destmem , mode , <NUM_LIT> ) ; if ( ! issetmem ) { srcmem = offset_address ( srcmem , copy_rtx ( tmp ) , piece_size_n ) ; srcmem = adjust_address ( srcmem , mode , <NUM_LIT> ) ; if ( ! TARGET_64BIT && <NUM_LIT> ) { for ( i = <NUM_LIT> ; i < unroll ; i ++ ) { if ( i ) { destmem = adjust_address ( copy_rtx ( destmem ) , mode , GET_MODE_SIZE ( mode ) ) ; srcmem = adjust_address ( copy_rtx ( srcmem ) , mode , GET_MODE_SIZE ( mode ) ) ; } emit_move_insn ( destmem , srcmem ) ; } } else { rtx tmpreg [ <NUM_LIT> ] ; gcc_assert ( unroll <= <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < unroll ; i ++ ) { tmpreg [ i ] = gen_reg_rtx ( mode ) ; if ( i ) srcmem = adjust_address ( copy_rtx ( srcmem ) , mode , GET_MODE_SIZE ( mode ) ) ; emit_move_insn ( tmpreg [ i ] , srcmem ) ; } for ( i = <NUM_LIT> ; i < unroll ; i ++ ) { if ( i ) destmem = adjust_address ( copy_rtx ( destmem ) , mode , GET_MODE_SIZE ( mode ) ) ;

emit_move_insn ( destmem , tmpreg [ i ] ) ;


<s> rtx call = get_call_rtx_from ( insn ) ; rtx fnaddr = XEXP ( call , <NUM_LIT> ) ; tree fndecl = NULL_TREE ; if ( GET_CODE ( XEXP ( fnaddr , <NUM_LIT> ) ) == SYMBOL_REF ) fndecl = SYMBOL_REF_DECL ( XEXP ( fnaddr , <NUM_LIT> ) ) ; if ( fndecl == NULL_TREE ) fndecl = MEM_EXPR ( fnaddr ) ; if ( fndecl && TREE_CODE ( TREE_TYPE ( fndecl ) ) != FUNCTION_TYPE && TREE_CODE ( TREE_TYPE ( fndecl ) ) != METHOD_TYPE ) fndecl = NULL_TREE ; if ( fndecl && TYPE_ARG_TYPES ( TREE_TYPE ( fndecl ) ) ) { tree fntype = TREE_TYPE ( fndecl ) ; if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) need_endbr = true ; } } if ( ! need_endbr ) continue ; cet_eb = gen_nop_endbr ( ) ; emit_insn_after_setloc ( cet_eb , insn , INSN_LOCATION ( insn ) ) ; continue ;


<s> function_args_iterator iter ; tree argtype ; bool seen_empty_type = false ; FOREACH_FUNCTION_ARGS ( fntype , argtype , iter ) { if ( argtype == error_mark_node || VOID_TYPE_P ( argtype ) ) break ; if ( TYPE_EMPTY_P ( argtype ) ) seen_empty_type = true ; else if ( seen_empty_type ) { cum -> warn_empty = true ; break ; } } } if ( ! TARGET_64BIT ) { if ( stdarg_p ( fntype ) ) { cum -> nregs = <NUM_LIT> ; cfun -> machine -> arg_reg_available = true ; cum -> sse_nregs = <NUM_LIT> ; cum -> mmx_nregs = <NUM_LIT> ; cum -> warn_avx512f = false ; cum -> warn_avx = false ; cum -> warn_sse = false ; cum -> warn_mmx = false ; return ; } if ( fntype ) { unsigned int ccvt = ix86_get_callcvt ( fntype ) ; if ( ( ccvt & IX86_CALLCVT_THISCALL ) != <NUM_LIT> ) { cum -> nregs = <NUM_LIT> ; cum -> fastcall = <NUM_LIT> ; } else if ( ( ccvt & IX86_CALLCVT_FASTCALL ) != <NUM_LIT> ) { cum -> nregs = <NUM_LIT> ; cum -> fastcall = <NUM_LIT> ; } else cum -> nregs = ix86_function_regparm ( fntype , fndecl ) ; } cum -> float_in_sse = ix86_function_sseregparm ( fntype , fndecl , true ) ;


<s> switch ( mode ) { case E_SFmode : index = <NUM_LIT> ; break ; case E_DFmode : index = <NUM_LIT> ; break ; case E_XFmode : index = <NUM_LIT> ; break ; default : return <NUM_LIT> ; } if ( in == <NUM_LIT> ) return MAX ( ix86_cost -> fp_load [ index ] , ix86_cost -> fp_store [ index ] ) ; return in ? ix86_cost -> fp_load [ index ] : ix86_cost -> fp_store [ index ] ; } if ( SSE_CLASS_P ( regclass ) ) { int index = sse_store_index ( mode ) ; if ( index == - <NUM_LIT> ) return <NUM_LIT> ; if ( in == <NUM_LIT> ) return MAX ( ix86_cost -> sse_load [ index ] , ix86_cost -> sse_store [ index ] ) ; return in ? ix86_cost -> sse_load [ index ] : ix86_cost -> sse_store [ index ] ; } if ( MMX_CLASS_P ( regclass ) ) {


<s> deferred_isa_values2 &= ~ isa2 ; int i ; tree saved_current_target_pragma = current_target_pragma ; current_target_pragma = NULL_TREE ; for ( i = <NUM_LIT> ; i < ( int ) IX86_BUILTIN_MAX ; i ++ ) {

if ( ( ( ix86_builtins_isa [ i ] . isa & isa ) != <NUM_LIT> || ( ix86_builtins_isa [ i ] . isa2 & isa2 ) != <NUM_LIT> ) && ix86_builtins_isa [ i ] . set_and_not_built_p ) {


<s> if ( ( ( ix86_builtins_isa [ i ] . isa & isa ) != <NUM_LIT> || ( ix86_builtins_isa [ i ] . isa2 & isa2 ) != <NUM_LIT> ) && ix86_builtins_isa [ i ] . set_and_not_built_p ) { tree decl , type ; ix86_builtins_isa [ i ] . set_and_not_built_p = false ; type = ix86_get_builtin_func_type ( ix86_builtins_isa [ i ] . tcode ) ; decl = add_builtin_function_ext_scope ( ix86_builtins_isa [ i ] . name , type , i , BUILT_IN_MD , NULL , NULL_TREE ) ; ix86_builtins [ i ] = decl ; if ( ix86_builtins_isa [ i ] . const_p ) TREE_READONLY ( decl ) = <NUM_LIT> ;


<s> case MINUS_EXPR : if ( kind == scalar_stmt ) { if ( SSE_FLOAT_MODE_P ( mode ) && TARGET_SSE_MATH ) stmt_cost = ix86_cost -> addss ; else if ( X87_FLOAT_MODE_P ( mode ) ) stmt_cost = ix86_cost -> fadd ; else stmt_cost = ix86_cost -> add ; } else stmt_cost = ix86_vec_cost ( mode , fp ? ix86_cost -> addss : ix86_cost -> sse_op ) ; break ; case MULT_EXPR : case WIDEN_MULT_EXPR : case MULT_HIGHPART_EXPR : stmt_cost = ix86_multiplication_cost ( ix86_cost , mode ) ; break ; case NEGATE_EXPR : if ( SSE_FLOAT_MODE_P ( mode ) && TARGET_SSE_MATH ) stmt_cost = ix86_cost -> sse_op ; else if ( X87_FLOAT_MODE_P ( mode ) ) stmt_cost = ix86_cost -> fchs ; else if ( VECTOR_MODE_P ( mode ) ) stmt_cost = ix86_vec_cost ( mode , ix86_cost -> sse_op ) ; else stmt_cost = ix86_cost -> add ; break ; case TRUNC_DIV_EXPR : case CEIL_DIV_EXPR : case FLOOR_DIV_EXPR : case ROUND_DIV_EXPR : case TRUNC_MOD_EXPR : case CEIL_MOD_EXPR : case FLOOR_MOD_EXPR : case RDIV_EXPR : case ROUND_MOD_EXPR : case EXACT_DIV_EXPR : stmt_cost = ix86_division_cost ( ix86_cost , mode ) ; break ; case RSHIFT_EXPR : case LSHIFT_EXPR : case LROTATE_EXPR : case RROTATE_EXPR : { tree op2 = gimple_assign_rhs2 ( stmt_info -> stmt ) ; stmt_cost = ix86_shift_rotate_cost ( ix86_cost , mode , TREE_CODE ( op2 ) == INTEGER_CST , cst_and_fits_in_hwi ( op2 ) ? int_cst_value ( op2 ) : - <NUM_LIT> , true , false , false , NULL , NULL ) ; } break ; case NOP_EXPR : if ( tree_nop_conversion_p ( TREE_TYPE ( gimple_assign_lhs ( stmt_info -> stmt ) ) , TREE_TYPE ( gimple_assign_rhs1 ( stmt_info -> stmt ) ) ) ) stmt_cost = <NUM_LIT> ; break ; case BIT_IOR_EXPR : case ABS_EXPR : case ABSU_EXPR :


<s> if ( CALL_P ( insn ) ) { bool avx_upper_reg_found = false ;

note_stores ( pat , ix86_check_avx_upper_stores , & avx_upper_reg_found ) ;


<s> rtx pat = PATTERN ( insn ) ; if ( vzeroupper_pattern ( pat , VOIDmode ) || vzeroall_pattern ( pat , VOIDmode ) ) return AVX_U128_CLEAN ;


<s> int i , c_mask ; if ( cfun && cfun -> machine -> no_caller_saved_registers ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( ! fixed_regs [ i ] && ! ix86_function_value_regno_p ( i ) ) call_used_regs [ i ] = <NUM_LIT> ; if ( ! TARGET_64BIT ) { for ( i = FIRST_REX_INT_REG ; i <= LAST_REX_INT_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; for ( i = FIRST_REX_SSE_REG ; i <= LAST_REX_SSE_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; for ( i = FIRST_EXT_REX_SSE_REG ; i <= LAST_EXT_REX_SSE_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; } c_mask = CALL_USED_REGISTERS_MASK ( TARGET_64BIT_MS_ABI ) ; CLEAR_HARD_REG_SET ( reg_class_contents [ ( int ) CLOBBERED_REGS ] ) ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) { if ( call_used_regs [ i ] > <NUM_LIT> ) call_used_regs [ i ] = ! ! ( call_used_regs [ i ] & c_mask ) ; if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) GENERAL_REGS ] , i ) && call_used_regs [ i ] ) SET_HARD_REG_BIT ( reg_class_contents [ ( int ) CLOBBERED_REGS ] , i ) ; } if ( ! TARGET_MMX ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) MMX_REGS ] , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; if ( ! TARGET_SSE ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) SSE_REGS ] , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; if ( ! ( TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387 ) ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) FLOAT_REGS ] , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; if ( ! TARGET_AVX512F ) { for ( i = FIRST_EXT_REX_SSE_REG ; i <= LAST_EXT_REX_SSE_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ; for ( i = FIRST_MASK_REG ; i <= LAST_MASK_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> , reg_names [ i ] = <STR_LIT> ;


<s> case AVX_U128 : if ( mode == AVX_U128_CLEAN ) emit_insn ( gen_avx_vzeroupper ( ) ) ; break ; case I387_TRUNC : case I387_FLOOR : case I387_CEIL : if ( mode != I387_CW_ANY && mode != I387_CW_UNINITIALIZED ) emit_i387_cw_initialization ( mode ) ; break ;


<s> if ( ix86_cmodel == CM_LARGE_PIC && ! TARGET_PECOFF && MEM_P ( fnaddr ) && GET_CODE ( XEXP ( fnaddr , <NUM_LIT> ) ) == SYMBOL_REF && ! local_symbolic_operand ( XEXP ( fnaddr , <NUM_LIT> ) , VOIDmode ) ) fnaddr = gen_rtx_MEM ( QImode , construct_plt_address ( XEXP ( fnaddr , <NUM_LIT> ) ) ) ; else if ( ! ( TARGET_X32 && MEM_P ( fnaddr ) && GET_CODE ( XEXP ( fnaddr , <NUM_LIT> ) ) == ZERO_EXTEND && GOT_memory_operand ( XEXP ( XEXP ( fnaddr , <NUM_LIT> ) , <NUM_LIT> ) , Pmode ) ) && ( sibcall ? ! sibcall_insn_operand ( XEXP ( fnaddr , <NUM_LIT> ) , word_mode ) : ! call_insn_operand ( XEXP ( fnaddr , <NUM_LIT> ) , word_mode ) ) ) { fnaddr = convert_to_mode ( word_mode , XEXP ( fnaddr , <NUM_LIT> ) , <NUM_LIT> ) ; fnaddr = gen_rtx_MEM ( QImode , copy_to_mode_reg ( word_mode , fnaddr ) ) ; } call = gen_rtx_CALL ( VOIDmode , fnaddr , callarg1 ) ; if ( retval ) call = gen_rtx_SET ( retval , call ) ; vec [ vec_len ++ ] = call ; if ( pop ) { pop = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , pop ) ; pop = gen_rtx_SET ( stack_pointer_rtx , pop ) ; vec [ vec_len ++ ] = pop ; } if ( cfun -> machine -> no_caller_saved_registers && ( ! fndecl || ( ! TREE_THIS_VOLATILE ( fndecl ) && ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( fndecl ) ) ) ) ) ) { static const char ix86_call_used_regs [ ] = CALL_USED_REGISTERS ; bool is_64bit_ms_abi = ( TARGET_64BIT && ix86_function_abi ( fndecl ) == MS_ABI ) ; char c_mask = CALL_USED_REGISTERS_MASK ( is_64bit_ms_abi ) ; for ( int i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( ! fixed_regs [ i ] && ( ix86_call_used_regs [ i ] == <NUM_LIT> || ( ix86_call_used_regs [ i ] & c_mask ) ) && ! STACK_REGNO_P ( i ) && ! MMX_REGNO_P ( i ) ) clobber_reg ( & use , gen_rtx_REG ( GET_MODE ( regno_reg_rtx [ i ] ) , i ) ) ; } else if ( TARGET_64BIT_MS_ABI && ( ! callarg2 || INTVAL ( callarg2 ) != - <NUM_LIT> ) ) { unsigned i ;

for ( i = <NUM_LIT> ; i < NUM_X86_64_MS_CLOBBERED_REGS ; i ++ ) {


<s> static void ix86_expand_divmod_libfunc ( rtx libfunc , machine_mode mode , rtx op0 , rtx op1 , rtx * quot_p , rtx * rem_p ) { rtx rem = assign_386_stack_local ( mode , SLOT_TEMP ) ; rtx quot = emit_library_call_value ( libfunc , NULL_RTX , LCT_NORMAL , mode , op0 , mode , op1 , mode , XEXP ( rem , <NUM_LIT> ) , Pmode ) ;


<s> rtx opfalse = op_false ? op_false : CONST0_RTX ( data_mode ) ; if ( * negate ) std :: swap ( optrue , opfalse ) ; if ( ( code != EQ && GET_MODE_SIZE ( mode ) != <NUM_LIT> && vector_all_ones_operand ( opfalse , data_mode ) && optrue == CONST0_RTX ( data_mode ) ) || ( code == GTU && GET_MODE_SIZE ( GET_MODE_INNER ( mode ) ) >= <NUM_LIT> && ( GET_MODE_SIZE ( mode ) == <NUM_LIT> || ! vector_all_ones_operand ( optrue , data_mode ) || opfalse != CONST0_RTX ( data_mode ) ) ) ) { rtx ( * gen ) ( rtx , rtx , rtx ) = NULL ; switch ( mode ) { case E_V16SImode : gen = ( code == GTU ) ? gen_uminv16si3 : gen_sminv16si3 ; break ; case E_V8DImode : gen = ( code == GTU ) ? gen_uminv8di3 : gen_sminv8di3 ; cop0 = force_reg ( mode , cop0 ) ; cop1 = force_reg ( mode , cop1 ) ; break ; case E_V32QImode : if ( TARGET_AVX2 ) gen = ( code == GTU ) ? gen_uminv32qi3 : gen_sminv32qi3 ; break ; case E_V16HImode : if ( TARGET_AVX2 ) gen = ( code == GTU ) ? gen_uminv16hi3 : gen_sminv16hi3 ; break ; case E_V8SImode : if ( TARGET_AVX2 ) gen = ( code == GTU ) ? gen_uminv8si3 : gen_sminv8si3 ; break ; case E_V4DImode : if ( TARGET_AVX512VL ) { gen = ( code == GTU ) ? gen_uminv4di3 : gen_sminv4di3 ; cop0 = force_reg ( mode , cop0 ) ; cop1 = force_reg ( mode , cop1 ) ; } break ; case E_V16QImode : if ( code == GTU && TARGET_SSE2 ) gen = gen_uminv16qi3 ; else if ( code == GT && TARGET_SSE4_1 ) gen = gen_sminv16qi3 ; break ; case E_V8HImode : if ( code == GTU && TARGET_SSE4_1 ) gen = gen_uminv8hi3 ; else if ( code == GT && TARGET_SSE2 ) gen = gen_sminv8hi3 ; break ; case E_V4SImode : if ( TARGET_SSE4_1 ) gen = ( code == GTU ) ? gen_uminv4si3 : gen_sminv4si3 ; break ; case E_V2DImode : if ( TARGET_AVX512VL ) { gen = ( code == GTU ) ? gen_uminv2di3 : gen_sminv2di3 ; cop0 = force_reg ( mode , cop0 ) ; cop1 = force_reg ( mode , cop1 ) ; } break ; default : break ; } if ( gen ) { rtx tem = gen_reg_rtx ( mode ) ; if ( ! vector_operand ( cop0 , mode ) ) cop0 = force_reg ( mode , cop0 ) ; if ( ! vector_operand ( cop1 , mode ) ) cop1 = force_reg ( mode , cop1 ) ; * negate = ! * negate ;

emit_insn ( gen ( tem , cop0 , cop1 ) ) ;


<s> } current = scratch_reg ; } ix86_expand_branch ( GEU , current , limit , label ) ; rtx_insn * jump_insn = get_last_insn ( ) ; JUMP_LABEL ( jump_insn ) = label ; add_reg_br_prob_note ( jump_insn , profile_probability :: very_likely ( ) ) ; if ( split_stack_fn == NULL_RTX ) { split_stack_fn = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; SYMBOL_REF_FLAGS ( split_stack_fn ) |= SYMBOL_FLAG_LOCAL ; } fn = split_stack_fn ; allocate_rtx = GEN_INT ( allocate ) ; args_size = crtl -> args . size >= <NUM_LIT> ? ( HOST_WIDE_INT ) crtl -> args . size : <NUM_LIT> ; call_fusage = NULL_RTX ; rtx pop = NULL_RTX ; if ( TARGET_64BIT ) { rtx reg10 , reg11 ; reg10 = gen_rtx_REG ( Pmode , R10_REG ) ; reg11 = gen_rtx_REG ( Pmode , R11_REG ) ; if ( DECL_STATIC_CHAIN ( cfun -> decl ) ) { rtx rax ; rax = gen_rtx_REG ( word_mode , AX_REG ) ; emit_move_insn ( rax , gen_rtx_REG ( word_mode , R10_REG ) ) ; use_reg ( & call_fusage , rax ) ; } if ( ( ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC ) && ! TARGET_PECOFF ) { HOST_WIDE_INT argval ; gcc_assert ( Pmode == DImode ) ; gcc_assert ( ( allocate & HOST_WIDE_INT_C ( <NUM_LIT> ) ) == allocate ) ; gcc_assert ( ( args_size & <NUM_LIT> ) == args_size ) ; if ( split_stack_fn_large == NULL_RTX ) { split_stack_fn_large = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; SYMBOL_REF_FLAGS ( split_stack_fn_large ) |= SYMBOL_FLAG_LOCAL ; } if ( ix86_cmodel == CM_LARGE_PIC ) { rtx_code_label * label ; rtx x ; label = gen_label_rtx ( ) ; emit_label ( label ) ; LABEL_PRESERVE_P ( label ) = <NUM_LIT> ; emit_insn ( gen_set_rip_rex64 ( reg10 , label ) ) ; emit_insn ( gen_set_got_offset_rex64 ( reg11 , label ) ) ; emit_insn ( ix86_gen_add3 ( reg10 , reg10 , reg11 ) ) ; x = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , split_stack_fn_large ) , UNSPEC_GOT ) ; x = gen_rtx_CONST ( Pmode , x ) ; emit_move_insn ( reg11 , x ) ; x = gen_rtx_PLUS ( Pmode , reg10 , reg11 ) ; x = gen_const_mem ( Pmode , x ) ; emit_move_insn ( reg11 , x ) ; } else emit_move_insn ( reg11 , split_stack_fn_large ) ; fn = reg11 ; argval = ( ( args_size << <NUM_LIT> ) << <NUM_LIT> ) + allocate ; emit_move_insn ( reg10 , GEN_INT ( argval ) ) ; } else { emit_move_insn ( reg10 , allocate_rtx ) ; emit_move_insn ( reg11 , GEN_INT ( args_size ) ) ;


<s> else cmp_mode = cmp_ops_mode ; cmp_op0 = force_reg ( cmp_ops_mode , cmp_op0 ) ; int ( * op1_predicate ) ( rtx , machine_mode ) = VECTOR_MODE_P ( cmp_ops_mode ) ? vector_operand : nonimmediate_operand ; if ( ! op1_predicate ( cmp_op1 , cmp_ops_mode ) ) cmp_op1 = force_reg ( cmp_ops_mode , cmp_op1 ) ; if ( optimize || ( maskcmp && cmp_mode != mode ) || ( op_true && reg_overlap_mentioned_p ( dest , op_true ) ) || ( op_false && reg_overlap_mentioned_p ( dest , op_false ) ) ) dest = gen_reg_rtx ( maskcmp ? cmp_mode : mode ) ; if ( maskcmp && ( code == GT || code == EQ ) ) { rtx ( * gen ) ( rtx , rtx , rtx ) ; switch ( cmp_ops_mode ) { case E_V64QImode : gcc_assert ( TARGET_AVX512BW ) ; gen = code == GT ? gen_avx512bw_gtv64qi3 : gen_avx512bw_eqv64qi3_1 ; break ; case E_V32HImode : gcc_assert ( TARGET_AVX512BW ) ; gen = code == GT ? gen_avx512bw_gtv32hi3 : gen_avx512bw_eqv32hi3_1 ; break ; case E_V16SImode : gen = code == GT ? gen_avx512f_gtv16si3 : gen_avx512f_eqv16si3_1 ; break ; case E_V8DImode : gen = code == GT ? gen_avx512f_gtv8di3 : gen_avx512f_eqv8di3_1 ; break ; default : gen = NULL ; } if ( gen ) { emit_insn ( gen ( dest , cmp_op0 , cmp_op1 ) ) ; return dest ; } } x = gen_rtx_fmt_ee ( code , cmp_mode , cmp_op0 , cmp_op1 ) ;


<s> op1 = operands [ <NUM_LIT> ] ; mode = GET_MODE ( dest ) ; if ( mode == SFmode ) { xorsign_insn = gen_xorsignsf3_1 ; vmode = V4SFmode ; } else if ( mode == DFmode ) { xorsign_insn = gen_xorsigndf3_1 ; vmode = V2DFmode ; } else gcc_unreachable ( ) ; mask = ix86_build_signbit_mask ( vmode , <NUM_LIT> , <NUM_LIT> ) ; emit_insn ( xorsign_insn ( dest , op0 , op1 , mask ) ) ;


<s> dest = operands [ <NUM_LIT> ] ; op0 = operands [ <NUM_LIT> ] ; op1 = operands [ <NUM_LIT> ] ; mode = GET_MODE ( dest ) ; if ( mode == SFmode ) { xorsign_insn = gen_xorsignsf3_1 ; vmode = V4SFmode ; } else if ( mode == DFmode ) { xorsign_insn = gen_xorsigndf3_1 ; vmode = V2DFmode ;


<s> } else cfun -> machine -> no_drap_save_restore = true ; frame_pointer_needed = false ; stack_realign = false ; crtl -> max_used_stack_slot_alignment = incoming_stack_boundary ; crtl -> stack_alignment_needed = incoming_stack_boundary ; crtl -> stack_alignment_estimated = incoming_stack_boundary ; if ( crtl -> preferred_stack_boundary > incoming_stack_boundary ) crtl -> preferred_stack_boundary = incoming_stack_boundary ; df_finish_pass ( true ) ; df_scan_alloc ( NULL ) ; df_scan_blocks ( ) ; df_compute_regs_ever_live ( true ) ; df_analyze ( ) ; if ( flag_var_tracking ) { df_ref ref , next ; for ( ref = DF_REG_USE_CHAIN ( HARD_FRAME_POINTER_REGNUM ) ; ref ; ref = next ) { next = DF_REF_NEXT_REG ( ref ) ; if ( ! DF_REF_INSN_INFO ( ref ) ) continue ; rtx_insn * insn = DF_REF_INSN ( ref ) ; while ( next && DF_REF_INSN ( next ) == insn ) next = DF_REF_NEXT_REG ( next ) ; if ( DEBUG_INSN_P ( insn ) ) { bool changed = false ;

for ( ; ref != next ; ref = DF_REF_NEXT_REG ( ref ) ) {


<s> int nregs ; if ( ! cum -> caller && cfun -> machine -> func_type != TYPE_NORMAL ) return ; if ( mode == BLKmode ) bytes = int_size_in_bytes ( type ) ; else bytes = GET_MODE_SIZE ( mode ) ; words = CEIL ( bytes , UNITS_PER_WORD ) ; if ( type ) mode = type_natural_mode ( type , NULL , false ) ; if ( TARGET_64BIT ) { enum calling_abi call_abi = cum ? cum -> call_abi : ix86_abi ;

if ( call_abi == MS_ABI ) nregs = function_arg_advance_ms_64 ( cum , bytes , words ) ;


<s> opts -> x_ix86_arch_string = ptr -> x_ix86_arch_string ; opts -> x_ix86_tune_string = ptr -> x_ix86_tune_string ; opts -> x_ix86_cmodel = ptr -> x_ix86_cmodel ; opts -> x_ix86_abi = ptr -> x_ix86_abi ; opts -> x_ix86_asm_dialect = ptr -> x_ix86_asm_dialect ; opts -> x_ix86_branch_cost = ptr -> x_ix86_branch_cost ; opts -> x_ix86_dump_tunes = ptr -> x_ix86_dump_tunes ; opts -> x_ix86_force_align_arg_pointer = ptr -> x_ix86_force_align_arg_pointer ; opts -> x_ix86_force_drap = ptr -> x_ix86_force_drap ; opts -> x_ix86_incoming_stack_boundary_arg = ptr -> x_ix86_incoming_stack_boundary_arg ; opts -> x_ix86_pmode = ptr -> x_ix86_pmode ; opts -> x_ix86_preferred_stack_boundary_arg = ptr -> x_ix86_preferred_stack_boundary_arg ; opts -> x_ix86_recip_name = ptr -> x_ix86_recip_name ; opts -> x_ix86_regparm = ptr -> x_ix86_regparm ;

opts -> x_ix86_section_threshold = ptr -> x_ix86_section_threshold ;


<s> tree resolver_decl ; basic_block empty_bb ; tree default_ver_decl ; struct cgraph_node * versn ; struct cgraph_node * node ; struct cgraph_function_version_info * node_version_info = NULL ; struct cgraph_function_version_info * versn_info = NULL ; node = ( cgraph_node * ) node_p ; node_version_info = node -> function_version ( ) ; gcc_assert ( node -> dispatcher_function && node_version_info != NULL ) ; if ( node_version_info -> dispatcher_resolver ) return node_version_info -> dispatcher_resolver ; default_ver_decl = node_version_info -> next -> this_node -> decl ; node -> definition = false ; resolver_decl = make_resolver_func ( default_ver_decl , node -> decl , & empty_bb ) ; node_version_info -> dispatcher_resolver = resolver_decl ; push_cfun ( DECL_STRUCT_FUNCTION ( resolver_decl ) ) ; auto_vec < tree , <NUM_LIT> > fn_ver_vec ; for ( versn_info = node_version_info -> next ; versn_info ; versn_info = versn_info -> next ) { versn = versn_info -> this_node ; if ( DECL_VINDEX ( versn -> decl ) ) sorry ( <STR_LIT> ) ; fn_ver_vec . safe_push ( versn -> decl ) ; } dispatch_function_versions ( resolver_decl , & fn_ver_vec , & empty_bb ) ; cgraph_edge :: rebuild_edges ( ) ; pop_cfun ( ) ; return resolver_decl ;


<s> return ( ( TARGET_AVX && VALID_AVX256_REG_OR_OI_MODE ( mode ) ) || VALID_SSE_REG_MODE ( mode ) || VALID_SSE2_REG_MODE ( mode ) || VALID_MMX_REG_MODE ( mode ) || VALID_MMX_REG_MODE_3DNOW ( mode ) ) ; } if ( MMX_REGNO_P ( regno ) ) { return ( VALID_MMX_REG_MODE ( mode ) || VALID_MMX_REG_MODE_3DNOW ( mode ) ) ; } if ( mode == QImode ) { if ( ANY_QI_REGNO_P ( regno ) ) return true ; if ( ! TARGET_PARTIAL_REG_STALL ) return true ; if ( lra_in_progress ) return true ; return ! can_create_pseudo_p ( ) ; } else if ( VALID_INT_MODE_P ( mode ) ) return true ;

else if ( VALID_FP_MODE_P ( mode ) ) return true ;


<s> case I387_TRUNC : if ( mode == I387_CW_TRUNC ) return mode ; break ; case I387_FLOOR : if ( mode == I387_CW_FLOOR ) return mode ; break ; case I387_CEIL : if ( mode == I387_CW_CEIL ) return mode ; break ;


<s> tree ftype , decl ; ix86_init_builtin_types ( ) ; ix86_init_platform_type_builtins ( ) ; def_builtin_const ( <NUM_LIT> , <NUM_LIT> , <STR_LIT> , FLOAT128_FTYPE_VOID , IX86_BUILTIN_INFQ ) ; def_builtin_const ( <NUM_LIT> , <NUM_LIT> , <STR_LIT> , FLOAT128_FTYPE_VOID , IX86_BUILTIN_HUGE_VALQ ) ; ftype = ix86_get_builtin_func_type ( FLOAT128_FTYPE_CONST_STRING ) ; decl = add_builtin_function ( <STR_LIT> , ftype , IX86_BUILTIN_NANQ , BUILT_IN_MD , <STR_LIT> , NULL_TREE ) ; TREE_READONLY ( decl ) = <NUM_LIT> ; ix86_builtins [ ( int ) IX86_BUILTIN_NANQ ] = decl ; decl = add_builtin_function ( <STR_LIT> , ftype , IX86_BUILTIN_NANSQ , BUILT_IN_MD , <STR_LIT> , NULL_TREE ) ; TREE_READONLY ( decl ) = <NUM_LIT> ; ix86_builtins [ ( int ) IX86_BUILTIN_NANSQ ] = decl ; ftype = ix86_get_builtin_func_type ( FLOAT128_FTYPE_FLOAT128 ) ; decl = add_builtin_function ( <STR_LIT> , ftype , IX86_BUILTIN_FABSQ , BUILT_IN_MD , <STR_LIT> , NULL_TREE ) ; TREE_READONLY ( decl ) = <NUM_LIT> ; ix86_builtins [ ( int ) IX86_BUILTIN_FABSQ ] = decl ; ftype = ix86_get_builtin_func_type ( FLOAT128_FTYPE_FLOAT128_FLOAT128 ) ;


<s> dist_use = distance_agu_use ( regno0 , insn ) ; if ( dist_define < <NUM_LIT> || dist_define >= LEA_MAX_STALL ) { if ( dist_use < <NUM_LIT> && split_cost == <NUM_LIT> ) return TARGET_64BIT || IX86_LEA_PRIORITY ; else return true ; }


<s> if ( has_scale ) return true ; if ( split_cost < <NUM_LIT> ) return false ; if ( regno0 == regno1 || regno0 == regno2 ) return false ; return true ; } dist_define = distance_non_agu_define ( regno1 , regno2 , insn ) ;

dist_use = distance_agu_use ( regno0 , insn ) ;


<s> if ( DECL_VIRTUAL_P ( decl ) || DECL_VINDEX ( decl ) ) sorry ( <STR_LIT> ) ; version_attr = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ; gcc_assert ( version_attr != NULL_TREE ) ; orig_name = IDENTIFIER_POINTER ( id ) ; version_string = TREE_STRING_POINTER ( TREE_VALUE ( TREE_VALUE ( version_attr ) ) ) ; if ( strcmp ( version_string , <STR_LIT> ) == <NUM_LIT> ) return id ; attr_str = sorted_attr_string ( TREE_VALUE ( version_attr ) ) ; assembler_name = XNEWVEC ( char , strlen ( orig_name ) + strlen ( attr_str ) + <NUM_LIT> ) ; sprintf ( assembler_name , <STR_LIT> , orig_name , attr_str ) ;

if ( DECL_ASSEMBLER_NAME_SET_P ( decl ) ) SET_DECL_RTL ( decl , NULL ) ;


<s> case 'p' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCPmode , code = EQ ; break ; case 's' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCSmode , code = EQ ; break ; case 'z' : if ( con [ <NUM_LIT> ] == <NUM_LIT> ) mode = CCZmode , code = EQ ; break ; } if ( code == UNKNOWN ) { error ( <STR_LIT> , constraints [ i ] ) ; continue ; } if ( invert ) code = reverse_condition ( code ) ; rtx dest = outputs [ i ] ; if ( ! saw_asm_flag ) { constraints [ i ] = <STR_LIT> ; outputs [ i ] = gen_rtx_REG ( CCmode , FLAGS_REG ) ; saw_asm_flag = true ; } else { constraints [ i ] = <STR_LIT> ; outputs [ i ] = gen_rtx_SCRATCH ( SImode ) ; } rtx x = gen_rtx_REG ( mode , FLAGS_REG ) ; x = gen_rtx_fmt_ee ( code , QImode , x , const0_rtx ) ; machine_mode dest_mode = GET_MODE ( dest ) ; if ( ! SCALAR_INT_MODE_P ( dest_mode ) ) { error ( <STR_LIT> ) ; continue ; } if ( dest_mode == DImode && ! TARGET_64BIT ) dest_mode = SImode ; if ( dest_mode != QImode ) { rtx destqi = gen_reg_rtx ( QImode ) ; emit_insn ( gen_rtx_SET ( destqi , x ) ) ; if ( TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p ( cfun ) ) { x = force_reg ( dest_mode , const0_rtx ) ; emit_insn ( gen_movstrictqi ( gen_lowpart ( QImode , x ) , destqi ) ) ; } else x = gen_rtx_ZERO_EXTEND ( dest_mode , destqi ) ; } if ( dest_mode != GET_MODE ( dest ) ) { rtx tmp = gen_reg_rtx ( SImode ) ; emit_insn ( gen_rtx_SET ( tmp , x ) ) ; emit_insn ( gen_zero_extendsidi2 ( dest , tmp ) ) ; } else emit_insn ( gen_rtx_SET ( dest , x ) ) ; }


<s> switch ( entity ) { case X86_DIRFLAG : return ix86_dirflag_mode_entry ( ) ; case AVX_U128 : return ix86_avx_u128_mode_entry ( ) ;


<s> case X86_DIRFLAG : return ix86_dirflag_mode_entry ( ) ; case AVX_U128 : return ix86_avx_u128_mode_entry ( ) ; case I387_TRUNC :


<s> static int ix86_mode_exit ( int entity ) { switch ( entity ) { case X86_DIRFLAG : return X86_DIRFLAG_ANY ; case AVX_U128 : return ix86_avx_u128_mode_exit ( ) ; case I387_TRUNC : case I387_FLOOR : case I387_CEIL : return I387_CW_ANY ; default : gcc_unreachable ( ) ;


<s> case X86_DIRFLAG : return ix86_dirflag_mode_needed ( insn ) ; case AVX_U128 : return ix86_avx_u128_mode_needed ( insn ) ; case I387_TRUNC : case I387_FLOOR : case I387_CEIL :

return ix86_i387_mode_needed ( entity , insn ) ;


<s> char push_buf [ <NUM_LIT> ] ; enum indirect_thunk_prefix need_prefix = indirect_thunk_need_prefix ( current_output_insn ) ; int regno = - <NUM_LIT> ; if ( cfun -> machine -> indirect_branch_type != indirect_branch_thunk_inline ) { if ( cfun -> machine -> indirect_branch_type == indirect_branch_thunk ) indirect_thunk_needed = true ; indirect_thunk_name ( thunk_name_buf , regno , need_prefix , false ) ; thunk_name = thunk_name_buf ; } else thunk_name = NULL ; snprintf ( push_buf , sizeof ( push_buf ) , <STR_LIT> , TARGET_64BIT ? 'q' : 'l' , xasm ) ; if ( sibcall_p ) { output_asm_insn ( push_buf , & call_op ) ; if ( thunk_name != NULL ) fprintf ( asm_out_file , <STR_LIT> , thunk_name ) ; else output_indirect_thunk ( regno ) ; } else { char indirectlabel1 [ <NUM_LIT> ] ; char indirectlabel2 [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( indirectlabel1 , INDIRECT_LABEL , indirectlabelno ++ ) ; ASM_GENERATE_INTERNAL_LABEL ( indirectlabel2 , INDIRECT_LABEL , indirectlabelno ++ ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , indirectlabel2 ) ; fputc ( '\n' , asm_out_file ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel1 ) ; if ( MEM_P ( call_op ) ) { struct ix86_address parts ; rtx addr = XEXP ( call_op , <NUM_LIT> ) ; if ( ix86_decompose_address ( addr , & parts ) && parts . base == stack_pointer_rtx ) { if ( parts . index ) { addr = gen_rtx_MULT ( Pmode , parts . index , GEN_INT ( parts . scale ) ) ; addr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , addr ) ; } else addr = stack_pointer_rtx ; rtx disp ; if ( parts . disp != NULL_RTX ) disp = plus_constant ( Pmode , parts . disp , UNITS_PER_WORD ) ; else disp = GEN_INT ( UNITS_PER_WORD ) ; addr = gen_rtx_PLUS ( Pmode , addr , disp ) ; call_op = gen_rtx_MEM ( GET_MODE ( call_op ) , addr ) ; } } output_asm_insn ( push_buf , & call_op ) ; if ( thunk_name != NULL ) fprintf ( asm_out_file , <STR_LIT> , thunk_name ) ; else output_indirect_thunk ( regno ) ;


<s> if ( i >= FIRST_REX_INT_REG ) i -= ( FIRST_REX_INT_REG - LAST_INT_REG - <NUM_LIT> ) ; indirect_thunks_used |= <NUM_LIT> << i ; } indirect_thunk_name ( thunk_name_buf , regno , need_prefix , false ) ; thunk_name = thunk_name_buf ; } else thunk_name = NULL ; if ( sibcall_p ) { if ( thunk_name != NULL ) fprintf ( asm_out_file , <STR_LIT> , thunk_name ) ; else output_indirect_thunk ( regno ) ; } else { if ( thunk_name != NULL ) { fprintf ( asm_out_file , <STR_LIT> , thunk_name ) ; return ; } char indirectlabel1 [ <NUM_LIT> ] ; char indirectlabel2 [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( indirectlabel1 , INDIRECT_LABEL , indirectlabelno ++ ) ; ASM_GENERATE_INTERNAL_LABEL ( indirectlabel2 , INDIRECT_LABEL , indirectlabelno ++ ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , indirectlabel2 ) ; fputc ( '\n' , asm_out_file ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel1 ) ; if ( thunk_name != NULL ) fprintf ( asm_out_file , <STR_LIT> , thunk_name ) ; else output_indirect_thunk ( regno ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , indirectlabel2 ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , indirectlabel1 ) ; fputc ( '\n' , asm_out_file ) ; }


<s> const char * ix86_output_indirect_function_return ( rtx ret_op ) { if ( cfun -> machine -> function_return_type != indirect_branch_keep ) { char thunk_name [ <NUM_LIT> ] ; enum indirect_thunk_prefix need_prefix = indirect_thunk_need_prefix ( current_output_insn ) ; unsigned int regno = REGNO ( ret_op ) ; gcc_assert ( regno == CX_REG ) ; if ( cfun -> machine -> function_return_type != indirect_branch_thunk_inline ) { bool need_thunk = ( cfun -> machine -> function_return_type == indirect_branch_thunk ) ; indirect_thunk_name ( thunk_name , regno , need_prefix , true ) ; if ( need_thunk ) { indirect_return_via_cx = true ; indirect_thunks_used |= <NUM_LIT> << CX_REG ;


<s> if ( TARGET_AVX128_OPTIMAL && GET_MODE_BITSIZE ( mode ) > <NUM_LIT> ) div = GET_MODE_BITSIZE ( mode ) / <NUM_LIT> ; else if ( TARGET_SSE_SPLIT_REGS && GET_MODE_BITSIZE ( mode ) > <NUM_LIT> ) div = GET_MODE_BITSIZE ( mode ) / <NUM_LIT> ; width = ( width + div - <NUM_LIT> ) / div ; } else if ( INTEGRAL_MODE_P ( mode ) ) width = ix86_cost -> reassoc_int ; else if ( FLOAT_MODE_P ( mode ) ) width = ix86_cost -> reassoc_fp ; if ( ! TARGET_64BIT && width > <NUM_LIT> ) width = <NUM_LIT> ; return width ;


<s> CUMULATIVE_ARGS next_cum ; tree fntype ; int max ; gcc_assert ( ! no_rtl ) ; if ( ! TARGET_64BIT || cum -> call_abi == MS_ABI ) return ; fntype = TREE_TYPE ( current_function_decl ) ; next_cum = * cum ; if ( stdarg_p ( fntype ) ) ix86_function_arg_advance ( pack_cumulative_args ( & next_cum ) , mode , type , true ) ;

max = cum -> regno + cfun -> va_list_gpr_size / UNITS_PER_WORD ;


<s> if ( stdarg_p ( fntype ) ) ix86_function_arg_advance ( pack_cumulative_args ( & next_cum ) , mode , type , true ) ; max = cum -> regno + cfun -> va_list_gpr_size / UNITS_PER_WORD ; if ( max > X86_64_REGPARM_MAX ) max = X86_64_REGPARM_MAX ;


<s> ix86_set_indirect_branch_type ( fndecl ) ; tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) ; if ( new_tree == NULL_TREE ) new_tree = target_option_default_node ; if ( old_tree != new_tree ) { cl_target_option_restore ( & global_options , TREE_TARGET_OPTION ( new_tree ) ) ; if ( TREE_TARGET_GLOBALS ( new_tree ) ) restore_target_globals ( TREE_TARGET_GLOBALS ( new_tree ) ) ; else if ( new_tree == target_option_default_node ) restore_target_globals ( & default_target_globals ) ; else TREE_TARGET_GLOBALS ( new_tree ) = save_target_globals_default_opts ( ) ; } ix86_previous_fndecl = fndecl ; static bool prev_no_caller_saved_registers ; if ( TARGET_64BIT && ( call_used_regs [ SI_REG ] == ( cfun -> machine -> call_abi == MS_ABI ) ) ) reinit_regs ( ) ; else if ( prev_no_caller_saved_registers != cfun -> machine -> no_caller_saved_registers ) reinit_regs ( ) ;

if ( cfun -> machine -> func_type != TYPE_NORMAL || cfun -> machine -> no_caller_saved_registers ) {


<s> if ( fndecl == NULL_TREE ) { if ( old_tree != target_option_current_node ) ix86_reset_previous_fndecl ( ) ; return ; } ix86_set_func_type ( fndecl ) ; ix86_set_indirect_branch_type ( fndecl ) ; tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) ; if ( new_tree == NULL_TREE ) new_tree = target_option_default_node ; if ( old_tree != new_tree ) { cl_target_option_restore ( & global_options , TREE_TARGET_OPTION ( new_tree ) ) ; if ( TREE_TARGET_GLOBALS ( new_tree ) ) restore_target_globals ( TREE_TARGET_GLOBALS ( new_tree ) ) ; else if ( new_tree == target_option_default_node ) restore_target_globals ( & default_target_globals ) ; else TREE_TARGET_GLOBALS ( new_tree ) = save_target_globals_default_opts ( ) ; } ix86_previous_fndecl = fndecl ; static bool prev_no_caller_saved_registers ; if ( TARGET_64BIT && ( call_used_regs [ SI_REG ] == ( cfun -> machine -> call_abi == MS_ABI ) ) ) reinit_regs ( ) ; else if ( prev_no_caller_saved_registers != cfun -> machine -> no_caller_saved_registers ) reinit_regs ( ) ; if ( cfun -> machine -> func_type != TYPE_NORMAL || cfun -> machine -> no_caller_saved_registers ) { const char * isa ; if ( TARGET_SSE ) isa = <STR_LIT> ; else if ( TARGET_MMX ) isa = <STR_LIT> ; else if ( TARGET_80387 ) isa = <STR_LIT> ; else isa = NULL ; if ( isa != NULL ) {

if ( cfun -> machine -> func_type != TYPE_NORMAL ) sorry ( cfun -> machine -> func_type == TYPE_EXCEPTION ? G_ ( <STR_LIT> <STR_LIT> ) : G_ ( <STR_LIT> <STR_LIT> ) , isa ) ;


<s> if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) cfun -> machine -> indirect_branch_type = indirect_branch_keep ; else if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) cfun -> machine -> indirect_branch_type = indirect_branch_thunk ; else if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) cfun -> machine -> indirect_branch_type = indirect_branch_thunk_inline ; else if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) cfun -> machine -> indirect_branch_type = indirect_branch_thunk_extern ; else gcc_unreachable ( ) ; } else cfun -> machine -> indirect_branch_type = ix86_indirect_branch ; if ( ( ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC ) && ( ( cfun -> machine -> indirect_branch_type == indirect_branch_thunk_extern ) || ( cfun -> machine -> indirect_branch_type == indirect_branch_thunk ) ) ) error ( <STR_LIT> <STR_LIT> , ( ( cfun -> machine -> indirect_branch_type == indirect_branch_thunk_extern ) ? <STR_LIT> : <STR_LIT> ) ) ; if ( cfun -> machine -> indirect_branch_type != indirect_branch_keep && ( flag_cf_protection & CF_RETURN ) ) error ( <STR_LIT> <STR_LIT> ) ; } if ( cfun -> machine -> function_return_type == indirect_branch_unset ) { tree attr = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( fndecl ) ) ; if ( attr != NULL ) { tree args = TREE_VALUE ( attr ) ; if ( args == NULL ) gcc_unreachable ( ) ; tree cst = TREE_VALUE ( args ) ; if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) cfun -> machine -> function_return_type = indirect_branch_keep ; else if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) cfun -> machine -> function_return_type = indirect_branch_thunk ; else if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) cfun -> machine -> function_return_type = indirect_branch_thunk_inline ; else if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) cfun -> machine -> function_return_type = indirect_branch_thunk_extern ; else gcc_unreachable ( ) ; }

else cfun -> machine -> function_return_type = ix86_function_return ;


<s> else abi = <STR_LIT> ; opts [ num ++ ] [ <NUM_LIT> ] = abi ; } isa &= ~ ( OPTION_MASK_ISA_64BIT | OPTION_MASK_ABI_64 | OPTION_MASK_ABI_X32 ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( isa2_opts ) ; i ++ ) { if ( ( isa2 & isa2_opts [ i ] . mask ) != <NUM_LIT> ) { opts [ num ++ ] [ <NUM_LIT> ] = isa2_opts [ i ] . option ; isa2 &= ~ isa2_opts [ i ] . mask ; } } if ( isa2 && add_nl_p ) { opts [ num ++ ] [ <NUM_LIT> ] = isa2_other ; sprintf ( isa2_other , <STR_LIT> HOST_WIDE_INT_PRINT <STR_LIT> , isa2 ) ; } for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( isa_opts ) ; i ++ ) { if ( ( isa & isa_opts [ i ] . mask ) != <NUM_LIT> ) { opts [ num ++ ] [ <NUM_LIT> ] = isa_opts [ i ] . option ; isa &= ~ isa_opts [ i ] . mask ; } } if ( isa && add_nl_p ) { opts [ num ++ ] [ <NUM_LIT> ] = isa_other ; sprintf ( isa_other , <STR_LIT> HOST_WIDE_INT_PRINT <STR_LIT> , isa ) ; } for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( flag_opts ) ; i ++ ) { if ( ( flags & flag_opts [ i ] . mask ) != <NUM_LIT> ) { opts [ num ++ ] [ <NUM_LIT> ] = flag_opts [ i ] . option ; flags &= ~ flag_opts [ i ] . mask ; } } if ( flags && add_nl_p ) { opts [ num ++ ] [ <NUM_LIT> ] = flags_other ; sprintf ( flags_other , <STR_LIT> , flags ) ; } for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( flag2_opts ) ; i ++ ) { if ( ( flags2 & flag2_opts [ i ] . mask ) != <NUM_LIT> ) { opts [ num ++ ] [ <NUM_LIT> ] = flag2_opts [ i ] . option ; flags2 &= ~ flag2_opts [ i ] . mask ; } } if ( flags2 && add_nl_p ) { opts [ num ++ ] [ <NUM_LIT> ] = flags2_other ; sprintf ( flags2_other , <STR_LIT> , flags2 ) ; } if ( fpmath ) { opts [ num ] [ <NUM_LIT> ] = <STR_LIT> ; switch ( ( int ) fpmath ) { case FPMATH_387 : opts [ num ++ ] [ <NUM_LIT> ] = <STR_LIT> ; break ; case FPMATH_SSE : opts [ num ++ ] [ <NUM_LIT> ] = <STR_LIT> ; break ; case FPMATH_387 | FPMATH_SSE : opts [ num ++ ] [ <NUM_LIT> ] = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } } if ( num == <NUM_LIT> ) return NULL ; gcc_assert ( num < ARRAY_SIZE ( opts ) ) ; len = <NUM_LIT> ; sep_len = ( add_nl_p ) ? <NUM_LIT> : <NUM_LIT> ;

for ( i = <NUM_LIT> ; i < num ; i ++ ) {


<s> static int ix86_vec_cost ( machine_mode mode , int cost ) {

if ( ! VECTOR_MODE_P ( mode ) ) return cost ;


<s> DECL_STATIC_CONSTRUCTOR ( decl ) = <NUM_LIT> ; if ( DECL_COMDAT_GROUP ( default_decl ) || TREE_PUBLIC ( default_decl ) ) { DECL_COMDAT ( decl ) = <NUM_LIT> ; make_decl_one_only ( decl , DECL_ASSEMBLER_NAME ( decl ) ) ; } t = build_decl ( UNKNOWN_LOCATION , RESULT_DECL , NULL_TREE , ptr_type_node ) ; DECL_CONTEXT ( t ) = decl ; DECL_ARTIFICIAL ( t ) = <NUM_LIT> ; DECL_IGNORED_P ( t ) = <NUM_LIT> ; DECL_RESULT ( decl ) = t ; gimplify_function_tree ( decl ) ; push_cfun ( DECL_STRUCT_FUNCTION ( decl ) ) ; * empty_bb = init_lowered_empty_function ( decl , false , profile_count :: uninitialized ( ) ) ;

cgraph_node :: add_new_function ( decl , true ) ;


<s> rtx reg = regno_reg_rtx [ regno ] ; rtx vreg = gen_reg_rtx ( DImode ) ; df_ref ref ; for ( ref = DF_REG_DEF_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) if ( ! bitmap_bit_p ( insns , DF_REF_INSN_UID ( ref ) ) ) { start_sequence ( ) ; if ( ! TARGET_INTER_UNIT_MOVES_TO_VEC ) { rtx tmp = assign_386_stack_local ( DImode , SLOT_STV_TEMP ) ; emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( vreg , tmp ) ; } else if ( TARGET_SSE4_1 ) { emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_sse4_1_pinsrd ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ) ; } else { rtx tmp = gen_reg_rtx ( DImode ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_vec_interleave_lowv4si ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) ) ) ; } rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; rtx_insn * insn = DF_REF_INSN ( ref ) ; emit_conversion_insns ( seq , insn ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , REGNO ( vreg ) , INSN_UID ( insn ) ) ; } for ( ref = DF_REG_USE_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) if ( bitmap_bit_p ( insns , DF_REF_INSN_UID ( ref ) ) ) { rtx_insn * insn = DF_REF_INSN ( ref ) ; replace_with_subreg_in_insn ( insn , reg , vreg ) ;


<s> void dimode_scalar_chain :: make_vector_copies ( unsigned regno ) { rtx reg = regno_reg_rtx [ regno ] ; rtx vreg = gen_reg_rtx ( DImode ) ; df_ref ref ; for ( ref = DF_REG_DEF_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) if ( ! bitmap_bit_p ( insns , DF_REF_INSN_UID ( ref ) ) ) { start_sequence ( ) ; if ( ! TARGET_INTER_UNIT_MOVES_TO_VEC ) { rtx tmp = assign_386_stack_local ( DImode , SLOT_STV_TEMP ) ; emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( adjust_address ( tmp , SImode , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ; emit_move_insn ( vreg , tmp ) ; } else if ( TARGET_SSE4_1 ) { emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_sse4_1_pinsrd ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ) ; } else { rtx tmp = gen_reg_rtx ( DImode ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_sse2_loadld ( gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) , CONST0_RTX ( V4SImode ) , gen_rtx_SUBREG ( SImode , reg , <NUM_LIT> ) ) ) ; emit_insn ( gen_vec_interleave_lowv4si ( gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , vreg , <NUM_LIT> ) , gen_rtx_SUBREG ( V4SImode , tmp , <NUM_LIT> ) ) ) ; } rtx_insn * seq = get_insns ( ) ; end_sequence ( ) ; rtx_insn * insn = DF_REF_INSN ( ref ) ; emit_conversion_insns ( seq , insn ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , regno , REGNO ( vreg ) , INSN_UID ( insn ) ) ; }

for ( ref = DF_REG_USE_CHAIN ( regno ) ; ref ; ref = DF_REF_NEXT_REG ( ref ) ) if ( bitmap_bit_p ( insns , DF_REF_INSN_UID ( ref ) ) ) {


<s> bool clear = false ; next_feature_string = strchr ( curr_feature_string , ',' ) ; if ( next_feature_string ) * next_feature_string ++ = '\0' ; if ( * curr_feature_string == '^' ) { curr_feature_string ++ ; clear = true ; } for ( i = <NUM_LIT> ; i < X86_TUNE_LAST ; i ++ ) { if ( ! strcmp ( curr_feature_string , ix86_tune_feature_names [ i ] ) ) { ix86_tune_features [ i ] = ! clear ; if ( dump ) fprintf ( stderr , <STR_LIT> , clear ? <STR_LIT> : <STR_LIT> , ix86_tune_feature_names [ i ] ) ;


<s> if ( ! need_endbr && ! SIBLING_CALL_P ( insn ) ) { rtx call = get_call_rtx_from ( insn ) ; rtx fnaddr = XEXP ( call , <NUM_LIT> ) ; tree fndecl = NULL_TREE ; if ( GET_CODE ( XEXP ( fnaddr , <NUM_LIT> ) ) == SYMBOL_REF ) fndecl = SYMBOL_REF_DECL ( XEXP ( fnaddr , <NUM_LIT> ) ) ; if ( fndecl == NULL_TREE ) fndecl = MEM_EXPR ( fnaddr ) ; if ( fndecl && TREE_CODE ( TREE_TYPE ( fndecl ) ) != FUNCTION_TYPE && TREE_CODE ( TREE_TYPE ( fndecl ) ) != METHOD_TYPE ) fndecl = NULL_TREE ; if ( fndecl && TYPE_ARG_TYPES ( TREE_TYPE ( fndecl ) ) ) { tree fntype = TREE_TYPE ( fndecl ) ; if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) need_endbr = true ; } } if ( ! need_endbr ) continue ; cet_eb = gen_nop_endbr ( ) ; emit_insn_after_setloc ( cet_eb , insn , INSN_LOCATION ( insn ) ) ; continue ; } if ( JUMP_P ( insn ) && flag_cet_switch ) { rtx target = JUMP_LABEL ( insn ) ;

if ( target == NULL_RTX || ANY_RETURN_P ( target ) ) continue ;


<s> warning ( <NUM_LIT> , <STR_LIT> , feature ) ; warned_once = true ; }


<s> if ( ! warned_once ) { warning ( <NUM_LIT> , <STR_LIT> , feature ) ; warned_once = true ;


<s> if ( ! TARGET_SSE_MATH ) for ( i = FIRST_STACK_REG ; i <= LAST_STACK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_SSE_REG ; i <= LAST_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_REX_SSE_REG ; i <= LAST_REX_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_EXT_REX_SSE_REG ; i <= LAST_EXT_REX_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_MASK_REG ; i <= LAST_MASK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; if ( TARGET_SSE_MATH ) for ( i = FIRST_STACK_REG ; i <= LAST_STACK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ; for ( i = FIRST_MMX_REG ; i <= LAST_MMX_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ;

while ( pos < FIRST_PSEUDO_REGISTER ) reg_alloc_order [ pos ++ ] = <NUM_LIT> ;


<s> int pos = <NUM_LIT> ; int i ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( GENERAL_REGNO_P ( i ) && call_used_regs [ i ] ) reg_alloc_order [ pos ++ ] = i ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( GENERAL_REGNO_P ( i ) && ! call_used_regs [ i ] ) reg_alloc_order [ pos ++ ] = i ; if ( ! TARGET_SSE_MATH ) for ( i = FIRST_STACK_REG ; i <= LAST_STACK_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ;

for ( i = FIRST_SSE_REG ; i <= LAST_SSE_REG ; i ++ ) reg_alloc_order [ pos ++ ] = i ;


<s> if ( NONDEBUG_INSN_P ( insn ) && NONJUMP_INSN_P ( insn ) ) { rtx set = single_set ( insn ) ; if ( set ) { avoid_func_arg_motion ( arg , insn ) ; return ; } } if ( insn == BB_HEAD ( bb ) ) return ; insn = PREV_INSN ( insn ) ;


<s> if ( NONDEBUG_INSN_P ( insn ) && NONJUMP_INSN_P ( insn ) ) { rtx set = single_set ( insn ) ; if ( set ) { avoid_func_arg_motion ( arg , insn ) ; return ; } }


<s> bool fp = false ; machine_mode mode = scalar_p ? SImode : TImode ; if ( vectype != NULL ) { fp = FLOAT_TYPE_P ( vectype ) ; mode = TYPE_MODE ( vectype ) ; if ( scalar_p ) mode = TYPE_MODE ( TREE_TYPE ( vectype ) ) ; } if ( ( kind == vector_stmt || kind == scalar_stmt ) && stmt_info && stmt_info -> stmt && gimple_code ( stmt_info -> stmt ) == GIMPLE_ASSIGN ) { tree_code subcode = gimple_assign_rhs_code ( stmt_info -> stmt ) ; switch ( subcode ) { case PLUS_EXPR : case POINTER_PLUS_EXPR : case MINUS_EXPR : if ( kind == scalar_stmt ) { if ( SSE_FLOAT_MODE_SSEMATH_OR_HF_P ( mode ) ) stmt_cost = ix86_cost -> addss ; else if ( X87_FLOAT_MODE_P ( mode ) ) stmt_cost = ix86_cost -> fadd ; else stmt_cost = ix86_cost -> add ; } else stmt_cost = ix86_vec_cost ( mode , fp ? ix86_cost -> addss : ix86_cost -> sse_op ) ; break ; case MULT_EXPR : case MULT_HIGHPART_EXPR : stmt_cost = ix86_multiplication_cost ( ix86_cost , mode ) ; break ; case WIDEN_MULT_EXPR : stmt_cost = ix86_widen_mult_cost ( ix86_cost , mode , TYPE_UNSIGNED ( vectype ) ) ; break ; case NEGATE_EXPR : if ( SSE_FLOAT_MODE_SSEMATH_OR_HF_P ( mode ) ) stmt_cost = ix86_cost -> sse_op ; else if ( X87_FLOAT_MODE_P ( mode ) ) stmt_cost = ix86_cost -> fchs ; else if ( VECTOR_MODE_P ( mode ) ) stmt_cost = ix86_vec_cost ( mode , ix86_cost -> sse_op ) ; else stmt_cost = ix86_cost -> add ; break ; case TRUNC_DIV_EXPR : case CEIL_DIV_EXPR : case FLOOR_DIV_EXPR : case ROUND_DIV_EXPR : case TRUNC_MOD_EXPR : case CEIL_MOD_EXPR : case FLOOR_MOD_EXPR : case RDIV_EXPR : case ROUND_MOD_EXPR : case EXACT_DIV_EXPR : stmt_cost = ix86_division_cost ( ix86_cost , mode ) ; break ; case RSHIFT_EXPR : case LSHIFT_EXPR : case LROTATE_EXPR : case RROTATE_EXPR : { tree op1 = gimple_assign_rhs1 ( stmt_info -> stmt ) ; tree op2 = gimple_assign_rhs2 ( stmt_info -> stmt ) ; stmt_cost = ix86_shift_rotate_cost ( ix86_cost , ( subcode == RSHIFT_EXPR && ! TYPE_UNSIGNED ( TREE_TYPE ( op1 ) ) ) ? ASHIFTRT : LSHIFTRT , mode , TREE_CODE ( op2 ) == INTEGER_CST , cst_and_fits_in_hwi ( op2 ) ? int_cst_value ( op2 ) : - <NUM_LIT> , true , false , false , NULL , NULL ) ; } break ; case NOP_EXPR : if ( tree_nop_conversion_p ( TREE_TYPE ( gimple_assign_lhs ( stmt_info -> stmt ) ) , TREE_TYPE ( gimple_assign_rhs1 ( stmt_info -> stmt ) ) ) ) stmt_cost = <NUM_LIT> ; break ; case BIT_IOR_EXPR : case ABS_EXPR : case ABSU_EXPR : case MIN_EXPR : case MAX_EXPR : case BIT_XOR_EXPR : case BIT_AND_EXPR : case BIT_NOT_EXPR : if ( SSE_FLOAT_MODE_SSEMATH_OR_HF_P ( mode ) ) stmt_cost = ix86_cost -> sse_op ; else if ( VECTOR_MODE_P ( mode ) ) stmt_cost = ix86_vec_cost ( mode , ix86_cost -> sse_op ) ; else stmt_cost = ix86_cost -> add ; break ; default : break ; }


<s> int type = DW_EH_PE_sdata8 ; if ( ptr_mode == SImode || ix86_cmodel == CM_SMALL_PIC || ( ix86_cmodel == CM_MEDIUM_PIC && ( global || code ) ) ) type = DW_EH_PE_sdata4 ; return ( global ? DW_EH_PE_indirect : <NUM_LIT> ) | DW_EH_PE_pcrel | type ; } if ( ix86_cmodel == CM_SMALL || ( ix86_cmodel == CM_MEDIUM && code ) ) return DW_EH_PE_udata4 ; return DW_EH_PE_absptr ;


<s> s = ggc_alloc < stack_local_entry > ( ) ; s -> n = n ; s -> mode = mode ;

s -> rtl = assign_stack_local ( mode , GET_MODE_SIZE ( mode ) , <NUM_LIT> ) ;


<s> tmp = SET_DEST ( set ) ; if ( REG_P ( tmp ) ) { add_dependence ( first_arg , insn , REG_DEP_OUTPUT ) ; return ;


<s> rtx tmp ; set = single_set ( insn ) ; if ( ! set ) return ; tmp = SET_DEST ( set ) ;


<s> if ( ei >= <NUM_LIT> * nelt ) return <NUM_LIT> ; ipar [ i ] = ei ; } for ( i = <NUM_LIT> ; i < nelt2 - <NUM_LIT> ; ++ i ) if ( ipar [ i ] + <NUM_LIT> != ipar [ i + <NUM_LIT> ] ) return <NUM_LIT> ; for ( i = nelt2 ; i < nelt - <NUM_LIT> ; ++ i ) if ( ipar [ i ] + <NUM_LIT> != ipar [ i + <NUM_LIT> ] ) return <NUM_LIT> ;

for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) {


<s> HOST_WIDE_INT base_offset = <NUM_LIT> ; if ( align && * align ) choose_basereg ( cfa_offset , base_reg , base_offset , * align , align ) ; if ( ! base_reg ) choose_basereg ( cfa_offset , base_reg , base_offset , <NUM_LIT> , align ) ; gcc_assert ( base_reg != NULL ) ; rtx base_offset_rtx = GEN_INT ( base_offset ) ; if ( ! x86_64_immediate_operand ( base_offset_rtx , Pmode ) ) { gcc_assert ( scratch_regno != INVALID_REGNUM ) ; rtx scratch_reg = gen_rtx_REG ( Pmode , scratch_regno ) ; emit_move_insn ( scratch_reg , base_offset_rtx ) ; return gen_rtx_PLUS ( Pmode , base_reg , scratch_reg ) ;


<s> else if ( IN_RANGE ( offset , - <NUM_LIT> , <NUM_LIT> ) ) len = <NUM_LIT> ; if ( regno == SP_REG || regno == R12_REG ) len ++ ;


<s> len = ( regno == BP_REG || regno == R13_REG ) ; }

else if ( IN_RANGE ( offset , - <NUM_LIT> , <NUM_LIT> ) ) len = <NUM_LIT> ;


<s> } else if ( drap_ok ) { base_reg = crtl -> drap_reg ; base_offset = <NUM_LIT> - cfa_offset ; } else if ( sp_ok ) { base_reg = stack_pointer_rtx ; base_offset = m -> fs . sp_offset - cfa_offset ; } } else { HOST_WIDE_INT toffset ; int len = <NUM_LIT> , tlen ; if ( sp_ok ) { base_reg = stack_pointer_rtx ; base_offset = m -> fs . sp_offset - cfa_offset ; len = choose_baseaddr_len ( STACK_POINTER_REGNUM , base_offset ) ; } if ( drap_ok ) { toffset = <NUM_LIT> - cfa_offset ; tlen = choose_baseaddr_len ( REGNO ( crtl -> drap_reg ) , toffset ) ; if ( tlen <= len ) { base_reg = crtl -> drap_reg ; base_offset = toffset ; len = tlen ; } }


<s> enum x86_64_reg_class alt_classes [ MAX_CLASSES ] ; zero_width_bitfields = <NUM_LIT> ; if ( classify_argument ( mode , type , alt_classes , bit_offset , zero_width_bitfields ) != n ) zero_width_bitfields = <NUM_LIT> ; else for ( int i = <NUM_LIT> ; i < n ; i ++ ) if ( classes [ i ] != alt_classes [ i ] ) { zero_width_bitfields = <NUM_LIT> ; break ; }

if ( zero_width_bitfields == <NUM_LIT> ) {


<s> static int classify_argument ( machine_mode mode , const_tree type , enum x86_64_reg_class classes [ MAX_CLASSES ] , int bit_offset ) { int zero_width_bitfields = <NUM_LIT> ; static bool warned = false ; int n = classify_argument ( mode , type , classes , bit_offset , zero_width_bitfields ) ;

if ( ! zero_width_bitfields || warned || ! warn_psabi ) return n ;


return CONSTANT_P ( x ) && ix86_legitimate_address_p ( Pmode , x , <NUM_LIT> ) ;


<s> if ( i * <NUM_LIT> + <NUM_LIT> > bytes ) { unsigned int tmpbits = ( bytes - i * <NUM_LIT> ) * BITS_PER_UNIT ; if ( ! int_mode_for_size ( tmpbits , <NUM_LIT> ) . exists ( & tmpmode ) ) tmpmode = DImode ; } else if ( regclass [ i ] == X86_64_INTEGERSI_CLASS ) tmpmode = SImode ; else tmpmode = DImode ; exp [ nexps ++ ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( tmpmode , * intreg ) , GEN_INT ( i * <NUM_LIT> ) ) ; intreg ++ ; break ; case X86_64_SSEHF_CLASS : exp [ nexps ++ ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( HFmode , GET_SSE_REGNO ( sse_regno ) ) , GEN_INT ( i * <NUM_LIT> ) ) ; sse_regno ++ ; break ; case X86_64_SSESF_CLASS : exp [ nexps ++ ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( SFmode , GET_SSE_REGNO ( sse_regno ) ) , GEN_INT ( i * <NUM_LIT> ) ) ; sse_regno ++ ; break ; case X86_64_SSEDF_CLASS : exp [ nexps ++ ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( DFmode , GET_SSE_REGNO ( sse_regno ) ) , GEN_INT ( i * <NUM_LIT> ) ) ; sse_regno ++ ; break ; case X86_64_SSE_CLASS : pos = i ; switch ( n ) { case <NUM_LIT> : tmpmode = DImode ; break ; case <NUM_LIT> : if ( i == <NUM_LIT> && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS ) { tmpmode = TImode ; i ++ ; } else tmpmode = DImode ; break ; case <NUM_LIT> : gcc_assert ( i == <NUM_LIT> && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS ) ; tmpmode = OImode ; i += <NUM_LIT> ; break ; case <NUM_LIT> : gcc_assert ( i == <NUM_LIT> && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS && regclass [ <NUM_LIT> ] == X86_64_SSEUP_CLASS ) ; tmpmode = XImode ; i += <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } exp [ nexps ++ ] = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( tmpmode , GET_SSE_REGNO ( sse_regno ) ) , GEN_INT ( pos * <NUM_LIT> ) ) ; sse_regno ++ ; break ;


<s> * name = TREE_STRING_POINTER ( TREE_VALUE ( TREE_VALUE ( attr ) ) ) ; return true ;


<s> if ( ! attr ) return false ; * name = TREE_STRING_POINTER ( TREE_VALUE ( TREE_VALUE ( attr ) ) ) ;


<s> if ( ! attr ) return false ; * name = TREE_STRING_POINTER ( TREE_VALUE ( TREE_VALUE ( attr ) ) ) ; return true ;


<s> static bool darwin_local_data_pic ( rtx disp ) {

return ( GET_CODE ( disp ) == UNSPEC && XINT ( disp , <NUM_LIT> ) == UNSPEC_MACHOPIC_OFFSET ) ;


<s> if ( insn != BB_END ( bb ) ) distance = distance_agu_use_in_bb ( regno0 , insn , distance , NEXT_INSN ( insn ) , & found , & redefined ) ; if ( ! found && ! redefined && distance < LEA_SEARCH_THRESHOLD ) { edge e ; edge_iterator ei ; bool simple_loop = false ; FOR_EACH_EDGE ( e , ei , bb -> succs ) if ( e -> dest == bb ) { simple_loop = true ; break ; } if ( simple_loop ) distance = distance_agu_use_in_bb ( regno0 , insn , distance , BB_HEAD ( bb ) , & found , & redefined ) ; else { int shortest_dist = - <NUM_LIT> ; bool found_in_bb = false ; bool redefined_in_bb = false ; FOR_EACH_EDGE ( e , ei , bb -> succs ) {

int bb_dist = distance_agu_use_in_bb ( regno0 , insn , distance , BB_HEAD ( e -> dest ) , & found_in_bb , & redefined_in_bb ) ;


<s> static int distance_agu_use ( unsigned int regno0 , rtx_insn * insn ) { basic_block bb = BLOCK_FOR_INSN ( insn ) ; int distance = <NUM_LIT> ; bool found = false ; bool redefined = false ; if ( insn != BB_END ( bb ) ) distance = distance_agu_use_in_bb ( regno0 , insn , distance , NEXT_INSN ( insn ) , & found , & redefined ) ; if ( ! found && ! redefined && distance < LEA_SEARCH_THRESHOLD ) { edge e ; edge_iterator ei ; bool simple_loop = false ; FOR_EACH_EDGE ( e , ei , bb -> succs ) if ( e -> dest == bb ) { simple_loop = true ; break ; } if ( simple_loop ) distance = distance_agu_use_in_bb ( regno0 , insn , distance , BB_HEAD ( bb ) , & found , & redefined ) ; else { int shortest_dist = - <NUM_LIT> ; bool found_in_bb = false ; bool redefined_in_bb = false ; FOR_EACH_EDGE ( e , ei , bb -> succs ) { int bb_dist = distance_agu_use_in_bb ( regno0 , insn , distance , BB_HEAD ( e -> dest ) , & found_in_bb , & redefined_in_bb ) ; if ( found_in_bb ) { if ( shortest_dist < <NUM_LIT> ) shortest_dist = bb_dist ; else if ( bb_dist > <NUM_LIT> ) shortest_dist = MIN ( bb_dist , shortest_dist ) ; found = true ; } } distance = shortest_dist ; }


<s> distance = increase_distance ( prev , next , distance ) ; if ( insn_uses_reg_mem ( regno , next ) ) { * found = true ; return distance ; } if ( insn_defines_reg ( regno , INVALID_REGNUM , next ) ) { * redefined = true ; return - <NUM_LIT> ; } prev = next ; } if ( next == BB_END ( bb ) ) break ;


<s> bool simple_loop = false ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( e -> src == bb ) { simple_loop = true ; break ; } if ( simple_loop ) distance = distance_non_agu_define_in_bb ( regno1 , regno2 , insn , distance , BB_END ( bb ) , & found ) ; else { int shortest_dist = - <NUM_LIT> ; bool found_in_bb = false ; FOR_EACH_EDGE ( e , ei , bb -> preds ) { int bb_dist = distance_non_agu_define_in_bb ( regno1 , regno2 , insn , distance , BB_END ( e -> src ) , & found_in_bb ) ; if ( found_in_bb ) { if ( shortest_dist < <NUM_LIT> ) shortest_dist = bb_dist ; else if ( bb_dist > <NUM_LIT> ) shortest_dist = MIN ( bb_dist , shortest_dist ) ; found = true ; } } distance = shortest_dist ; } }


<s> int distance = <NUM_LIT> ; bool found = false ; if ( insn != BB_HEAD ( bb ) ) distance = distance_non_agu_define_in_bb ( regno1 , regno2 , insn , distance , PREV_INSN ( insn ) , & found ) ; if ( ! found && distance < LEA_SEARCH_THRESHOLD ) { edge e ; edge_iterator ei ; bool simple_loop = false ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( e -> src == bb ) { simple_loop = true ; break ; } if ( simple_loop ) distance = distance_non_agu_define_in_bb ( regno1 , regno2 , insn , distance , BB_END ( bb ) , & found ) ; else { int shortest_dist = - <NUM_LIT> ; bool found_in_bb = false ; FOR_EACH_EDGE ( e , ei , bb -> preds ) { int bb_dist = distance_non_agu_define_in_bb ( regno1 , regno2 , insn , distance , BB_END ( e -> src ) , & found_in_bb ) ; if ( found_in_bb ) { if ( shortest_dist < <NUM_LIT> ) shortest_dist = bb_dist ; else if ( bb_dist > <NUM_LIT> ) shortest_dist = MIN ( bb_dist , shortest_dist ) ; found = true ; }


<s> rtx_insn * prev = start ; rtx_insn * next = NULL ; * found = false ; while ( prev && prev != insn && distance < LEA_SEARCH_THRESHOLD ) { if ( NONDEBUG_INSN_P ( prev ) && NONJUMP_INSN_P ( prev ) ) { distance = increase_distance ( prev , next , distance ) ; if ( insn_defines_reg ( regno1 , regno2 , prev ) ) { if ( recog_memoized ( prev ) < <NUM_LIT> || get_attr_type ( prev ) != TYPE_LEA ) { * found = true ; return distance ; } }


<s> if ( NONDEBUG_INSN_P ( prev ) && NONJUMP_INSN_P ( prev ) ) { distance = increase_distance ( prev , next , distance ) ; if ( insn_defines_reg ( regno1 , regno2 , prev ) ) { if ( recog_memoized ( prev ) < <NUM_LIT> || get_attr_type ( prev ) != TYPE_LEA ) { * found = true ; return distance ; } } next = prev ;


<s> static inline bool equal ( tree_map * a , tree_map * b ) {

return a -> base . from == b -> base . from ;


<s> enum x86_64_reg_class regclass [ MAX_CLASSES ] ; int n = classify_argument ( mode , type , regclass , <NUM_LIT> ) ; * int_nregs = <NUM_LIT> ; * sse_nregs = <NUM_LIT> ; if ( ! n ) return true ; for ( n -- ; n >= <NUM_LIT> ; n -- ) switch ( regclass [ n ] ) { case X86_64_INTEGER_CLASS : case X86_64_INTEGERSI_CLASS : ( * int_nregs ) ++ ; break ; case X86_64_SSE_CLASS :


<s> static bool extract_base_offset_in_addr ( rtx mem , rtx * base , rtx * offset ) { rtx addr ; gcc_assert ( MEM_P ( mem ) ) ; addr = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == CONST ) addr = XEXP ( addr , <NUM_LIT> ) ; if ( REG_P ( addr ) || GET_CODE ( addr ) == SYMBOL_REF ) { * base = addr ; * offset = const0_rtx ; return true ;


<s> return true ; } if ( GET_CODE ( addr ) == PLUS && ( REG_P ( XEXP ( addr , <NUM_LIT> ) ) || GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == SYMBOL_REF ) && CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) ) {


<s> if ( ix86_function_regparm ( TREE_TYPE ( decl ) , decl ) <= <NUM_LIT> ) { unsigned int ccvt = ix86_get_callcvt ( TREE_TYPE ( decl ) ) ;

if ( ( ccvt & ( IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL ) ) == <NUM_LIT> ) return CX_REG ;


<s> if ( argtype == error_mark_node || VOID_TYPE_P ( argtype ) ) break ; if ( TYPE_EMPTY_P ( argtype ) ) seen_empty_type = true ; else if ( seen_empty_type ) {


<s> if ( NONDEBUG_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER ) { insn_count ++ ; if ( insn_count >= <NUM_LIT> ) return insn_count ; }


<s> if ( insn == NULL || ! can_throw_internal ( insn ) ) continue ;

for ( next = NEXT_INSN ( insn ) ; next != NULL ; next = NEXT_INSN ( next ) ) if ( NOTE_P ( next ) && NOTE_KIND ( next ) == NOTE_INSN_VAR_LOCATION ) insn = next ;


<s> rtx * x = & addr ; while ( GET_CODE ( * x ) == PLUS ) { int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { rtx u = XEXP ( * x , i ) ; if ( GET_CODE ( u ) == ZERO_EXTEND ) u = XEXP ( u , <NUM_LIT> ) ; if ( GET_CODE ( u ) == UNSPEC && XINT ( u , <NUM_LIT> ) == UNSPEC_TP ) { addr_space_t as = DEFAULT_TLS_SEG_REG ; * x = XEXP ( * x , <NUM_LIT> - i ) ; * loc = replace_equiv_address_nv ( * loc , addr , true ) ; set_mem_addr_space ( * loc , as ) ; return ; } } x = & XEXP ( * x , <NUM_LIT> ) ;


<s> return true ; case UNSPEC_TPOFF : if ( ! TARGET_64BIT ) return true ; break ; default : break ;


<s> gimple * def = SSA_NAME_DEF_STMT ( op ) ; tree tem ; if ( is_gimple_assign ( def ) && CONVERT_EXPR_CODE_P ( gimple_assign_rhs_code ( def ) ) && ( ( tem = gimple_assign_rhs1 ( def ) ) , true ) && TREE_CODE ( tem ) == SSA_NAME && tree_nop_conversion_p ( TREE_TYPE ( gimple_assign_lhs ( def ) ) , TREE_TYPE ( tem ) ) ) def = SSA_NAME_DEF_STMT ( tem ) ;

if ( ! is_gimple_assign ( def ) || ( ! gimple_assign_load_p ( def ) && ( gimple_assign_rhs_code ( def ) != BIT_FIELD_REF || ! VECTOR_TYPE_P ( TREE_TYPE ( TREE_OPERAND ( gimple_assign_rhs1 ( def ) , <NUM_LIT> ) ) ) ) ) ) stmt_cost += ix86_cost -> sse_to_integer ;


<s> if ( fs . sp_realigned && cfa_offset > fs . sp_realigned_fp_last ) { gcc_assert ( cfa_offset >= fs . sp_realigned_offset ) ; return false ; }


<s> case E_V8HFmode : case E_V4SFmode : case E_V2DFmode : if ( ! type || ! AGGREGATE_TYPE_P ( type ) ) { if ( cum -> sse_nregs ) return gen_reg_or_parallel ( mode , orig_mode , cum -> sse_regno + FIRST_SSE_REG ) ; } break ; case E_OImode : case E_XImode : gcc_unreachable ( ) ; case E_V64QImode : case E_V32HImode : case E_V16SImode : case E_V8DImode : case E_V32HFmode : case E_V16SFmode : case E_V8DFmode : case E_V16HFmode : case E_V8SFmode : case E_V8SImode : case E_V32QImode : case E_V16HImode : case E_V4DFmode : case E_V4DImode : if ( ! type || ! AGGREGATE_TYPE_P ( type ) ) { if ( cum -> sse_nregs ) return gen_reg_or_parallel ( mode , orig_mode , cum -> sse_regno + FIRST_SSE_REG ) ; } break ; case E_V8QImode : case E_V4HImode : case E_V4HFmode : case E_V2SImode : case E_V2SFmode : case E_V1TImode : case E_V1DImode : if ( ! type || ! AGGREGATE_TYPE_P ( type ) ) { if ( cum -> mmx_nregs ) return gen_reg_or_parallel ( mode , orig_mode , cum -> mmx_regno + FIRST_MMX_REG ) ; } break ; } if ( error_p ) {


<s> cum -> nregs -= int_nregs ; cum -> sse_nregs -= sse_nregs ; cum -> regno += int_nregs ; cum -> sse_regno += sse_nregs ; return int_nregs ; } else { int align = ix86_function_arg_boundary ( mode , type ) / BITS_PER_WORD ;

cum -> words = ROUND_UP ( cum -> words , align ) ;


<s> static int function_arg_advance_ms_64 ( CUMULATIVE_ARGS * cum , HOST_WIDE_INT bytes , HOST_WIDE_INT words ) { gcc_assert ( bytes == <NUM_LIT> || bytes == <NUM_LIT> || bytes == <NUM_LIT> || bytes == <NUM_LIT> ) ; cum -> words += words ; if ( cum -> nregs > <NUM_LIT> ) {


<s> t2 = gen_rtx_EXPR_LIST ( VOIDmode , t2 , const0_rtx ) ; return gen_rtx_PARALLEL ( mode , gen_rtvec ( <NUM_LIT> , t1 , t2 ) ) ; } } if ( orig_mode == BLKmode ) { if ( bytes > <NUM_LIT> && bytes <= <NUM_LIT> ) mode = ( bytes > <NUM_LIT> ? DImode : SImode ) ; if ( mode == BLKmode ) mode = DImode ; }

return gen_reg_or_parallel ( mode , orig_mode , regno ) ;


<s> if ( mode == VOIDmode ) return GEN_INT ( - <NUM_LIT> ) ; if ( cum -> nregs == <NUM_LIT> ) return NULL_RTX ; regno = x86_64_ms_abi_int_parameter_registers [ cum -> regno ] ; if ( TARGET_SSE && ( mode == SFmode || mode == DFmode ) ) { if ( named ) { if ( type == NULL_TREE || ! AGGREGATE_TYPE_P ( type ) ) regno = cum -> regno + FIRST_SSE_REG ; } else { rtx t1 , t2 ;

t1 = gen_rtx_REG ( mode , cum -> regno + FIRST_SSE_REG ) ;


<s> if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) regno = FIRST_MMX_REG ; else if ( mode == TImode || ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) ) regno = FIRST_SSE_REG ; else if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) regno = FIRST_SSE_REG ; else if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) regno = FIRST_SSE_REG ; else if ( X87_FLOAT_MODE_P ( mode ) && TARGET_FLOAT_RETURNS_IN_80387 ) regno = FIRST_FLOAT_REG ; else regno = AX_REG ; if ( mode == HFmode ) regno = FIRST_SSE_REG ; if ( mode == HCmode ) { rtx ret = gen_rtx_PARALLEL ( mode , rtvec_alloc ( <NUM_LIT> ) ) ; XVECEXP ( ret , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( SImode , FIRST_SSE_REG ) , GEN_INT ( <NUM_LIT> ) ) ; return ret ; } if ( ( fn || fntype ) && ( mode == SFmode || mode == DFmode ) ) {

int sse_level = ix86_function_sseregparm ( fntype , fn , false ) ;


<s> unsigned int regno ; switch ( mode ) { case E_HFmode : case E_HCmode : case E_SFmode : case E_SCmode : case E_DFmode : case E_DCmode : case E_TFmode : case E_SDmode : case E_DDmode : case E_TDmode : regno = FIRST_SSE_REG ; break ; case E_XFmode : case E_XCmode :


<s> static rtx function_value_ms_32 ( machine_mode orig_mode , machine_mode mode , const_tree fntype , const_tree fn , const_tree valtype ) { unsigned int regno ;

if ( X87_FLOAT_MODE_P ( mode ) && TARGET_FLOAT_RETURNS_IN_80387 && ( GET_MODE_SIZE ( mode ) > <NUM_LIT> || valtype == NULL_TREE || ! AGGREGATE_TYPE_P ( valtype ) ) ) {


<s> if ( TARGET_SSE ) { switch ( GET_MODE_SIZE ( mode ) ) { case <NUM_LIT> : if ( valtype != NULL_TREE && ! VECTOR_INTEGER_TYPE_P ( valtype ) && ! VECTOR_INTEGER_TYPE_P ( valtype ) && ! INTEGRAL_TYPE_P ( valtype ) && ! VECTOR_FLOAT_TYPE_P ( valtype ) ) break ; if ( ( SCALAR_INT_MODE_P ( mode ) || VECTOR_MODE_P ( mode ) ) && ! COMPLEX_MODE_P ( mode ) ) regno = FIRST_SSE_REG ;


<s> gcc_assert ( insn_operand_matches ( icode , <NUM_LIT> , x ) ) ; gcc_assert ( insn_operand_matches ( icode , <NUM_LIT> , y ) ) ; return GEN_FCN ( icode ) ( x , x , y ) ;


<s> gcc_assert ( insn_operand_matches ( icode , <NUM_LIT> , y ) ) ; return GEN_FCN ( icode ) ( x , x , y ) ;


<s> return gen_frame_set ( reg , frame_reg , offset , false ) ;


<s> static inline rtx gen_frame_load ( rtx reg , rtx frame_reg , int offset ) { return gen_frame_set ( reg , frame_reg , offset , false ) ;


<s> static rtx gen_frame_set ( rtx reg , rtx frame_reg , int offset , bool store ) { rtx addr , mem ; if ( offset ) addr = plus_constant ( Pmode , frame_reg , offset ) ;

mem = gen_frame_mem ( GET_MODE ( reg ) , offset ? addr : frame_reg ) ;


<s> rtx gen_pop ( rtx arg ) { if ( REG_P ( arg ) && GET_MODE ( arg ) != word_mode ) arg = gen_rtx_REG ( word_mode , REGNO ( arg ) ) ;

return gen_rtx_SET ( arg , gen_rtx_MEM ( word_mode , gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ) ) ;


<s> if ( m -> fs . cfa_reg == stack_pointer_rtx ) m -> fs . cfa_offset += UNITS_PER_WORD ; m -> fs . sp_offset += UNITS_PER_WORD ; if ( REG_P ( arg ) && GET_MODE ( arg ) != word_mode ) arg = gen_rtx_REG ( word_mode , REGNO ( arg ) ) ; return gen_rtx_SET ( gen_rtx_MEM ( word_mode , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) , arg ) ;


<s> if ( REG_P ( arg ) && GET_MODE ( arg ) != word_mode ) arg = gen_rtx_REG ( word_mode , REGNO ( arg ) ) ; return gen_rtx_SET ( gen_rtx_MEM ( word_mode , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) , arg ) ;


<s> tmp = gen_rtx_EXPR_LIST ( VOIDmode , tmp , const0_rtx ) ; tmp = gen_rtx_PARALLEL ( orig_mode , gen_rtvec ( <NUM_LIT> , tmp ) ) ; }


<s> const char * prefix ; size_t namelen , prefixlen ; char * imp_name ; tree to ; rtx rtl ; if ( ! dllimport_map ) dllimport_map = hash_table < dllimport_hasher > :: create_ggc ( <NUM_LIT> ) ; in . hash = htab_hash_pointer ( decl ) ; in . base . from = decl ; tree_map * * loc = dllimport_map -> find_slot_with_hash ( & in , in . hash , INSERT ) ; h = * loc ; if ( h ) return h -> to ; * loc = h = ggc_alloc < tree_map > ( ) ; h -> hash = in . hash ; h -> base . from = decl ; h -> to = to = build_decl ( DECL_SOURCE_LOCATION ( decl ) , VAR_DECL , NULL , ptr_type_node ) ; DECL_ARTIFICIAL ( to ) = <NUM_LIT> ; DECL_IGNORED_P ( to ) = <NUM_LIT> ; DECL_EXTERNAL ( to ) = <NUM_LIT> ; TREE_READONLY ( to ) = <NUM_LIT> ;

name = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ;


<s> name = targetm . strip_name_encoding ( name ) ; if ( beimport ) prefix = name [ <NUM_LIT> ] == FASTCALL_PREFIX || user_label_prefix [ <NUM_LIT> ] == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ; else prefix = user_label_prefix [ <NUM_LIT> ] == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ; namelen = strlen ( name ) ; prefixlen = strlen ( prefix ) ; imp_name = ( char * ) alloca ( namelen + prefixlen + <NUM_LIT> ) ; memcpy ( imp_name , prefix , prefixlen ) ; memcpy ( imp_name + prefixlen , name , namelen + <NUM_LIT> ) ; name = ggc_alloc_string ( imp_name , namelen + prefixlen ) ; rtl = gen_rtx_SYMBOL_REF ( Pmode , name ) ; SET_SYMBOL_REF_DECL ( rtl , to ) ; SYMBOL_REF_FLAGS ( rtl ) = SYMBOL_FLAG_LOCAL | SYMBOL_FLAG_STUBVAR ; if ( ! beimport ) { SYMBOL_REF_FLAGS ( rtl ) |= SYMBOL_FLAG_EXTERNAL ;


<s> static void get_pc_thunk_name ( char name [ <NUM_LIT> ] , unsigned int regno ) { gcc_assert ( ! TARGET_64BIT ) ; if ( USE_HIDDEN_LINKONCE ) sprintf ( name , <STR_LIT> , reg_names [ regno ] ) ;

else ASM_GENERATE_INTERNAL_LABEL ( name , <STR_LIT> , regno ) ;


<s> static HOST_WIDE_INT get_probe_interval ( void ) {