<s> else if ( thiscall_p && ! static_chain_p && drap_regno != AX_REG ) regno = AX_REG ; else if ( regparm < <NUM_LIT> && ! thiscall_p && drap_regno != DX_REG ) regno = DX_REG ; else if ( regparm < <NUM_LIT> && ! fastcall_p && ! thiscall_p && ! static_chain_p && drap_regno != CX_REG ) regno = CX_REG ; else if ( ix86_save_reg ( BX_REG , true , false ) ) regno = BX_REG ; else if ( ! ( regparm == <NUM_LIT> && static_chain_p ) && ix86_save_reg ( SI_REG , true , false ) ) regno = SI_REG ; else if ( ix86_save_reg ( DI_REG , true , false ) ) regno = DI_REG ; else {


<s> static rtx get_thread_pointer ( machine_mode tp_mode , bool to_reg ) { rtx tp = gen_rtx_UNSPEC ( ptr_mode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_TP ) ; if ( GET_MODE ( tp ) != tp_mode ) { gcc_assert ( GET_MODE ( tp ) == SImode ) ; gcc_assert ( tp_mode == DImode ) ; tp = gen_rtx_ZERO_EXTEND ( tp_mode , tp ) ; } if ( to_reg ) tp = copy_to_mode_reg ( tp_mode , tp ) ; return tp ;


<s> static inline hashval_t hash ( tree_map * m ) {


<s> output_addr_const ( file , op ) ; fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_GOTTPOFF : output_addr_const ( file , op ) ; fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_TPOFF : output_addr_const ( file , op ) ; fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_NTPOFF : output_addr_const ( file , op ) ; if ( TARGET_64BIT ) fputs ( <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_DTPOFF : output_addr_const ( file , op ) ; fputs ( <STR_LIT> , file ) ;


<s> fputs ( <STR_LIT> , file ) ; switch ( size ) { case <NUM_LIT> : break ; case <NUM_LIT> :


<s> } if ( HAVE_COMDAT_GROUP && flags & SECTION_LINKONCE ) { solaris_elf_asm_comdat_section ( name , flags , decl ) ; return ; } if ( flags & SECTION_EXCLUDE ) { fprintf ( asm_out_file , <STR_LIT> , name ) ; return ;


<s> if ( align < <NUM_LIT> || TYPE_USER_ALIGN ( type ) ) return align ; type = strip_array_types ( type ) ; if ( TYPE_ATOMIC ( type ) ) return align ;


<s> mode = TYPE_MODE ( type ) ; switch ( GET_MODE_CLASS ( mode ) ) { case MODE_INT : case MODE_COMPLEX_INT : case MODE_COMPLEX_FLOAT : case MODE_FLOAT : case MODE_DECIMAL_FLOAT : return <NUM_LIT> ; default : return align ; }


<s> df_ref def , use ; if ( ! prev || ! next ) return distance + ( distance & <NUM_LIT> ) + <NUM_LIT> ; if ( ! DF_INSN_USES ( next ) || ! DF_INSN_DEFS ( prev ) ) return distance + <NUM_LIT> ; FOR_EACH_INSN_USE ( use , next ) FOR_EACH_INSN_DEF ( def , prev ) if ( ! DF_REF_IS_ARTIFICIAL ( def ) && DF_REF_REGNO ( use ) == DF_REF_REGNO ( def ) ) return distance + ( distance & <NUM_LIT> ) + <NUM_LIT> ;


<s> if ( LEGACY_INT_REGNO_P ( regno ) ) reg_prefix = TARGET_64BIT ? <STR_LIT> : <STR_LIT> ; else reg_prefix = <STR_LIT> ; sprintf ( name , <STR_LIT> , ret , prefix , reg_prefix , reg_names [ regno ] ) ; } else sprintf ( name , <STR_LIT> , ret , prefix ) ; } else { if ( regno != INVALID_REGNUM ) ASM_GENERATE_INTERNAL_LABEL ( name , <STR_LIT> , regno ) ; else { if ( ret_p ) ASM_GENERATE_INTERNAL_LABEL ( name , <STR_LIT> , <NUM_LIT> ) ; else ASM_GENERATE_INTERNAL_LABEL ( name , <STR_LIT> , <NUM_LIT> ) ;


<s> const char * ret = ret_p ? <STR_LIT> : <STR_LIT> ; if ( regno != INVALID_REGNUM ) { const char * reg_prefix ; if ( LEGACY_INT_REGNO_P ( regno ) ) reg_prefix = TARGET_64BIT ? <STR_LIT> : <STR_LIT> ; else reg_prefix = <STR_LIT> ; sprintf ( name , <STR_LIT> , ret , prefix , reg_prefix , reg_names [ regno ] ) ; } else sprintf ( name , <STR_LIT> , ret , prefix ) ; } else {

if ( regno != INVALID_REGNUM ) ASM_GENERATE_INTERNAL_LABEL ( name , <STR_LIT> , regno ) ;


<s> enum indirect_thunk_prefix indirect_thunk_need_prefix ( rtx_insn * insn ) { enum indirect_thunk_prefix need_prefix ; if ( ( cfun -> machine -> indirect_branch_type == indirect_branch_thunk_extern ) && ix86_notrack_prefixed_insn_p ( insn ) ) { need_prefix = indirect_thunk_prefix_nt ; } else need_prefix = indirect_thunk_prefix_none ; return need_prefix ;


<s> void init_cumulative_args ( CUMULATIVE_ARGS * cum , tree fntype , rtx libname , tree fndecl , int caller ) { struct cgraph_node * local_info_node = NULL ; struct cgraph_node * target = NULL ; cfun -> machine -> silent_p = false ; memset ( cum , <NUM_LIT> , sizeof ( * cum ) ) ; if ( fndecl ) { target = cgraph_node :: get ( fndecl ) ; if ( target ) { target = target -> function_symbol ( ) ; local_info_node = cgraph_node :: local_info_node ( target -> decl ) ; cum -> call_abi = ix86_function_abi ( target -> decl ) ; } else cum -> call_abi = ix86_function_abi ( fndecl ) ; } else cum -> call_abi = ix86_function_type_abi ( fntype ) ; cum -> caller = caller ; cum -> nregs = ix86_regparm ; if ( TARGET_64BIT ) { cum -> nregs = ( cum -> call_abi == SYSV_ABI ? X86_64_REGPARM_MAX : X86_64_MS_REGPARM_MAX ) ; } if ( TARGET_SSE ) { cum -> sse_nregs = SSE_REGPARM_MAX ; if ( TARGET_64BIT ) { cum -> sse_nregs = ( cum -> call_abi == SYSV_ABI ? X86_64_SSE_REGPARM_MAX : X86_64_MS_SSE_REGPARM_MAX ) ; } } if ( TARGET_MMX ) cum -> mmx_nregs = MMX_REGPARM_MAX ; cum -> warn_avx512f = true ; cum -> warn_avx = true ; cum -> warn_sse = true ; cum -> warn_mmx = true ; if ( local_info_node && local_info_node -> local && local_info_node -> can_change_signature ) fntype = TREE_TYPE ( target -> decl ) ; cum -> stdarg = stdarg_p ( fntype ) ; cum -> maybe_vaarg = ( fntype ? ( ! prototype_p ( fntype ) || stdarg_p ( fntype ) ) : ! libname ) ; cum -> decl = fndecl ; cum -> warn_empty = ! warn_abi || cum -> stdarg ; if ( ! cum -> warn_empty && fntype ) { function_args_iterator iter ; tree argtype ; bool seen_empty_type = false ; FOREACH_FUNCTION_ARGS ( fntype , argtype , iter ) { if ( argtype == error_mark_node || VOID_TYPE_P ( argtype ) ) break ; if ( TYPE_EMPTY_P ( argtype ) ) seen_empty_type = true ;


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

real_from_string ( & ext_80387_constants_table [ i ] , cst [ i ] ) ;


<s> if ( MASK_CLASS_P ( class1 ) != MASK_CLASS_P ( class2 ) ) { if ( ! ( INTEGER_CLASS_P ( class1 ) || INTEGER_CLASS_P ( class2 ) ) || GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return true ; } if ( SSE_CLASS_P ( class1 ) != SSE_CLASS_P ( class2 ) ) { if ( ! TARGET_SSE2 ) return true ; if ( ! ( INTEGER_CLASS_P ( class1 ) || INTEGER_CLASS_P ( class2 ) ) ) return true ; int msize = GET_MODE_SIZE ( mode ) ; if ( msize > UNITS_PER_WORD ) return true ; int minsize = GET_MODE_SIZE ( TARGET_SSE2 ? HImode : SImode ) ; if ( msize < minsize ) return true ; if ( ( SSE_CLASS_P ( class1 ) && ! TARGET_INTER_UNIT_MOVES_FROM_VEC ) || ( SSE_CLASS_P ( class2 ) && ! TARGET_INTER_UNIT_MOVES_TO_VEC ) ) return true ; } return false ;


<s> df_ref def ; FOR_EACH_INSN_DEF ( def , insn ) if ( DF_REF_REG_DEF_P ( def ) && ! DF_REF_IS_ARTIFICIAL ( def ) && ( regno1 == DF_REF_REGNO ( def ) || regno2 == DF_REF_REGNO ( def ) ) ) return true ; return false ;


<s> insn = PATTERN ( insn ) ; if ( GET_CODE ( insn ) == PARALLEL ) insn = XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( insn ) != SET ) return false ;


<s> if ( CALL_P ( insn ) ) return false ; insn = PATTERN ( insn ) ; if ( GET_CODE ( insn ) == PARALLEL ) insn = XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( insn ) != SET ) return false ; dst = SET_DEST ( insn ) ; if ( REG_P ( dst ) && HARD_REGISTER_P ( dst ) && ix86_function_arg_regno_p ( REGNO ( dst ) ) ) { if ( ! TEST_HARD_REG_BIT ( fixed_reg_set , REGNO ( dst ) ) && ix86_class_likely_spilled_p ( REGNO_REG_CLASS ( REGNO ( dst ) ) ) ) * is_spilled = true ; return true ; }


<s> FOR_EACH_INSN_USE ( use , insn ) if ( DF_REF_REG_MEM_P ( use ) && regno == DF_REF_REGNO ( use ) ) return true ; return false ;


<s> static bool is_imported_p ( rtx x ) { if ( ! TARGET_DLLIMPORT_DECL_ATTRIBUTES || GET_CODE ( x ) != SYMBOL_REF ) return false ;

return SYMBOL_REF_DLLIMPORT_P ( x ) || SYMBOL_REF_STUBVAR_P ( x ) ;


<s> if ( ! TARGET_64BIT ) return true ; canonic = ix86_canonical_va_list_type ( type ) ;

return ( canonic == ms_va_list_type_node || ( ix86_abi == MS_ABI && canonic == va_list_type_node ) ) ;


<s> if ( parts . base && ( ! REG_P ( parts . base ) || REGNO ( parts . base ) >= FIRST_PSEUDO_REGISTER ) && ( current_pass -> type == GIMPLE_PASS || ! pic_offset_table_rtx || ! REG_P ( parts . base ) || REGNO ( pic_offset_table_rtx ) != REGNO ( parts . base ) ) ) cost ++ ;

if ( parts . index && ( ! REG_P ( parts . index ) || REGNO ( parts . index ) >= FIRST_PSEUDO_REGISTER ) && ( current_pass -> type == GIMPLE_PASS || ! pic_offset_table_rtx || ! REG_P ( parts . index ) || REGNO ( pic_offset_table_rtx ) != REGNO ( parts . index ) ) ) cost ++ ;


<s> gcc_assert ( ok ) ; if ( parts . base && SUBREG_P ( parts . base ) ) parts . base = SUBREG_REG ( parts . base ) ; if ( parts . index && SUBREG_P ( parts . index ) ) parts . index = SUBREG_REG ( parts . index ) ; if ( parts . base && ( ! REG_P ( parts . base ) || REGNO ( parts . base ) >= FIRST_PSEUDO_REGISTER ) && ( current_pass -> type == GIMPLE_PASS || ! pic_offset_table_rtx || ! REG_P ( parts . base ) || REGNO ( pic_offset_table_rtx ) != REGNO ( parts . base ) ) ) cost ++ ; if ( parts . index && ( ! REG_P ( parts . index ) || REGNO ( parts . index ) >= FIRST_PSEUDO_REGISTER ) && ( current_pass -> type == GIMPLE_PASS || ! pic_offset_table_rtx || ! REG_P ( parts . index ) || REGNO ( pic_offset_table_rtx ) != REGNO ( parts . index ) ) ) cost ++ ; if ( TARGET_CPU_P ( K6 ) && ( ( ! parts . disp && parts . base && parts . index && parts . scale != <NUM_LIT> ) || ( parts . disp && ! parts . base && parts . index && parts . scale != <NUM_LIT> ) || ( ! parts . disp && parts . base && parts . index && parts . scale == <NUM_LIT> ) ) ) cost += <NUM_LIT> ;


<s> static void ix86_add_cfa_restore_note ( rtx_insn * insn , rtx reg , HOST_WIDE_INT cfa_offset ) { if ( ! crtl -> shrink_wrapped && cfa_offset <= cfun -> machine -> fs . red_zone_offset ) return ; if ( insn ) { add_reg_note ( insn , REG_CFA_RESTORE , reg ) ;

RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> if ( ! crtl -> shrink_wrapped && cfa_offset <= cfun -> machine -> fs . red_zone_offset ) return ; if ( insn ) {

add_reg_note ( insn , REG_CFA_RESTORE , reg ) ;


<s> if ( ! queued_cfa_restores ) return ; for ( last = queued_cfa_restores ; XEXP ( last , <NUM_LIT> ) ; last = XEXP ( last , <NUM_LIT> ) ) ; XEXP ( last , <NUM_LIT> ) = REG_NOTES ( insn ) ; REG_NOTES ( insn ) = queued_cfa_restores ; queued_cfa_restores = NULL_RTX ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> if ( ! queued_cfa_restores ) return ; for ( last = queued_cfa_restores ; XEXP ( last , <NUM_LIT> ) ; last = XEXP ( last , <NUM_LIT> ) ) ; XEXP ( last , <NUM_LIT> ) = REG_NOTES ( insn ) ; REG_NOTES ( insn ) = queued_cfa_restores ;


<s> else stmt_cost = ix86_cost -> add ; break ; case TRUNC_DIV_EXPR : case CEIL_DIV_EXPR : case FLOOR_DIV_EXPR : case ROUND_DIV_EXPR : case TRUNC_MOD_EXPR : case CEIL_MOD_EXPR : case FLOOR_MOD_EXPR : case RDIV_EXPR : case ROUND_MOD_EXPR : case EXACT_DIV_EXPR : stmt_cost = ix86_division_cost ( ix86_cost , mode ) ; break ; case RSHIFT_EXPR : case LSHIFT_EXPR : case LROTATE_EXPR : case RROTATE_EXPR : { tree op2 = gimple_assign_rhs2 ( stmt_info -> stmt ) ; stmt_cost = ix86_shift_rotate_cost ( ix86_cost , mode , TREE_CODE ( op2 ) == INTEGER_CST , cst_and_fits_in_hwi ( op2 ) ? int_cst_value ( op2 ) : - <NUM_LIT> , true , false , false , NULL , NULL ) ; } break ; case NOP_EXPR : if ( tree_nop_conversion_p ( TREE_TYPE ( gimple_assign_lhs ( stmt_info -> stmt ) ) , TREE_TYPE ( gimple_assign_rhs1 ( stmt_info -> stmt ) ) ) ) stmt_cost = <NUM_LIT> ; break ; case BIT_IOR_EXPR : case ABS_EXPR : case ABSU_EXPR : case MIN_EXPR : case MAX_EXPR : case BIT_XOR_EXPR : case BIT_AND_EXPR : case BIT_NOT_EXPR : if ( SSE_FLOAT_MODE_P ( mode ) && TARGET_SSE_MATH ) stmt_cost = ix86_cost -> sse_op ; else if ( VECTOR_MODE_P ( mode ) ) stmt_cost = ix86_vec_cost ( mode , ix86_cost -> sse_op ) ; else stmt_cost = ix86_cost -> add ; break ; default : break ; } } combined_fn cfn ; if ( ( kind == vector_stmt || kind == scalar_stmt ) && stmt_info && stmt_info -> stmt && ( cfn = gimple_call_combined_fn ( stmt_info -> stmt ) ) != CFN_LAST ) switch ( cfn ) { case CFN_FMA : stmt_cost = ix86_vec_cost ( mode , mode == SFmode ? ix86_cost -> fmass : ix86_cost -> fmasd ) ; break ; default : break ; } if ( ( kind == vec_construct || kind == vec_to_scalar ) && stmt_info && ( STMT_VINFO_TYPE ( stmt_info ) == load_vec_info_type || STMT_VINFO_TYPE ( stmt_info ) == store_vec_info_type ) && STMT_VINFO_MEMORY_ACCESS_TYPE ( stmt_info ) == VMAT_ELEMENTWISE && TREE_CODE ( DR_STEP ( STMT_VINFO_DATA_REF ( stmt_info ) ) ) != INTEGER_CST ) { stmt_cost = ix86_builtin_vectorization_cost ( kind , vectype , misalign ) ; stmt_cost *= ( TYPE_VECTOR_SUBPARTS ( vectype ) + <NUM_LIT> ) ; } if ( stmt_cost == - <NUM_LIT> ) stmt_cost = ix86_builtin_vectorization_cost ( kind , vectype , misalign ) ; if ( TARGET_BONNELL && kind == vector_stmt && vectype && GET_MODE_INNER ( TYPE_MODE ( vectype ) ) == DFmode ) stmt_cost *= <NUM_LIT> ; if ( where == vect_body && stmt_info && stmt_in_inner_loop_p ( stmt_info ) ) count *= <NUM_LIT> ; retval = ( unsigned ) ( count * stmt_cost ) ; if ( ( TARGET_SILVERMONT || TARGET_GOLDMONT || TARGET_GOLDMONT_PLUS || TARGET_TREMONT || TARGET_INTEL ) && stmt_info && stmt_info -> stmt ) { tree lhs_op = gimple_get_lhs ( stmt_info -> stmt ) ; if ( lhs_op && TREE_CODE ( TREE_TYPE ( lhs_op ) ) == INTEGER_TYPE ) retval = ( retval * <NUM_LIT> ) / <NUM_LIT> ; } cost [ where ] += retval ;


<s> break ; case RSHIFT_EXPR : case LSHIFT_EXPR : case LROTATE_EXPR : case RROTATE_EXPR : { tree op2 = gimple_assign_rhs2 ( stmt_info -> stmt ) ; stmt_cost = ix86_shift_rotate_cost ( ix86_cost , mode , TREE_CODE ( op2 ) == INTEGER_CST , cst_and_fits_in_hwi ( op2 ) ? int_cst_value ( op2 ) : - <NUM_LIT> , true , false , false , NULL , NULL ) ; } break ; case NOP_EXPR : if ( tree_nop_conversion_p ( TREE_TYPE ( gimple_assign_lhs ( stmt_info -> stmt ) ) , TREE_TYPE ( gimple_assign_rhs1 ( stmt_info -> stmt ) ) ) ) stmt_cost = <NUM_LIT> ; break ; case BIT_IOR_EXPR : case ABS_EXPR : case ABSU_EXPR : case MIN_EXPR : case MAX_EXPR : case BIT_XOR_EXPR : case BIT_AND_EXPR : case BIT_NOT_EXPR : if ( SSE_FLOAT_MODE_P ( mode ) && TARGET_SSE_MATH ) stmt_cost = ix86_cost -> sse_op ; else if ( VECTOR_MODE_P ( mode ) ) stmt_cost = ix86_vec_cost ( mode , ix86_cost -> sse_op ) ; else stmt_cost = ix86_cost -> add ; break ; default : break ; } } combined_fn cfn ; if ( ( kind == vector_stmt || kind == scalar_stmt ) && stmt_info && stmt_info -> stmt && ( cfn = gimple_call_combined_fn ( stmt_info -> stmt ) ) != CFN_LAST ) switch ( cfn ) { case CFN_FMA : stmt_cost = ix86_vec_cost ( mode , mode == SFmode ? ix86_cost -> fmass : ix86_cost -> fmasd ) ; break ; default : break ; } if ( ( kind == vec_construct || kind == vec_to_scalar ) && stmt_info && ( STMT_VINFO_TYPE ( stmt_info ) == load_vec_info_type || STMT_VINFO_TYPE ( stmt_info ) == store_vec_info_type ) && STMT_VINFO_MEMORY_ACCESS_TYPE ( stmt_info ) == VMAT_ELEMENTWISE && TREE_CODE ( DR_STEP ( STMT_VINFO_DATA_REF ( stmt_info ) ) ) != INTEGER_CST ) { stmt_cost = ix86_builtin_vectorization_cost ( kind , vectype , misalign ) ; stmt_cost *= ( TYPE_VECTOR_SUBPARTS ( vectype ) + <NUM_LIT> ) ; } if ( stmt_cost == - <NUM_LIT> ) stmt_cost = ix86_builtin_vectorization_cost ( kind , vectype , misalign ) ; if ( TARGET_BONNELL && kind == vector_stmt && vectype && GET_MODE_INNER ( TYPE_MODE ( vectype ) ) == DFmode ) stmt_cost *= <NUM_LIT> ; if ( where == vect_body && stmt_info && stmt_in_inner_loop_p ( stmt_info ) ) count *= <NUM_LIT> ; retval = ( unsigned ) ( count * stmt_cost ) ; if ( ( TARGET_SILVERMONT || TARGET_GOLDMONT || TARGET_GOLDMONT_PLUS || TARGET_TREMONT || TARGET_INTEL ) && stmt_info && stmt_info -> stmt ) {

tree lhs_op = gimple_get_lhs ( stmt_info -> stmt ) ;


<s> if ( set ) { rtx tmp = SET_SRC ( set ) ; if ( REG_P ( tmp ) && HARD_REGISTER_P ( tmp ) && ! TEST_HARD_REG_BIT ( fixed_reg_set , REGNO ( tmp ) ) && ix86_class_likely_spilled_p ( REGNO_REG_CLASS ( REGNO ( tmp ) ) ) ) return current_sched_info -> sched_max_insns_priority ; } return priority ;


<s> } if ( size <= <NUM_LIT> * probe_interval ) { HOST_WIDE_INT i ; for ( i = probe_interval ; i <= size ; i += probe_interval ) { rtx insn = pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - probe_interval ) , - <NUM_LIT> , m -> fs . cfa_reg == stack_pointer_rtx ) ; add_reg_note ( insn , REG_STACK_CHECK , const0_rtx ) ; emit_stack_probe ( stack_pointer_rtx ) ; emit_insn ( gen_blockage ( ) ) ; } HOST_WIDE_INT residual = ( i - probe_interval - size ) ; if ( residual ) { pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( residual ) , - <NUM_LIT> , m -> fs . cfa_reg == stack_pointer_rtx ) ; if ( protection_area ) emit_stack_probe ( stack_pointer_rtx ) ; } dump_stack_clash_frame_info ( PROBE_INLINE , residual != <NUM_LIT> ) ; } else { gcc_assert ( int_registers_saved ) ; struct scratch_reg sr ; get_scratch_register_on_entry ( & sr ) ; if ( sr . saved ) size -= UNITS_PER_WORD ; HOST_WIDE_INT rounded_size = size & - probe_interval ; rtx addr = plus_constant ( Pmode , stack_pointer_rtx , - rounded_size ) ; rtx insn ; if ( address_no_seg_operand ( addr , Pmode ) ) insn = emit_insn ( gen_rtx_SET ( sr . reg , addr ) ) ; else { emit_move_insn ( sr . reg , GEN_INT ( - rounded_size ) ) ; insn = emit_insn ( gen_rtx_SET ( sr . reg , gen_rtx_PLUS ( Pmode , sr . reg , stack_pointer_rtx ) ) ) ; } if ( m -> fs . cfa_reg == stack_pointer_rtx ) { add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , sr . reg , m -> fs . cfa_offset + rounded_size ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } rtx size_rtx = GEN_INT ( rounded_size ) ; insn = emit_insn ( gen_adjust_stack_and_probe ( Pmode , sr . reg , sr . reg , size_rtx ) ) ; if ( m -> fs . cfa_reg == stack_pointer_rtx ) { m -> fs . cfa_offset += rounded_size ; add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , stack_pointer_rtx , m -> fs . cfa_offset ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } m -> fs . sp_offset += rounded_size ; emit_insn ( gen_blockage ( ) ) ; if ( size != rounded_size ) {


<s> rtx_insn * insn_pop = emit_insn ( gen_pop ( dummy_reg ) ) ; m -> fs . sp_offset -= UNITS_PER_WORD ; if ( m -> fs . cfa_reg == stack_pointer_rtx ) { m -> fs . cfa_offset -= UNITS_PER_WORD ; rtx x = plus_constant ( Pmode , stack_pointer_rtx , - UNITS_PER_WORD ) ; x = gen_rtx_SET ( stack_pointer_rtx , x ) ; add_reg_note ( insn_push , REG_CFA_ADJUST_CFA , x ) ; RTX_FRAME_RELATED_P ( insn_push ) = <NUM_LIT> ; x = plus_constant ( Pmode , stack_pointer_rtx , UNITS_PER_WORD ) ; x = gen_rtx_SET ( stack_pointer_rtx , x ) ; add_reg_note ( insn_pop , REG_CFA_ADJUST_CFA , x ) ; RTX_FRAME_RELATED_P ( insn_pop ) = <NUM_LIT> ; } emit_insn ( gen_blockage ( ) ) ; } const HOST_WIDE_INT probe_interval = get_probe_interval ( ) ; const int dope = <NUM_LIT> * UNITS_PER_WORD ; if ( protection_area ) size += probe_interval + dope ; else if ( size < ( <NUM_LIT> << param_stack_clash_protection_guard_size ) ) { pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - size ) , - <NUM_LIT> , m -> fs . cfa_reg == stack_pointer_rtx ) ; dump_stack_clash_frame_info ( NO_PROBE_SMALL_FRAME , true ) ; return ; } if ( size <= <NUM_LIT> * probe_interval ) { HOST_WIDE_INT i ; for ( i = probe_interval ; i <= size ; i += probe_interval ) { rtx insn = pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - probe_interval ) , - <NUM_LIT> , m -> fs . cfa_reg == stack_pointer_rtx ) ; add_reg_note ( insn , REG_STACK_CHECK , const0_rtx ) ; emit_stack_probe ( stack_pointer_rtx ) ; emit_insn ( gen_blockage ( ) ) ; } HOST_WIDE_INT residual = ( i - probe_interval - size ) ; if ( residual ) { pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( residual ) , - <NUM_LIT> , m -> fs . cfa_reg == stack_pointer_rtx ) ; if ( protection_area ) emit_stack_probe ( stack_pointer_rtx ) ; } dump_stack_clash_frame_info ( PROBE_INLINE , residual != <NUM_LIT> ) ; } else { gcc_assert ( int_registers_saved ) ; struct scratch_reg sr ; get_scratch_register_on_entry ( & sr ) ; if ( sr . saved ) size -= UNITS_PER_WORD ; HOST_WIDE_INT rounded_size = size & - probe_interval ; rtx addr = plus_constant ( Pmode , stack_pointer_rtx , - rounded_size ) ; rtx insn ; if ( address_no_seg_operand ( addr , Pmode ) ) insn = emit_insn ( gen_rtx_SET ( sr . reg , addr ) ) ;


<s> emit_insn ( gen_blockage ( ) ) ; } if ( size < ( <NUM_LIT> << param_stack_clash_protection_guard_size ) ) { pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - size ) , - <NUM_LIT> , m -> fs . cfa_reg == stack_pointer_rtx ) ; dump_stack_clash_frame_info ( NO_PROBE_SMALL_FRAME , true ) ; return ; } HOST_WIDE_INT probe_interval = get_probe_interval ( ) ; if ( size <= <NUM_LIT> * probe_interval ) { HOST_WIDE_INT i ; for ( i = probe_interval ; i <= size ; i += probe_interval ) { rtx insn = pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - probe_interval ) , - <NUM_LIT> , m -> fs . cfa_reg == stack_pointer_rtx ) ; add_reg_note ( insn , REG_STACK_CHECK , const0_rtx ) ; emit_stack_probe ( stack_pointer_rtx ) ; emit_insn ( gen_blockage ( ) ) ; } HOST_WIDE_INT residual = ( i - probe_interval - size ) ; if ( residual ) pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( residual ) , - <NUM_LIT> , m -> fs . cfa_reg == stack_pointer_rtx ) ; dump_stack_clash_frame_info ( PROBE_INLINE , residual != <NUM_LIT> ) ; } else { gcc_assert ( int_registers_saved ) ; struct scratch_reg sr ; get_scratch_register_on_entry ( & sr ) ; if ( sr . saved ) size -= UNITS_PER_WORD ; HOST_WIDE_INT rounded_size = size & - probe_interval ; rtx addr = plus_constant ( Pmode , stack_pointer_rtx , - rounded_size ) ; rtx insn ; if ( address_no_seg_operand ( addr , Pmode ) ) insn = emit_insn ( gen_rtx_SET ( sr . reg , addr ) ) ; else { emit_move_insn ( sr . reg , GEN_INT ( - rounded_size ) ) ; insn = emit_insn ( gen_rtx_SET ( sr . reg , gen_rtx_PLUS ( Pmode , sr . reg , stack_pointer_rtx ) ) ) ; } if ( m -> fs . cfa_reg == stack_pointer_rtx ) { add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , sr . reg , m -> fs . cfa_offset + rounded_size ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } rtx size_rtx = GEN_INT ( rounded_size ) ; insn = emit_insn ( gen_adjust_stack_and_probe ( Pmode , sr . reg , sr . reg , size_rtx ) ) ;


<s> dump_stack_clash_frame_info ( PROBE_INLINE , residual != <NUM_LIT> ) ; } else { gcc_assert ( int_registers_saved ) ; struct scratch_reg sr ; get_scratch_register_on_entry ( & sr ) ; if ( sr . saved ) size -= UNITS_PER_WORD ; HOST_WIDE_INT rounded_size = size & - probe_interval ; rtx addr = plus_constant ( Pmode , stack_pointer_rtx , - rounded_size ) ; rtx insn ; if ( address_no_seg_operand ( addr , Pmode ) ) insn = emit_insn ( gen_rtx_SET ( sr . reg , addr ) ) ; else { emit_move_insn ( sr . reg , GEN_INT ( - rounded_size ) ) ; insn = emit_insn ( gen_rtx_SET ( sr . reg , gen_rtx_PLUS ( Pmode , sr . reg , stack_pointer_rtx ) ) ) ; } if ( m -> fs . cfa_reg == stack_pointer_rtx ) { add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , sr . reg , m -> fs . cfa_offset + rounded_size ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } rtx size_rtx = GEN_INT ( rounded_size ) ; insn = emit_insn ( gen_adjust_stack_and_probe ( Pmode , sr . reg , sr . reg , size_rtx ) ) ; if ( m -> fs . cfa_reg == stack_pointer_rtx ) { m -> fs . cfa_offset += rounded_size ; add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , stack_pointer_rtx , m -> fs . cfa_offset ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } m -> fs . sp_offset += rounded_size ; emit_insn ( gen_blockage ( ) ) ; if ( size != rounded_size ) pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( rounded_size - size ) , - <NUM_LIT> , m -> fs . cfa_reg == stack_pointer_rtx ) ;

