<s> type = TREE_TYPE ( type ) ; decl_or_type = type ; } a = ix86_function_value ( TREE_TYPE ( exp ) , decl_or_type , false ) ; b = ix86_function_value ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) , cfun -> decl , false ) ; if ( STACK_REG_P ( a ) || STACK_REG_P ( b ) ) { if ( ! rtx_equal_p ( a , b ) ) return false ; } else if ( VOID_TYPE_P ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) ) ) ; else if ( ! rtx_equal_p ( a , b ) ) return false ; if ( TARGET_64BIT ) { if ( cfun -> machine -> call_abi == MS_ABI && ix86_function_type_abi ( type ) == SYSV_ABI ) return false ; } else { if ( ! decl || ( TARGET_DLLIMPORT_DECL_ATTRIBUTES && DECL_DLLIMPORT_P ( decl ) ) ) { if ( ix86_function_regparm ( type , NULL ) >= <NUM_LIT> ) { return false ;


<s> else if ( ( ccvt & IX86_CALLCVT_THISCALL ) != <NUM_LIT> ) return <NUM_LIT> ; if ( decl && TREE_CODE ( decl ) == FUNCTION_DECL ) { cgraph_node * target = cgraph_node :: get ( decl ) ; if ( target ) target = target -> function_symbol ( ) ; if ( target && opt_for_fn ( target -> decl , optimize ) && ! ( profile_flag && ! flag_fentry ) ) { cgraph_local_info * i = & target -> local ; if ( i && i -> local && i -> can_change_signature ) { int local_regparm , globals = <NUM_LIT> , regno ; for ( local_regparm = <NUM_LIT> ; local_regparm < REGPARM_MAX ; local_regparm ++ ) if ( fixed_regs [ local_regparm ] ) break ; if ( local_regparm == <NUM_LIT> && DECL_STATIC_CHAIN ( target -> decl ) ) local_regparm = <NUM_LIT> ; if ( local_regparm == <NUM_LIT> && flag_split_stack ) local_regparm = <NUM_LIT> ;

for ( regno = AX_REG ; regno <= DI_REG ; regno ++ ) if ( fixed_regs [ regno ] ) globals ++ ;


<s> ptr -> x_ix86_cmodel = CM_SMALL_PIC ; break ; case CM_MEDIUM : ptr -> x_ix86_cmodel = CM_MEDIUM_PIC ; break ; case CM_LARGE : ptr -> x_ix86_cmodel = CM_LARGE_PIC ; break ; case CM_KERNEL : error ( <STR_LIT> , <STR_LIT> ) ; break ; default : break ; } else switch ( ptr -> x_ix86_cmodel ) { case CM_SMALL_PIC : ptr -> x_ix86_cmodel = CM_SMALL ; break ; case CM_MEDIUM_PIC : ptr -> x_ix86_cmodel = CM_MEDIUM ; break ; case CM_LARGE_PIC :


<s> case CM_MEDIUM : ptr -> x_ix86_cmodel = CM_MEDIUM_PIC ; break ; case CM_LARGE : ptr -> x_ix86_cmodel = CM_LARGE_PIC ; break ; case CM_KERNEL : error ( <STR_LIT> , <STR_LIT> ) ; break ; default : break ; } else switch ( ptr -> x_ix86_cmodel ) { case CM_SMALL_PIC : ptr -> x_ix86_cmodel = CM_SMALL ; break ; case CM_MEDIUM_PIC : ptr -> x_ix86_cmodel = CM_MEDIUM ; break ; case CM_LARGE_PIC :


<s> fprintf ( file , <STR_LIT> , indent , <STR_LIT> , ptr -> tune , processor_target_table [ ptr -> tune ] . name ) ; fprintf ( file , <STR_LIT> , indent , <STR_LIT> , ptr -> branch_cost ) ; if ( target_string ) { fprintf ( file , <STR_LIT> , indent , <STR_LIT> , target_string ) ; free ( target_string ) ; }


<s> gcc_assert ( ptr -> arch < PROCESSOR_max ) ; fprintf ( file , <STR_LIT> , indent , <STR_LIT> , ptr -> arch , processor_target_table [ ptr -> arch ] . name ) ; gcc_assert ( ptr -> tune < PROCESSOR_max ) ; fprintf ( file , <STR_LIT> , indent , <STR_LIT> , ptr -> tune , processor_target_table [ ptr -> tune ] . name ) ; fprintf ( file , <STR_LIT> , indent , <STR_LIT> , ptr -> branch_cost ) ;


<s> 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 ; opts -> x_ix86_sse2avx = ptr -> x_ix86_sse2avx ; opts -> x_ix86_stack_protector_guard = ptr -> x_ix86_stack_protector_guard ; opts -> x_ix86_stringop_alg = ptr -> x_ix86_stringop_alg ; opts -> x_ix86_tls_dialect = ptr -> x_ix86_tls_dialect ; opts -> x_ix86_tune_ctrl_string = ptr -> x_ix86_tune_ctrl_string ; opts -> x_ix86_tune_memcpy_strategy = ptr -> x_ix86_tune_memcpy_strategy ; opts -> x_ix86_tune_memset_strategy = ptr -> x_ix86_tune_memset_strategy ; opts -> x_ix86_tune_no_default = ptr -> x_ix86_tune_no_default ; opts -> x_ix86_veclibabi_type = ptr -> x_ix86_veclibabi_type ; ix86_tune_cost = processor_target_table [ ix86_tune ] . cost ; if ( opts -> x_optimize_size ) ix86_cost = & ix86_size_cost ; else ix86_cost = ix86_tune_cost ; if ( old_arch != ix86_arch ) {


<s> ptr -> x_ix86_tune_string = opts -> x_ix86_tune_string ; ptr -> x_ix86_cmodel = opts -> x_ix86_cmodel ; ptr -> x_ix86_abi = opts -> x_ix86_abi ; ptr -> x_ix86_asm_dialect = opts -> x_ix86_asm_dialect ; ptr -> x_ix86_branch_cost = opts -> x_ix86_branch_cost ; ptr -> x_ix86_dump_tunes = opts -> x_ix86_dump_tunes ; ptr -> x_ix86_force_align_arg_pointer = opts -> x_ix86_force_align_arg_pointer ; ptr -> x_ix86_force_drap = opts -> x_ix86_force_drap ; ptr -> x_ix86_incoming_stack_boundary_arg = opts -> x_ix86_incoming_stack_boundary_arg ; ptr -> x_ix86_pmode = opts -> x_ix86_pmode ; ptr -> x_ix86_preferred_stack_boundary_arg = opts -> x_ix86_preferred_stack_boundary_arg ; ptr -> x_ix86_recip_name = opts -> x_ix86_recip_name ; ptr -> x_ix86_regparm = opts -> x_ix86_regparm ; ptr -> x_ix86_section_threshold = opts -> x_ix86_section_threshold ; ptr -> x_ix86_sse2avx = opts -> x_ix86_sse2avx ; ptr -> x_ix86_stack_protector_guard = opts -> x_ix86_stack_protector_guard ; ptr -> x_ix86_stringop_alg = opts -> x_ix86_stringop_alg ; ptr -> x_ix86_tls_dialect = opts -> x_ix86_tls_dialect ; ptr -> x_ix86_tune_ctrl_string = opts -> x_ix86_tune_ctrl_string ; ptr -> x_ix86_tune_memcpy_strategy = opts -> x_ix86_tune_memcpy_strategy ; ptr -> x_ix86_tune_memset_strategy = opts -> x_ix86_tune_memset_strategy ; ptr -> x_ix86_tune_no_default = opts -> x_ix86_tune_no_default ; ptr -> x_ix86_veclibabi_type = opts -> x_ix86_veclibabi_type ; gcc_assert ( ptr -> arch == ix86_arch ) ; gcc_assert ( ptr -> schedule == ix86_schedule ) ; gcc_assert ( ptr -> tune == ix86_tune ) ; gcc_assert ( ptr -> branch_cost == ix86_branch_cost ) ;


<s> ptr -> x_ix86_abi = opts -> x_ix86_abi ; ptr -> x_ix86_asm_dialect = opts -> x_ix86_asm_dialect ; ptr -> x_ix86_branch_cost = opts -> x_ix86_branch_cost ; ptr -> x_ix86_dump_tunes = opts -> x_ix86_dump_tunes ; ptr -> x_ix86_force_align_arg_pointer = opts -> x_ix86_force_align_arg_pointer ; ptr -> x_ix86_force_drap = opts -> x_ix86_force_drap ; ptr -> x_ix86_incoming_stack_boundary_arg = opts -> x_ix86_incoming_stack_boundary_arg ; ptr -> x_ix86_pmode = opts -> x_ix86_pmode ; ptr -> x_ix86_preferred_stack_boundary_arg = opts -> x_ix86_preferred_stack_boundary_arg ; ptr -> x_ix86_recip_name = opts -> x_ix86_recip_name ; ptr -> x_ix86_regparm = opts -> x_ix86_regparm ; ptr -> x_ix86_section_threshold = opts -> x_ix86_section_threshold ; ptr -> x_ix86_sse2avx = opts -> x_ix86_sse2avx ; ptr -> x_ix86_stack_protector_guard = opts -> x_ix86_stack_protector_guard ; ptr -> x_ix86_stringop_alg = opts -> x_ix86_stringop_alg ; ptr -> x_ix86_tls_dialect = opts -> x_ix86_tls_dialect ; ptr -> x_ix86_tune_ctrl_string = opts -> x_ix86_tune_ctrl_string ; ptr -> x_ix86_tune_memcpy_strategy = opts -> x_ix86_tune_memcpy_strategy ; ptr -> x_ix86_tune_memset_strategy = opts -> x_ix86_tune_memset_strategy ; ptr -> x_ix86_tune_no_default = opts -> x_ix86_tune_no_default ;

ptr -> x_ix86_veclibabi_type = opts -> x_ix86_veclibabi_type ;


<s> if ( warn ) { if ( decl ) error ( <STR_LIT> <STR_LIT> , decl ) ; else error ( <STR_LIT> <STR_LIT> , type ) ; } return <NUM_LIT> ; } return <NUM_LIT> ; } if ( ! decl ) return <NUM_LIT> ; cgraph_node * target = cgraph_node :: get ( decl ) ; if ( target ) target = target -> function_symbol ( ) ; if ( target && ( target_opts_for_fn ( target -> decl ) -> x_ix86_fpmath & FPMATH_SSE ) && opt_for_fn ( target -> decl , optimize ) && ! ( profile_flag && ! flag_fentry ) ) { cgraph_local_info * i = & target -> local ; if ( i && i -> local && i -> can_change_signature ) { if ( ! TARGET_SSE && warn ) { error ( <STR_LIT> <STR_LIT> , decl ) ; return <NUM_LIT> ; } return TARGET_SSE2_P ( target_opts_for_fn ( target -> decl ) -> x_ix86_isa_flags ) ? <NUM_LIT> : <NUM_LIT> ;


<s> else error ( <STR_LIT> <STR_LIT> , type ) ; } return <NUM_LIT> ; } return <NUM_LIT> ; } if ( ! decl ) return <NUM_LIT> ; cgraph_node * target = cgraph_node :: get ( decl ) ; if ( target ) target = target -> function_symbol ( ) ; if ( target && ( target_opts_for_fn ( target -> decl ) -> x_ix86_fpmath & FPMATH_SSE ) && opt_for_fn ( target -> decl , optimize ) && ! ( profile_flag && ! flag_fentry ) ) { cgraph_local_info * i = & target -> local ; if ( i && i -> local && i -> can_change_signature ) { if ( ! TARGET_SSE && warn ) { error ( <STR_LIT> <STR_LIT> , decl ) ; return <NUM_LIT> ; }

return TARGET_SSE2_P ( target_opts_for_fn ( target -> decl ) -> x_ix86_isa_flags ) ? <NUM_LIT> : <NUM_LIT> ;


<s> if ( ! warned ) { error ( <STR_LIT> ) ; warned = true ; } } abi = MS_ABI ; } } else if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) abi = SYSV_ABI ;


<s> enum calling_abi abi = ix86_abi ; if ( abi == SYSV_ABI ) { if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) { if ( TARGET_X32 ) { static bool warned = false ; if ( ! warned ) { error ( <STR_LIT> ) ; warned = true ; } }


<s> const_tree fn , fntype ; fn = NULL_TREE ; if ( fntype_or_decl && DECL_P ( fntype_or_decl ) ) fn = fntype_or_decl ; fntype = fn ? TREE_TYPE ( fn ) : fntype_or_decl ; if ( ( valtype && POINTER_BOUNDS_TYPE_P ( valtype ) ) || POINTER_BOUNDS_MODE_P ( mode ) ) return gen_rtx_REG ( BNDmode , FIRST_BND_REG ) ; else if ( TARGET_64BIT && ix86_function_type_abi ( fntype ) == MS_ABI ) return function_value_ms_64 ( orig_mode , mode , valtype ) ; else if ( TARGET_64BIT ) return function_value_64 ( orig_mode , mode , valtype ) ;

else return function_value_32 ( orig_mode , mode , fntype , fn ) ;


<s> if ( TARGET_64BIT && ix86_abi == MS_ABI ) return false ; return TARGET_FLOAT_RETURNS_IN_80387 ; case XMM0_REG : case XMM1_REG : return TARGET_SSE ; case MM0_REG : if ( TARGET_MACHO || TARGET_64BIT ) return false ; return TARGET_MMX ;


<s> 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> ) ;


<s> } else if ( MEM_P ( slot ) ) { addr = XEXP ( slot , <NUM_LIT> ) ; if ( ! register_operand ( addr , Pmode ) ) addr = copy_addr_to_reg ( addr ) ; } else gcc_unreachable ( ) ;


<s> if ( target_tree == NULL ) target_tree = target_option_default_node ; opts = TREE_TARGET_OPTION ( target_tree ) ; if ( ix86_builtins_isa [ ( int ) code ] . isa & opts -> x_ix86_isa_flags ) return ix86_builtin_decl ( code , true ) ; else return NULL_TREE ;


<s> crtl -> drap_reg = arg_ptr ; start_sequence ( ) ; drap_vreg = copy_to_reg ( arg_ptr ) ; seq = get_insns ( ) ; end_sequence ( ) ; insn = emit_insn_before ( seq , NEXT_INSN ( entry_of_function ( ) ) ) ; if ( ! optimize ) { add_reg_note ( insn , REG_CFA_SET_VDRAP , drap_vreg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> tree fn = ( tree ) decl ; struct cgraph_node * node = NULL ; struct cgraph_node * default_node = NULL ; struct cgraph_function_version_info * node_v = NULL ; struct cgraph_function_version_info * first_v = NULL ; tree dispatch_decl = NULL ; struct cgraph_function_version_info * default_version_info = NULL ; gcc_assert ( fn != NULL && DECL_FUNCTION_VERSIONED ( fn ) ) ; node = cgraph_node :: get ( fn ) ; gcc_assert ( node != NULL ) ; node_v = node -> function_version ( ) ; gcc_assert ( node_v != NULL ) ; if ( node_v -> dispatcher_resolver != NULL ) return node_v -> dispatcher_resolver ; first_v = node_v ; while ( first_v -> prev != NULL ) first_v = first_v -> prev ; default_version_info = first_v ; while ( default_version_info != NULL ) { if ( is_function_default_version ( default_version_info -> this_node -> decl ) ) break ; default_version_info = default_version_info -> next ; } if ( default_version_info == NULL ) return NULL ; if ( first_v != default_version_info ) { default_version_info -> prev -> next = default_version_info -> next ; if ( default_version_info -> next ) default_version_info -> next -> prev = default_version_info -> prev ; first_v -> prev = default_version_info ; default_version_info -> next = first_v ; default_version_info -> prev = NULL ; } default_node = default_version_info -> this_node ; if ( targetm . has_ifunc_p ( ) ) { struct cgraph_function_version_info * it_v = NULL ; struct cgraph_node * dispatcher_node = NULL ; struct cgraph_function_version_info * dispatcher_version_info = NULL ; dispatch_decl = make_dispatcher_decl ( default_node -> decl ) ;


<s> static alias_set_type ix86_GOT_alias_set ( void ) { static alias_set_type set = - <NUM_LIT> ; if ( set == - <NUM_LIT> ) set = new_alias_set ( ) ;


<s> static alias_set_type ix86_GOT_alias_set ( void ) {

static alias_set_type set = - <NUM_LIT> ;


<s> if ( TREE_CODE ( * node ) != FUNCTION_TYPE && TREE_CODE ( * node ) != METHOD_TYPE && TREE_CODE ( * node ) != FIELD_DECL && TREE_CODE ( * node ) != TYPE_DECL ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; return NULL_TREE ;


<s> warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; return NULL_TREE ; } if ( is_attribute_p ( <STR_LIT> , name ) ) { if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * node ) ) ) { error ( <STR_LIT> ) ; } return NULL_TREE ; } else if ( is_attribute_p ( <STR_LIT> , name ) ) { if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * node ) ) ) { error ( <STR_LIT> ) ;


<s> static tree ix86_handle_fndecl_attribute ( tree * node , tree name , tree , int , bool * no_add_attrs ) { if ( TREE_CODE ( * node ) != FUNCTION_DECL ) {

warning ( OPT_Wattributes , <STR_LIT> , name ) ;


<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 ; else if ( VALID_DFP_MODE_P ( mode ) ) return true ; else if ( VALID_MMX_REG_MODE_3DNOW ( mode ) || VALID_MMX_REG_MODE ( mode ) ) return true ; return false ;


<s> enum attr_i387_cw mode ; if ( CALL_P ( insn ) || ( NONJUMP_INSN_P ( insn ) && ( asm_noperands ( PATTERN ( insn ) ) >= <NUM_LIT> || GET_CODE ( PATTERN ( insn ) ) == ASM_INPUT ) ) ) return I387_CW_UNINITIALIZED ; if ( recog_memoized ( insn ) < <NUM_LIT> ) return I387_CW_ANY ; mode = get_attr_i387_cw ( insn ) ; switch ( entity ) { 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 ; case I387_MASK_PM : if ( mode == I387_CW_MASK_PM ) return mode ; break ; default : gcc_unreachable ( ) ;


<s> enum attr_i387_cw mode ; if ( CALL_P ( insn ) || ( NONJUMP_INSN_P ( insn ) && ( asm_noperands ( PATTERN ( insn ) ) >= <NUM_LIT> || GET_CODE ( PATTERN ( insn ) ) == ASM_INPUT ) ) ) return I387_CW_UNINITIALIZED ; if ( recog_memoized ( insn ) < <NUM_LIT> ) return I387_CW_ANY ; mode = get_attr_i387_cw ( insn ) ; switch ( entity ) { case I387_TRUNC :

if ( mode == I387_CW_TRUNC ) return mode ;


<s> modify = build2 ( MODIFY_EXPR , TREE_TYPE ( lhs ) , lhs , lb ) ; append_to_statement_list ( modify , stmts ) ; lhs = build1 ( INDIRECT_REF , pointer_sized_int_node , build2 ( POINTER_PLUS_EXPR , bnd_ptr , var_p , TYPE_SIZE_UNIT ( pointer_sized_int_node ) ) ) ;

modify = build2 ( MODIFY_EXPR , TREE_TYPE ( lhs ) , lhs , ub ) ;


ix86_builtins [ ( int ) IX86_BUILTIN_FABSQ ] = t ;


<s> cost [ vect_prologue ] = cost [ vect_body ] = cost [ vect_epilogue ] = <NUM_LIT> ;


<s> unsigned * cost = XNEWVEC ( unsigned , <NUM_LIT> ) ; cost [ vect_prologue ] = cost [ vect_body ] = cost [ vect_epilogue ] = <NUM_LIT> ; return cost ;


<s> tmp_reg = gen_rtx_REG ( Pmode , tmp_regno ) ; gcc_assert ( REGNO ( pic_offset_table_rtx ) != tmp_regno ) ; emit_insn ( gen_set_rip_rex64 ( pic_offset_table_rtx , label ) ) ; emit_insn ( gen_set_got_offset_rex64 ( tmp_reg , label ) ) ;


<s> f -> use_fast_prologue_epilogue_nregs = - <NUM_LIT> ; f -> call_abi = ix86_abi ; return f ;


<s> static struct machine_function * ix86_init_machine_status ( void ) { struct machine_function * f ; f = ggc_cleared_alloc < machine_function > ( ) ;

f -> use_fast_prologue_epilogue_nregs = - <NUM_LIT> ;


<s> for ( i = <NUM_LIT> , d = bdesc_mpx_const ; i < ARRAY_SIZE ( bdesc_mpx_const ) ; i ++ , d ++ ) { if ( d -> name == <NUM_LIT> ) continue ; ftype = ( enum ix86_builtin_func_type ) d -> flag ; decl = def_builtin_const ( d -> mask , d -> name , ftype , d -> code ) ; if ( decl ) { DECL_ATTRIBUTES ( decl ) = build_tree_list ( get_identifier ( <STR_LIT> ) , NULL_TREE ) ; TREE_NOTHROW ( decl ) = <NUM_LIT> ; } else { ix86_builtins_isa [ ( int ) d -> code ] . leaf_p = true ; ix86_builtins_isa [ ( int ) d -> code ] . nothrow_p = true ; } }


<s> } else { rtx reg = crtl -> profile ? gen_rtx_REG ( Pmode , REAL_PIC_OFFSET_TABLE_REGNUM ) : pic_offset_table_rtx ; rtx insn = emit_insn ( gen_set_got ( reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;

if ( crtl -> profile ) emit_move_insn ( pic_offset_table_rtx , reg ) ;


<s> if ( TARGET_64BIT ) { if ( ix86_cmodel == CM_LARGE_PIC ) ix86_init_large_pic_reg ( R11_REG ) ; else emit_insn ( gen_set_got_rex64 ( pic_offset_table_rtx ) ) ; } else { rtx reg = crtl -> profile ? gen_rtx_REG ( Pmode , REAL_PIC_OFFSET_TABLE_REGNUM ) : pic_offset_table_rtx ; rtx insn = emit_insn ( gen_set_got ( reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( crtl -> profile ) emit_move_insn ( pic_offset_table_rtx , reg ) ; add_reg_note ( insn , REG_CFA_FLUSH_QUEUE , NULL_RTX ) ;


<s> decl = builtin_decl_explicit ( BUILT_IN_TM_STORE_1 ) ; attrs_store = DECL_ATTRIBUTES ( decl ) ; attrs_type_store = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; decl = builtin_decl_explicit ( BUILT_IN_TM_LOG ) ; attrs_log = DECL_ATTRIBUTES ( decl ) ; attrs_type_log = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; for ( i = <NUM_LIT> , d = bdesc_tm ; i < ARRAY_SIZE ( bdesc_tm ) ; i ++ , d ++ ) {

if ( ( d -> mask & ix86_isa_flags ) != <NUM_LIT> || ( lang_hooks . builtin_function == lang_hooks . builtin_function_ext_scope ) ) {


<s> enum ix86_builtin_func_type ftype ; const struct builtin_description * d ; size_t i ; tree decl ; tree attrs_load , attrs_type_load , attrs_store , attrs_type_store ; tree attrs_log , attrs_type_log ; if ( ! flag_tm ) return ; if ( ! builtin_decl_explicit_p ( BUILT_IN_TM_LOAD_1 ) ) return ; decl = builtin_decl_explicit ( BUILT_IN_TM_LOAD_1 ) ; attrs_load = DECL_ATTRIBUTES ( decl ) ; attrs_type_load = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; decl = builtin_decl_explicit ( BUILT_IN_TM_STORE_1 ) ; attrs_store = DECL_ATTRIBUTES ( decl ) ; attrs_type_store = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; decl = builtin_decl_explicit ( BUILT_IN_TM_LOG ) ;


<s> if ( TREE_CODE ( exp ) == VAR_DECL && DECL_SECTION_NAME ( exp ) ) { const char * section = DECL_SECTION_NAME ( exp ) ; if ( strcmp ( section , <STR_LIT> ) == <NUM_LIT> || strcmp ( section , <STR_LIT> ) == <NUM_LIT> ) return true ;


<s> if ( TREE_CODE ( exp ) == VAR_DECL && ! is_global_var ( exp ) ) return false ; if ( TREE_CODE ( exp ) == VAR_DECL && DECL_SECTION_NAME ( exp ) ) { const char * section = DECL_SECTION_NAME ( exp ) ; if ( strcmp ( section , <STR_LIT> ) == <NUM_LIT> || strcmp ( section , <STR_LIT> ) == <NUM_LIT> ) return true ;


<s> return <NUM_LIT> ; case PROCESSOR_PENTIUMPRO : case PROCESSOR_ATHLON : case PROCESSOR_K8 : case PROCESSOR_AMDFAM10 : case PROCESSOR_GENERIC : case PROCESSOR_BTVER1 : return <NUM_LIT> ; case PROCESSOR_BDVER1 : case PROCESSOR_BDVER2 : case PROCESSOR_BDVER3 : case PROCESSOR_BDVER4 : case PROCESSOR_CORE2 : case PROCESSOR_NEHALEM : case PROCESSOR_SANDYBRIDGE : case PROCESSOR_HASWELL : return <NUM_LIT> ; default : return <NUM_LIT> ; }


<s> static bool ix86_lea_outperforms ( rtx_insn * insn , unsigned int regno0 , unsigned int regno1 , unsigned int regno2 , int split_cost , bool has_scale ) { int dist_define , dist_use ; if ( TARGET_SILVERMONT || TARGET_INTEL ) { 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 ) ; 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 ( ! ( REG_P ( op ) && HARD_REGISTER_P ( op ) ) ) continue ; op_alt = recog_op_alt ; win = ! n_alternatives ; alternative_mask preferred = get_preferred_alternatives ( insn ) ; for ( j = <NUM_LIT> ; j < n_alternatives ; j ++ , op_alt += n_operands ) { if ( ! TEST_BIT ( preferred , j ) ) continue ; if ( op_alt [ i ] . anything_ok || ( op_alt [ i ] . matches != - <NUM_LIT> && operands_match_p ( recog_data . operand [ i ] , recog_data . operand [ op_alt [ i ] . matches ] ) ) || reg_fits_class_p ( op , op_alt [ i ] . cl , offset , mode ) ) { win = true ; break ; } } if ( ! win ) return false ; } } return true ;


<s> if ( ( INSN_CODE ( insn ) = recog ( PATTERN ( insn ) , insn , <NUM_LIT> ) ) >= <NUM_LIT> ) { int i ; extract_insn ( insn ) ; preprocess_constraints ( insn ) ; int n_operands = recog_data . n_operands ; int n_alternatives = recog_data . n_alternatives ; for ( i = <NUM_LIT> ; i < n_operands ; i ++ ) { rtx op = recog_data . operand [ i ] ; machine_mode mode = GET_MODE ( op ) ; const operand_alternative * op_alt ; int offset = <NUM_LIT> ; bool win ; int j ; if ( ! TARGET_AVX && VECTOR_MODE_P ( GET_MODE ( op ) ) && misaligned_operand ( op , GET_MODE ( op ) ) ) { int min_align = get_attr_ssememalign ( insn ) ; if ( min_align == <NUM_LIT> ) return false ; } if ( UNARY_P ( op ) ) op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( op ) == SUBREG ) { if ( REG_P ( SUBREG_REG ( op ) ) && REGNO ( SUBREG_REG ( op ) ) < FIRST_PSEUDO_REGISTER ) offset = subreg_regno_offset ( REGNO ( SUBREG_REG ( op ) ) , GET_MODE ( SUBREG_REG ( op ) ) , SUBREG_BYTE ( op ) , GET_MODE ( op ) ) ; op = SUBREG_REG ( op ) ; } if ( ! ( REG_P ( op ) && HARD_REGISTER_P ( op ) ) ) continue ; op_alt = recog_op_alt ; win = ! n_alternatives ; alternative_mask preferred = get_preferred_alternatives ( insn ) ; for ( j = <NUM_LIT> ; j < n_alternatives ; j ++ , op_alt += n_operands ) { if ( ! TEST_BIT ( preferred , j ) ) continue ; if ( op_alt [ i ] . anything_ok || ( op_alt [ i ] . matches != - <NUM_LIT> && operands_match_p ( recog_data . operand [ i ] , recog_data . operand [ op_alt [ i ] . matches ] ) ) || reg_fits_class_p ( op , op_alt [ i ] . cl , offset , mode ) ) { win = true ; break ; } } if ( ! win ) return false ; } } return true ;


<s> } if ( TARGET_MACHO && darwin_local_data_pic ( x ) ) return true ; if ( GET_CODE ( x ) == UNSPEC ) switch ( XINT ( x , <NUM_LIT> ) ) { case UNSPEC_GOT : case UNSPEC_GOTOFF : case UNSPEC_PLTOFF : return TARGET_64BIT ; case UNSPEC_TPOFF : case UNSPEC_NTPOFF : x = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_EXEC ) ; case UNSPEC_DTPOFF : x = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_DYNAMIC ) ; default : return false ; } if ( GET_CODE ( x ) == LABEL_REF ) return true ; if ( GET_CODE ( x ) != SYMBOL_REF ) return false ; case SYMBOL_REF : if ( SYMBOL_REF_TLS_MODEL ( x ) ) return false ; if ( TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P ( x ) ) return false ; if ( MACHO_DYNAMIC_NO_PIC_P ) return machopic_symbol_defined_p ( x ) ; break ; case CONST_DOUBLE : if ( GET_MODE ( x ) == TImode && x != CONST0_RTX ( TImode ) && ! TARGET_64BIT ) return false ; break ; case CONST_VECTOR : if ( ! standard_sse_constant_p ( x ) ) return false ; default : break ; } return true ;


<s> rtx base , index ; bool something_reloaded = false ; base = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ! REG_OK_FOR_BASE_STRICT_P ( base ) ) { push_reload ( base , NULL_RTX , & XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , NULL , BASE_REG_CLASS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; something_reloaded = true ; } index = XEXP ( x , <NUM_LIT> ) ;

if ( ! REG_OK_FOR_INDEX_STRICT_P ( index ) ) {


<s> rtx addr ; addr = ix86_get_arg_address_for_bt ( slot , slot_no , arg_pointer_rtx ) ; if ( ! ptr ) { gcc_assert ( MEM_P ( slot ) ) ; ptr = copy_addr_to_reg ( slot ) ; } emit_insn ( BNDmode == BND64mode ? gen_bnd64_ldx ( reg , addr , ptr ) : gen_bnd32_ldx ( reg , addr , ptr ) ) ; return reg ;


<s> if ( ! TARGET_64BIT && align == <NUM_LIT> && ix86_preferred_stack_boundary < <NUM_LIT> && ( mode == DImode || ( type && TYPE_MODE ( type ) == DImode ) ) && ( ! type || ! TYPE_USER_ALIGN ( type ) ) && ( ! decl || ! DECL_USER_ALIGN ( decl ) ) ) align = <NUM_LIT> ; if ( ! type ) { if ( mode == XFmode && align < GET_MODE_ALIGNMENT ( DFmode ) ) align = GET_MODE_ALIGNMENT ( DFmode ) ; return align ; } if ( TARGET_64BIT && optimize_function_for_speed_p ( cfun ) && TARGET_SSE ) { if ( AGGREGATE_TYPE_P ( type ) && ( va_list_type_node == NULL_TREE || ( TYPE_MAIN_VARIANT ( type ) != TYPE_MAIN_VARIANT ( va_list_type_node ) ) ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: geu_p ( TYPE_SIZE ( type ) , <NUM_LIT> ) && align < <NUM_LIT> ) return <NUM_LIT> ; } if ( TREE_CODE ( type ) == ARRAY_TYPE ) { if ( TYPE_MODE ( TREE_TYPE ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; } else if ( TREE_CODE ( type ) == COMPLEX_TYPE ) { if ( TYPE_MODE ( type ) == DCmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ( TYPE_MODE ( type ) == XCmode || TYPE_MODE ( type ) == TCmode ) && align < <NUM_LIT> ) return <NUM_LIT> ; } else if ( ( TREE_CODE ( type ) == RECORD_TYPE || TREE_CODE ( type ) == UNION_TYPE || TREE_CODE ( type ) == QUAL_UNION_TYPE ) && TYPE_FIELDS ( type ) ) { if ( DECL_MODE ( TYPE_FIELDS ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ALIGN_MODE_128 ( DECL_MODE ( TYPE_FIELDS ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; } else if ( TREE_CODE ( type ) == REAL_TYPE || TREE_CODE ( type ) == VECTOR_TYPE || TREE_CODE ( type ) == INTEGER_TYPE ) { if ( TYPE_MODE ( type ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ;

if ( ALIGN_MODE_128 ( TYPE_MODE ( type ) ) && align < <NUM_LIT> ) return <NUM_LIT> ;


<s> if ( ! type ) { if ( mode == XFmode && align < GET_MODE_ALIGNMENT ( DFmode ) ) align = GET_MODE_ALIGNMENT ( DFmode ) ; return align ; } if ( TARGET_64BIT && optimize_function_for_speed_p ( cfun ) && TARGET_SSE ) { if ( AGGREGATE_TYPE_P ( type ) && ( va_list_type_node == NULL_TREE || ( TYPE_MAIN_VARIANT ( type ) != TYPE_MAIN_VARIANT ( va_list_type_node ) ) ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: geu_p ( TYPE_SIZE ( type ) , <NUM_LIT> ) && align < <NUM_LIT> ) return <NUM_LIT> ; } if ( TREE_CODE ( type ) == ARRAY_TYPE ) { if ( TYPE_MODE ( TREE_TYPE ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; } else if ( TREE_CODE ( type ) == COMPLEX_TYPE ) { if ( TYPE_MODE ( type ) == DCmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ( TYPE_MODE ( type ) == XCmode || TYPE_MODE ( type ) == TCmode ) && align < <NUM_LIT> ) return <NUM_LIT> ; } else if ( ( TREE_CODE ( type ) == RECORD_TYPE || TREE_CODE ( type ) == UNION_TYPE || TREE_CODE ( type ) == QUAL_UNION_TYPE ) && TYPE_FIELDS ( type ) ) { if ( DECL_MODE ( TYPE_FIELDS ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ;

if ( ALIGN_MODE_128 ( DECL_MODE ( TYPE_FIELDS ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ;


<s> static unsigned ix86_loop_unroll_adjust ( unsigned nunroll , struct loop * loop ) { basic_block * bbs ; rtx_insn * insn ; unsigned i ; unsigned mem_count = <NUM_LIT> ; if ( ! TARGET_ADJUST_UNROLL ) return nunroll ; subrtx_iterator :: array_type array ; bbs = get_loop_body ( loop ) ; for ( i = <NUM_LIT> ; i < loop -> num_nodes ; i ++ ) FOR_BB_INSNS ( bbs [ i ] , insn ) if ( NONDEBUG_INSN_P ( insn ) ) FOR_EACH_SUBRTX ( iter , array , insn , NONCONST ) if ( const_rtx x = * iter ) if ( MEM_P ( x ) ) { machine_mode mode = GET_MODE ( x ) ; unsigned int n_words = GET_MODE_SIZE ( mode ) / UNITS_PER_WORD ; if ( n_words > <NUM_LIT> ) mem_count += <NUM_LIT> ; else mem_count += <NUM_LIT> ; }


<s> static bool ix86_macro_fusion_p ( ) {


<s> static bool ix86_macro_fusion_p ( ) { return TARGET_FUSE_CMP_AND_BRANCH ;


<s> static bool ix86_macro_fusion_pair_p ( rtx_insn * condgen , rtx_insn * condjmp ) { rtx src , dest ; enum rtx_code ccode ; rtx compare_set = NULL_RTX , test_if , cond ; rtx alu_set = NULL_RTX , addr = NULL_RTX ; if ( ! any_condjump_p ( condjmp ) ) return false ; if ( get_attr_type ( condgen ) != TYPE_TEST && get_attr_type ( condgen ) != TYPE_ICMP && get_attr_type ( condgen ) != TYPE_INCDEC && get_attr_type ( condgen ) != TYPE_ALU ) return false ; compare_set = single_set ( condgen ) ; if ( compare_set == NULL_RTX && ! TARGET_FUSE_ALU_AND_BRANCH ) return false ; if ( compare_set == NULL_RTX ) { int i ; rtx pat = PATTERN ( condgen ) ; for ( i = <NUM_LIT> ; i < XVECLEN ( pat , <NUM_LIT> ) ; i ++ ) if ( GET_CODE ( XVECEXP ( pat , <NUM_LIT> , i ) ) == SET ) { rtx set_src = SET_SRC ( XVECEXP ( pat , <NUM_LIT> , i ) ) ; if ( GET_CODE ( set_src ) == COMPARE ) compare_set = XVECEXP ( pat , <NUM_LIT> , i ) ; else alu_set = XVECEXP ( pat , <NUM_LIT> , i ) ; } } if ( compare_set == NULL_RTX ) return false ; src = SET_SRC ( compare_set ) ; if ( GET_CODE ( src ) != COMPARE ) return false ; if ( ( MEM_P ( XEXP ( src , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) || ( MEM_P ( XEXP ( src , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( src , <NUM_LIT> ) ) ) ) return false ; if ( MEM_P ( XEXP ( src , <NUM_LIT> ) ) ) addr = XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ; else if ( MEM_P ( XEXP ( src , <NUM_LIT> ) ) ) addr = XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) ; if ( addr ) { ix86_address parts ; int ok = ix86_decompose_address ( addr , & parts ) ; gcc_assert ( ok ) ; if ( rip_relative_addr_p ( & parts ) ) return false ; } test_if = SET_SRC ( pc_set ( condjmp ) ) ; cond = XEXP ( test_if , <NUM_LIT> ) ; ccode = GET_CODE ( cond ) ; if ( ! TARGET_FUSE_CMP_AND_BRANCH_SOFLAGS && ( ccode == GE || ccode == GT || ccode == LE || ccode == LT ) ) return false ; if ( get_attr_type ( condgen ) == TYPE_TEST || get_attr_type ( condgen ) == TYPE_ICMP ) return true ; if ( ! TARGET_FUSE_ALU_AND_BRANCH || ! alu_set ) return false ; dest = SET_DEST ( alu_set ) ; if ( MEM_P ( dest ) ) return false ;

if ( get_attr_type ( condgen ) == TYPE_INCDEC && ( ccode == GEU || ccode == GTU || ccode == LEU || ccode == LTU ) ) return false ;


<s> tree high = ub ? build_zero_cst ( pointer_sized_int_node ) : build_minus_one_cst ( pointer_sized_int_node ) ; gcc_assert ( ( lb == <NUM_LIT> && ub == - <NUM_LIT> ) || ( lb == - <NUM_LIT> && ub == <NUM_LIT> ) ) ;

return build_complex ( NULL , low , high ) ;


<s> static tree ix86_make_bounds_constant ( HOST_WIDE_INT lb , HOST_WIDE_INT ub ) { tree low = lb ? build_minus_one_cst ( pointer_sized_int_node ) : build_zero_cst ( pointer_sized_int_node ) ; tree high = ub ? build_zero_cst ( pointer_sized_int_node ) : build_minus_one_cst ( pointer_sized_int_node ) ; gcc_assert ( ( lb == <NUM_LIT> && ub == - <NUM_LIT> ) || ( lb == - <NUM_LIT> && ub == <NUM_LIT> ) ) ;


<s> char * attr_str , * assembler_name ; if ( DECL_DECLARED_INLINE_P ( decl ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) error_at ( DECL_SOURCE_LOCATION ( decl ) , <STR_LIT> <STR_LIT> ) ; 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> ) ;


<s> if ( TREE_CODE ( type ) != VOID_TYPE && TREE_CODE ( type ) != BOOLEAN_TYPE && TREE_CODE ( type ) != INTEGER_TYPE && TREE_CODE ( type ) != REAL_TYPE ) return NULL ; switch ( TYPE_MODE ( type ) ) { case TFmode : return <STR_LIT> ;


<s> static void ix86_maybe_switch_abi ( void ) {

if ( TARGET_64BIT && call_used_regs [ SI_REG ] == ( cfun -> machine -> call_abi == MS_ABI ) ) reinit_regs ( ) ;


<s> if ( TARGET_64BIT && call_used_regs [ SI_REG ] == ( cfun -> machine -> call_abi == MS_ABI ) ) reinit_regs ( ) ;


<s> clobbers = tree_cons ( NULL_TREE , build_string ( <NUM_LIT> , <STR_LIT> ) , clobbers ) ; return clobbers ;


<s> static tree ix86_md_asm_clobbers ( tree , tree , tree clobbers ) {

clobbers = tree_cons ( NULL_TREE , build_string ( <NUM_LIT> , <STR_LIT> ) , clobbers ) ;


<s> } strong = ( model == MEMMODEL_ACQ_REL || model == MEMMODEL_SEQ_CST ) ; if ( val & IX86_HLE_ACQUIRE && ! ( model == MEMMODEL_ACQUIRE || strong ) ) { warning ( OPT_Winvalid_memory_model , <STR_LIT> ) ; return MEMMODEL_SEQ_CST | IX86_HLE_ACQUIRE ; } if ( val & IX86_HLE_RELEASE && ! ( model == MEMMODEL_RELEASE || strong ) ) { warning ( OPT_Winvalid_memory_model , <STR_LIT> ) ;


<s> unsigned int incoming_stack_boundary ; if ( ix86_user_incoming_stack_boundary ) incoming_stack_boundary = ix86_user_incoming_stack_boundary ; else if ( ! sibcall && ! TARGET_64BIT && ix86_force_align_arg_pointer && crtl -> stack_alignment_estimated == <NUM_LIT> ) incoming_stack_boundary = MIN_STACK_BOUNDARY ;


<s> else if ( ! sibcall && ! TARGET_64BIT && ix86_force_align_arg_pointer && crtl -> stack_alignment_estimated == <NUM_LIT> ) incoming_stack_boundary = MIN_STACK_BOUNDARY ; else incoming_stack_boundary = ix86_default_incoming_stack_boundary ; if ( incoming_stack_boundary > MIN_STACK_BOUNDARY && lookup_attribute ( ix86_force_align_arg_pointer_string , TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ) ) incoming_stack_boundary = MIN_STACK_BOUNDARY ; if ( incoming_stack_boundary < crtl -> parm_stack_boundary ) incoming_stack_boundary = crtl -> parm_stack_boundary ;


<s> if ( mode2 == XFmode ) return mode1 == SFmode || mode1 == DFmode ; if ( mode2 == DFmode ) return mode1 == SFmode ; if ( GET_MODE_SIZE ( mode2 ) == <NUM_LIT> && ix86_hard_regno_mode_ok ( FIRST_SSE_REG , mode2 ) ) return ( GET_MODE_SIZE ( mode1 ) == <NUM_LIT> && ix86_hard_regno_mode_ok ( FIRST_SSE_REG , mode1 ) ) ; if ( GET_MODE_SIZE ( mode2 ) == <NUM_LIT> && ix86_hard_regno_mode_ok ( FIRST_SSE_REG , mode2 ) ) return ( GET_MODE_SIZE ( mode1 ) == <NUM_LIT> && ix86_hard_regno_mode_ok ( FIRST_SSE_REG , mode1 ) ) ; if ( GET_MODE_SIZE ( mode2 ) == <NUM_LIT> && ix86_hard_regno_mode_ok ( FIRST_MMX_REG , mode2 ) ) return ( GET_MODE_SIZE ( mode1 ) == <NUM_LIT> && ix86_hard_regno_mode_ok ( FIRST_MMX_REG , mode1 ) ) ;


<s> return ix86_avx_u128_mode_after ( mode , insn ) ; case I387_TRUNC : case I387_FLOOR : case I387_CEIL : case I387_MASK_PM : return mode ; default :


<s> case I387_FLOOR : case I387_CEIL : case I387_MASK_PM : return I387_CW_ANY ; default : gcc_unreachable ( ) ; }


<s> static int ix86_mode_entry ( int entity ) { switch ( entity ) { case AVX_U128 : return ix86_avx_u128_mode_entry ( ) ; case I387_TRUNC : case I387_FLOOR :


<s> case AVX_U128 : return ix86_avx_u128_mode_exit ( ) ; case I387_TRUNC : case I387_FLOOR : case I387_CEIL :


<s> case AVX_U128 : return ix86_avx_u128_mode_needed ( insn ) ; case I387_TRUNC : case I387_FLOOR : case I387_CEIL : case I387_MASK_PM : return ix86_i387_mode_needed ( entity , insn ) ; default :


<s> case I387_FLOOR : case I387_CEIL : case I387_MASK_PM : return ix86_i387_mode_needed ( entity , insn ) ; default : gcc_unreachable ( ) ;


<s> if ( flag_check_pointer_bounds ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> ) ; return VOIDmode ; }


<s> if ( must_pass_in_stack_var_size_or_pad ( mode , type ) ) return true ; return ( ! TARGET_64BIT && mode == TImode && type && TREE_CODE ( type ) != VECTOR_TYPE ) ;


<s> static bool ix86_must_pass_in_stack ( machine_mode mode , const_tree type ) { if ( must_pass_in_stack_var_size_or_pad ( mode , type ) ) return true ;

return ( ! TARGET_64BIT && mode == TImode && type && TREE_CODE ( type ) != VECTOR_TYPE ) ;


for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( ! SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , true ) ) nregs ++ ;


<s> static int ix86_nsaved_sseregs ( void ) { int nregs = <NUM_LIT> ; int regno ;

if ( ! TARGET_64BIT_MS_ABI ) return <NUM_LIT> ;


<s> if ( TARGET_LP64 ) return xstrdup ( <STR_LIT> ) ;


ix86_option_override_internal ( true , & global_options , & global_options_set ) ;


<s> if ( TARGET_64BIT || TARGET_VXWORKS_RTP ) fprintf ( file , <STR_LIT> , directive , LPREFIX , value , LPREFIX , rel ) ; else if ( HAVE_AS_GOTOFF_IN_DATA ) fprintf ( file , ASM_LONG <STR_LIT> , LPREFIX , value ) ; else if ( TARGET_MACHO ) { fprintf ( file , ASM_LONG <STR_LIT> , LPREFIX , value ) ; machopic_output_function_base_name ( file ) ; putc ( '\n' , file ) ; }

else asm_fprintf ( file , ASM_LONG <STR_LIT> , GOT_SYMBOL_NAME , LPREFIX , value ) ;


<s> if ( TARGET_64BIT && CASE_VECTOR_MODE == DImode ) directive = ASM_QUAD ; gcc_assert ( ! TARGET_64BIT ) ; if ( TARGET_64BIT || TARGET_VXWORKS_RTP ) fprintf ( file , <STR_LIT> , directive , LPREFIX , value , LPREFIX , rel ) ; else if ( HAVE_AS_GOTOFF_IN_DATA ) fprintf ( file , ASM_LONG <STR_LIT> , LPREFIX , value ) ; else if ( TARGET_MACHO ) {


<s> const char * xasm ; if ( SIBLING_CALL_P ( insn ) ) { if ( direct_p ) xasm = <STR_LIT> ; else if ( TARGET_SEH ) xasm = <STR_LIT> ; else xasm = <STR_LIT> ; output_asm_insn ( xasm , & call_op ) ; return <STR_LIT> ; } if ( TARGET_SEH ) { rtx_insn * i ; for ( i = NEXT_INSN ( insn ) ; i ; i = NEXT_INSN ( i ) ) { if ( INSN_P ( i ) ) break ; if ( NOTE_P ( i ) && NOTE_KIND ( i ) == NOTE_INSN_EPILOGUE_BEG && ! flag_non_call_exceptions && ! can_throw_internal ( insn ) ) { seh_nop_p = true ; break ; } }


<s> const char * ix86_output_call_insn ( rtx_insn * insn , rtx call_op ) { bool direct_p = constant_call_address_operand ( call_op , VOIDmode ) ; bool seh_nop_p = false ; const char * xasm ; if ( SIBLING_CALL_P ( insn ) ) { if ( direct_p ) xasm = <STR_LIT> ;

else if ( TARGET_SEH ) xasm = <STR_LIT> ;


<s> error ( <STR_LIT> , align , is_memset ? <STR_LIT> : <STR_LIT> ) ; return ; } n ++ ; curr_range_str = next_range_str ; } while ( curr_range_str ) ; if ( input_ranges [ n - <NUM_LIT> ] . max != - <NUM_LIT> ) { error ( <STR_LIT> <STR_LIT> , is_memset ? <STR_LIT> : <STR_LIT> ) ; return ; } if ( n > MAX_STRINGOP_ALGS ) { error ( <STR_LIT> , is_memset ? <STR_LIT> : <STR_LIT> ) ; return ; } for ( i = <NUM_LIT> ; i < n ; i ++ ) { * const_cast < int * > ( & default_algs -> size [ i ] . max ) = input_ranges [ i ] . max ; * const_cast < stringop_alg * > ( & default_algs -> size [ i ] . alg ) = input_ranges [ i ] . alg ; * const_cast < int * > ( & default_algs -> size [ i ] . noalign ) = input_ranges [ i ] . noalign ;


<s> if ( TARGET_64BIT && ( cum ? cum -> call_abi : ix86_abi ) == MS_ABI ) { int msize = ( int ) GET_MODE_SIZE ( mode ) ; if ( type ) { if ( TREE_CODE ( type ) == ARRAY_TYPE ) return true ; if ( AGGREGATE_TYPE_P ( type ) ) { msize = int_size_in_bytes ( type ) ;


<s> static bool ix86_pic_register_p ( rtx x ) { if ( GET_CODE ( x ) == VALUE && CSELIB_VAL_PTR ( x ) ) return ( pic_offset_table_rtx && rtx_equal_for_cselib_p ( x , pic_offset_table_rtx ) ) ;

else if ( ! REG_P ( x ) ) return false ;


<s> static reg_class_t ix86_preferred_output_reload_class ( rtx x , reg_class_t regclass ) { machine_mode mode = GET_MODE ( x ) ; mode = GET_MODE ( x ) ; if ( TARGET_SSE_MATH && SSE_FLOAT_MODE_P ( mode ) ) return MAYBE_SSE_CLASS_P ( regclass ) ? ALL_SSE_REGS : NO_REGS ;


<s> if ( TARGET_SSE_MATH && ! TARGET_MIX_SSE_I387 && SSE_FLOAT_MODE_P ( mode ) ) return SSE_CLASS_P ( regclass ) ? regclass : NO_REGS ; if ( GET_CODE ( x ) == CONST_DOUBLE && GET_MODE ( x ) != VOIDmode ) { if ( reg_class_subset_p ( regclass , GENERAL_REGS ) ) return regclass ; if ( TARGET_80387 && standard_80387_constant_p ( x ) > <NUM_LIT> ) { if ( regclass == FLOAT_SSE_REGS ) return FLOAT_REGS ;

if ( regclass == FP_TOP_SSE_REGS ) return FP_TOP_REG ;


<s> ( TARGET_AVX && ! TARGET_PREFER_AVX128 ) ? V8SImode : V4SImode ; case DImode : return TARGET_AVX512F ? V8DImode : ( TARGET_AVX && ! TARGET_PREFER_AVX128 ) ? V4DImode : V2DImode ; case SFmode : if ( TARGET_AVX512F ) return V16SFmode ; else if ( TARGET_AVX && ! TARGET_PREFER_AVX128 ) return V8SFmode ; else return V4SFmode ; case DFmode :

if ( ! TARGET_VECTORIZE_DOUBLE ) return word_mode ;


<s> if ( ! is_sse && ( fpcmp_mode == CCFPUmode || ( op_mode == XFmode && ! ( standard_80387_constant_p ( op0 ) == <NUM_LIT> || standard_80387_constant_p ( op1 ) == <NUM_LIT> ) && GET_CODE ( op1 ) != FLOAT ) || ix86_fp_comparison_strategy ( code ) == IX86_FPCMP_COMI ) ) { op0 = force_reg ( op_mode , op0 ) ; op1 = force_reg ( op_mode , op1 ) ; } else { if ( standard_80387_constant_p ( op0 ) == <NUM_LIT> || ( MEM_P ( op0 ) && ! ( standard_80387_constant_p ( op1 ) == <NUM_LIT> || MEM_P ( op1 ) ) ) ) { enum rtx_code new_code = ix86_fp_swap_condition ( code ) ; if ( new_code != UNKNOWN ) { std :: swap ( op0 , op1 ) ; code = new_code ; } } if ( ! REG_P ( op0 ) ) op0 = force_reg ( op_mode , op0 ) ; if ( CONSTANT_P ( op1 ) ) { int tmp = standard_80387_constant_p ( op1 ) ; if ( tmp == <NUM_LIT> ) op1 = validize_mem ( force_const_mem ( op_mode , op1 ) ) ;


<s> } else { if ( standard_80387_constant_p ( op0 ) == <NUM_LIT> || ( MEM_P ( op0 ) && ! ( standard_80387_constant_p ( op1 ) == <NUM_LIT> || MEM_P ( op1 ) ) ) ) { enum rtx_code new_code = ix86_fp_swap_condition ( code ) ; if ( new_code != UNKNOWN ) { std :: swap ( op0 , op1 ) ; code = new_code ; } } if ( ! REG_P ( op0 ) ) op0 = force_reg ( op_mode , op0 ) ; if ( CONSTANT_P ( op1 ) ) { int tmp = standard_80387_constant_p ( op1 ) ; if ( tmp == <NUM_LIT> ) op1 = validize_mem ( force_const_mem ( op_mode , op1 ) ) ; else if ( tmp == <NUM_LIT> ) { if ( TARGET_CMOVE ) op1 = force_reg ( op_mode , op1 ) ; } else op1 = force_reg ( op_mode , op1 ) ; } } if ( ix86_fp_comparison_cost ( code ) > ix86_fp_comparison_cost ( swap_condition ( code ) ) && ( REG_P ( op1 ) || can_create_pseudo_p ( ) ) ) {


<s> if ( ASSEMBLER_DIALECT == ASM_ATT ) { if ( disp ) { if ( flag_pic ) output_pic_addr_const ( file , disp , <NUM_LIT> ) ; else if ( GET_CODE ( disp ) == LABEL_REF ) output_asm_label ( disp ) ; else output_addr_const ( file , disp ) ; } putc ( '(' , file ) ; if ( base ) print_reg ( base , code , file ) ; if ( index ) { putc ( ',' , file ) ; print_reg ( index , vsib ? <NUM_LIT> : code , file ) ; if ( scale != <NUM_LIT> || vsib ) fprintf ( file , <STR_LIT> , scale ) ; } putc ( ')' , file ) ; } else { rtx offset = NULL_RTX ; if ( disp ) { if ( GET_CODE ( disp ) == CONST && GET_CODE ( XEXP ( disp , <NUM_LIT> ) ) == PLUS && CONST_INT_P ( XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ) ) { offset = XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ; disp = gen_rtx_CONST ( VOIDmode , XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ) ; } if ( flag_pic ) output_pic_addr_const ( file , disp , <NUM_LIT> ) ; else if ( GET_CODE ( disp ) == LABEL_REF ) output_asm_label ( disp ) ; else if ( CONST_INT_P ( disp ) ) offset = disp ; else output_addr_const ( file , disp ) ; } putc ( '[' , file ) ; if ( base ) { print_reg ( base , code , file ) ; if ( offset ) { if ( INTVAL ( offset ) >= <NUM_LIT> ) putc ( '+' , file ) ; fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( offset ) ) ; } } else if ( offset ) fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( offset ) ) ; else putc ( '0' , file ) ; if ( index ) { putc ( '+' , file ) ; print_reg ( index , vsib ? <NUM_LIT> : code , file ) ; if ( scale != <NUM_LIT> || vsib ) fprintf ( file , <STR_LIT> , scale ) ; } putc ( ']' , file ) ; }


<s> return word_mode ; } return default_promote_function_mode ( type , mode , punsignedp , fntype , for_return ) ;


<s> static int ix86_reassociation_width ( unsigned int , machine_mode mode ) { if ( VECTOR_MODE_P ( mode ) ) { if ( TARGET_VECTOR_PARALLEL_EXECUTION ) return <NUM_LIT> ; else return <NUM_LIT> ; } if ( INTEGRAL_MODE_P ( mode ) && TARGET_REASSOC_INT_TO_PARALLEL ) return <NUM_LIT> ; else if ( FLOAT_MODE_P ( mode ) && TARGET_REASSOC_FP_TO_PARALLEL ) return <NUM_LIT> ; else return <NUM_LIT> ;


<s> else return <NUM_LIT> ; } if ( INTEGRAL_MODE_P ( mode ) && TARGET_REASSOC_INT_TO_PARALLEL ) return <NUM_LIT> ; else if ( FLOAT_MODE_P ( mode ) && TARGET_REASSOC_FP_TO_PARALLEL ) return <NUM_LIT> ;


<s> cost += inline_memory_move_cost ( mode , class1 , <NUM_LIT> ) ; cost += inline_memory_move_cost ( mode , class2 , <NUM_LIT> ) ; if ( targetm . class_max_nregs ( class1 , mode ) > targetm . class_max_nregs ( class2 , mode ) ) cost += <NUM_LIT> ; if ( ( MMX_CLASS_P ( class1 ) && MAYBE_FLOAT_CLASS_P ( class2 ) ) || ( MMX_CLASS_P ( class2 ) && MAYBE_FLOAT_CLASS_P ( class1 ) ) ) cost += <NUM_LIT> ; return cost ; } if ( MMX_CLASS_P ( class1 ) != MMX_CLASS_P ( class2 ) || SSE_CLASS_P ( class1 ) != SSE_CLASS_P ( class2 ) ) return MAX ( <NUM_LIT> , ix86_cost -> mmxsse_to_integer ) ; if ( MAYBE_FLOAT_CLASS_P ( class1 ) ) return ix86_cost -> fp_move ; if ( MAYBE_SSE_CLASS_P ( class1 ) ) return ix86_cost -> sse_move ; if ( MAYBE_MMX_CLASS_P ( class1 ) ) return ix86_cost -> mmx_move ; return <NUM_LIT> ;


if ( hard_regno == AX_REG ) return <NUM_LIT> ;


<s> if ( ix86_function_type_abi ( fntype ) == MS_ABI ) { size = int_size_in_bytes ( type ) ; if ( ( ! type || VECTOR_INTEGER_TYPE_P ( type ) || INTEGRAL_TYPE_P ( type ) || VECTOR_FLOAT_TYPE_P ( type ) ) && ( SCALAR_INT_MODE_P ( mode ) || VECTOR_MODE_P ( mode ) ) && ! COMPLEX_MODE_P ( mode ) && ( GET_MODE_SIZE ( mode ) == <NUM_LIT> || size == <NUM_LIT> ) ) return false ; return size != <NUM_LIT> && size != <NUM_LIT> && size != <NUM_LIT> && size != <NUM_LIT> ; } else { int needed_intregs , needed_sseregs ; return examine_argument ( mode , type , <NUM_LIT> , & needed_intregs , & needed_sseregs ) ; } } else { if ( mode == BLKmode ) return true ; size = int_size_in_bytes ( type ) ; if ( MS_AGGREGATE_RETURN && AGGREGATE_TYPE_P ( type ) && size <= <NUM_LIT> ) return false ; if ( VECTOR_MODE_P ( mode ) || mode == TImode ) { if ( size < <NUM_LIT> ) return false ; if ( size == <NUM_LIT> ) return TARGET_VECT8_RETURNS || ! TARGET_MMX ; if ( size == <NUM_LIT> ) return ! TARGET_SSE ; if ( size == <NUM_LIT> ) return ! TARGET_AVX ; if ( size == <NUM_LIT> ) return ! TARGET_AVX512F ; } if ( mode == XFmode ) return false ; if ( size > <NUM_LIT> ) return true ; gcc_assert ( mode != OImode ) ;


<s> ccvt = ix86_get_callcvt ( funtype ) ; if ( ( ccvt & ( IX86_CALLCVT_STDCALL | IX86_CALLCVT_FASTCALL | IX86_CALLCVT_THISCALL ) ) != <NUM_LIT> && ! stdarg_p ( funtype ) ) return size ; if ( aggregate_value_p ( TREE_TYPE ( funtype ) , fundecl ) && ! ix86_keep_aggregate_return_pointer ( funtype ) ) {

int nregs = ix86_function_regparm ( funtype , fundecl ) ;


<s> for ( i = <NUM_LIT> ; ; i ++ ) { unsigned test = EH_RETURN_DATA_REGNO ( i ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) return true ; } } if ( crtl -> drap_reg && regno == REGNO ( crtl -> drap_reg ) && ! cfun -> machine -> no_drap_save_restore ) return true ; return ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] && ! fixed_regs [ regno ] && ( regno != HARD_FRAME_POINTER_REGNUM || ! frame_pointer_needed ) ) ;


<s> if ( DECIMAL_FLOAT_MODE_P ( mode ) ) return default_decimal_float_supported_p ( ) ; else if ( mode == TFmode ) return true ; else return default_scalar_mode_supported_p ( mode ) ;


<s> default : targetm . sched . dfa_post_advance_cycle = NULL ; targetm . sched . first_cycle_multipass_init = NULL ; targetm . sched . first_cycle_multipass_begin = NULL ; targetm . sched . first_cycle_multipass_issue = NULL ; targetm . sched . first_cycle_multipass_backtrack = NULL ; targetm . sched . first_cycle_multipass_end = NULL ; targetm . sched . first_cycle_multipass_fini = NULL ; break ;


<s> case PROCESSOR_NEHALEM : case PROCESSOR_SANDYBRIDGE : case PROCESSOR_HASWELL : if ( reload_completed ) { targetm . sched . dfa_post_advance_cycle = core2i7_dfa_post_advance_cycle ; targetm . sched . first_cycle_multipass_init = core2i7_first_cycle_multipass_init ; targetm . sched . first_cycle_multipass_begin = core2i7_first_cycle_multipass_begin ; targetm . sched . first_cycle_multipass_issue = core2i7_first_cycle_multipass_issue ; targetm . sched . first_cycle_multipass_backtrack = core2i7_first_cycle_multipass_backtrack ; targetm . sched . first_cycle_multipass_end = core2i7_first_cycle_multipass_end ; targetm . sched . first_cycle_multipass_fini = core2i7_first_cycle_multipass_fini ; core2i7_secondary_decoder_max_insn_size = <NUM_LIT> ; core2i7_ifetch_block_size = <NUM_LIT> ; core2i7_ifetch_block_max_insns = <NUM_LIT> ; break ; } default : targetm . sched . dfa_post_advance_cycle = NULL ; targetm . sched . first_cycle_multipass_init = NULL ; targetm . sched . first_cycle_multipass_begin = NULL ; targetm . sched . first_cycle_multipass_issue = NULL ; targetm . sched . first_cycle_multipass_backtrack = NULL ; targetm . sched . first_cycle_multipass_end = NULL ; targetm . sched . first_cycle_multipass_fini = NULL ;


<s> if ( sched_verbose > <NUM_LIT> ) fprintf ( dump , <STR_LIT> , INSN_UID ( ready [ index ] ) ) ; insn = ready [ index ] ; for ( i = index ; i < n_ready - <NUM_LIT> ; i ++ ) ready [ i ] = ready [ i + <NUM_LIT> ] ; ready [ n_ready - <NUM_LIT> ] = insn ; return issue_rate ; } if ( clock_var != <NUM_LIT> && ! sel_sched_p ( ) && swap_top_of_ready_list ( ready , n_ready ) ) {

if ( sched_verbose > <NUM_LIT> ) fprintf ( dump , <STR_LIT> , INSN_UID ( ready [ n_ready - <NUM_LIT> ] ) , INSN_UID ( ready [ n_ready - <NUM_LIT> ] ) ) ;


<s> return inline_secondary_memory_needed ( class1 , class2 , mode , strict ) ;


<s> sri -> icode = ( in_p ? CODE_FOR_reload_noff_load : CODE_FOR_reload_noff_store ) ; sri -> extra_cost = <NUM_LIT> ; return NO_REGS ; } if ( mode == QImode && ( MAYBE_MASK_CLASS_P ( rclass ) || ( ! TARGET_64BIT && ! in_p && INTEGER_CLASS_P ( rclass ) && MAYBE_NON_Q_CLASS_P ( rclass ) ) ) ) {


<s> if ( insn == NULL ) continue ; insn = prev_active_insn ( insn ) ; 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 || NOTE_KIND ( next ) == NOTE_INSN_CALL_ARG_LOCATION ) ) insn = next ; else break ;

emit_insn_after ( gen_nops ( const1_rtx ) , insn ) ;


<s> insn = prev_active_insn ( insn ) ; 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 || NOTE_KIND ( next ) == NOTE_INSN_CALL_ARG_LOCATION ) ) insn = next ; else break ; emit_insn_after ( gen_nops ( const1_rtx ) , insn ) ; }


<s> next_cum = * cum ; if ( stdarg_p ( fntype ) ) ix86_function_arg_advance ( pack_cumulative_args ( & next_cum ) , mode , type , true ) ;

if ( cum -> call_abi == MS_ABI ) setup_incoming_varargs_ms_64 ( & next_cum ) ;


<s> 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 ) ; save_area = frame_pointer_rtx ; max = cum -> regno + cfun -> va_list_gpr_size / UNITS_PER_WORD ; if ( max > X86_64_REGPARM_MAX ) max = X86_64_REGPARM_MAX ; bnd_reg = cum -> bnd_regno + cum -> force_bnd_pass ; if ( chkp_function_instrumented_p ( current_function_decl ) ) for ( i = cum -> regno ; i < max ; i ++ ) { rtx addr = plus_constant ( Pmode , save_area , i * UNITS_PER_WORD ) ; rtx reg = gen_rtx_REG ( DImode , x86_64_int_parameter_registers [ i ] ) ; rtx ptr = reg ; rtx bounds ; if ( bnd_reg <= LAST_BND_REG ) bounds = gen_rtx_REG ( BNDmode , bnd_reg ) ; else { rtx ldx_addr = plus_constant ( Pmode , arg_pointer_rtx , ( LAST_BND_REG - bnd_reg ) * GET_MODE_SIZE ( Pmode ) ) ; bounds = gen_reg_rtx ( BNDmode ) ; emit_insn ( BNDmode == BND64mode ? gen_bnd64_ldx ( bounds , ldx_addr , ptr ) : gen_bnd32_ldx ( bounds , ldx_addr , ptr ) ) ; } emit_insn ( BNDmode == BND64mode ? gen_bnd64_stx ( addr , ptr , bounds ) : gen_bnd32_stx ( addr , ptr , bounds ) ) ;


<s> rtx save_area ; int bnd_reg , i , 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 ) ; save_area = frame_pointer_rtx ; max = cum -> regno + cfun -> va_list_gpr_size / UNITS_PER_WORD ; if ( max > X86_64_REGPARM_MAX ) max = X86_64_REGPARM_MAX ; bnd_reg = cum -> bnd_regno + cum -> force_bnd_pass ;

if ( chkp_function_instrumented_p ( current_function_decl ) ) for ( i = cum -> regno ; i < max ; i ++ ) {


<s> if ( fndecl == ix86_previous_fndecl ) return ; tree old_tree ; if ( ix86_previous_fndecl == NULL_TREE ) old_tree = target_option_current_node ; else if ( DECL_FUNCTION_SPECIFIC_TARGET ( ix86_previous_fndecl ) ) old_tree = DECL_FUNCTION_SPECIFIC_TARGET ( ix86_previous_fndecl ) ; else old_tree = target_option_default_node ; if ( fndecl == NULL_TREE ) { if ( old_tree != target_option_current_node ) ix86_reset_previous_fndecl ( ) ; return ; } 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 ( ) ;


<s> if ( ( TARGET_SSE && mode == TCmode ) || ( TARGET_80387 && mode == XCmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DCmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SCmode ) ) units = GET_MODE_SIZE ( mode ) ; break ; case MODE_VECTOR_INT : case MODE_VECTOR_FLOAT : if ( ( TARGET_AVX512F && VALID_AVX512F_REG_MODE ( mode ) ) || ( TARGET_AVX && VALID_AVX256_REG_MODE ( mode ) ) || ( TARGET_SSE2 && VALID_SSE2_REG_MODE ( mode ) ) || ( TARGET_SSE && VALID_SSE_REG_MODE ( mode ) ) || ( TARGET_MMX && VALID_MMX_REG_MODE ( mode ) ) ) units = GET_MODE_SIZE ( mode ) ;


<s> if ( ( TARGET_SSE && mode == TFmode ) || ( TARGET_80387 && mode == XFmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DFmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SFmode ) ) units = GET_MODE_SIZE ( mode ) ; break ; case MODE_COMPLEX_FLOAT : if ( ( TARGET_SSE && mode == TCmode ) || ( TARGET_80387 && mode == XCmode ) || ( ( TARGET_80387 || TARGET_SSE2 ) && mode == DCmode ) || ( ( TARGET_80387 || TARGET_SSE ) && mode == SCmode ) ) units = GET_MODE_SIZE ( mode ) ;


<s> } if ( str == NULL ) return ; push_cfun ( NULL ) ; tree args = build_tree_list ( NULL_TREE , build_string ( strlen ( str ) , str ) ) ; bool ok = ix86_valid_target_attribute_p ( node -> decl , NULL , args , <NUM_LIT> ) ; gcc_assert ( ok ) ; pop_cfun ( ) ; ix86_reset_previous_fndecl ( ) ; ix86_set_current_function ( node -> decl ) ;


<s> break ; case 'd' : if ( ! TARGET_AVX2 ) str = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } if ( str == NULL ) return ; push_cfun ( NULL ) ; tree args = build_tree_list ( NULL_TREE , build_string ( strlen ( str ) , str ) ) ; bool ok = ix86_valid_target_attribute_p ( node -> decl , NULL , args , <NUM_LIT> ) ; gcc_assert ( ok ) ;


<s> } else if ( ! TREE_PUBLIC ( node -> decl ) ) { if ( TARGET_AVX2 ) clonei -> vecsize_mangle = 'd' ; else if ( TARGET_AVX ) clonei -> vecsize_mangle = 'c' ; else clonei -> vecsize_mangle = 'b' ; ret = <NUM_LIT> ; } else { clonei -> vecsize_mangle = <STR_LIT> [ num ] ; ret = <NUM_LIT> ; } switch ( clonei -> vecsize_mangle ) { case 'b' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ; break ; case 'c' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ; break ; case 'd' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ; break ; } if ( clonei -> simdlen == <NUM_LIT> ) { if ( SCALAR_INT_MODE_P ( TYPE_MODE ( base_type ) ) ) clonei -> simdlen = clonei -> vecsize_int ; else clonei -> simdlen = clonei -> vecsize_float ;

clonei -> simdlen /= GET_MODE_BITSIZE ( TYPE_MODE ( base_type ) ) ;


<s> break ; default : warning_at ( DECL_SOURCE_LOCATION ( node -> decl ) , <NUM_LIT> , <STR_LIT> , TREE_TYPE ( t ) ) ; return <NUM_LIT> ; } if ( clonei -> cilk_elemental ) { clonei -> vecsize_mangle = 'b' ; } else if ( ! TREE_PUBLIC ( node -> decl ) ) { if ( TARGET_AVX2 ) clonei -> vecsize_mangle = 'd' ; else if ( TARGET_AVX ) clonei -> vecsize_mangle = 'c' ; else clonei -> vecsize_mangle = 'b' ; ret = <NUM_LIT> ; } else { clonei -> vecsize_mangle = <STR_LIT> [ num ] ; ret = <NUM_LIT> ; } switch ( clonei -> vecsize_mangle ) { case 'b' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ; break ; case 'c' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ; break ; case 'd' : clonei -> vecsize_int = <NUM_LIT> ; clonei -> vecsize_float = <NUM_LIT> ;


<s> if ( ! TARGET_SSE2 ) return - <NUM_LIT> ; if ( ! TARGET_AVX ) return <NUM_LIT> ; return TARGET_AVX2 ? <NUM_LIT> : <NUM_LIT> ; case 'c' : if ( ! TARGET_AVX ) return - <NUM_LIT> ; return TARGET_AVX2 ? <NUM_LIT> : <NUM_LIT> ; break ; case 'd' : if ( ! TARGET_AVX2 ) return - <NUM_LIT> ; return <NUM_LIT> ; default :


<s> if ( TARGET_SSE && TARGET_GENERAL_REGS_SSE_SPILL && ! TARGET_MMX && ( mode == SImode || ( TARGET_64BIT && mode == DImode ) ) && rclass != NO_REGS && INTEGER_CLASS_P ( rclass ) ) return ALL_SSE_REGS ;


<s> static reg_class_t ix86_spill_class ( reg_class_t rclass , machine_mode mode ) { if ( TARGET_SSE && TARGET_GENERAL_REGS_SSE_SPILL && ! TARGET_MMX && ( mode == SImode || ( TARGET_64BIT && mode == DImode ) ) && rclass != NO_REGS && INTEGER_CLASS_P ( rclass ) ) return ALL_SSE_REGS ; return NO_REGS ;


<s> void ix86_split_ashl ( rtx * operands , rtx scratch , machine_mode mode ) { rtx ( * gen_ashl3 ) ( rtx , rtx , rtx ) ; rtx ( * gen_shld ) ( rtx , rtx , rtx ) ; int half_width = GET_MODE_BITSIZE ( mode ) >> <NUM_LIT> ; rtx low [ <NUM_LIT> ] , high [ <NUM_LIT> ] ; int count ; if ( CONST_INT_P ( operands [ <NUM_LIT> ] ) ) { split_double_mode ( mode , operands , <NUM_LIT> , low , high ) ; count = INTVAL ( operands [ <NUM_LIT> ] ) & ( GET_MODE_BITSIZE ( mode ) - <NUM_LIT> ) ; if ( count >= half_width ) { emit_move_insn ( high [ <NUM_LIT> ] , low [ <NUM_LIT> ] ) ; emit_move_insn ( low [ <NUM_LIT> ] , const0_rtx ) ; if ( count > half_width ) ix86_expand_ashl_const ( high [ <NUM_LIT> ] , count - half_width , mode ) ; } else { gen_shld = mode == DImode ? gen_x86_shld : gen_x86_64_shld ; if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_shld ( high [ <NUM_LIT> ] , low [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; ix86_expand_ashl_const ( low [ <NUM_LIT> ] , count , mode ) ; } return ; } split_double_mode ( mode , operands , <NUM_LIT> , low , high ) ; gen_ashl3 = mode == DImode ? gen_ashlsi3 : gen_ashldi3 ; if ( operands [ <NUM_LIT> ] == const1_rtx ) { if ( ANY_QI_REG_P ( low [ <NUM_LIT> ] ) && ANY_QI_REG_P ( high [ <NUM_LIT> ] ) ) { rtx s , d , flags = gen_rtx_REG ( CCZmode , FLAGS_REG ) ; ix86_expand_clear ( low [ <NUM_LIT> ] ) ; ix86_expand_clear ( high [ <NUM_LIT> ] ) ; emit_insn ( gen_testqi_ccz_1 ( operands [ <NUM_LIT> ] , GEN_INT ( half_width ) ) ) ; d = gen_lowpart ( QImode , low [ <NUM_LIT> ] ) ;

d = gen_rtx_STRICT_LOW_PART ( VOIDmode , d ) ;


<s> emit_insn ( gen_ashr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; } } else { gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd ; if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; split_double_mode ( mode , operands , <NUM_LIT> , low , high ) ; emit_insn ( gen_shrd ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_ashr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; if ( TARGET_CMOVE && scratch ) { rtx ( * gen_x86_shift_adj_1 ) ( rtx , rtx , rtx , rtx ) = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1 ; emit_move_insn ( scratch , high [ <NUM_LIT> ] ) ;

emit_insn ( gen_ashr3 ( scratch , scratch , GEN_INT ( half_width - <NUM_LIT> ) ) ) ;


<s> gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd ; if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_shrd ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; emit_insn ( gen_ashr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; } } else { gen_shrd = mode == DImode ? gen_x86_shrd : gen_x86_64_shrd ; if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; split_double_mode ( mode , operands , <NUM_LIT> , low , high ) ; emit_insn ( gen_shrd ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_ashr3 ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; if ( TARGET_CMOVE && scratch ) { rtx ( * gen_x86_shift_adj_1 ) ( rtx , rtx , rtx , rtx ) = mode == DImode ? gen_x86_shiftsi_adj_1 : gen_x86_shiftdi_adj_1 ; emit_move_insn ( scratch , high [ <NUM_LIT> ] ) ; emit_insn ( gen_ashr3 ( scratch , scratch , GEN_INT ( half_width - <NUM_LIT> ) ) ) ;

emit_insn ( gen_x86_shift_adj_1 ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , scratch ) ) ;


<s> input = operands [ <NUM_LIT> ] ; two31 = operands [ <NUM_LIT> ] ; vecmode = GET_MODE ( large ) ; value = gen_rtx_REG ( vecmode , REGNO ( operands [ <NUM_LIT> ] ) ) ; if ( MEM_P ( input ) ) { if ( vecmode == V4SFmode ) emit_insn ( gen_vec_setv4sf_0 ( value , CONST0_RTX ( V4SFmode ) , input ) ) ; else emit_insn ( gen_sse2_loadlpd ( value , CONST0_RTX ( V2DFmode ) , input ) ) ; } else { input = gen_rtx_REG ( vecmode , REGNO ( input ) ) ; emit_move_insn ( value , CONST0_RTX ( vecmode ) ) ; if ( vecmode == V4SFmode ) emit_insn ( gen_sse_movss ( value , value , input ) ) ; else emit_insn ( gen_sse2_movsd ( value , value , input ) ) ; } emit_move_insn ( large , two31 ) ; emit_move_insn ( zero_or_two31 , MEM_P ( two31 ) ? large : two31 ) ; x = gen_rtx_fmt_ee ( LE , vecmode , large , value ) ; emit_insn ( gen_rtx_SET ( VOIDmode , large , x ) ) ; x = gen_rtx_AND ( vecmode , zero_or_two31 , large ) ; emit_insn ( gen_rtx_SET ( VOIDmode , zero_or_two31 , x ) ) ; x = gen_rtx_MINUS ( vecmode , value , zero_or_two31 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , value , x ) ) ; large = gen_rtx_REG ( V4SImode , REGNO ( large ) ) ; emit_insn ( gen_ashlv4si3 ( large , large , GEN_INT ( <NUM_LIT> ) ) ) ; x = gen_rtx_REG ( V4SImode , REGNO ( value ) ) ; if ( vecmode == V4SFmode ) emit_insn ( gen_fix_truncv4sfv4si2 ( x , value ) ) ; else emit_insn ( gen_sse2_cvttpd2dq ( x , value ) ) ; value = x ; emit_insn ( gen_xorv4si3 ( value , value , large ) ) ;


<s> zero_or_two31 = operands [ <NUM_LIT> ] ; input = operands [ <NUM_LIT> ] ; two31 = operands [ <NUM_LIT> ] ; vecmode = GET_MODE ( large ) ; value = gen_rtx_REG ( vecmode , REGNO ( operands [ <NUM_LIT> ] ) ) ; if ( MEM_P ( input ) ) { if ( vecmode == V4SFmode ) emit_insn ( gen_vec_setv4sf_0 ( value , CONST0_RTX ( V4SFmode ) , input ) ) ; else emit_insn ( gen_sse2_loadlpd ( value , CONST0_RTX ( V2DFmode ) , input ) ) ; } else { input = gen_rtx_REG ( vecmode , REGNO ( input ) ) ; emit_move_insn ( value , CONST0_RTX ( vecmode ) ) ;

if ( vecmode == V4SFmode ) emit_insn ( gen_sse_movss ( value , value , input ) ) ;


<s> mode = GET_MODE ( dest ) ; vmode = GET_MODE ( mask ) ; dest = simplify_gen_subreg ( vmode , dest , mode , <NUM_LIT> ) ; x = gen_rtx_AND ( vmode , dest , mask ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , x ) ) ; if ( op0 != CONST0_RTX ( vmode ) ) { x = gen_rtx_IOR ( vmode , dest , op0 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , x ) ) ; }


<s> op0 = operands [ <NUM_LIT> ] ; mask = operands [ <NUM_LIT> ] ; mode = GET_MODE ( dest ) ; vmode = GET_MODE ( mask ) ; dest = simplify_gen_subreg ( vmode , dest , mode , <NUM_LIT> ) ; x = gen_rtx_AND ( vmode , dest , mask ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , x ) ) ; if ( op0 != CONST0_RTX ( vmode ) ) { x = gen_rtx_IOR ( vmode , dest , op0 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , x ) ) ; }


<s> op1 = operands [ <NUM_LIT> ] ; nmask = operands [ <NUM_LIT> ] ; mask = operands [ <NUM_LIT> ] ; mode = GET_MODE ( dest ) ; vmode = GET_MODE ( mask ) ; if ( rtx_equal_p ( op0 , op1 ) ) { emit_move_insn ( dest , op0 ) ; return ; } if ( REG_P ( mask ) && REGNO ( dest ) == REGNO ( mask ) ) { gcc_assert ( REGNO ( op1 ) == REGNO ( scratch ) ) ; x = gen_rtx_AND ( vmode , scratch , mask ) ; emit_insn ( gen_rtx_SET ( VOIDmode , scratch , x ) ) ; dest = mask ; op0 = simplify_gen_subreg ( vmode , op0 , mode , <NUM_LIT> ) ; x = gen_rtx_NOT ( vmode , dest ) ; x = gen_rtx_AND ( vmode , x , op0 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest , x ) ) ;


<s> } condition = ix86_expand_fp_compare ( code , op1 , op2 , tmp ) ; i = emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , condition , target1 , target2 ) ) ) ; if ( split_branch_probability >= <NUM_LIT> ) add_int_reg_note ( i , REG_BR_PROB , split_branch_probability ) ;


<s> tmp1 = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , mode , <NUM_LIT> ) ; tmp2 = simplify_gen_subreg ( QImode , operands [ <NUM_LIT> ] , mode , <NUM_LIT> ) ; emit_insn ( gen_udivmodhiqi3 ( tmp0 , tmp1 , tmp2 ) ) ; if ( signed_p ) { div = gen_rtx_DIV ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; mod = gen_rtx_MOD ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } else { div = gen_rtx_UDIV ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; mod = gen_rtx_UMOD ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } tmp1 = gen_rtx_ZERO_EXTRACT ( mode , tmp0 , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ; if ( REG_P ( operands [ <NUM_LIT> ] ) ) insn = emit_move_insn ( operands [ <NUM_LIT> ] , tmp1 ) ; else { scratch = gen_reg_rtx ( mode ) ;


<s> parts . index = gen_lowpart ( mode , parts . index ) ; regno2 = true_regnum ( parts . index ) ; } if ( parts . disp ) parts . disp = gen_lowpart ( mode , parts . disp ) ; if ( parts . scale > <NUM_LIT> ) { if ( regno1 == regno0 ) { gcc_assert ( regno2 != regno0 ) ; for ( adds = parts . scale ; adds > <NUM_LIT> ; adds -- ) ix86_emit_binop ( PLUS , mode , target , parts . index ) ; } else { if ( regno0 != regno2 ) emit_insn ( gen_rtx_SET ( VOIDmode , target , parts . index ) ) ; ix86_emit_binop ( ASHIFT , mode , target , GEN_INT ( exact_log2 ( parts . scale ) ) ) ; if ( parts . base ) ix86_emit_binop ( PLUS , mode , target , parts . base ) ; if ( parts . disp && parts . disp != const0_rtx ) ix86_emit_binop ( PLUS , mode , target , parts . disp ) ; } } else if ( ! parts . base && ! parts . index ) { gcc_assert ( parts . disp ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , parts . disp ) ) ; } else { if ( ! parts . base ) { if ( regno0 != regno2 ) emit_insn ( gen_rtx_SET ( VOIDmode , target , parts . index ) ) ; } else if ( ! parts . index ) { if ( regno0 != regno1 ) emit_insn ( gen_rtx_SET ( VOIDmode , target , parts . base ) ) ; } else { if ( regno0 == regno1 ) tmp = parts . index ; else if ( regno0 == regno2 ) tmp = parts . base ; else { rtx tmp1 ; if ( find_nearest_reg_def ( insn , regno1 , regno2 ) ) tmp = parts . index , tmp1 = parts . base ; else tmp = parts . base , tmp1 = parts . index ; emit_insn ( gen_rtx_SET ( VOIDmode , target , tmp ) ) ; if ( parts . disp && parts . disp != const0_rtx ) ix86_emit_binop ( PLUS , mode , target , parts . disp ) ; ix86_emit_binop ( PLUS , mode , target , tmp1 ) ;


<s> regno2 = INVALID_REGNUM ; if ( parts . base ) { parts . base = gen_lowpart ( mode , parts . base ) ; regno1 = true_regnum ( parts . base ) ; } if ( parts . index ) { parts . index = gen_lowpart ( mode , parts . index ) ; regno2 = true_regnum ( parts . index ) ; } if ( parts . disp ) parts . disp = gen_lowpart ( mode , parts . disp ) ; if ( parts . scale > <NUM_LIT> ) { if ( regno1 == regno0 ) { gcc_assert ( regno2 != regno0 ) ; for ( adds = parts . scale ; adds > <NUM_LIT> ; adds -- ) ix86_emit_binop ( PLUS , mode , target , parts . index ) ; } else { if ( regno0 != regno2 ) emit_insn ( gen_rtx_SET ( VOIDmode , target , parts . index ) ) ; ix86_emit_binop ( ASHIFT , mode , target , GEN_INT ( exact_log2 ( parts . scale ) ) ) ; if ( parts . base ) ix86_emit_binop ( PLUS , mode , target , parts . base ) ; if ( parts . disp && parts . disp != const0_rtx ) ix86_emit_binop ( PLUS , mode , target , parts . disp ) ; } } else if ( ! parts . base && ! parts . index ) { gcc_assert ( parts . disp ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , parts . disp ) ) ; } else { if ( ! parts . base ) { if ( regno0 != regno2 ) emit_insn ( gen_rtx_SET ( VOIDmode , target , parts . index ) ) ; } else if ( ! parts . index ) { if ( regno0 != regno1 ) emit_insn ( gen_rtx_SET ( VOIDmode , target , parts . base ) ) ; }


<s> machine_mode mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; bool collisionparts [ <NUM_LIT> ] ; if ( TARGET_64BIT && GET_MODE_SIZE ( GET_MODE ( operands [ <NUM_LIT> ] ) ) == <NUM_LIT> ) { if ( MEM_P ( operands [ <NUM_LIT> ] ) && GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ) operands [ <NUM_LIT> ] = get_pool_constant ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ; if ( push_operand ( operands [ <NUM_LIT> ] , VOIDmode ) ) { operands [ <NUM_LIT> ] = copy_rtx ( operands [ <NUM_LIT> ] ) ; PUT_MODE ( operands [ <NUM_LIT> ] , word_mode ) ; } else operands [ <NUM_LIT> ] = gen_lowpart ( DImode , operands [ <NUM_LIT> ] ) ; operands [ <NUM_LIT> ] = gen_lowpart ( DImode , operands [ <NUM_LIT> ] ) ; emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; return ; } if ( push_operand ( operands [ <NUM_LIT> ] , VOIDmode ) ) push = <NUM_LIT> ; else gcc_assert ( ! MEM_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) ; nparts = ix86_split_to_parts ( operands [ <NUM_LIT> ] , part [ <NUM_LIT> ] , GET_MODE ( operands [ <NUM_LIT> ] ) ) ; ix86_split_to_parts ( operands [ <NUM_LIT> ] , part [ <NUM_LIT> ] , GET_MODE ( operands [ <NUM_LIT> ] ) ) ; if ( push && MEM_P ( operands [ <NUM_LIT> ] ) && reg_overlap_mentioned_p ( stack_pointer_rtx , operands [ <NUM_LIT> ] ) ) { rtx src_base = XEXP ( part [ <NUM_LIT> ] [ nparts - <NUM_LIT> ] , <NUM_LIT> ) ; if ( ! TARGET_64BIT && nparts == <NUM_LIT> && mode == XFmode && TARGET_128BIT_LONG_DOUBLE ) src_base = plus_constant ( Pmode , src_base , <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nparts ; i ++ ) part [ <NUM_LIT> ] [ i ] = change_address ( part [ <NUM_LIT> ] [ i ] , GET_MODE ( part [ <NUM_LIT> ] [ i ] ) , src_base ) ; } if ( REG_P ( part [ <NUM_LIT> ] [ <NUM_LIT> ] ) && MEM_P ( part [ <NUM_LIT> ] [ <NUM_LIT> ] ) ) { rtx tmp ; for ( i = <NUM_LIT> ; i < nparts ; i ++ ) { collisionparts [ i ] = reg_overlap_mentioned_p ( part [ <NUM_LIT> ] [ i ] , XEXP ( part [ <NUM_LIT> ] [ <NUM_LIT> ] , <NUM_LIT> ) ) ;

if ( collisionparts [ i ] ) collisions ++ ;


<s> } else gcc_unreachable ( ) ; } } else { if ( mode == TImode ) split_double_mode ( mode , & operand , <NUM_LIT> , & parts [ <NUM_LIT> ] , & parts [ <NUM_LIT> ] ) ; if ( mode == XFmode || mode == TFmode ) { machine_mode upper_mode = mode == XFmode ? SImode : DImode ; if ( REG_P ( operand ) ) { gcc_assert ( reload_completed ) ; parts [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( operand ) + <NUM_LIT> ) ; parts [ <NUM_LIT> ] = gen_rtx_REG ( upper_mode , REGNO ( operand ) + <NUM_LIT> ) ; } else if ( offsettable_memref_p ( operand ) ) { operand = adjust_address ( operand , DImode , <NUM_LIT> ) ; parts [ <NUM_LIT> ] = operand ; parts [ <NUM_LIT> ] = adjust_address ( operand , upper_mode , <NUM_LIT> ) ; } else if ( GET_CODE ( operand ) == CONST_DOUBLE ) { REAL_VALUE_TYPE r ; long l [ <NUM_LIT> ] ; REAL_VALUE_FROM_CONST_DOUBLE ( r , operand ) ; real_to_target ( l , & r , mode ) ; if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> ) parts [ <NUM_LIT> ] = gen_int_mode ( ( l [ <NUM_LIT> ] & ( ( ( HOST_WIDE_INT ) <NUM_LIT> << <NUM_LIT> ) - <NUM_LIT> ) ) + ( ( ( ( HOST_WIDE_INT ) l [ <NUM_LIT> ] ) << <NUM_LIT> ) << <NUM_LIT> ) , DImode ) ; else parts [ <NUM_LIT> ] = immed_double_const ( l [ <NUM_LIT> ] , l [ <NUM_LIT> ] , DImode ) ; if ( upper_mode == SImode ) parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; else if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> ) parts [ <NUM_LIT> ] = gen_int_mode ( ( l [ <NUM_LIT> ] & ( ( ( HOST_WIDE_INT ) <NUM_LIT> << <NUM_LIT> ) - <NUM_LIT> ) ) + ( ( ( ( HOST_WIDE_INT ) l [ <NUM_LIT> ] ) << <NUM_LIT> ) << <NUM_LIT> ) , DImode ) ;


<s> if ( ! VECTOR_MODE_P ( mode ) ) { rtx tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) ) ; tmp = gen_rtx_VEC_SELECT ( mode , mask , tmp ) ; mask = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , mask , tmp ) ) ; } } else mask = gen_rtx_NOT ( mode , mask ) ; emit_insn ( gen_rtx_SET ( VOIDmode , sgn , gen_rtx_AND ( mode , mask , sign ) ) ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , result , gen_rtx_IOR ( mode , abs_value , sgn ) ) ) ;


<s> static void ix86_store_bounds ( rtx ptr , rtx slot , rtx bounds , rtx slot_no ) { rtx addr ; addr = ix86_get_arg_address_for_bt ( slot , slot_no , stack_pointer_rtx ) ; if ( ! ptr ) {


<s> rtx addr ; addr = ix86_get_arg_address_for_bt ( slot , slot_no , stack_pointer_rtx ) ; if ( ! ptr ) { gcc_assert ( MEM_P ( slot ) ) ; ptr = copy_addr_to_reg ( slot ) ;


<s> gcc_assert ( REG_P ( slot ) ) ; emit_move_insn ( slot , bounds ) ;


<s> if ( immediate_operand ( src2 , mode ) ) return false ; if ( immediate_operand ( src1 , mode ) ) return true ; if ( MEM_P ( src2 ) ) return false ; if ( MEM_P ( src1 ) ) return true ;


<s> return TARGET_64BIT || ! TARGET_PARTIAL_REG_STALL ; case DImode : return TARGET_64BIT ; default : return false ;


<s> case SImode : return true ; case QImode : return TARGET_64BIT || ! TARGET_PARTIAL_REG_STALL ; case DImode : return TARGET_64BIT ; default : return false ; }


<s> rtx ix86_tls_module_base ( void ) { if ( ! ix86_tls_module_base_symbol ) { ix86_tls_module_base_symbol = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; SYMBOL_REF_FLAGS ( ix86_tls_module_base_symbol ) |= TLS_MODEL_GLOBAL_DYNAMIC << SYMBOL_FLAG_TLS_SHIFT ; }


<s> else { opcode = <NUM_LIT> ; size = <NUM_LIT> ; } mem = adjust_address ( m_tramp , HImode , offset ) ; emit_move_insn ( mem , gen_int_mode ( opcode , HImode ) ) ; mem = adjust_address ( m_tramp , ptr_mode , offset + <NUM_LIT> ) ; emit_move_insn ( mem , chain_value ) ; offset += size ; mem = adjust_address ( m_tramp , SImode , offset ) ; emit_move_insn ( mem , gen_int_mode ( <NUM_LIT> , SImode ) ) ; offset += <NUM_LIT> ; } else { rtx disp , chain ; chain = ix86_static_chain ( fndecl , true ) ; if ( REG_P ( chain ) ) { switch ( REGNO ( chain ) ) { case AX_REG : opcode = <NUM_LIT> ; break ; case CX_REG : opcode = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } } else opcode = <NUM_LIT> ; mem = adjust_address ( m_tramp , QImode , offset ) ; emit_move_insn ( mem , gen_int_mode ( opcode , QImode ) ) ; mem = adjust_address ( m_tramp , SImode , offset + <NUM_LIT> ) ;


<s> if ( TARGET_64BIT && cfun -> stdarg && crtl -> stack_alignment_estimated < <NUM_LIT> ) crtl -> stack_alignment_estimated = <NUM_LIT> ;


<s> return TARGET_RED_ZONE && ! TARGET_64BIT_MS_ABI ;


<s> else if ( GET_CODE ( op ) == SUBREG ) { rtx reg = SUBREG_REG ( op ) ; if ( ! REG_P ( reg ) ) return NULL_RTX ;


<s> else if ( GET_CODE ( op ) == SUBREG ) { rtx reg = SUBREG_REG ( op ) ; if ( ! REG_P ( reg ) ) return NULL_RTX ; mode = GET_MODE ( reg ) ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return NULL_RTX ;

if ( register_no_elim_operand ( reg , mode ) ) return reg ;


<s> bool ret = true ; if ( TREE_VALUE ( args ) && TREE_CODE ( TREE_VALUE ( args ) ) == STRING_CST && TREE_CHAIN ( args ) == NULL_TREE && strcmp ( TREE_STRING_POINTER ( TREE_VALUE ( args ) ) , <STR_LIT> ) == <NUM_LIT> ) return true ; tree old_optimize = build_optimization_node ( & global_options ) ; tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION ( fndecl ) ; if ( ! func_optimize ) func_optimize = old_optimize ; memset ( & func_options , <NUM_LIT> , sizeof ( func_options ) ) ; init_options_struct ( & func_options , NULL ) ; lang_hooks . init_options_struct ( & func_options ) ; cl_optimization_restore ( & func_options , TREE_OPTIMIZATION ( func_optimize ) ) ; cl_target_option_restore ( & func_options , TREE_TARGET_OPTION ( target_option_default_node ) ) ;

new_target = ix86_valid_target_attribute_tree ( args , & func_options , & global_options_set ) ;


<s> tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION ( fndecl ) ; if ( ! func_optimize ) func_optimize = old_optimize ; memset ( & func_options , <NUM_LIT> , sizeof ( func_options ) ) ; init_options_struct ( & func_options , NULL ) ; lang_hooks . init_options_struct ( & func_options ) ; cl_optimization_restore ( & func_options , TREE_OPTIMIZATION ( func_optimize ) ) ; cl_target_option_restore ( & func_options , TREE_TARGET_OPTION ( target_option_default_node ) ) ; new_target = ix86_valid_target_attribute_tree ( args , & func_options , & global_options_set ) ; new_optimize = build_optimization_node ( & func_options ) ; if ( new_target == error_mark_node ) ret = false ; else if ( fndecl && new_target ) { DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) = new_target ; if ( old_optimize != new_optimize ) DECL_FUNCTION_SPECIFIC_OPTIMIZATION ( fndecl ) = new_optimize ; }


<s> memset ( & enum_opts_set , <NUM_LIT> , sizeof ( enum_opts_set ) ) ; if ( ! ix86_valid_target_attribute_inner_p ( args , option_strings , opts , opts_set , & enum_opts_set ) ) return error_mark_node ; if ( opts -> x_ix86_isa_flags != def -> x_ix86_isa_flags || opts -> x_target_flags != def -> x_target_flags || option_strings [ IX86_FUNCTION_SPECIFIC_ARCH ] || option_strings [ IX86_FUNCTION_SPECIFIC_TUNE ] || enum_opts_set . x_ix86_fpmath ) { if ( option_strings [ IX86_FUNCTION_SPECIFIC_ARCH ] ) opts -> x_ix86_arch_string = option_strings [ IX86_FUNCTION_SPECIFIC_ARCH ] ; else if ( ! orig_arch_specified ) opts -> x_ix86_arch_string = NULL ; if ( option_strings [ IX86_FUNCTION_SPECIFIC_TUNE ] ) opts -> x_ix86_tune_string = option_strings [ IX86_FUNCTION_SPECIFIC_TUNE ] ; else if ( orig_tune_defaulted ) opts -> x_ix86_tune_string = NULL ; if ( enum_opts_set . x_ix86_fpmath ) opts_set -> x_ix86_fpmath = ( enum fpmath_unit ) <NUM_LIT> ; else if ( ! TARGET_64BIT_P ( opts -> x_ix86_isa_flags ) && TARGET_SSE_P ( opts -> x_ix86_isa_flags ) ) { opts -> x_ix86_fpmath = ( enum fpmath_unit ) ( FPMATH_SSE | FPMATH_387 ) ; opts_set -> x_ix86_fpmath = ( enum fpmath_unit ) <NUM_LIT> ; } ix86_option_override_internal ( false , opts , opts_set ) ; ix86_add_new_builtins ( opts -> x_ix86_isa_flags ) ; t = build_target_option_node ( opts ) ; opts -> x_ix86_arch_string = orig_arch_string ; opts -> x_ix86_tune_string = orig_tune_string ; opts_set -> x_ix86_fpmath = orig_fpmath_set ;

for ( i = <NUM_LIT> ; i < IX86_FUNCTION_SPECIFIC_MAX ; i ++ ) free ( option_strings [ i ] ) ;


<s> t = build2 ( MODIFY_EXPR , type , gpr , build_int_cst ( type , n_gpr * <NUM_LIT> ) ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; } if ( TARGET_SSE && cfun -> va_list_fpr_size ) { type = TREE_TYPE ( fpr ) ; t = build2 ( MODIFY_EXPR , type , fpr , build_int_cst ( type , n_fpr * <NUM_LIT> + <NUM_LIT> * X86_64_REGPARM_MAX ) ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; } type = TREE_TYPE ( ovf ) ; if ( cfun -> machine -> split_stack_varargs_pointer == NULL_RTX ) ovf_rtx = crtl -> args . internal_arg_pointer ; else ovf_rtx = cfun -> machine -> split_stack_varargs_pointer ; t = make_tree ( type , ovf_rtx ) ; if ( words != <NUM_LIT> ) t = fold_build_pointer_plus_hwi ( t , words * UNITS_PER_WORD ) ; if ( chkp_function_instrumented_p ( current_function_decl ) ) chkp_expand_bounds_reset_for_mem ( ovf , t ) ; t = build2 ( MODIFY_EXPR , type , ovf , t ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; if ( ix86_varargs_gpr_size || ix86_varargs_fpr_size ) { type = TREE_TYPE ( sav ) ; t = make_tree ( type , frame_pointer_rtx ) ; if ( ! ix86_varargs_gpr_size ) t = fold_build_pointer_plus_hwi ( t , - <NUM_LIT> * X86_64_REGPARM_MAX ) ;

if ( chkp_function_instrumented_p ( current_function_decl ) ) chkp_expand_bounds_reset_for_mem ( sav , t ) ;


<s> if ( scale <= <NUM_LIT> || scale > <NUM_LIT> || ( scale & ( scale - <NUM_LIT> ) ) != <NUM_LIT> ) return NULL_TREE ; si = TYPE_MODE ( index_type ) == SImode ; switch ( TYPE_MODE ( mem_vectype ) ) { case V2DFmode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_GATHER3SIV2DF : IX86_BUILTIN_GATHER3DIV2DF ; else code = si ? IX86_BUILTIN_GATHERSIV2DF : IX86_BUILTIN_GATHERDIV2DF ; break ; case V4DFmode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_GATHER3ALTSIV4DF : IX86_BUILTIN_GATHER3DIV4DF ; else code = si ? IX86_BUILTIN_GATHERALTSIV4DF : IX86_BUILTIN_GATHERDIV4DF ; break ; case V2DImode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_GATHER3SIV2DI : IX86_BUILTIN_GATHER3DIV2DI ; else code = si ? IX86_BUILTIN_GATHERSIV2DI : IX86_BUILTIN_GATHERDIV2DI ; break ; case V4DImode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_GATHER3ALTSIV4DI : IX86_BUILTIN_GATHER3DIV4DI ; else code = si ? IX86_BUILTIN_GATHERALTSIV4DI : IX86_BUILTIN_GATHERDIV4DI ; break ; case V4SFmode : if ( TARGET_AVX512VL ) code = si ? IX86_BUILTIN_GATHER3SIV4SF : IX86_BUILTIN_GATHER3DIV4SF ; else code = si ? IX86_BUILTIN_GATHERSIV4SF : IX86_BUILTIN_GATHERDIV4SF ;


<s> case V8SFmode : case V4DFmode : case V4DImode : if ( TARGET_AVX512VL ) return true ; break ; case V16HImode : if ( TARGET_AVX2 ) return true ; break ; case V32QImode : if ( TARGET_AVX2 ) return true ; break ; case V4SImode : case V4SFmode : case V8HImode : case V16QImode : if ( TARGET_XOP ) return true ; if ( TARGET_SSSE3 ) return true ; break ; case V2DImode : case V2DFmode : return true ; default : return false ; } memcpy ( d . perm , sel , nelt ) ; for ( i = which = <NUM_LIT> ; i < nelt ; ++ i ) { unsigned char e = d . perm [ i ] ; gcc_assert ( e < <NUM_LIT> * nelt ) ; which |= ( e < nelt ? <NUM_LIT> : <NUM_LIT> ) ; } if ( which == <NUM_LIT> ) for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d . perm [ i ] -= nelt ;

d . one_operand_p = ( which != <NUM_LIT> ) ;


<s> rtx dup ; dup = gen_rtx_VEC_DUPLICATE ( mode , val ) ; insn = emit_insn ( gen_rtx_SET ( VOIDmode , target , dup ) ) ; if ( recog_memoized ( insn ) < <NUM_LIT> ) { rtx_insn * seq ; start_sequence ( ) ; XEXP ( dup , <NUM_LIT> ) = force_reg ( GET_MODE_INNER ( mode ) , val ) ; seq = get_insns ( ) ; end_sequence ( ) ; if ( seq ) emit_insn_before ( seq , insn ) ;

ok = recog_memoized ( insn ) >= <NUM_LIT> ;


<s> XEXP ( dup , <NUM_LIT> ) = force_reg ( GET_MODE_INNER ( mode ) , val ) ; seq = get_insns ( ) ; end_sequence ( ) ; if ( seq ) emit_insn_before ( seq , insn ) ; ok = recog_memoized ( insn ) >= <NUM_LIT> ; gcc_assert ( ok ) ;


<s> static bool ix86_vector_mode_supported_p ( machine_mode mode ) { if ( TARGET_SSE && VALID_SSE_REG_MODE ( mode ) ) return true ; if ( TARGET_SSE2 && VALID_SSE2_REG_MODE ( mode ) ) return true ; if ( TARGET_AVX && VALID_AVX256_REG_MODE ( mode ) ) return true ; if ( TARGET_AVX512F && VALID_AVX512F_REG_MODE ( mode ) ) return true ; if ( TARGET_MMX && VALID_MMX_REG_MODE ( mode ) ) return true ; if ( TARGET_3DNOW && VALID_MMX_REG_MODE_3DNOW ( mode ) ) return true ; return false ;


<s> if ( GET_CODE ( disp ) == PLUS ) { if ( ! CONST_INT_P ( XEXP ( disp , <NUM_LIT> ) ) ) return false ; disp = XEXP ( disp , <NUM_LIT> ) ; saw_plus = true ; } if ( TARGET_MACHO && darwin_local_data_pic ( disp ) ) return true ; if ( GET_CODE ( disp ) != UNSPEC ) return false ; switch ( XINT ( disp , <NUM_LIT> ) ) { case UNSPEC_GOT : if ( saw_plus ) return false ; return ( GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF || GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) == LABEL_REF ) ; case UNSPEC_GOTOFF : if ( ( GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF || GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) == LABEL_REF ) && ! TARGET_64BIT ) return ! TARGET_PECOFF && gotoff_operand ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) , Pmode ) ; return false ; case UNSPEC_GOTTPOFF : case UNSPEC_GOTNTPOFF : case UNSPEC_INDNTPOFF : if ( saw_plus ) return false ; disp = XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ; return ( GET_CODE ( disp ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( disp ) == TLS_MODEL_INITIAL_EXEC ) ; case UNSPEC_NTPOFF :


<s> static rtx legitimize_pe_coff_symbol ( rtx addr , bool inreg ) { if ( ! TARGET_PECOFF ) return NULL_RTX ; if ( TARGET_DLLIMPORT_DECL_ATTRIBUTES ) { if ( GET_CODE ( addr ) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P ( addr ) ) return legitimize_dllimport_symbol ( addr , inreg ) ; if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && SYMBOL_REF_DLLIMPORT_P ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ) { rtx t = legitimize_dllimport_symbol ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , inreg ) ; return gen_rtx_PLUS ( Pmode , t , XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ; } } if ( ix86_cmodel != CM_LARGE_PIC && ix86_cmodel != CM_MEDIUM_PIC ) return NULL_RTX ; if ( GET_CODE ( addr ) == SYMBOL_REF && ! is_imported_p ( addr ) && SYMBOL_REF_EXTERNAL_P ( addr ) && SYMBOL_REF_DECL ( addr ) ) return legitimize_pe_coff_extern_decl ( addr , inreg ) ;

if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && ! is_imported_p ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) && SYMBOL_REF_EXTERNAL_P ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) && SYMBOL_REF_DECL ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ) {


<s> static tree make_attribute ( const char * name , const char * arg_name , tree chain ) { tree attr_name ; tree attr_arg_name ; tree attr_args ; tree attr ; attr_name = get_identifier ( name ) ; attr_arg_name = build_string ( strlen ( arg_name ) , arg_name ) ;


<s> tree attr ; attr_name = get_identifier ( name ) ; attr_arg_name = build_string ( strlen ( arg_name ) , arg_name ) ; attr_args = tree_cons ( NULL_TREE , attr_arg_name , NULL_TREE ) ; attr = tree_cons ( attr_name , attr_args , chain ) ; return attr ;


<s> if ( make_unique ) name_len += strlen ( unique_name ) + <NUM_LIT> ; global_var_name = XNEWVEC ( char , name_len ) ; if ( make_unique ) snprintf ( global_var_name , name_len , <STR_LIT> , name , unique_name , suffix ) ; else snprintf ( global_var_name , name_len , <STR_LIT> , name , suffix ) ;


<s> int name_len ; const char * name ; const char * unique_name = NULL ; name = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ; if ( make_unique ) unique_name = IDENTIFIER_POINTER ( get_file_function_name ( <STR_LIT> ) ) ; name_len = strlen ( name ) + strlen ( suffix ) + <NUM_LIT> ;

if ( make_unique ) name_len += strlen ( unique_name ) + <NUM_LIT> ;


<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_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 , <NUM_LIT> ) ; cgraph_node :: add_new_function ( decl , true ) ; symtab -> call_cgraph_insertion_hooks ( cgraph_node :: get_create ( decl ) ) ;


<s> ok = ix86_decompose_address ( addr , & parts ) ; gcc_assert ( ok ) ; len = ( parts . seg == SEG_DEFAULT ) ? <NUM_LIT> : <NUM_LIT> ; if ( TARGET_64BIT && ! lea && ( SImode_address_operand ( addr , VOIDmode ) || ( parts . base && GET_MODE ( parts . base ) == SImode ) || ( parts . index && GET_MODE ( parts . index ) == SImode ) ) ) len ++ ; base = parts . base ; index = parts . index ; disp = parts . disp ; if ( base && GET_CODE ( base ) == SUBREG ) base = SUBREG_REG ( base ) ; if ( index && GET_CODE ( index ) == SUBREG ) index = SUBREG_REG ( index ) ; gcc_assert ( base == NULL_RTX || REG_P ( base ) ) ; gcc_assert ( index == NULL_RTX || REG_P ( index ) ) ; if ( base && ! index && ! disp ) { if ( base == arg_pointer_rtx || base == frame_pointer_rtx || REGNO ( base ) == SP_REG || REGNO ( base ) == BP_REG || REGNO ( base ) == R12_REG || REGNO ( base ) == R13_REG ) len ++ ; } else if ( disp && ! base && ! index ) { len += <NUM_LIT> ; if ( rip_relative_addr_p ( & parts ) ) len ++ ; } else { if ( disp ) { if ( base && satisfies_constraint_K ( disp ) ) len += <NUM_LIT> ; else len += <NUM_LIT> ; } else if ( base && ( REGNO ( base ) == BP_REG || REGNO ( base ) == R13_REG ) ) len ++ ; if ( index || base == arg_pointer_rtx || base == frame_pointer_rtx || ( base && ( REGNO ( base ) == SP_REG || REGNO ( base ) == R12_REG ) ) ) len ++ ; }


<s> enum attr_type type = get_attr_type ( insn ) ; switch ( type ) { case TYPE_MULTI : if ( GET_CODE ( PATTERN ( insn ) ) == ASM_INPUT || asm_noperands ( PATTERN ( insn ) ) >= <NUM_LIT> ) return <NUM_LIT> ; break ; case TYPE_OTHER : case TYPE_FCMP : break ; default : return len ; } l = get_attr_length_address ( insn ) ; if ( l < <NUM_LIT> && symbolic_reference_mentioned_p ( PATTERN ( insn ) ) ) l = <NUM_LIT> ;


<s> if ( is_sse ) { if ( TARGET_AVX ) { strcpy ( buf , ssep ) ; if ( GET_MODE ( operands [ <NUM_LIT> ] ) == SFmode ) strcat ( buf , <STR_LIT> ) ; else strcat ( buf , <STR_LIT> ) ; } else { strcpy ( buf , ssep + <NUM_LIT> ) ; if ( GET_MODE ( operands [ <NUM_LIT> ] ) == SFmode ) strcat ( buf , <STR_LIT> ) ; else strcat ( buf , <STR_LIT> ) ; } return buf ; } strcpy ( buf , p ) ; switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { case MULT : case PLUS : if ( REG_P ( operands [ <NUM_LIT> ] ) && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; case MINUS : case DIV : if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; break ; } if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ;


<s> } if ( is_sse ) { if ( TARGET_AVX ) { strcpy ( buf , ssep ) ; if ( GET_MODE ( operands [ <NUM_LIT> ] ) == SFmode ) strcat ( buf , <STR_LIT> ) ; else strcat ( buf , <STR_LIT> ) ; } else { strcpy ( buf , ssep + <NUM_LIT> ) ; if ( GET_MODE ( operands [ <NUM_LIT> ] ) == SFmode ) strcat ( buf , <STR_LIT> ) ; else strcat ( buf , <STR_LIT> ) ; } return buf ; } strcpy ( buf , p ) ; switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { case MULT : case PLUS : if ( REG_P ( operands [ <NUM_LIT> ] ) && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; case MINUS : case DIV : if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; break ; } if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ;


<s> else if ( MEM_P ( operands [ <NUM_LIT> ] ) ) { gcc_assert ( REG_P ( operands [ <NUM_LIT> ] ) ) ; if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) return <STR_LIT> ; else { if ( GET_MODE ( operands [ <NUM_LIT> ] ) == XFmode ) return <STR_LIT> ; else return <STR_LIT> ; } } else gcc_unreachable ( ) ;


<s> ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ <NUM_LIT> ] = stack_pointer_rtx ; xops [ <NUM_LIT> ] = reg ; output_asm_insn ( <STR_LIT> , xops ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name_raw ( asm_out_file , end_lab ) ; fputc ( '\n' , asm_out_file ) ; xops [ <NUM_LIT> ] = GEN_INT ( PROBE_INTERVAL ) ; output_asm_insn ( <STR_LIT> , xops ) ;


<s> int stack_top_dies = find_regno_note ( insn , REG_DEAD , FIRST_STACK_REG ) != <NUM_LIT> ; int dimode_p = GET_MODE ( operands [ <NUM_LIT> ] ) == DImode ; int round_mode = get_attr_i387_cw ( insn ) ; if ( ( dimode_p || fisttp ) && ! stack_top_dies ) output_asm_insn ( <STR_LIT> , operands ) ; gcc_assert ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) ; gcc_assert ( MEM_P ( operands [ <NUM_LIT> ] ) ) ; gcc_assert ( GET_MODE ( operands [ <NUM_LIT> ] ) != TFmode ) ; if ( fisttp ) output_asm_insn ( <STR_LIT> , operands ) ; else { if ( round_mode != I387_CW_ANY ) output_asm_insn ( <STR_LIT> , operands ) ; if ( stack_top_dies || dimode_p ) output_asm_insn ( <STR_LIT> , operands ) ; else output_asm_insn ( <STR_LIT> , operands ) ; if ( round_mode != I387_CW_ANY ) output_asm_insn ( <STR_LIT> , operands ) ; } return <STR_LIT> ;


<s> gcc_assert ( STACK_TOP_P ( cmp_op0 ) ) ; stack_top_dies = find_regno_note ( insn , REG_DEAD , FIRST_STACK_REG ) != <NUM_LIT> ; if ( cmp_op1 == CONST0_RTX ( GET_MODE ( cmp_op1 ) ) ) { if ( stack_top_dies ) { output_asm_insn ( <STR_LIT> , operands ) ; return output_387_ffreep ( operands , <NUM_LIT> ) ; } else return <STR_LIT> ; } if ( STACK_REG_P ( cmp_op1 ) && stack_top_dies && find_regno_note ( insn , REG_DEAD , REGNO ( cmp_op1 ) ) && REGNO ( cmp_op1 ) != FIRST_STACK_REG ) { if ( eflags_p ) { if ( unordered_p ) output_asm_insn ( <STR_LIT> , operands ) ; else output_asm_insn ( <STR_LIT> , operands ) ; return output_387_ffreep ( operands , <NUM_LIT> ) ; } else { if ( unordered_p ) return <STR_LIT> ; else return <STR_LIT> ; } } else { static const char * const alt [ <NUM_LIT> ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , NULL , NULL , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , NULL , NULL , NULL , NULL } ; int mask ; const char * ret ; mask = eflags_p << <NUM_LIT> ; mask |= ( GET_MODE_CLASS ( GET_MODE ( cmp_op1 ) ) == MODE_INT ) << <NUM_LIT> ; mask |= unordered_p << <NUM_LIT> ; mask |= stack_top_dies ; gcc_assert ( mask < <NUM_LIT> ) ; ret = alt [ mask ] ; gcc_assert ( ret ) ; return ret ;


<s> 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 : if ( XINT ( x , <NUM_LIT> ) == UNSPEC_STACK_CHECK ) { bool f = i386_asm_output_addr_const_extra ( file , x ) ; gcc_assert ( f ) ; break ; } 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 ;


<s> xops [ <NUM_LIT> ] = gen_rtx_MEM ( Pmode , gen_rtx_SYMBOL_REF ( Pmode , VXWORKS_GOTT_BASE ) ) ; output_asm_insn ( <STR_LIT> , xops ) ; xops [ <NUM_LIT> ] = gen_rtx_SYMBOL_REF ( Pmode , VXWORKS_GOTT_INDEX ) ; SYMBOL_REF_FLAGS ( xops [ <NUM_LIT> ] ) |= SYMBOL_FLAG_LOCAL ; output_asm_insn ( <STR_LIT> , xops ) ; return <STR_LIT> ; } xops [ <NUM_LIT> ] = gen_rtx_SYMBOL_REF ( Pmode , GOT_SYMBOL_NAME ) ; if ( ! flag_pic ) { if ( TARGET_MACHO ) gcc_unreachable ( ) ; xops [ <NUM_LIT> ] = gen_rtx_LABEL_REF ( Pmode , label ? label : gen_label_rtx ( ) ) ; output_asm_insn ( <STR_LIT> , xops ) ;

targetm . asm_out . internal_label ( asm_out_file , <STR_LIT> , CODE_LABEL_NUMBER ( XEXP ( xops [ <NUM_LIT> ] , <NUM_LIT> ) ) ) ;


<s> if ( dump ) fprintf ( stderr , <STR_LIT> , clear ? <STR_LIT> : <STR_LIT> , ix86_tune_feature_names [ i ] ) ; break ; } } if ( i == X86_TUNE_LAST ) error ( <STR_LIT> , clear ? curr_feature_string - <NUM_LIT> : curr_feature_string ) ; curr_feature_string = next_feature_string ; } while ( curr_feature_string ) ; free ( orig ) ;


add_int_reg_note ( insn , REG_BR_PROB , prob ) ;


<s> rtx insn = get_last_insn ( ) ; gcc_assert ( JUMP_P ( insn ) ) ;