dump_stack_clash_frame_info ( PROBE_LOOP , size != rounded_size ) ;


<s> static bool ix86_allocate_stack_slots_for_args ( void ) {

return ! ix86_function_naked ( current_function_decl ) ;


<s> static bool ix86_allocate_stack_slots_for_args ( void ) { return ! ix86_function_naked ( current_function_decl ) ;


<s> static unsigned HOST_WIDE_INT ix86_asan_shadow_offset ( void ) {


<s> int i , filler_count = ( TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ) ; unsigned int filler_cc = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < filler_count ; i += <NUM_LIT> ) fprintf ( out_file , ASM_LONG <STR_LIT> , filler_cc ) ; } SUBTARGET_ASM_UNWIND_INIT ( out_file ) ; ASM_OUTPUT_LABEL ( out_file , fname ) ; if ( is_ms_hook ) { if ( TARGET_64BIT ) { fputs ( ASM_BYTE <STR_LIT> , out_file ) ; } else { fputs ( ASM_BYTE <STR_LIT> , out_file ) ;


<s> if ( is_ms_hook ) { int i , filler_count = ( TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ) ; unsigned int filler_cc = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < filler_count ; i += <NUM_LIT> ) fprintf ( out_file , ASM_LONG <STR_LIT> , filler_cc ) ; } SUBTARGET_ASM_UNWIND_INIT ( out_file ) ; ASM_OUTPUT_LABEL ( out_file , fname ) ; if ( is_ms_hook ) { if ( TARGET_64BIT ) {


<s> extract_insn_cached ( insn ) ; for ( i = recog_data . n_operands - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { rtx op = recog_data . operand [ i ] ; if ( MEM_P ( op ) ) { constrain_operands_cached ( insn , reload_completed ) ; if ( which_alternative != - <NUM_LIT> ) { const char * constraints = recog_data . constraints [ i ] ; int alt = which_alternative ; while ( * constraints == '=' || * constraints == '+' ) constraints ++ ; while ( alt -- > <NUM_LIT> ) while ( * constraints ++ != ',' ) ; if ( * constraints == 'X' ) continue ; } int len = memory_address_length ( XEXP ( op , <NUM_LIT> ) , false ) ; if ( ! ADDR_SPACE_GENERIC_P ( MEM_ADDR_SPACE ( op ) ) ) len ++ ; return len ; }


<s> int i ; extract_insn_cached ( insn ) ; for ( i = recog_data . n_operands - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) if ( CONSTANT_P ( recog_data . operand [ i ] ) ) { enum attr_mode mode = get_attr_mode ( insn ) ; gcc_assert ( ! len ) ; if ( shortform && CONST_INT_P ( recog_data . operand [ i ] ) ) { HOST_WIDE_INT ival = INTVAL ( recog_data . operand [ i ] ) ; switch ( mode ) { case MODE_QI : len = <NUM_LIT> ; continue ; case MODE_HI : ival = trunc_int_for_mode ( ival , HImode ) ; break ; case MODE_SI : ival = trunc_int_for_mode ( ival , SImode ) ; break ; default : break ; } if ( IN_RANGE ( ival , - <NUM_LIT> , <NUM_LIT> ) ) {


<s> extract_insn_cached ( insn ) ; for ( i = recog_data . n_operands - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) if ( REG_P ( recog_data . operand [ i ] ) ) { if ( GET_MODE ( recog_data . operand [ i ] ) == DImode && GENERAL_REG_P ( recog_data . operand [ i ] ) ) return <NUM_LIT> + <NUM_LIT> ; } else { if ( MEM_P ( recog_data . operand [ i ] ) && x86_extended_reg_mentioned_p ( recog_data . operand [ i ] ) ) return <NUM_LIT> + <NUM_LIT> ; }


<s> if ( ! has_0f_opcode || has_vex_w ) return <NUM_LIT> + <NUM_LIT> ; if ( ! TARGET_64BIT ) return <NUM_LIT> + <NUM_LIT> ; extract_insn_cached ( insn ) ; for ( i = recog_data . n_operands - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) if ( REG_P ( recog_data . operand [ i ] ) ) { if ( GET_MODE ( recog_data . operand [ i ] ) == DImode && GENERAL_REG_P ( recog_data . operand [ i ] ) ) return <NUM_LIT> + <NUM_LIT> ; } else {

if ( MEM_P ( recog_data . operand [ i ] ) && x86_extended_reg_mentioned_p ( recog_data . operand [ i ] ) ) return <NUM_LIT> + <NUM_LIT> ;


<s> else if ( TARGET_AVX && all ) { modes -> safe_push ( V16QImode ) ; modes -> safe_push ( V32QImode ) ; } else if ( TARGET_SSE2 ) modes -> safe_push ( V16QImode ) ; if ( TARGET_MMX_WITH_SSE ) modes -> safe_push ( V8QImode ) ;

if ( TARGET_SSE2 ) modes -> safe_push ( V4QImode ) ;


<s> int nbytes = <NUM_LIT> , njumps = <NUM_LIT> ; bool isjump = false ; for ( insn = start ; insn ; insn = NEXT_INSN ( insn ) ) { int min_size ; if ( LABEL_P ( insn ) ) { align_flags alignment = label_to_alignment ( insn ) ; int align = alignment . levels [ <NUM_LIT> ] . log ; int max_skip = alignment . levels [ <NUM_LIT> ] . maxskip ; if ( max_skip > <NUM_LIT> ) max_skip = <NUM_LIT> ; if ( align <= <NUM_LIT> || ( align <= <NUM_LIT> && max_skip != ( <NUM_LIT> << align ) - <NUM_LIT> ) ) max_skip = <NUM_LIT> ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( insn ) , max_skip ) ; if ( max_skip ) { while ( nbytes + max_skip >= <NUM_LIT> ) { start = NEXT_INSN ( start ) ; if ( ( JUMP_P ( start ) && asm_noperands ( PATTERN ( start ) ) < <NUM_LIT> ) || CALL_P ( start ) ) njumps -- , isjump = true ; else isjump = false ; nbytes -= ix86_min_insn_size ( start ) ; } } continue ; } min_size = ix86_min_insn_size ( insn ) ; nbytes += min_size ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( insn ) , min_size ) ; if ( ( JUMP_P ( insn ) && asm_noperands ( PATTERN ( insn ) ) < <NUM_LIT> ) || CALL_P ( insn ) ) njumps ++ ; else continue ; while ( njumps > <NUM_LIT> ) { start = NEXT_INSN ( start ) ; if ( ( JUMP_P ( start ) && asm_noperands ( PATTERN ( start ) ) < <NUM_LIT> ) || CALL_P ( start ) ) njumps -- , isjump = true ; else isjump = false ; nbytes -= ix86_min_insn_size ( start ) ; } gcc_assert ( njumps >= <NUM_LIT> ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( start ) , INSN_UID ( insn ) , nbytes ) ; if ( njumps == <NUM_LIT> && isjump && nbytes < <NUM_LIT> ) {

int padsize = <NUM_LIT> - nbytes + ix86_min_insn_size ( insn ) ;


<s> if ( max_skip ) { while ( nbytes + max_skip >= <NUM_LIT> ) { start = NEXT_INSN ( start ) ; if ( ( JUMP_P ( start ) && asm_noperands ( PATTERN ( start ) ) < <NUM_LIT> ) || CALL_P ( start ) ) njumps -- , isjump = true ; else isjump = false ; nbytes -= ix86_min_insn_size ( start ) ; } } continue ; } min_size = ix86_min_insn_size ( insn ) ; nbytes += min_size ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( insn ) , min_size ) ; if ( ( JUMP_P ( insn ) && asm_noperands ( PATTERN ( insn ) ) < <NUM_LIT> ) || CALL_P ( insn ) ) njumps ++ ; else continue ; while ( njumps > <NUM_LIT> ) { start = NEXT_INSN ( start ) ;


<s> regno2 = true_regnum ( operands [ <NUM_LIT> ] ) ; if ( regno0 == regno1 || regno0 == regno2 ) return false ; else return ! ix86_lea_outperforms ( insn , regno0 , regno1 , regno2 , <NUM_LIT> , false ) ;


<s> static int ix86_avx_u128_mode_after ( int mode , rtx_insn * insn ) { rtx pat = PATTERN ( insn ) ; if ( vzeroupper_pattern ( pat , VOIDmode ) || vzeroall_pattern ( pat , VOIDmode ) ) return AVX_U128_CLEAN ;


<s> bool avx_upper_reg_found = false ; note_stores ( insn , ix86_check_avx_upper_stores , & avx_upper_reg_found ) ; return avx_upper_reg_found ? AVX_U128_DIRTY : AVX_U128_CLEAN ; }


<s> tree arg ; for ( arg = DECL_ARGUMENTS ( current_function_decl ) ; arg ; arg = TREE_CHAIN ( arg ) ) {

rtx incoming = DECL_INCOMING_RTL ( arg ) ;


<s> tree arg ; for ( arg = DECL_ARGUMENTS ( current_function_decl ) ; arg ; arg = TREE_CHAIN ( arg ) ) { rtx incoming = DECL_INCOMING_RTL ( arg ) ; if ( incoming && ix86_check_avx_upper_register ( incoming ) ) return AVX_U128_DIRTY ; } return AVX_U128_CLEAN ;


<s> if ( reg && ix86_check_avx_upper_register ( reg ) ) return AVX_U128_DIRTY ;


<s> static int ix86_avx_u128_mode_exit ( void ) { rtx reg = crtl -> return_rtx ; if ( reg && ix86_check_avx_upper_register ( reg ) ) return AVX_U128_DIRTY ;


<s> if ( DEBUG_INSN_P ( insn ) ) return AVX_U128_ANY ; if ( CALL_P ( insn ) ) { rtx link ; for ( link = CALL_INSN_FUNCTION_USAGE ( insn ) ; link ; link = XEXP ( link , <NUM_LIT> ) ) { if ( GET_CODE ( XEXP ( link , <NUM_LIT> ) ) == USE ) { rtx arg = XEXP ( XEXP ( link , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ix86_check_avx_upper_register ( arg ) ) return AVX_U128_DIRTY ; } } bool avx_upper_reg_found = false ; note_stores ( insn , ix86_check_avx_upper_stores , & avx_upper_reg_found ) ; if ( avx_upper_reg_found ) return AVX_U128_DIRTY ; const function_abi & abi = insn_callee_abi ( insn ) ; if ( ! hard_reg_set_subset_p ( reg_class_contents [ SSE_REGS ] , abi . mode_clobbers ( V4DImode ) ) ) return AVX_U128_ANY ; return AVX_U128_CLEAN ; } subrtx_iterator :: array_type array ; rtx set = single_set ( insn ) ; if ( set ) { rtx dest = SET_DEST ( set ) ; rtx src = SET_SRC ( set ) ; if ( ix86_check_avx_upper_register ( dest ) ) { if ( standard_sse_constant_p ( src , GET_MODE ( dest ) ) != <NUM_LIT> ) return AVX_U128_DIRTY ; else return AVX_U128_ANY ; } else { FOR_EACH_SUBRTX ( iter , array , src , NONCONST ) if ( ix86_check_avx_upper_register ( * iter ) ) return AVX_U128_DIRTY ; } return AVX_U128_ANY ; } FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) if ( ix86_check_avx_upper_register ( * iter ) ) return AVX_U128_DIRTY ;


<s> if ( ! direct_extern_access ) ix86_has_no_direct_extern_access = true ; return default_binds_local_p_3 ( exp , flag_shlib != <NUM_LIT> , true , direct_extern_access , ( direct_extern_access && ( ! flag_pic || ( TARGET_64BIT && HAVE_LD_PIE_COPYRELOC != <NUM_LIT> ) ) ) ) ;


<s> bool direct_extern_access = ( ix86_direct_extern_access && ! ( VAR_OR_FUNCTION_DECL_P ( exp ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( exp ) ) ) ) ; if ( ! direct_extern_access ) ix86_has_no_direct_extern_access = true ;

return default_binds_local_p_3 ( exp , flag_shlib != <NUM_LIT> , true , direct_extern_access , ( direct_extern_access && ( ! flag_pic || ( TARGET_64BIT && HAVE_LD_PIE_COPYRELOC != <NUM_LIT> ) ) ) ) ;


<s> if ( TARGET_64BIT ) { sysv_va_list_type_node = ix86_build_builtin_va_list_64 ( ) ; tree char_ptr_type = build_pointer_type ( char_type_node ) ; tree attr = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , TYPE_ATTRIBUTES ( char_ptr_type ) ) ; ms_va_list_type_node = build_type_attribute_variant ( char_ptr_type , attr ) ; return ( ( ix86_abi == MS_ABI ) ? ms_va_list_type_node : sysv_va_list_type_node ) ; } else { return build_pointer_type ( char_type_node ) ; }


<s> static tree ix86_build_builtin_va_list ( void ) { if ( TARGET_64BIT ) { sysv_va_list_type_node = ix86_build_builtin_va_list_64 ( ) ; tree char_ptr_type = build_pointer_type ( char_type_node ) ; tree attr = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , TYPE_ATTRIBUTES ( char_ptr_type ) ) ; ms_va_list_type_node = build_type_attribute_variant ( char_ptr_type , attr ) ; return ( ( ix86_abi == MS_ABI ) ? ms_va_list_type_node : sysv_va_list_type_node ) ; } else { return build_pointer_type ( char_type_node ) ;


<s> case E_V8HFmode : case E_V16HFmode : case E_V32HFmode : case E_V16SFmode : case E_V8SFmode : case E_V4SFmode : case E_V2SFmode : case E_V8DFmode : case E_V4DFmode : case E_V2DFmode : n_elt = GET_MODE_NUNITS ( mode ) ; v = rtvec_alloc ( n_elt ) ; scalar_mode = GET_MODE_INNER ( mode ) ;


<s> case E_V16SFmode : case E_V8SImode : case E_V4SImode : case E_V8SFmode : case E_V4SFmode : case E_V2SFmode : case E_V2SImode : vec_mode = mode ; imode = SImode ; break ; case E_V8DImode : case E_V4DImode : case E_V2DImode : case E_V8DFmode : case E_V4DFmode : case E_V2DFmode : vec_mode = mode ; imode = DImode ; break ; case E_TImode : case E_TFmode : vec_mode = VOIDmode ; imode = TImode ; break ; default : gcc_unreachable ( ) ; } machine_mode inner_mode = GET_MODE_INNER ( mode ) ; w = wi :: set_bit_in_zero ( GET_MODE_BITSIZE ( inner_mode ) - <NUM_LIT> , GET_MODE_BITSIZE ( inner_mode ) ) ; if ( invert ) w = wi :: bit_not ( w ) ; mask = immed_wide_int_const ( w , imode ) ; mask = gen_lowpart ( inner_mode , mask ) ;

if ( vec_mode == VOIDmode ) return force_reg ( inner_mode , mask ) ;


<s> fp = FLOAT_TYPE_P ( vectype ) ; mode = TYPE_MODE ( vectype ) ; } switch ( type_of_cost ) { case scalar_stmt : return fp ? ix86_cost -> addss : COSTS_N_INSNS ( <NUM_LIT> ) ; case scalar_load : return COSTS_N_INSNS ( fp ? ix86_cost -> sse_load [ <NUM_LIT> ] : ix86_cost -> int_load [ <NUM_LIT> ] ) / <NUM_LIT> ; case scalar_store : return COSTS_N_INSNS ( fp ? ix86_cost -> sse_store [ <NUM_LIT> ] : ix86_cost -> int_store [ <NUM_LIT> ] ) / <NUM_LIT> ; case vector_stmt : return ix86_vec_cost ( mode , fp ? ix86_cost -> addss : ix86_cost -> sse_op ) ; case vector_load : index = sse_store_index ( mode ) ; if ( index < <NUM_LIT> ) index = <NUM_LIT> ; return COSTS_N_INSNS ( ix86_cost -> sse_load [ index ] ) / <NUM_LIT> ; case vector_store : index = sse_store_index ( mode ) ; if ( index < <NUM_LIT> ) index = <NUM_LIT> ; return COSTS_N_INSNS ( ix86_cost -> sse_store [ index ] ) / <NUM_LIT> ; case vec_to_scalar : case scalar_to_vec : return ix86_vec_cost ( mode , ix86_cost -> sse_op ) ; case unaligned_load : index = sse_store_index ( mode ) ; if ( index < <NUM_LIT> ) index = <NUM_LIT> ; return COSTS_N_INSNS ( ix86_cost -> sse_unaligned_load [ index ] ) / <NUM_LIT> ; case unaligned_store : index = sse_store_index ( mode ) ; if ( index < <NUM_LIT> ) index = <NUM_LIT> ; return COSTS_N_INSNS ( ix86_cost -> sse_unaligned_store [ index ] ) / <NUM_LIT> ; case vector_gather_load : return ix86_vec_cost ( mode , COSTS_N_INSNS ( ix86_cost -> gather_static + ix86_cost -> gather_per_elt * TYPE_VECTOR_SUBPARTS ( vectype ) ) / <NUM_LIT> ) ; case vector_scatter_store : return ix86_vec_cost ( mode , COSTS_N_INSNS ( ix86_cost -> scatter_static + ix86_cost -> scatter_per_elt * TYPE_VECTOR_SUBPARTS ( vectype ) ) / <NUM_LIT> ) ; case cond_branch_taken : return ix86_cost -> cond_taken_branch_cost ; case cond_branch_not_taken : return ix86_cost -> cond_not_taken_branch_cost ; case vec_perm : case vec_promote_demote : return ix86_vec_cost ( mode , ix86_cost -> sse_op ) ; case vec_construct : { int n = TYPE_VECTOR_SUBPARTS ( vectype ) ; if ( GET_MODE_BITSIZE ( mode ) <= <NUM_LIT> ) return ( n - <NUM_LIT> ) * ix86_cost -> sse_op ; else if ( GET_MODE_BITSIZE ( mode ) == <NUM_LIT> ) return ( ( n - <NUM_LIT> ) * ix86_cost -> sse_op + ix86_vec_cost ( mode , ix86_cost -> addss ) ) ; else if ( GET_MODE_BITSIZE ( mode ) == <NUM_LIT> ) return ( ( n - <NUM_LIT> ) * ix86_cost -> sse_op + <NUM_LIT> * ix86_vec_cost ( mode , ix86_cost -> addss ) ) ; gcc_unreachable ( ) ; } default : gcc_unreachable ( ) ; }


<s> switch ( GET_CODE ( x ) ) { CASE_CONST_ANY : return false ;


<s> if ( ! op0_preserve_value && GET_CODE ( * op0 ) == FLOAT && MEM_P ( XEXP ( * op0 , <NUM_LIT> ) ) && REG_P ( * op1 ) ) {

enum rtx_code scode = swap_condition ( ( enum rtx_code ) * code ) ;


<s> if ( MAYBE_SSE_CLASS_P ( regclass ) || MAYBE_MMX_CLASS_P ( regclass ) ) {


<s> if ( stack_realign_fp ) return ( ( from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) || ( from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) ) ;

else return to == STACK_POINTER_REGNUM ? ! frame_pointer_needed : true ;


<s> bool always_inline = ( DECL_DISREGARD_INLINE_LIMITS ( callee ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( callee ) ) ) ; if ( TARGET_GENERAL_REGS_ONLY_P ( callee_opts -> x_ix86_target_flags ) ) always_inline_safe_mask |= MASK_80387 ; cgraph_node * callee_node = cgraph_node :: get ( callee ) ; if ( ( ( caller_opts -> x_ix86_isa_flags & callee_opts -> x_ix86_isa_flags ) != callee_opts -> x_ix86_isa_flags ) || ( ( caller_opts -> x_ix86_isa_flags2 & callee_opts -> x_ix86_isa_flags2 ) != callee_opts -> x_ix86_isa_flags2 ) ) ret = false ; else if ( ( ! always_inline && caller_opts -> x_target_flags != callee_opts -> x_target_flags ) || ( caller_opts -> x_target_flags & ~ always_inline_safe_mask ) != ( callee_opts -> x_target_flags & ~ always_inline_safe_mask ) ) ret = false ; else if ( caller_opts -> arch != callee_opts -> arch ) ret = false ; else if ( ! always_inline && caller_opts -> tune != callee_opts -> tune ) ret = false ; else if ( caller_opts -> x_ix86_fpmath != callee_opts -> x_ix86_fpmath && ( ! ipa_fn_summaries || ipa_fn_summaries -> get ( callee_node ) == NULL || ipa_fn_summaries -> get ( callee_node ) -> fp_expressions ) ) ret = false ; else if ( ! always_inline && caller_opts -> branch_cost != callee_opts -> branch_cost ) ret = false ; else ret = true ;


<s> bool always_inline = ( DECL_DISREGARD_INLINE_LIMITS ( callee ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( callee ) ) ) ; if ( TARGET_GENERAL_REGS_ONLY_P ( callee_opts -> x_ix86_target_flags ) ) always_inline_safe_mask |= MASK_80387 ; cgraph_node * callee_node = cgraph_node :: get ( callee ) ; if ( ( ( caller_opts -> x_ix86_isa_flags & callee_opts -> x_ix86_isa_flags ) != callee_opts -> x_ix86_isa_flags ) || ( ( caller_opts -> x_ix86_isa_flags2 & callee_opts -> x_ix86_isa_flags2 ) != callee_opts -> x_ix86_isa_flags2 ) ) ret = false ; else if ( ( ! always_inline && caller_opts -> x_target_flags != callee_opts -> x_target_flags ) || ( caller_opts -> x_target_flags & ~ always_inline_safe_mask ) != ( callee_opts -> x_target_flags & ~ always_inline_safe_mask ) ) ret = false ; else if ( caller_opts -> arch != callee_opts -> arch ) ret = false ; else if ( ! always_inline && caller_opts -> tune != callee_opts -> tune ) ret = false ; else if ( caller_opts -> x_ix86_fpmath != callee_opts -> x_ix86_fpmath && ( ! ipa_fn_summaries || ipa_fn_summaries -> get ( callee_node ) == NULL || ipa_fn_summaries -> get ( callee_node ) -> fp_expressions ) ) ret = false ; else if ( ! always_inline && caller_opts -> branch_cost != callee_opts -> branch_cost ) ret = false ;


<s> if ( ! reload_completed || frame_pointer_needed || cfun -> machine -> func_type != TYPE_NORMAL ) return <NUM_LIT> ;

if ( crtl -> args . pops_args && crtl -> args . size >= <NUM_LIT> ) return <NUM_LIT> ;


<s> gcc_assert ( ! DECIMAL_FLOAT_MODE_P ( mode ) ) ; return CCFPmode ; } switch ( code ) { case EQ : case NE : return CCZmode ; case GEU : case LTU : rtx geu ; if ( GET_CODE ( op0 ) == PLUS && ( rtx_equal_p ( op1 , XEXP ( op0 , <NUM_LIT> ) ) || rtx_equal_p ( op1 , XEXP ( op0 , <NUM_LIT> ) ) ) ) return CCCmode ; else if ( code == LTU && GET_CODE ( op0 ) == NEG && GET_CODE ( geu = XEXP ( op0 , <NUM_LIT> ) ) == GEU && REG_P ( XEXP ( geu , <NUM_LIT> ) ) && ( GET_MODE ( XEXP ( geu , <NUM_LIT> ) ) == CCCmode || GET_MODE ( XEXP ( geu , <NUM_LIT> ) ) == CCmode ) && REGNO ( XEXP ( geu , <NUM_LIT> ) ) == FLAGS_REG && XEXP ( geu , <NUM_LIT> ) == const0_rtx && GET_CODE ( op1 ) == LTU && REG_P ( XEXP ( op1 , <NUM_LIT> ) ) && GET_MODE ( XEXP ( op1 , <NUM_LIT> ) ) == GET_MODE ( XEXP ( geu , <NUM_LIT> ) ) && REGNO ( XEXP ( op1 , <NUM_LIT> ) ) == FLAGS_REG && XEXP ( op1 , <NUM_LIT> ) == const0_rtx ) return CCCmode ; else return CCmode ; case GTU : case LEU :


<s> case LTU : rtx geu ; if ( GET_CODE ( op0 ) == PLUS && ( rtx_equal_p ( op1 , XEXP ( op0 , <NUM_LIT> ) ) || rtx_equal_p ( op1 , XEXP ( op0 , <NUM_LIT> ) ) ) ) return CCCmode ; else if ( code == LTU && GET_CODE ( op0 ) == NEG && GET_CODE ( geu = XEXP ( op0 , <NUM_LIT> ) ) == GEU && REG_P ( XEXP ( geu , <NUM_LIT> ) ) && ( GET_MODE ( XEXP ( geu , <NUM_LIT> ) ) == CCCmode || GET_MODE ( XEXP ( geu , <NUM_LIT> ) ) == CCmode ) && REGNO ( XEXP ( geu , <NUM_LIT> ) ) == FLAGS_REG && XEXP ( geu , <NUM_LIT> ) == const0_rtx && GET_CODE ( op1 ) == LTU && REG_P ( XEXP ( op1 , <NUM_LIT> ) ) && GET_MODE ( XEXP ( op1 , <NUM_LIT> ) ) == GET_MODE ( XEXP ( geu , <NUM_LIT> ) ) && REGNO ( XEXP ( op1 , <NUM_LIT> ) ) == FLAGS_REG && XEXP ( op1 , <NUM_LIT> ) == const0_rtx ) return CCCmode ; else return CCmode ; case GTU : case LEU : return CCmode ;


<s> if ( m1 == CCZmode && ( m2 == CCGCmode || m2 == CCGOCmode || m2 == CCNOmode ) ) return m2 ; else if ( m2 == CCZmode && ( m1 == CCGCmode || m1 == CCGOCmode || m1 == CCNOmode ) ) return m1 ; switch ( m1 ) { default : gcc_unreachable ( ) ; case E_CCmode : case E_CCGCmode : case E_CCGOCmode : case E_CCNOmode : case E_CCAmode : case E_CCCmode : case E_CCOmode :


<s> return cfun ? cfun -> machine -> call_abi : ix86_abi ;


<s> return ( SSE_REG_P ( exp ) && ! EXT_REX_SSE_REG_P ( exp ) && GET_MODE_BITSIZE ( GET_MODE ( exp ) ) > <NUM_LIT> ) ;


<s> gcc_assert ( GET_CODE ( set ) == SET ) ; mem = XEXP ( set , opnum ) ; while ( SUBREG_P ( mem ) ) mem = SUBREG_REG ( mem ) ; gcc_assert ( MEM_P ( mem ) ) ;

return volatile_ok || ! MEM_VOLATILE_P ( mem ) ;


<s> bool ix86_check_no_addr_space ( rtx insn ) { subrtx_var_iterator :: array_type array ;

FOR_EACH_SUBRTX_VAR ( iter , array , PATTERN ( insn ) , ALL ) {


if ( MEM_P ( x ) && ! ADDR_SPACE_GENERIC_P ( MEM_ADDR_SPACE ( x ) ) ) return false ;


<s> case SIREG : case DIREG : case SSE_FIRST_REG : case FP_TOP_REG : case FP_SECOND_REG : return true ; default : break ; }


<s> static bool ix86_class_likely_spilled_p ( reg_class_t rclass ) { switch ( rclass ) { case AREG : case DREG : case CREG : case BREG : case AD_REGS : case SIREG : case DIREG : case SSE_FIRST_REG : case FP_TOP_REG :


<s> static unsigned char ix86_class_max_nregs ( reg_class_t rclass , machine_mode mode ) { if ( MAYBE_INTEGER_CLASS_P ( rclass ) ) { if ( mode == XFmode ) return ( TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ) ; else if ( mode == XCmode ) return ( TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ) ; else return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ; } else { if ( COMPLEX_MODE_P ( mode ) ) return <NUM_LIT> ; else return <NUM_LIT> ; }


<s> if ( indirect_return_via_cx ) output_indirect_thunk_function ( indirect_thunk_prefix_none , CX_REG , true ) ; if ( indirect_thunk_needed ) output_indirect_thunk_function ( indirect_thunk_prefix_none , INVALID_REGNUM , false ) ; for ( regno = FIRST_REX_INT_REG ; regno <= LAST_REX_INT_REG ; regno ++ ) { if ( TEST_HARD_REG_BIT ( indirect_thunks_used , regno ) ) output_indirect_thunk_function ( indirect_thunk_prefix_none , regno , false ) ; } for ( regno = FIRST_INT_REG ; regno <= LAST_INT_REG ; regno ++ ) { char name [ <NUM_LIT> ] ; tree decl ; if ( TEST_HARD_REG_BIT ( indirect_thunks_used , regno ) ) output_indirect_thunk_function ( indirect_thunk_prefix_none , regno , false ) ; if ( ! ( pic_labels_used & ( <NUM_LIT> << regno ) ) ) continue ; get_pc_thunk_name ( name , regno ) ; decl = build_decl ( BUILTINS_LOCATION , FUNCTION_DECL , get_identifier ( name ) , build_function_type_list ( void_type_node , NULL_TREE ) ) ; DECL_RESULT ( decl ) = build_decl ( BUILTINS_LOCATION , RESULT_DECL , NULL_TREE , void_type_node ) ; TREE_PUBLIC ( decl ) = <NUM_LIT> ; TREE_STATIC ( decl ) = <NUM_LIT> ; DECL_IGNORED_P ( decl ) = <NUM_LIT> ; if ( TARGET_MACHO ) { switch_to_section ( darwin_sections [ picbase_thunk_section ] ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; putc ( '\n' , asm_out_file ) ; ASM_OUTPUT_LABEL ( asm_out_file , name ) ; DECL_WEAK ( decl ) = <NUM_LIT> ; } else if ( USE_HIDDEN_LINKONCE ) { cgraph_node :: create ( decl ) -> set_comdat_group ( DECL_ASSEMBLER_NAME ( decl ) ) ;

targetm . asm_out . unique_section ( decl , <NUM_LIT> ) ;


<s> } else if ( USE_HIDDEN_LINKONCE ) { cgraph_node :: create ( decl ) -> set_comdat_group ( DECL_ASSEMBLER_NAME ( decl ) ) ; targetm . asm_out . unique_section ( decl , <NUM_LIT> ) ; switch_to_section ( get_named_section ( decl , NULL , <NUM_LIT> ) ) ; targetm . asm_out . globalize_label ( asm_out_file , name ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , name ) ; putc ( '\n' , asm_out_file ) ; ASM_DECLARE_FUNCTION_NAME ( asm_out_file , name , decl ) ; } else { switch_to_section ( text_section ) ; ASM_OUTPUT_LABEL ( asm_out_file , name ) ; } DECL_INITIAL ( decl ) = make_node ( BLOCK ) ; current_function_decl = decl ; allocate_struct_function ( decl , false ) ; init_function_start ( decl ) ; cfun -> is_thunk = true ; first_function_block_is_cold = false ; final_start_function ( emit_barrier ( ) , asm_out_file , <NUM_LIT> ) ; if ( TARGET_PAD_SHORT_FUNCTION ) { int i = <NUM_LIT> ; while ( i -- ) fputs ( <STR_LIT> , asm_out_file ) ; } xops [ <NUM_LIT> ] = gen_rtx_REG ( Pmode , regno ) ; xops [ <NUM_LIT> ] = gen_rtx_MEM ( Pmode , stack_pointer_rtx ) ; output_asm_insn ( <STR_LIT> , xops ) ; fputs ( <STR_LIT> , asm_out_file ) ; final_end_function ( ) ; init_insn_lengths ( ) ; free_after_compilation ( cfun ) ;


<s> if ( AGGREGATE_TYPE_P ( type ) ) { switch ( TREE_CODE ( type ) ) { case RECORD_TYPE : case UNION_TYPE : case QUAL_UNION_TYPE : { tree field ; for ( field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) { if ( TREE_CODE ( field ) == FIELD_DECL && ix86_compat_aligned_value_p ( TREE_TYPE ( field ) ) ) return true ; }


<s> if ( ! TARGET_64BIT && mode != TDmode && mode != TFmode ) { if ( ! type ) { if ( ! ( TARGET_SSE && SSE_REG_MODE_P ( mode ) ) ) align = PARM_BOUNDARY ; } else { if ( ! ix86_compat_aligned_value_p ( type ) ) align = PARM_BOUNDARY ; } } if ( align > BIGGEST_ALIGNMENT ) align = BIGGEST_ALIGNMENT ; return align ;


<s> CLEAR_HARD_REG_SET ( reg_class_contents [ ( int ) CLOBBERED_REGS ] ) ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) { if ( call_used_regs [ i ] > <NUM_LIT> ) call_used_regs [ i ] = ! ! ( call_used_regs [ i ] & c_mask ) ; if ( TEST_HARD_REG_BIT ( reg_class_contents [ ( int ) GENERAL_REGS ] , i ) && call_used_regs [ i ] ) SET_HARD_REG_BIT ( reg_class_contents [ ( int ) CLOBBERED_REGS ] , i ) ; } if ( ! TARGET_MMX ) accessible_reg_set &= ~ reg_class_contents [ MMX_REGS ] ; if ( ! TARGET_SSE ) accessible_reg_set &= ~ reg_class_contents [ ALL_SSE_REGS ] ; if ( ! ( TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387 ) ) accessible_reg_set &= ~ reg_class_contents [ FLOAT_REGS ] ;


<s> int i , c_mask ; if ( cfun && cfun -> machine -> no_caller_saved_registers ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( ! fixed_regs [ i ] && ! ix86_function_value_regno_p ( i ) ) call_used_regs [ i ] = <NUM_LIT> ; if ( ! TARGET_64BIT ) { for ( i = FIRST_REX_INT_REG ; i <= LAST_REX_INT_REG ; i ++ ) CLEAR_HARD_REG_BIT ( accessible_reg_set , i ) ; for ( i = FIRST_REX_SSE_REG ; i <= LAST_REX_SSE_REG ; i ++ ) CLEAR_HARD_REG_BIT ( accessible_reg_set , i ) ; for ( i = FIRST_EXT_REX_SSE_REG ; i <= LAST_EXT_REX_SSE_REG ; i ++ ) CLEAR_HARD_REG_BIT ( accessible_reg_set , i ) ; } c_mask = CALL_USED_REGISTERS_MASK ( TARGET_64BIT_MS_ABI ) ; CLEAR_HARD_REG_SET ( reg_class_contents [ ( int ) CLOBBERED_REGS ] ) ;

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


<s> if ( TREE_CODE ( exp ) == REAL_CST || TREE_CODE ( exp ) == VECTOR_CST || TREE_CODE ( exp ) == INTEGER_CST ) { machine_mode mode = TYPE_MODE ( TREE_TYPE ( exp ) ) ; HOST_WIDE_INT mode_align = ix86_static_rtx_alignment ( mode ) ; return MAX ( mode_align , align ) ; }

else if ( ! optimize_size && TREE_CODE ( exp ) == STRING_CST && TREE_STRING_LENGTH ( exp ) >= <NUM_LIT> && align < BITS_PER_WORD ) return BITS_PER_WORD ;


<s> HOST_WIDE_INT mode_align = ix86_static_rtx_alignment ( mode ) ; return MAX ( mode_align , align ) ; }


<s> static bool ix86_const_not_ok_for_debug_p ( rtx x ) { if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) != UNSPEC_GOTOFF ) return true ; if ( SYMBOL_REF_P ( x ) && strcmp ( XSTR ( x , <NUM_LIT> ) , GOT_SYMBOL_NAME ) == <NUM_LIT> ) return true ;


<s> if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) != UNSPEC_GOTOFF ) return true ; if ( SYMBOL_REF_P ( x ) && strcmp ( XSTR ( x , <NUM_LIT> ) , GOT_SYMBOL_NAME ) == <NUM_LIT> ) return true ;


<s> for ( field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) { if ( TREE_CODE ( field ) == FIELD_DECL && ix86_contains_aligned_value_p ( TREE_TYPE ( field ) ) ) return true ; } break ; } case ARRAY_TYPE : if ( ix86_contains_aligned_value_p ( TREE_TYPE ( type ) ) ) return true ;


<s> int min_prev_count ; min_prev_count = <NUM_LIT> ; FOR_EACH_EDGE ( e , ei , bb -> preds ) { edge prev_e ; edge_iterator prev_ei ; if ( e -> src == ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) { min_prev_count = <NUM_LIT> ; break ; } FOR_EACH_EDGE ( prev_e , prev_ei , e -> src -> preds ) { if ( prev_e -> src == ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) { int count = ix86_count_insn_bb ( e -> src ) ; if ( count < min_prev_count ) min_prev_count = count ; break ; } } } if ( min_prev_count < <NUM_LIT> ) min_prev_count += ix86_count_insn_bb ( bb ) ;


<s> rtx_insn * insn ; int insn_count = <NUM_LIT> ; FOR_BB_INSNS ( bb , insn ) { if ( JUMP_P ( insn ) && ANY_RETURN_P ( PATTERN ( insn ) ) ) break ; if ( NONDEBUG_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER ) { insn_count ++ ; if ( insn_count >= <NUM_LIT> ) return insn_count ; }


<s> FOR_BB_INSNS ( bb , insn ) { if ( JUMP_P ( insn ) && ANY_RETURN_P ( PATTERN ( insn ) ) ) break ; if ( NONDEBUG_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER ) {


<s> if ( suffix == 'w' ) return XFmode ;


<s> case ix86_align_data_type_abi : opt = false ; break ; case ix86_align_data_type_compat : max_align = BITS_PER_WORD ; break ; case ix86_align_data_type_cacheline : break ; } if ( TARGET_IAMCU ) align = iamcu_alignment ( type , align ) ; if ( opt && AGGREGATE_TYPE_P ( type ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST ) { if ( wi :: geu_p ( wi :: to_wide ( TYPE_SIZE ( type ) ) , max_align_compat ) && align < max_align_compat ) align = max_align_compat ; if ( wi :: geu_p ( wi :: to_wide ( TYPE_SIZE ( type ) ) , max_align ) && align < max_align ) align = max_align ; } if ( TARGET_64BIT ) { if ( ( opt ? AGGREGATE_TYPE_P ( type ) : TREE_CODE ( type ) == ARRAY_TYPE ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: geu_p ( wi :: to_wide ( TYPE_SIZE ( type ) ) , <NUM_LIT> ) && align < <NUM_LIT> ) return <NUM_LIT> ; } if ( ! opt ) return align ; 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> return ix86_delegitimize_address_1 ( x , false ) ;


<s> static rtx ix86_delegitimize_address ( rtx x ) {

return ix86_delegitimize_address_1 ( x , false ) ;


<s> rtx result = NULL_RTX ; x = orig_x ; if ( MEM_P ( x ) ) x = XEXP ( x , <NUM_LIT> ) ; if ( TARGET_64BIT ) { if ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_MODE ( XEXP ( x , <NUM_LIT> ) ) == Pmode && CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_PCREL ) { if ( base_term_p && MEM_P ( orig_x ) ) return orig_x ; rtx x2 = XVECEXP ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ; x = gen_rtx_PLUS ( Pmode , XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , x2 ) ; if ( MEM_P ( orig_x ) ) x = replace_equiv_address_nv ( orig_x , x ) ; return x ; } if ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC && ( XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_GOTPCREL || XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_PCREL ) && ( MEM_P ( orig_x ) || XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_PCREL ) ) { x = XVECEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_MODE ( orig_x ) != GET_MODE ( x ) && MEM_P ( orig_x ) ) { x = lowpart_subreg ( GET_MODE ( orig_x ) , x , GET_MODE ( x ) ) ; if ( x == NULL_RTX ) return orig_x ; } return x ; } if ( ix86_cmodel != CM_MEDIUM_PIC && ix86_cmodel != CM_LARGE_PIC ) return ix86_delegitimize_tls_address ( orig_x ) ; } if ( GET_CODE ( x ) != PLUS || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST ) return ix86_delegitimize_tls_address ( orig_x ) ; if ( ix86_pic_register_p ( XEXP ( x , <NUM_LIT> ) ) ) ; else if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS ) { reg_addend = XEXP ( x , <NUM_LIT> ) ; if ( ix86_pic_register_p ( XEXP ( reg_addend , <NUM_LIT> ) ) ) reg_addend = XEXP ( reg_addend , <NUM_LIT> ) ; else if ( ix86_pic_register_p ( XEXP ( reg_addend , <NUM_LIT> ) ) ) reg_addend = XEXP ( reg_addend , <NUM_LIT> ) ; else { reg_addend = NULL_RTX ; addend = XEXP ( x , <NUM_LIT> ) ; } }


<s> struct ix86_address addr ; if ( ! TARGET_TLS_DIRECT_SEG_REFS ) return orig_x ; if ( MEM_P ( x ) ) x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) != PLUS || GET_MODE ( x ) != Pmode ) return orig_x ; if ( ix86_decompose_address ( x , & addr ) == <NUM_LIT> || addr . seg != DEFAULT_TLS_SEG_REG || addr . disp == NULL_RTX || GET_CODE ( addr . disp ) != CONST ) return orig_x ; unspec = XEXP ( addr . disp , <NUM_LIT> ) ;

if ( GET_CODE ( unspec ) == PLUS && CONST_INT_P ( XEXP ( unspec , <NUM_LIT> ) ) ) unspec = XEXP ( unspec , <NUM_LIT> ) ;


<s> if ( nr_blks > <NUM_LIT> && BLOCK_TO_BB ( bb -> index ) != <NUM_LIT> ) { edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , bb -> preds ) { if ( rgn == CONTAINING_RGN ( e -> src -> index ) && BLOCK_TO_BB ( bb -> index ) > BLOCK_TO_BB ( e -> src -> index ) ) add_dependee_for_func_arg ( first_arg , e -> src ) ; } } insn = first_arg ; if ( insn == head ) break ; }


<s> if ( rgn == CONTAINING_RGN ( e -> src -> index ) && BLOCK_TO_BB ( bb -> index ) > BLOCK_TO_BB ( e -> src -> index ) ) add_dependee_for_func_arg ( first_arg , e -> src ) ; } } insn = first_arg ; if ( insn == head ) break ; } }

else if ( first_arg ) avoid_func_arg_motion ( first_arg , insn ) ;


<s> bool ix86_dep_by_shift_count ( const_rtx set_insn , const_rtx use_insn ) { return ix86_dep_by_shift_count_body ( PATTERN ( set_insn ) , PATTERN ( use_insn ) ) ;


<s> case PARALLEL : for ( i = XVECLEN ( use_body , <NUM_LIT> ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) if ( ix86_dep_by_shift_count_body ( set_body , XVECEXP ( use_body , <NUM_LIT> , i ) ) ) return true ; default : return false ; } if ( shift_rtx && ( GET_CODE ( shift_rtx ) == ASHIFT || GET_CODE ( shift_rtx ) == LSHIFTRT || GET_CODE ( shift_rtx ) == ASHIFTRT || GET_CODE ( shift_rtx ) == ROTATE || GET_CODE ( shift_rtx ) == ROTATERT ) ) { rtx shift_count = XEXP ( shift_rtx , <NUM_LIT> ) ; if ( REG_P ( shift_count ) ) { if ( reload_completed && true_regnum ( set_dest ) == true_regnum ( shift_count ) ) return true ; else if ( REGNO ( set_dest ) == REGNO ( shift_count ) ) return true ; } }


<s> if ( TARGET_CLD || cfun -> machine -> func_type != TYPE_NORMAL ) return X86_DIRFLAG_ANY ;


<s> if ( recog_memoized ( insn ) < <NUM_LIT> ) return X86_DIRFLAG_ANY ; if ( get_attr_type ( insn ) == TYPE_STR ) { if ( cfun -> machine -> func_type == TYPE_NORMAL ) return TARGET_CLD ? X86_DIRFLAG_RESET : X86_DIRFLAG_ANY ; else return X86_DIRFLAG_RESET ; } return X86_DIRFLAG_ANY ;


<s> if ( CALL_P ( insn ) ) { if ( cfun -> machine -> func_type == TYPE_NORMAL ) return X86_DIRFLAG_ANY ; else return TARGET_CLD ? X86_DIRFLAG_ANY : X86_DIRFLAG_RESET ; } if ( recog_memoized ( insn ) < <NUM_LIT> ) return X86_DIRFLAG_ANY ; if ( get_attr_type ( insn ) == TYPE_STR ) { if ( cfun -> machine -> func_type == TYPE_NORMAL ) return TARGET_CLD ? X86_DIRFLAG_RESET : X86_DIRFLAG_ANY ;


<s> if ( VECTOR_MODE_P ( mode ) ) inner_mode = GET_MODE_INNER ( mode ) ; if ( SSE_FLOAT_MODE_SSEMATH_OR_HF_P ( mode ) ) return inner_mode == DFmode ? cost -> divsd : cost -> divss ; else if ( X87_FLOAT_MODE_P ( mode ) ) return cost -> fdiv ; else if ( FLOAT_MODE_P ( mode ) ) return ix86_vec_cost ( mode , inner_mode == DFmode ? cost -> divsd : cost -> divss ) ;

else return cost -> divide [ MODE_INDEX ( mode ) ] ;


<s> if ( SSE_FLOAT_MODE_SSEMATH_OR_HF_P ( mode ) ) return inner_mode == DFmode ? cost -> divsd : cost -> divss ; else if ( X87_FLOAT_MODE_P ( mode ) ) return cost -> fdiv ; else if ( FLOAT_MODE_P ( mode ) ) return ix86_vec_cost ( mode , inner_mode == DFmode ? cost -> divsd : cost -> divss ) ;


<s> static bool ix86_eax_live_at_start_p ( void ) { return REGNO_REG_SET_P ( df_get_live_out ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) , <NUM_LIT> ) ;


<s> rtx_insn * c_insn = BB_HEAD ( bb ) ; if ( ! NONDEBUG_INSN_P ( c_insn ) ) c_insn = next_nonnote_nondebug_insn ( c_insn ) ; if ( c_insn && NONJUMP_INSN_P ( c_insn ) ) { rtx pat = PATTERN ( c_insn ) ; if ( GET_CODE ( pat ) == PARALLEL ) { rtx vec = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ;

if ( GET_CODE ( vec ) == SET && XINT ( XEXP ( vec , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_SET_GOT && REGNO ( XEXP ( vec , <NUM_LIT> ) ) == REGNO ( reg ) ) delete_insn ( c_insn ) ;


<s> basic_block bb = ENTRY_BLOCK_PTR_FOR_FN ( cfun ) -> next_bb ; rtx_insn * c_insn = BB_HEAD ( bb ) ; if ( ! NONDEBUG_INSN_P ( c_insn ) ) c_insn = next_nonnote_nondebug_insn ( c_insn ) ; if ( c_insn && NONJUMP_INSN_P ( c_insn ) ) { rtx pat = PATTERN ( c_insn ) ; if ( GET_CODE ( pat ) == PARALLEL ) { rtx vec = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( vec ) == SET && XINT ( XEXP ( vec , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_SET_GOT && REGNO ( XEXP ( vec , <NUM_LIT> ) ) == REGNO ( reg ) ) delete_insn ( c_insn ) ; } }


<s> static void ix86_emit_leave ( rtx_insn * insn ) { struct machine_function * m = cfun -> machine ; if ( ! insn ) insn = emit_insn ( gen_leave ( word_mode ) ) ; ix86_add_queued_cfa_restore_notes ( insn ) ; gcc_assert ( m -> fs . fp_valid ) ; m -> fs . sp_valid = true ; m -> fs . sp_realigned = false ; m -> fs . sp_offset = m -> fs . fp_offset - UNITS_PER_WORD ; m -> fs . fp_valid = false ; if ( m -> fs . cfa_reg == hard_frame_pointer_rtx ) { m -> fs . cfa_reg = stack_pointer_rtx ; m -> fs . cfa_offset = m -> fs . sp_offset ; add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , stack_pointer_rtx , m -> fs . sp_offset ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } ix86_add_cfa_restore_note ( insn , hard_frame_pointer_rtx , m -> fs . fp_offset ) ;


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


<s> rtx rbp = gen_rtx_REG ( DImode , BP_REG ) ; gcc_assert ( m -> fs . fp_valid ) ; gcc_assert ( m -> fs . cfa_reg == hard_frame_pointer_rtx ) ; tmp = plus_constant ( DImode , rbp , <NUM_LIT> ) ; RTVEC_ELT ( v , vi ++ ) = gen_rtx_SET ( stack_pointer_rtx , tmp ) ; RTVEC_ELT ( v , vi ++ ) = gen_rtx_SET ( rbp , gen_rtx_MEM ( DImode , rbp ) ) ; tmp = gen_rtx_MEM ( BLKmode , gen_rtx_SCRATCH ( VOIDmode ) ) ; RTVEC_ELT ( v , vi ++ ) = gen_rtx_CLOBBER ( VOIDmode , tmp ) ; } else { gcc_assert ( ! m -> fs . fp_valid ) ; gcc_assert ( m -> fs . cfa_reg == stack_pointer_rtx ) ; gcc_assert ( m -> fs . sp_valid ) ; r10 = gen_rtx_REG ( DImode , R10_REG ) ; tmp = plus_constant ( Pmode , rsi , stub_ptr_offset ) ; emit_insn ( gen_rtx_SET ( r10 , tmp ) ) ; RTVEC_ELT ( v , vi ++ ) = gen_rtx_SET ( stack_pointer_rtx , r10 ) ; } } for ( i = <NUM_LIT> ; i < ncregs ; ++ i ) { const xlogue_layout :: reginfo & r = xlogue . get_reginfo ( i ) ; machine_mode mode = SSE_REGNO_P ( r . regno ) ? V4SFmode : word_mode ; rtx reg , frame_load ; reg = gen_rtx_REG ( mode , r . regno ) ; frame_load = gen_frame_load ( reg , rsi , r . offset ) ; if ( r . regno == SI_REG ) { gcc_assert ( ! rsi_frame_load ) ; rsi_frame_load = frame_load ; rsi_restore_offset = r . offset ; } else { RTVEC_ELT ( v , vi ++ ) = frame_load ; ix86_add_cfa_restore_note ( NULL , reg , r . offset ) ; } } gcc_assert ( rsi_frame_load ) ; gcc_assert ( rsi_restore_offset != ( HOST_WIDE_INT ) - <NUM_LIT> ) ; RTVEC_ELT ( v , vi ++ ) = rsi_frame_load ; ix86_add_cfa_restore_note ( NULL , gen_rtx_REG ( DImode , SI_REG ) , rsi_restore_offset ) ; if ( ! use_call && ! frame_pointer_needed ) { gcc_assert ( m -> fs . sp_valid ) ; gcc_assert ( ! m -> fs . sp_realigned ) ;

if ( m -> fs . cfa_reg == stack_pointer_rtx ) m -> fs . cfa_offset += m -> fs . sp_offset - frame . stack_realign_offset ;


<s> gcc_assert ( ! ix86_eax_live_at_start_p ( ) ) ; gcc_assert ( m -> fs . sp_offset >= frame . sse_reg_save_offset ) ; align = GET_MODE_ALIGNMENT ( V4SFmode ) ; addr = choose_baseaddr ( frame . stack_realign_offset + xlogue . get_stub_ptr_offset ( ) , & align , AX_REG ) ; gcc_assert ( align >= GET_MODE_ALIGNMENT ( V4SFmode ) ) ; emit_insn ( gen_rtx_SET ( rax , addr ) ) ; sym = xlogue . get_stub_rtx ( frame_pointer_needed ? XLOGUE_STUB_SAVE_HFP : XLOGUE_STUB_SAVE ) ; RTVEC_ELT ( v , vi ++ ) = gen_rtx_USE ( VOIDmode , sym ) ; for ( i = <NUM_LIT> ; i < ncregs ; ++ i ) { const xlogue_layout :: reginfo & r = xlogue . get_reginfo ( i ) ;

rtx reg = gen_rtx_REG ( ( SSE_REGNO_P ( r . regno ) ? V4SFmode : word_mode ) , r . regno ) ;


<s> last = first + rounded_size ; emit_insn ( gen_probe_stack_range ( Pmode , sr . reg , sr . reg , GEN_INT ( - last ) ) ) ; if ( size != rounded_size ) emit_stack_probe ( plus_constant ( Pmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , sr . reg ) , rounded_size - size ) ) ; release_scratch_register_on_entry ( & sr , size , true ) ; }


<s> for ( i = probe_interval ; i < size ; i += probe_interval ) emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + i ) ) ) ; emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + size ) ) ) ; } else { gcc_assert ( int_registers_saved ) ; HOST_WIDE_INT rounded_size , last ; struct scratch_reg sr ; get_scratch_register_on_entry ( & sr ) ; rounded_size = ROUND_DOWN ( size , probe_interval ) ; emit_move_insn ( sr . reg , GEN_INT ( - first ) ) ; last = first + rounded_size ; emit_insn ( gen_probe_stack_range ( Pmode , sr . reg , sr . reg , GEN_INT ( - last ) ) ) ;

if ( size != rounded_size ) emit_stack_probe ( plus_constant ( Pmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , sr . reg ) , rounded_size - size ) ) ;


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , maybe_eh_return , true ) ) { rtx reg = gen_rtx_REG ( word_mode , regno ) ; rtx mem ; rtx_insn * insn ; mem = choose_baseaddr ( cfa_offset , NULL ) ; mem = gen_frame_mem ( word_mode , mem ) ; insn = emit_move_insn ( reg , mem ) ; if ( m -> fs . cfa_reg == crtl -> drap_reg && regno == REGNO ( crtl -> drap_reg ) ) { add_reg_note ( insn , REG_CFA_DEF_CFA , reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; m -> fs . drap_valid = true ;


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , false , true ) ) ix86_emit_restore_reg_using_pop ( gen_rtx_REG ( word_mode , regno ) ) ;


<s> m -> fs . sp_offset -= UNITS_PER_WORD ; if ( m -> fs . cfa_reg == crtl -> drap_reg && REGNO ( reg ) == REGNO ( crtl -> drap_reg ) ) { add_reg_note ( insn , REG_CFA_DEF_CFA , reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; m -> fs . drap_valid = true ; return ; } if ( m -> fs . cfa_reg == stack_pointer_rtx ) { rtx x = plus_constant ( Pmode , stack_pointer_rtx , UNITS_PER_WORD ) ; x = gen_rtx_SET ( stack_pointer_rtx , x ) ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , x ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; m -> fs . cfa_offset -= UNITS_PER_WORD ; } if ( reg == hard_frame_pointer_rtx ) { m -> fs . fp_valid = false ; if ( m -> fs . cfa_reg == hard_frame_pointer_rtx ) { m -> fs . cfa_reg = stack_pointer_rtx ;


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , maybe_eh_return , true ) ) { rtx reg = gen_rtx_REG ( V4SFmode , regno ) ; rtx mem ; unsigned int align = GET_MODE_ALIGNMENT ( V4SFmode ) ; mem = choose_baseaddr ( cfa_offset , & align ) ; mem = gen_rtx_MEM ( V4SFmode , mem ) ; align = MIN ( GET_MODE_ALIGNMENT ( V4SFmode ) , align ) ; gcc_assert ( ! ( cfa_offset & ( align / BITS_PER_UNIT - <NUM_LIT> ) ) ) ; set_mem_align ( mem , align ) ; emit_insn ( gen_rtx_SET ( reg , mem ) ) ;

ix86_add_cfa_restore_note ( NULL , reg , cfa_offset ) ;


<s> unsigned int regno ; rtx_insn * insn ;

for ( regno = FIRST_PSEUDO_REGISTER - <NUM_LIT> ; regno -- > <NUM_LIT> ; ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , true , true ) ) {


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , true , true ) ) {

ix86_emit_save_reg_using_mov ( word_mode , regno , cfa_offset ) ;


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( GENERAL_REGNO_P ( regno ) && ix86_save_reg ( regno , true , true ) ) { ix86_emit_save_reg_using_mov ( word_mode , regno , cfa_offset ) ; cfa_offset -= UNITS_PER_WORD ;


<s> gcc_checking_assert ( cfun -> machine -> fs . fp_valid ) ; addr = plus_constant ( Pmode , hard_frame_pointer_rtx , cfun -> machine -> fs . fp_offset - cfa_offset ) ; mem = gen_rtx_MEM ( mode , addr ) ; add_reg_note ( insn , REG_CFA_EXPRESSION , gen_rtx_SET ( mem , reg ) ) ; } } else if ( base == stack_pointer_rtx && m -> fs . sp_realigned && cfa_offset >= m -> fs . sp_realigned_offset ) { gcc_checking_assert ( stack_realign_fp ) ; add_reg_note ( insn , REG_CFA_EXPRESSION , gen_rtx_SET ( mem , reg ) ) ; } else if ( base != m -> fs . cfa_reg ) {

addr = plus_constant ( Pmode , m -> fs . cfa_reg , m -> fs . cfa_offset - cfa_offset ) ;


<s> mem = gen_frame_mem ( mode , addr ) ; align = MIN ( GET_MODE_ALIGNMENT ( mode ) , align ) ; gcc_assert ( ! ( cfa_offset & ( align / BITS_PER_UNIT - <NUM_LIT> ) ) ) ; set_mem_align ( mem , align ) ; insn = emit_insn ( gen_rtx_SET ( mem , reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; base = addr ; if ( GET_CODE ( base ) == PLUS ) base = XEXP ( base , <NUM_LIT> ) ; gcc_checking_assert ( REG_P ( base ) ) ; if ( m -> fs . realigned ) { gcc_checking_assert ( stack_realign_drap ) ; if ( regno == REGNO ( crtl -> drap_reg ) ) { gcc_checking_assert ( cfun -> machine -> fs . fp_valid ) ; addr = plus_constant ( Pmode , hard_frame_pointer_rtx , cfun -> machine -> fs . fp_offset - cfa_offset ) ; mem = gen_rtx_MEM ( mode , addr ) ; add_reg_note ( insn , REG_CFA_DEF_CFA , mem ) ; } else { gcc_checking_assert ( cfun -> machine -> fs . fp_valid ) ; addr = plus_constant ( Pmode , hard_frame_pointer_rtx , cfun -> machine -> fs . fp_offset - cfa_offset ) ; mem = gen_rtx_MEM ( mode , addr ) ; add_reg_note ( insn , REG_CFA_EXPRESSION , gen_rtx_SET ( mem , reg ) ) ; } } else if ( base == stack_pointer_rtx && m -> fs . sp_realigned && cfa_offset >= m -> fs . sp_realigned_offset ) { gcc_checking_assert ( stack_realign_fp ) ; add_reg_note ( insn , REG_CFA_EXPRESSION , gen_rtx_SET ( mem , reg ) ) ; } else if ( base != m -> fs . cfa_reg ) {


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( SSE_REGNO_P ( regno ) && ix86_save_reg ( regno , true , true ) ) { ix86_emit_save_reg_using_mov ( V4SFmode , regno , cfa_offset ) ; cfa_offset -= GET_MODE_SIZE ( V4SFmode ) ; }


<s> default_encode_section_info ( decl , rtl , first ) ; if ( ix86_in_large_data_p ( decl ) ) SYMBOL_REF_FLAGS ( XEXP ( rtl , <NUM_LIT> ) ) |= SYMBOL_FLAG_FAR_ADDR ;


<s> static void ATTRIBUTE_UNUSED ix86_encode_section_info ( tree decl , rtx rtl , int first ) {

default_encode_section_info ( decl , rtl , first ) ;


<s> break ; case <NUM_LIT> : * ptree = ms_va_list_type_node ; * pname = <STR_LIT> ; return <NUM_LIT> ; case <NUM_LIT> :


<s> return ( epilogue_completed && cfun -> machine -> no_caller_saved_registers && ! fixed_regs [ regno ] && ! STACK_REGNO_P ( regno ) && ! MMX_REGNO_P ( regno ) ) ;


<s> else if ( ! TARGET_MIX_SSE_I387 ) { if ( ! ( TARGET_SSE && TARGET_SSE_MATH ) ) return FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE ;

else if ( TARGET_SSE2 ) return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT ;


<s> else if ( ! TARGET_MIX_SSE_I387 ) { if ( ! ( TARGET_SSE && TARGET_SSE_MATH ) ) return FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE ; else if ( TARGET_SSE2 ) return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT ; } return ( type == EXCESS_PRECISION_TYPE_STANDARD ? FLT_EVAL_METHOD_PROMOTE_TO_FLOAT : FLT_EVAL_METHOD_UNPREDICTABLE ) ;


<s> void ix86_expand_avx_vzeroupper ( void ) { ix86_initialize_callee_abi ( ABI_VZEROUPPER ) ; rtx_insn * insn = emit_call_insn ( gen_avx_vzeroupper_callee_abi ( ) ) ; make_reg_eh_region_note ( insn , <NUM_LIT> , INT_MIN ) ; RTX_FLAG ( insn , used ) = <NUM_LIT> ;


crtl -> stack_realign_finalized = true ;


<s> term = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( term ) == PLUS && CONST_INT_P ( XEXP ( term , <NUM_LIT> ) ) ) term = XEXP ( term , <NUM_LIT> ) ; if ( GET_CODE ( term ) != UNSPEC || ( XINT ( term , <NUM_LIT> ) != UNSPEC_GOTPCREL && XINT ( term , <NUM_LIT> ) != UNSPEC_PCREL ) ) return x ;

return XVECEXP ( term , <NUM_LIT> , <NUM_LIT> ) ;


<s> if ( TARGET_64BIT ) { if ( GET_CODE ( x ) != CONST ) return x ; term = XEXP ( x , <NUM_LIT> ) ;

if ( GET_CODE ( term ) == PLUS && CONST_INT_P ( XEXP ( term , <NUM_LIT> ) ) ) term = XEXP ( term , <NUM_LIT> ) ;


<s> require_stack_frame = true ; if ( check_stack_slot ) { subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , ALL ) if ( MEM_P ( * iter ) && ( reg_mentioned_p ( stack_pointer_rtx , * iter ) || reg_mentioned_p ( frame_pointer_rtx , * iter ) ) ) { unsigned int alignment = MEM_ALIGN ( * iter ) ; if ( alignment > stack_alignment ) stack_alignment = alignment ; } } }


<s> if ( check_stack_slot ) { subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , ALL ) if ( MEM_P ( * iter ) && ( reg_mentioned_p ( stack_pointer_rtx , * iter ) || reg_mentioned_p ( frame_pointer_rtx , * iter ) ) ) { unsigned int alignment = MEM_ALIGN ( * iter ) ; if ( alignment > stack_alignment ) stack_alignment = alignment ;


<s> * prologue_cost = cost [ vect_prologue ] ; * body_cost = cost [ vect_body ] ; * epilogue_cost = cost [ vect_epilogue ] ;


<s> * p2 = INVALID_REGNUM ; return true ;


<s> return TARGET_80387 || ( TARGET_SSE && TARGET_SSE_MATH ) ;


<s> if ( ! TARGET_64BIT ) return va_list_type_node ; gcc_assert ( fndecl != NULL_TREE ) ; if ( ix86_function_abi ( ( const_tree ) fndecl ) == MS_ABI ) return ms_va_list_type_node ;


<s> bool ix86_force_load_from_GOT_p ( rtx x , bool call_p ) {

return ( ( TARGET_64BIT || ( ! flag_pic && HAVE_AS_IX86_GOT32X ) ) && ! TARGET_PECOFF && ! TARGET_MACHO && ( ! flag_pic || this_is_asm_operands ) && ix86_cmodel != CM_LARGE && ix86_cmodel != CM_LARGE_PIC && GET_CODE ( x ) == SYMBOL_REF && ( ( ! call_p && ( ! ix86_direct_extern_access || ( SYMBOL_REF_DECL ( x ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( SYMBOL_REF_DECL ( x ) ) ) ) ) ) || ( SYMBOL_REF_FUNCTION_P ( x ) && ( ! flag_plt || ( SYMBOL_REF_DECL ( x ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( SYMBOL_REF_DECL ( x ) ) ) ) ) ) ) && ! SYMBOL_REF_LOCAL_P ( x ) ) ;


<s> bool ix86_force_load_from_GOT_p ( rtx x , bool call_p ) { return ( ( TARGET_64BIT || ( ! flag_pic && HAVE_AS_IX86_GOT32X ) ) && ! TARGET_PECOFF && ! TARGET_MACHO && ( ! flag_pic || this_is_asm_operands ) && ix86_cmodel != CM_LARGE && ix86_cmodel != CM_LARGE_PIC && GET_CODE ( x ) == SYMBOL_REF && ( ( ! call_p && ( ! ix86_direct_extern_access || ( SYMBOL_REF_DECL ( x ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( SYMBOL_REF_DECL ( x ) ) ) ) ) ) || ( SYMBOL_REF_FUNCTION_P ( x ) && ( ! flag_plt || ( SYMBOL_REF_DECL ( x ) && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( SYMBOL_REF_DECL ( x ) ) ) ) ) ) ) && ! SYMBOL_REF_LOCAL_P ( x ) ) ;


<s> if ( TARGET_CMOVE ) return IX86_FPCMP_COMI ; if ( TARGET_SAHF && ( TARGET_USE_SAHF || optimize_insn_for_size_p ( ) ) ) return IX86_FPCMP_SAHF ; return IX86_FPCMP_ARITH ;


if ( crtl -> profile && ! flag_fentry ) return true ;


<s> if ( arg . type && TREE_CODE ( arg . type ) == VECTOR_TYPE ) mode = type_natural_mode ( arg . type , cum , false ) ; if ( TARGET_64BIT ) { enum calling_abi call_abi = cum ? cum -> call_abi : ix86_abi ; if ( call_abi == MS_ABI ) reg = function_arg_ms_64 ( cum , mode , arg . mode , arg . named , arg . type , bytes ) ; else reg = function_arg_64 ( cum , mode , arg . mode , arg . type , arg . named ) ; } else reg = function_arg_32 ( cum , mode , arg . mode , arg . type , bytes , words ) ; if ( reg == NULL_RTX && cum -> caller ) cfun -> machine -> outgoing_args_on_stack = true ;


<s> if ( call_abi == MS_ABI ) nregs = function_arg_advance_ms_64 ( cum , bytes , words ) ; else nregs = function_arg_advance_64 ( cum , mode , arg . type , words , arg . named ) ; } else nregs = function_arg_advance_32 ( cum , mode , arg . type , bytes , words ) ;


<s> int nregs ; if ( ! cum -> caller && cfun -> machine -> func_type != TYPE_NORMAL ) return ; bytes = arg . promoted_size_in_bytes ( ) ; words = CEIL ( bytes , UNITS_PER_WORD ) ; if ( arg . type ) mode = type_natural_mode ( arg . type , NULL , false ) ; if ( TARGET_64BIT ) { enum calling_abi call_abi = cum ? cum -> call_abi : ix86_abi ; if ( call_abi == MS_ABI ) nregs = function_arg_advance_ms_64 ( cum , bytes , words ) ; else nregs = function_arg_advance_64 ( cum , mode , arg . type , words , arg . named ) ; } else nregs = function_arg_advance_32 ( cum , mode , arg . type , bytes , words ) ;


<s> if ( TYPE_EMPTY_P ( type ) ) return PARM_BOUNDARY ; } else align = GET_MODE_ALIGNMENT ( mode ) ; if ( align < PARM_BOUNDARY ) align = PARM_BOUNDARY ; else { static bool warned ; unsigned int saved_align = align ; if ( ! TARGET_64BIT ) { if ( ! type ) { if ( mode == XFmode || mode == XCmode ) align = PARM_BOUNDARY ; } else if ( ! ix86_contains_aligned_value_p ( type ) ) align = PARM_BOUNDARY ; if ( align < <NUM_LIT> ) align = PARM_BOUNDARY ; } if ( warn_psabi && ! warned && align != ix86_compat_function_arg_boundary ( mode , type , saved_align ) ) { warned = true ;

inform ( input_location , <STR_LIT> <STR_LIT> , align / BITS_PER_UNIT ) ;


<s> call_abi = ix86_cfun_abi ( ) ; if ( call_abi == SYSV_ABI && regno == AX_REG ) return true ; if ( call_abi == MS_ABI ) parm_regs = x86_64_ms_abi_int_parameter_registers ; else parm_regs = x86_64_int_parameter_registers ; for ( i = <NUM_LIT> ; i < ( call_abi == MS_ABI ? X86_64_MS_REGPARM_MAX : X86_64_REGPARM_MAX ) ; i ++ ) if ( regno == parm_regs [ i ] ) return true ;


<s> const int * parm_regs ; if ( TARGET_SSE && SSE_REGNO_P ( regno ) && regno < FIRST_SSE_REG + SSE_REGPARM_MAX ) return true ; if ( ! TARGET_64BIT ) return ( regno < REGPARM_MAX || ( TARGET_MMX && MMX_REGNO_P ( regno ) && regno < FIRST_MMX_REG + MMX_REGPARM_MAX ) ) ; call_abi = ix86_cfun_abi ( ) ; if ( call_abi == SYSV_ABI && regno == AX_REG ) return true ;


<s> if ( decl_function_context ( fn ) != NULL_TREE ) error_at ( DECL_SOURCE_LOCATION ( fn ) , <STR_LIT> <STR_LIT> ) ; else return true ;


<s> bool ix86_function_ms_hook_prologue ( const_tree fn ) { if ( fn && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( fn ) ) ) { if ( decl_function_context ( fn ) != NULL_TREE ) error_at ( DECL_SOURCE_LOCATION ( fn ) , <STR_LIT> <STR_LIT> ) ; else return true ; }


<s> bool ix86_function_naked ( const_tree fn ) {

if ( fn && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( fn ) ) ) return true ;


<s> if ( ! TARGET_MACHO && ! TARGET_64BIT && flag_pic && flag_plt && bind_global ) return false ; if ( ix86_minimum_incoming_stack_boundary ( true ) < PREFERRED_STACK_BOUNDARY ) return false ; if ( decl ) { decl_or_type = decl ; type = TREE_TYPE ( decl ) ; } else { type = CALL_EXPR_FN ( exp ) ; type = TREE_TYPE ( type ) ; type = TREE_TYPE ( type ) ; decl_or_type = type ; } if ( ( OUTGOING_REG_PARM_STACK_SPACE ( type ) != OUTGOING_REG_PARM_STACK_SPACE ( TREE_TYPE ( current_function_decl ) ) ) || ( REG_PARM_STACK_SPACE ( decl_or_type ) != REG_PARM_STACK_SPACE ( current_function_decl ) ) ) { maybe_complain_about_tail_call ( exp , <STR_LIT> <STR_LIT> <STR_LIT> ) ; return false ; } 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 ;


<s> if ( target -> local && target -> 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 ( flag_split_stack ) { if ( local_regparm == <NUM_LIT> ) local_regparm = <NUM_LIT> ; else if ( local_regparm == <NUM_LIT> && DECL_STATIC_CHAIN ( target -> decl ) ) local_regparm = <NUM_LIT> ; } for ( regno = AX_REG ; regno <= DI_REG ; regno ++ ) if ( fixed_regs [ regno ] ) globals ++ ; local_regparm = globals < local_regparm ? local_regparm - globals : <NUM_LIT> ; if ( local_regparm > regparm ) regparm = local_regparm ;


<s> regparm = TREE_INT_CST_LOW ( TREE_VALUE ( TREE_VALUE ( attr ) ) ) ; return regparm ; } } else if ( ( ccvt & IX86_CALLCVT_FASTCALL ) != <NUM_LIT> ) return <NUM_LIT> ; 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 ) ) { if ( target -> local && target -> 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 ( flag_split_stack ) { if ( local_regparm == <NUM_LIT> ) local_regparm = <NUM_LIT> ; else if ( local_regparm == <NUM_LIT> && DECL_STATIC_CHAIN ( target -> decl ) ) local_regparm = <NUM_LIT> ;


<s> 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 ) ) { if ( target -> local && target -> can_change_signature ) { if ( ! TARGET_SSE && warn ) return - <NUM_LIT> ; return TARGET_SSE2_P ( target_opts_for_fn ( target -> decl ) -> x_ix86_isa_flags ) ? <NUM_LIT> : <NUM_LIT> ; } } return <NUM_LIT> ;


<s> enum calling_abi ix86_function_type_abi ( const_tree fntype ) { enum calling_abi abi = ix86_abi ; if ( fntype == NULL_TREE || TYPE_ATTRIBUTES ( fntype ) == NULL_TREE ) return abi ; if ( abi == SYSV_ABI && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) { static int warned ; if ( TARGET_X32 && ! warned ) { error ( <STR_LIT> ) ; warned = <NUM_LIT> ; } abi = MS_ABI ; } else if ( abi == MS_ABI && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) abi = SYSV_ABI ;


<s> static rtx ix86_function_value ( const_tree valtype , const_tree fntype_or_decl , bool ) { machine_mode mode , orig_mode ; orig_mode = TYPE_MODE ( valtype ) ; mode = type_natural_mode ( valtype , NULL , true ) ; return ix86_function_value_1 ( valtype , fntype_or_decl , orig_mode , mode ) ;


<s> machine_mode mode , orig_mode ; orig_mode = TYPE_MODE ( valtype ) ; mode = type_natural_mode ( valtype , NULL , true ) ;

return ix86_function_value_1 ( valtype , fntype_or_decl , orig_mode , mode ) ;


<s> else return function_value_ms_32 ( orig_mode , mode , fntype , fn , 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 ( fntype_or_decl && DECL_P ( fntype_or_decl ) ) fn = fntype_or_decl ; fntype = fn ? TREE_TYPE ( fn ) : fntype_or_decl ; if ( ix86_function_type_abi ( fntype ) == MS_ABI ) {

if ( TARGET_64BIT ) return function_value_ms_64 ( orig_mode , mode , valtype ) ;


<s> return TARGET_64BIT && ix86_cfun_abi ( ) != MS_ABI ; case ST0_REG : case ST1_REG : if ( TARGET_64BIT && ix86_cfun_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> case SI_REG : return TARGET_64BIT && ix86_cfun_abi ( ) != MS_ABI ; case ST0_REG : case ST1_REG : if ( TARGET_64BIT && ix86_cfun_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> rtx ix86_gen_scratch_sse_rtx ( machine_mode mode ) { return gen_reg_rtx ( mode ) ;


<s> if ( attrs != NULL_TREE ) { if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret |= IX86_CALLCVT_CDECL ; else if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret |= IX86_CALLCVT_STDCALL ; else if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret |= IX86_CALLCVT_FASTCALL ; else if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret |= IX86_CALLCVT_THISCALL ;

if ( ( ret & ( IX86_CALLCVT_THISCALL | IX86_CALLCVT_FASTCALL ) ) == <NUM_LIT> ) {


<s> else if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret |= IX86_CALLCVT_STDCALL ; else if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret |= IX86_CALLCVT_FASTCALL ; else if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret |= IX86_CALLCVT_THISCALL ; if ( ( ret & ( IX86_CALLCVT_THISCALL | IX86_CALLCVT_FASTCALL ) ) == <NUM_LIT> ) { if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret |= IX86_CALLCVT_REGPARM ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret |= IX86_CALLCVT_SSEREGPARM ; } if ( IX86_BASE_CALLCVT ( ret ) != <NUM_LIT> ) return ret ;


<s> rtx drap_vreg ; rtx arg_ptr ; rtx_insn * seq , * insn ; arg_ptr = gen_rtx_REG ( Pmode , regno ) ; 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 ) ;


<s> if ( ix86_force_drap || ( ( cfun -> machine -> outgoing_args_on_stack || crtl -> sp_is_clobbered_by_asm ) && ! ACCUMULATE_OUTGOING_ARGS ) ) crtl -> need_drap = true ; if ( stack_realign_drap ) { unsigned int regno = find_drap_reg ( ) ; rtx drap_vreg ; rtx arg_ptr ; rtx_insn * seq , * insn ; arg_ptr = gen_rtx_REG ( Pmode , regno ) ; 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 ( ) ) ) ;


<s> else if ( ! TARGET_80387 ) return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT ; else if ( ! TARGET_MIX_SSE_I387 ) { if ( ! ( TARGET_SSE && TARGET_SSE_MATH ) ) return FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE ; else if ( TARGET_SSE2 ) return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT ; } return ( type == EXCESS_PRECISION_TYPE_STANDARD ? FLT_EVAL_METHOD_PROMOTE_TO_FLOAT : FLT_EVAL_METHOD_UNPREDICTABLE ) ; case EXCESS_PRECISION_TYPE_FLOAT16 : if ( TARGET_80387 && ! ( TARGET_SSE_MATH && TARGET_SSE ) ) error ( <STR_LIT> ) ;


<s> unsigned nunits = GET_MODE_NUNITS ( data_mode ) ; unsigned elem_size = vector_size / nunits ; if ( ( TARGET_AVX512F && vector_size == <NUM_LIT> ) || ( TARGET_AVX512VL && ( vector_size == <NUM_LIT> || vector_size == <NUM_LIT> ) ) ) { if ( elem_size == <NUM_LIT> || elem_size == <NUM_LIT> || ( TARGET_AVX512BW && ( elem_size == <NUM_LIT> || elem_size == <NUM_LIT> ) ) ) return smallest_int_mode_for_size ( nunits ) ; } scalar_int_mode elem_mode = smallest_int_mode_for_size ( elem_size * BITS_PER_UNIT ) ; gcc_assert ( elem_size * nunits == vector_size ) ;

return mode_for_vector ( elem_mode , nunits ) ;


<s> else if ( TARGET_X32_P ( ix86_isa_flags ) ) return <STR_LIT> ;


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


<s> static alias_set_type set = - <NUM_LIT> ;

if ( set == - <NUM_LIT> ) set = new_alias_set ( ) ;


<s> if ( GET_CODE ( op ) == UNSPEC ) switch ( XINT ( op , <NUM_LIT> ) ) { case UNSPEC_GOTNTPOFF : return true ; case UNSPEC_TPOFF : if ( ! TARGET_64BIT ) return true ; break ; default :


<s> if ( GET_CODE ( op ) == UNSPEC ) switch ( XINT ( op , <NUM_LIT> ) ) { case UNSPEC_GOTNTPOFF : return true ; case UNSPEC_TPOFF : if ( ! TARGET_64BIT ) return true ; break ; default : break ; } } return false ;


<s> if ( REG_P ( dst ) && HARD_REGISTER_P ( dst ) && ! REG_P ( src ) && ! MEM_P ( src ) && ! ( VECTOR_MODE_P ( GET_MODE ( dst ) ) ? standard_sse_constant_p ( src , GET_MODE ( dst ) ) : x86_64_immediate_operand ( src , GET_MODE ( dst ) ) ) && ix86_class_likely_spilled_p ( REGNO_REG_CLASS ( REGNO ( dst ) ) ) && ! reload_completed ) return false ; return true ;


<s> bool ix86_hardreg_mov_ok ( rtx dst , rtx src ) {

if ( REG_P ( dst ) && HARD_REGISTER_P ( dst ) && ! REG_P ( src ) && ! MEM_P ( src ) && ! ( VECTOR_MODE_P ( GET_MODE ( dst ) ) ? standard_sse_constant_p ( src , GET_MODE ( dst ) ) : x86_64_immediate_operand ( src , GET_MODE ( dst ) ) ) && ix86_class_likely_spilled_p ( REGNO_REG_CLASS ( REGNO ( dst ) ) ) && ! reload_completed ) return false ;


<s> if ( abi_id == ABI_VZEROUPPER ) return ( GET_MODE_SIZE ( mode ) > <NUM_LIT> && ( ( TARGET_64BIT && REX_SSE_REGNO_P ( regno ) ) || LEGACY_SSE_REGNO_P ( regno ) ) ) ;

return SSE_REGNO_P ( regno ) && GET_MODE_SIZE ( mode ) > <NUM_LIT> ;


<s> if ( TARGET_AVX512VL && ( VALID_AVX256_REG_OR_OI_MODE ( mode ) || VALID_AVX512VL_128_REG_MODE ( mode ) ) ) return true ; if ( EXT_REX_SSE_REGNO_P ( regno ) ) return false ; 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 ) || VALID_FP_MODE_P ( mode ) ) return true ; else if ( VALID_MMX_REG_MODE_3DNOW ( mode ) || VALID_MMX_REG_MODE ( mode ) ) return true ; return false ;


<s> return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ; } if ( COMPLEX_MODE_P ( mode ) ) return <NUM_LIT> ; if ( mode == P2QImode || mode == P2HImode ) return <NUM_LIT> ; if ( mode == V64SFmode || mode == V64SImode ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> static unsigned int ix86_hard_regno_nregs ( unsigned int regno , machine_mode mode ) { if ( GENERAL_REGNO_P ( regno ) ) {

if ( mode == XFmode ) return TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ;


<s> static bool ix86_hard_regno_scratch_ok ( unsigned int regno ) {

return ( ! cfun -> machine -> no_caller_saved_registers || ( ! epilogue_completed && df_regs_ever_live_p ( regno ) ) ) ;


<s> static bool ix86_hard_regno_scratch_ok ( unsigned int regno ) { return ( ! cfun -> machine -> no_caller_saved_registers || ( ! epilogue_completed && df_regs_ever_live_p ( regno ) ) ) ;


<s> break ; 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 ; default :


if ( ! vzeroupper_abi . initialized_p ( ) ) {


<s> struct ix86_frame & frame = cfun -> machine -> frame ; if ( from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return frame . hard_frame_pointer_offset ;

else if ( from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return frame . hard_frame_pointer_offset - frame . frame_pointer_offset ;


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


<s> emit_label ( label ) ; LABEL_PRESERVE_P ( label ) = <NUM_LIT> ; 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 ) ) ; emit_insn ( gen_add2_insn ( pic_offset_table_rtx , tmp_reg ) ) ; const char * name = LABEL_NAME ( label ) ; PUT_CODE ( label , NOTE ) ;

NOTE_KIND ( label ) = NOTE_INSN_DELETED_LABEL ;


<s> emit_insn ( gen_set_got_offset_rex64 ( tmp_reg , label ) ) ; emit_insn ( gen_add2_insn ( pic_offset_table_rtx , tmp_reg ) ) ; const char * name = LABEL_NAME ( label ) ;


<s> } else { set_optab_libfunc ( sdivmod_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( udivmod_optab , DImode , <STR_LIT> ) ; }


<s> if ( crtl -> profile ) emit_move_insn ( pic_offset_table_rtx , reg ) ; add_reg_note ( insn , REG_CFA_FLUSH_QUEUE , NULL_RTX ) ; } seq = get_insns ( ) ; end_sequence ( ) ; entry_edge = single_succ_edge ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) ;

insert_insn_on_edge ( seq , entry_edge ) ;


<s> const predefined_function_abi & ix86_insn_callee_abi ( const rtx_insn * insn ) { unsigned int abi_id = <NUM_LIT> ; rtx pat = PATTERN ( insn ) ; if ( vzeroupper_pattern ( pat , VOIDmode ) ) abi_id = ABI_VZEROUPPER ; return function_abis [ abi_id ] ;


<s> static void ix86_instantiate_decls ( void ) { struct stack_local_entry * s ; for ( s = ix86_stack_locals ; s ; s = s -> next ) if ( s -> rtl != NULL_RTX ) instantiate_decl_rtl ( s -> rtl ) ;


<s> static rtx ix86_internal_arg_pointer ( void ) {


<s> if ( exp == NULL_TREE ) return false ; if ( TREE_CODE ( exp ) == FUNCTION_DECL ) return false ; if ( VAR_P ( exp ) && ! is_global_var ( exp ) ) return false ; if ( VAR_P ( exp ) && 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 ; return false ; } else {

HOST_WIDE_INT size = int_size_in_bytes ( TREE_TYPE ( exp ) ) ;


<s> if ( ! TARGET_64BIT ) return false ;

return default_is_empty_record ( type ) ;


<s> if ( ! TARGET_64BIT ) { attr = lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ; if ( attr ) return ( TREE_INT_CST_LOW ( TREE_VALUE ( TREE_VALUE ( attr ) ) ) == <NUM_LIT> ) ; if ( ix86_function_type_abi ( fntype ) == MS_ABI ) return true ; }


<s> if ( attr ) return ( TREE_INT_CST_LOW ( TREE_VALUE ( TREE_VALUE ( attr ) ) ) == <NUM_LIT> ) ; if ( ix86_function_type_abi ( fntype ) == MS_ABI ) return true ; }


<s> bool ix86_lea_for_add_ok ( rtx_insn * insn , rtx operands [ ] ) { unsigned int regno0 = true_regnum ( operands [ <NUM_LIT> ] ) ; unsigned int regno1 = true_regnum ( operands [ <NUM_LIT> ] ) ; unsigned int regno2 = true_regnum ( operands [ <NUM_LIT> ] ) ; if ( regno0 != regno1 && regno0 != regno2 ) return true ;

if ( ! TARGET_OPT_AGU || optimize_function_for_size_p ( cfun ) ) return false ;


<s> if ( split_cost < <NUM_LIT> ) return false ; if ( regno0 == regno1 || regno0 == regno2 ) return false ; return true ; } struct recog_data_d recog_data_save = recog_data ; dist_define = distance_non_agu_define ( regno1 , regno2 , insn ) ; dist_use = distance_agu_use ( regno0 , insn ) ;


<s> HOST_WIDE_INT scale ; addr_space_t seg ; if ( ix86_decompose_address ( addr , & parts ) == <NUM_LIT> ) return false ; base = parts . base ; index = parts . index ; disp = parts . disp ; scale = parts . scale ; seg = parts . seg ; if ( base ) { rtx reg = ix86_validate_address_register ( base ) ; if ( reg == NULL_RTX ) return false ; if ( ( strict && ! REG_OK_FOR_BASE_STRICT_P ( reg ) ) || ( ! strict && ! REG_OK_FOR_BASE_NONSTRICT_P ( reg ) ) ) return false ; } if ( index ) { rtx reg = ix86_validate_address_register ( index ) ; if ( reg == NULL_RTX ) return false ; if ( ( strict && ! REG_OK_FOR_INDEX_STRICT_P ( reg ) ) || ( ! strict && ! REG_OK_FOR_INDEX_NONSTRICT_P ( reg ) ) ) return false ; } if ( base && index && GET_MODE ( base ) != GET_MODE ( index ) ) return false ; if ( seg != ADDR_SPACE_GENERIC && ( ( base && GET_MODE ( base ) != word_mode ) || ( index && GET_MODE ( index ) != word_mode ) ) ) return false ; if ( scale != <NUM_LIT> ) { if ( ! index ) return false ; if ( scale != <NUM_LIT> && scale != <NUM_LIT> && scale != <NUM_LIT> ) return false ; } if ( disp ) { if ( ix86_endbr_immediate_operand ( disp , VOIDmode ) ) return false ; if ( GET_CODE ( disp ) == CONST && GET_CODE ( XEXP ( disp , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) != UNSPEC_MACHOPIC_OFFSET ) switch ( XINT ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ) { case UNSPEC_GOT : if ( ! TARGET_64BIT && ix86_force_load_from_GOT_p ( XVECEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ) ) goto is_legitimate_pic ;


<s> 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 ( UNARY_P ( op ) ) op = XEXP ( op , <NUM_LIT> ) ; if ( SUBREG_P ( op ) ) { 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> switch ( GET_CODE ( x ) ) { case CONST : x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS ) { if ( ! CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) return false ; x = XEXP ( x , <NUM_LIT> ) ; } 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 ) ; if ( ix86_force_load_from_GOT_p ( x ) ) return false ; break ; CASE_CONST_SCALAR_INT : if ( ix86_endbr_immediate_operand ( x , VOIDmode ) ) return false ; switch ( mode ) { case E_TImode : if ( TARGET_64BIT ) return true ; case E_OImode : case E_XImode : if ( ! standard_sse_constant_p ( x , mode ) && GET_MODE_SIZE ( TARGET_AVX512F ? XImode : ( TARGET_AVX ? OImode : ( TARGET_SSE2 ? TImode : DImode ) ) ) < GET_MODE_SIZE ( mode ) ) return false ; default : break ; } break ; case CONST_VECTOR : if ( ! standard_sse_constant_p ( x , mode ) ) return false ;


<s> bool ix86_libc_has_function ( enum function_class fn_class ) { return targetm . libc_has_function ( fn_class , NULL_TREE ) ;