<s> if ( ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type2 ) ) ) || ( ix86_function_regparm ( type1 , NULL ) != ix86_function_regparm ( type2 , NULL ) ) ) return <NUM_LIT> ;

if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type2 ) ) ) return <NUM_LIT> ;


<s> else if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( exp ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; }

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


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


<s> 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> ; } return align ;


<s> int ix86_data_alignment ( tree type , int align ) { if ( AGGREGATE_TYPE_P ( type ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && ( TREE_INT_CST_LOW ( TYPE_SIZE ( type ) ) >= <NUM_LIT> || TREE_INT_CST_HIGH ( TYPE_SIZE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; if ( TARGET_64BIT ) { if ( AGGREGATE_TYPE_P ( type ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && ( TREE_INT_CST_LOW ( TYPE_SIZE ( type ) ) >= <NUM_LIT> || TREE_INT_CST_HIGH ( TYPE_SIZE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; } if ( TREE_CODE ( type ) == ARRAY_TYPE ) { if ( TYPE_MODE ( TREE_TYPE ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; }

else if ( TREE_CODE ( type ) == COMPLEX_TYPE ) {


<s> case MULT : if ( index ) return <NUM_LIT> ; index = XEXP ( op , <NUM_LIT> ) ; scale_rtx = XEXP ( op , <NUM_LIT> ) ; break ; case UNSPEC : if ( XINT ( op , <NUM_LIT> ) == UNSPEC_TP && TARGET_TLS_DIRECT_SEG_REFS && seg == SEG_DEFAULT ) seg = TARGET_64BIT ? SEG_FS : SEG_GS ; else return <NUM_LIT> ; break ; case REG : case SUBREG : if ( ! base ) base = op ; else if ( ! index ) index = op ; else return <NUM_LIT> ; break ; case CONST : case CONST_INT : case SYMBOL_REF : case LABEL_REF : if ( disp ) return <NUM_LIT> ; disp = op ; break ; default : return <NUM_LIT> ; } } } else if ( GET_CODE ( addr ) == MULT ) { index = XEXP ( addr , <NUM_LIT> ) ; scale_rtx = XEXP ( addr , <NUM_LIT> ) ; } else if ( GET_CODE ( addr ) == ASHIFT ) { rtx tmp ; index = XEXP ( addr , <NUM_LIT> ) ; tmp = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( tmp ) != CONST_INT ) return <NUM_LIT> ; scale = INTVAL ( tmp ) ; if ( ( unsigned HOST_WIDE_INT ) scale > <NUM_LIT> ) return <NUM_LIT> ; scale = <NUM_LIT> << scale ; retval = - <NUM_LIT> ; } else disp = addr ; if ( scale_rtx ) { if ( GET_CODE ( scale_rtx ) != CONST_INT ) return <NUM_LIT> ; scale = INTVAL ( scale_rtx ) ; } base_reg = base && GET_CODE ( base ) == SUBREG ? SUBREG_REG ( base ) : base ; index_reg = index && GET_CODE ( index ) == SUBREG ? SUBREG_REG ( index ) : index ; if ( base_reg && index_reg && scale == <NUM_LIT> && ( index_reg == arg_pointer_rtx || index_reg == frame_pointer_rtx || ( REG_P ( index_reg ) && REGNO ( index_reg ) == STACK_POINTER_REGNUM ) ) ) { rtx tmp ; tmp = base , base = index , index = tmp ; tmp = base_reg , base_reg = index_reg , index_reg = tmp ; }

if ( ( base_reg == hard_frame_pointer_rtx || base_reg == frame_pointer_rtx || base_reg == arg_pointer_rtx ) && ! disp ) disp = const0_rtx ;


<s> if ( GET_CODE ( x ) == MEM ) x = XEXP ( x , <NUM_LIT> ) ; if ( TARGET_64BIT ) { if ( GET_CODE ( x ) != CONST || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != UNSPEC || XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) != UNSPEC_GOTPCREL || GET_CODE ( orig_x ) != MEM ) return orig_x ; return XVECEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ; } if ( GET_CODE ( x ) != PLUS || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST ) return orig_x ; if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x , <NUM_LIT> ) ) == PIC_OFFSET_TABLE_REGNUM ) y = NULL ;

else if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS ) {


<s> static void ix86_dwarf_handle_frame_unspec ( const char * label , rtx pattern , int index ) { rtx unspec = SET_SRC ( pattern ) ; gcc_assert ( GET_CODE ( unspec ) == UNSPEC ) ; switch ( index ) { case UNSPEC_REG_SAVE : dwarf2out_reg_save_reg ( label , XVECEXP ( unspec , <NUM_LIT> , <NUM_LIT> ) , SET_DEST ( pattern ) ) ; break ; case UNSPEC_DEF_CFA : dwarf2out_def_cfa ( label , REGNO ( SET_DEST ( pattern ) ) , INTVAL ( XVECEXP ( unspec , <NUM_LIT> , <NUM_LIT> ) ) ) ; break ; default :


<s> emit_insn ( gen_x86_fnstsw_1 ( reg ) ) ; if ( TARGET_USE_SAHF ) { emit_insn ( gen_x86_sahf_1 ( reg ) ) ; temp = gen_rtx_REG ( CCmode , FLAGS_REG ) ;

temp = gen_rtx_UNORDERED ( VOIDmode , temp , const0_rtx ) ;


<s> rtx temp ; emit_insn ( gen_x86_fnstsw_1 ( reg ) ) ; if ( TARGET_USE_SAHF ) { emit_insn ( gen_x86_sahf_1 ( reg ) ) ; temp = gen_rtx_REG ( CCmode , FLAGS_REG ) ; temp = gen_rtx_UNORDERED ( VOIDmode , temp , const0_rtx ) ; } else { emit_insn ( gen_testqi_ext_ccno_0 ( reg , GEN_INT ( <NUM_LIT> ) ) ) ;

temp = gen_rtx_REG ( CCNOmode , FLAGS_REG ) ;


<s> rtx label2 = gen_label_rtx ( ) ; rtx tmp = gen_reg_rtx ( XFmode ) ; rtx tmp2 = gen_reg_rtx ( XFmode ) ; emit_insn ( gen_absxf2 ( tmp , op1 ) ) ; emit_insn ( gen_cmpxf ( tmp , CONST_DOUBLE_FROM_REAL_VALUE ( REAL_VALUE_ATOF ( <STR_LIT> , XFmode ) , XFmode ) ) ) ; emit_jump_insn ( gen_bge ( label1 ) ) ; emit_move_insn ( tmp2 , standard_80387_constant_rtx ( <NUM_LIT> ) ) ;


<s> rtx base_address = gen_rtx_MEM ( Pmode , pointer ) ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( ix86_save_reg ( regno , maybe_eh_return ) ) { if ( TARGET_64BIT && offset != trunc_int_for_mode ( offset , SImode ) ) {


<s> r11 = gen_rtx_REG ( DImode , FIRST_REX_INT_REG + <NUM_LIT> ) ; emit_move_insn ( r11 , GEN_INT ( offset ) ) ; emit_insn ( gen_adddi3 ( r11 , r11 , pointer ) ) ;

base_address = gen_rtx_MEM ( Pmode , r11 ) ;


<s> unsigned int regno ; rtx insn ; for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) if ( ix86_save_reg ( regno , true ) ) {

insn = emit_insn ( gen_push ( gen_rtx_REG ( Pmode , regno ) ) ) ;


<s> rtx insn ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( ix86_save_reg ( regno , true ) ) { insn = emit_move_insn ( adjust_address ( gen_rtx_MEM ( Pmode , pointer ) , Pmode , offset ) , gen_rtx_REG ( Pmode , regno ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; offset += UNITS_PER_WORD ; }


<s> static void ix86_emit_save_regs_using_mov ( rtx pointer , HOST_WIDE_INT offset ) { unsigned int regno ; rtx insn ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( ix86_save_reg ( regno , true ) ) {

insn = emit_move_insn ( adjust_address ( gen_rtx_MEM ( Pmode , pointer ) , Pmode , offset ) , gen_rtx_REG ( Pmode , regno ) ) ;


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

default_encode_section_info ( decl , rtl , first ) ;


<s> else emit_insn ( gen_andsi3 ( tmpcount , variable , GEN_INT ( value ) ) ) ;

emit_cmp_and_jump_insns ( tmpcount , const0_rtx , EQ , <NUM_LIT> , GET_MODE ( variable ) , <NUM_LIT> , label ) ;


<s> if ( GET_MODE ( variable ) == DImode ) emit_insn ( gen_anddi3 ( tmpcount , variable , GEN_INT ( value ) ) ) ; else emit_insn ( gen_andsi3 ( tmpcount , variable , GEN_INT ( value ) ) ) ; emit_cmp_and_jump_insns ( tmpcount , const0_rtx , EQ , <NUM_LIT> , GET_MODE ( variable ) , <NUM_LIT> , label ) ; return label ;


<s> emit_insn ( ( mode == DImode ? gen_addsi3 : gen_adddi3 ) ( operand , operand , operand ) ) ; } else if ( ! optimize_size && count * ix86_cost -> add <= ix86_cost -> shift_const ) { int i ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { emit_insn ( ( mode == DImode ? gen_addsi3 : gen_adddi3 ) ( operand , operand , operand ) ) ; }


<s> clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , op , clob ) ) ) ; } if ( dst != operands [ <NUM_LIT> ] ) emit_move_insn ( operands [ <NUM_LIT> ] , dst ) ;


<s> op = gen_rtx_SET ( VOIDmode , dst , gen_rtx_fmt_ee ( code , mode , src1 , src2 ) ) ; if ( reload_in_progress ) { gcc_assert ( code == PLUS ) ; emit_insn ( op ) ; } else { clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , op , clob ) ) ) ;


<s> enum machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; enum machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; enum machine_mode mode1 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( VECTOR_MODE_P ( mode1 ) ) op1 = safe_vector_operand ( op1 , mode1 ) ; if ( optimize || ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; if ( GET_MODE ( op1 ) == SImode && mode1 == TImode ) {


<s> enum machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; enum machine_mode mode1 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( VECTOR_MODE_P ( mode1 ) ) op1 = safe_vector_operand ( op1 , mode1 ) ; if ( optimize || ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; if ( GET_MODE ( op1 ) == SImode && mode1 == TImode ) { rtx x = gen_reg_rtx ( V4SImode ) ; emit_insn ( gen_sse2_loadd ( x , op1 ) ) ;


<s> if ( ! call_insn_operand ( XEXP ( fnaddr , <NUM_LIT> ) , Pmode ) ) { fnaddr = copy_to_mode_reg ( Pmode , XEXP ( fnaddr , <NUM_LIT> ) ) ; fnaddr = gen_rtx_MEM ( QImode , fnaddr ) ; } if ( sibcall && TARGET_64BIT && ! constant_call_address_operand ( XEXP ( fnaddr , <NUM_LIT> ) , Pmode ) ) { rtx addr ; addr = copy_to_mode_reg ( Pmode , XEXP ( fnaddr , <NUM_LIT> ) ) ; fnaddr = gen_rtx_REG ( Pmode , FIRST_REX_INT_REG + <NUM_LIT> ) ; emit_move_insn ( fnaddr , addr ) ; fnaddr = gen_rtx_MEM ( QImode , fnaddr ) ; } call = gen_rtx_CALL ( VOIDmode , fnaddr , callarg1 ) ; if ( retval ) call = gen_rtx_SET ( VOIDmode , retval , call ) ; if ( pop ) { pop = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , pop ) ; pop = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , pop ) ; call = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , call , pop ) ) ; } call = emit_call_insn ( call ) ; if ( use ) CALL_INSN_FUNCTION_USAGE ( call ) = use ;


<s> tmp = gen_rtx_SET ( VOIDmode , dest , const0_rtx ) ; if ( reload_completed && ( ! TARGET_USE_MOV0 || optimize_size ) ) { rtx clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , <NUM_LIT> ) ) ;

tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , tmp , clob ) ) ;


<s> rtx tmp ; gcc_assert ( reload_completed ) ; if ( GET_MODE_SIZE ( GET_MODE ( dest ) ) < <NUM_LIT> ) dest = gen_rtx_REG ( SImode , REGNO ( dest ) ) ; tmp = gen_rtx_SET ( VOIDmode , dest , const0_rtx ) ;

if ( reload_completed && ( ! TARGET_USE_MOV0 || optimize_size ) ) {


<s> rtx op0 , op1 , ret ; op0 = ix86_compare_op0 ; op1 = ix86_compare_op1 ; if ( second_test ) * second_test = NULL_RTX ; if ( bypass_test ) * bypass_test = NULL_RTX ; if ( ix86_compare_emitted ) { ret = gen_rtx_fmt_ee ( code , VOIDmode , ix86_compare_emitted , const0_rtx ) ;


<s> rtx op0 , op1 , ret ; op0 = ix86_compare_op0 ; op1 = ix86_compare_op1 ; if ( second_test ) * second_test = NULL_RTX ; if ( bypass_test ) * bypass_test = NULL_RTX ; if ( ix86_compare_emitted ) { ret = gen_rtx_fmt_ee ( code , VOIDmode , ix86_compare_emitted , const0_rtx ) ; ix86_compare_emitted = NULL_RTX ; }

else if ( GET_MODE_CLASS ( GET_MODE ( op0 ) ) == MODE_FLOAT ) ret = ix86_expand_fp_compare ( code , op0 , op1 , NULL_RTX , second_test , bypass_test ) ;


<s> enum machine_mode mode , vmode ; rtx dest , op0 , op1 , mask , nmask ; dest = operands [ <NUM_LIT> ] ; op0 = operands [ <NUM_LIT> ] ; op1 = operands [ <NUM_LIT> ] ; mode = GET_MODE ( dest ) ; vmode = mode == SFmode ? V4SFmode : V2DFmode ; if ( GET_CODE ( op0 ) == CONST_DOUBLE ) { rtvec v ; if ( real_isneg ( CONST_DOUBLE_REAL_VALUE ( op0 ) ) ) op0 = simplify_unary_operation ( ABS , mode , op0 , mode ) ; if ( op0 == CONST0_RTX ( mode ) ) op0 = CONST0_RTX ( vmode ) ; else { if ( mode == SFmode ) v = gen_rtvec ( <NUM_LIT> , op0 , CONST0_RTX ( SFmode ) , CONST0_RTX ( SFmode ) , CONST0_RTX ( SFmode ) ) ; else v = gen_rtvec ( <NUM_LIT> , op0 , CONST0_RTX ( DFmode ) ) ; op0 = force_reg ( vmode , gen_rtx_CONST_VECTOR ( vmode , v ) ) ; } mask = ix86_build_signbit_mask ( mode , <NUM_LIT> , <NUM_LIT> ) ; if ( mode == SFmode ) emit_insn ( gen_copysignsf3_const ( dest , op0 , op1 , mask ) ) ; else emit_insn ( gen_copysigndf3_const ( dest , op0 , op1 , mask ) ) ; } else { nmask = ix86_build_signbit_mask ( mode , <NUM_LIT> , <NUM_LIT> ) ;


<s> matching_memory = false ; if ( MEM_P ( dst ) ) { if ( rtx_equal_p ( dst , src ) ) matching_memory = true ; else dst = gen_reg_rtx ( mode ) ; } if ( MEM_P ( src ) && ! matching_memory ) src = force_reg ( mode , src ) ; if ( vector_mode ) { set = gen_rtx_fmt_ee ( code == NEG ? XOR : AND , mode , src , mask ) ; set = gen_rtx_SET ( VOIDmode , dst , set ) ; emit_insn ( set ) ; }


<s> if ( ix86_expand_sse_fp_minmax ( operands [ <NUM_LIT> ] , code , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) return true ; cmp = ix86_expand_sse_cmp ( operands [ <NUM_LIT> ] , code , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; ix86_expand_sse_movcc ( operands [ <NUM_LIT> ] , cmp , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> enum machine_mode mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; if ( operands [ <NUM_LIT> ] != const1_rtx && operands [ <NUM_LIT> ] != constm1_rtx ) return <NUM_LIT> ; if ( ! ix86_expand_carry_flag_compare ( code , ix86_compare_op0 , ix86_compare_op1 , & compare_op ) ) return <NUM_LIT> ; code = GET_CODE ( compare_op ) ; if ( GET_MODE ( XEXP ( compare_op , <NUM_LIT> ) ) == CCFPmode || GET_MODE ( XEXP ( compare_op , <NUM_LIT> ) ) == CCFPUmode ) { fpcmp = true ; code = ix86_fp_compare_code_to_integer ( code ) ; } if ( code != LTU ) { val = constm1_rtx ; if ( fpcmp ) PUT_CODE ( compare_op , reverse_condition_maybe_unordered ( GET_CODE ( compare_op ) ) ) ; else PUT_CODE ( compare_op , reverse_condition ( GET_CODE ( compare_op ) ) ) ;


<s> enum machine_mode cmpmode ; rtx tmp , flags ; cmpmode = SELECT_CC_MODE ( code , op0 , op1 ) ; flags = gen_rtx_REG ( cmpmode , FLAGS_REG ) ; tmp = gen_rtx_COMPARE ( cmpmode , op0 , op1 ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , flags , tmp ) ) ;


<s> default : gcc_unreachable ( ) ; } if ( code == GTU ) { switch ( mode ) { case V4SImode : { rtx t1 , t2 , mask ; t1 = gen_reg_rtx ( mode ) ; emit_insn ( gen_subv4si3 ( t1 , cop0 , cop1 ) ) ; mask = GEN_INT ( - <NUM_LIT> ) ; mask = gen_rtx_CONST_VECTOR ( mode , gen_rtvec ( <NUM_LIT> , mask , mask , mask , mask ) ) ; mask = force_reg ( mode , mask ) ; t2 = gen_reg_rtx ( mode ) ; emit_insn ( gen_andv4si3 ( t2 , cop0 , mask ) ) ; x = gen_reg_rtx ( mode ) ; emit_insn ( gen_xorv4si3 ( x , t1 , t2 ) ) ; code = GT ; } break ; case V16QImode : case V8HImode : x = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , x , gen_rtx_US_MINUS ( mode , cop0 , cop1 ) ) ) ; code = EQ ; negate = ! negate ; break ; default :


<s> RTX_FRAME_RELATED_P ( y ) = <NUM_LIT> ; x = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , x , y ) ) ; x = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , x , NULL ) ; REG_NOTES ( insn ) = x ; emit_insn ( gen_andsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) ; x = cfun -> machine -> force_align_arg_pointer ; x = gen_frame_mem ( Pmode , plus_constant ( x , - <NUM_LIT> ) ) ; insn = emit_insn ( gen_push ( x ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; x = GEN_INT ( <NUM_LIT> ) ; x = gen_rtx_UNSPEC ( VOIDmode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_DEF_CFA ) ; x = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , x ) ; x = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , x , NULL ) ; REG_NOTES ( insn ) = x ; } if ( frame_pointer_needed ) { insn = emit_insn ( gen_push ( hard_frame_pointer_rtx ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } allocate = frame . to_allocate ; if ( ! frame . save_regs_using_mov ) ix86_emit_save_regs ( ) ; else allocate += frame . nregs * UNITS_PER_WORD ; if ( TARGET_RED_ZONE && frame . save_regs_using_mov ) ix86_emit_save_regs_using_mov ( frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx , - frame . nregs * UNITS_PER_WORD ) ; if ( allocate == <NUM_LIT> ) ; else if ( ! TARGET_STACK_PROBE || allocate < CHECK_STACK_LIMIT ) pro_epilogue_adjust_stack ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - allocate ) , - <NUM_LIT> ) ; else { rtx eax = gen_rtx_REG ( SImode , <NUM_LIT> ) ; bool eax_live = ix86_eax_live_at_start_p ( ) ; rtx t ; gcc_assert ( ! TARGET_64BIT ) ; if ( eax_live ) { emit_insn ( gen_push ( eax ) ) ; allocate -= <NUM_LIT> ; } emit_move_insn ( eax , GEN_INT ( allocate ) ) ; insn = emit_insn ( gen_allocate_stack_worker ( eax ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; t = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( - allocate ) ) ; t = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , t ) ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , t , REG_NOTES ( insn ) ) ; if ( eax_live ) { if ( frame_pointer_needed ) t = plus_constant ( hard_frame_pointer_rtx , allocate - frame . to_allocate - frame . nregs * UNITS_PER_WORD ) ; else t = plus_constant ( stack_pointer_rtx , allocate ) ; emit_move_insn ( eax , gen_rtx_MEM ( SImode , t ) ) ; } } if ( frame . save_regs_using_mov && ! TARGET_RED_ZONE ) { if ( ! frame_pointer_needed || ! frame . to_allocate ) ix86_emit_save_regs_using_mov ( stack_pointer_rtx , frame . to_allocate ) ; else ix86_emit_save_regs_using_mov ( hard_frame_pointer_rtx , - frame . nregs * UNITS_PER_WORD ) ; } pic_reg_used = false ;

if ( pic_offset_table_rtx && ( regs_ever_live [ REAL_PIC_OFFSET_TABLE_REGNUM ] || current_function_profile ) ) {


<s> tmp = expand_simple_binop ( Pmode , PLUS , stack_pointer_rtx , GEN_INT ( - GET_MODE_SIZE ( mode ) ) , stack_pointer_rtx , <NUM_LIT> , OPTAB_DIRECT ) ; if ( tmp != stack_pointer_rtx ) emit_move_insn ( stack_pointer_rtx , tmp ) ; tmp = gen_rtx_MEM ( mode , stack_pointer_rtx ) ; emit_move_insn ( tmp , x ) ;


emit_insn ( fn ( dest , tmp2 , tmp3 ) ) ;


<s> bypass = <NUM_LIT> ; PUT_CODE ( test , reverse_condition_maybe_unordered ( GET_CODE ( test ) ) ) ; } PUT_MODE ( test , QImode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmp2 , test ) ) ; if ( bypass ) emit_insn ( gen_andqi3 ( tmp , tmpreg , tmp2 ) ) ; else emit_insn ( gen_iorqi3 ( tmp , tmpreg , tmp2 ) ) ; } if ( ix86_compare_op0 && ix86_compare_op1 ) {

equiv = simplify_gen_relational ( code , QImode , GET_MODE ( ix86_compare_op0 ) , ix86_compare_op0 , ix86_compare_op1 ) ;


<s> rtx x ; cmp_op0 = force_reg ( mode , cmp_op0 ) ; if ( ! nonimmediate_operand ( cmp_op1 , mode ) ) cmp_op1 = force_reg ( mode , cmp_op1 ) ; if ( optimize || reg_overlap_mentioned_p ( dest , op_true ) || reg_overlap_mentioned_p ( dest , op_false ) ) dest = gen_reg_rtx ( mode ) ;

x = gen_rtx_fmt_ee ( code , mode , cmp_op0 , cmp_op1 ) ;


<s> target = gen_reg_rtx ( SImode ) ; emit_move_insn ( target , const0_rtx ) ; target = gen_rtx_SUBREG ( QImode , target , <NUM_LIT> ) ; if ( ( optimize && ! register_operand ( op0 , mode0 ) ) || ! ( * insn_data [ d -> icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; if ( ( optimize && ! register_operand ( op1 , mode1 ) ) || ! ( * insn_data [ d -> icode ] . operand [ <NUM_LIT> ] . predicate ) ( op1 , mode1 ) ) op1 = copy_to_mode_reg ( mode1 , op1 ) ; op2 = gen_rtx_fmt_ee ( comparison , mode0 , op0 , op1 ) ; pat = GEN_FCN ( d -> icode ) ( op0 , op1 ) ;


<s> enum machine_mode mode1 = insn_data [ d -> icode ] . operand [ <NUM_LIT> ] . mode ; enum rtx_code comparison = d -> comparison ; if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( VECTOR_MODE_P ( mode1 ) ) op1 = safe_vector_operand ( op1 , mode1 ) ; if ( d -> flag & BUILTIN_DESC_SWAP_OPERANDS ) { rtx tmp = gen_reg_rtx ( mode1 ) ; emit_move_insn ( tmp , op1 ) ; op1 = op0 ; op0 = tmp ; } if ( optimize || ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ d -> icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; if ( ( optimize && ! register_operand ( op0 , mode0 ) ) || ! ( * insn_data [ d -> icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; if ( ( optimize && ! register_operand ( op1 , mode1 ) ) || ! ( * insn_data [ d -> icode ] . operand [ <NUM_LIT> ] . predicate ) ( op1 , mode1 ) ) op1 = copy_to_mode_reg ( mode1 , op1 ) ; op2 = gen_rtx_fmt_ee ( comparison , mode0 , op0 , op1 ) ; pat = GEN_FCN ( d -> icode ) ( target , op0 , op1 , op2 ) ; if ( ! pat ) return <NUM_LIT> ;


<s> if ( ( optimize && ! register_operand ( op0 , mode0 ) ) || ! ( * insn_data [ d -> icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; if ( ( optimize && ! register_operand ( op1 , mode1 ) ) || ! ( * insn_data [ d -> icode ] . operand [ <NUM_LIT> ] . predicate ) ( op1 , mode1 ) ) op1 = copy_to_mode_reg ( mode1 , op1 ) ; op2 = gen_rtx_fmt_ee ( comparison , mode0 , op0 , op1 ) ; pat = GEN_FCN ( d -> icode ) ( target , op0 , op1 , op2 ) ; if ( ! pat ) return <NUM_LIT> ;


<s> else return false ; if ( rtx_equal_p ( cmp_op0 , if_true ) && rtx_equal_p ( cmp_op1 , if_false ) ) is_min = true ; else if ( rtx_equal_p ( cmp_op1 , if_true ) && rtx_equal_p ( cmp_op0 , if_false ) ) is_min = false ; else return false ; mode = GET_MODE ( dest ) ; if ( ! flag_finite_math_only || ! flag_unsafe_math_optimizations ) { int u = is_min ? UNSPEC_IEEE_MIN : UNSPEC_IEEE_MAX ; rtvec v ; if_true = force_reg ( mode , if_true ) ; v = gen_rtvec ( <NUM_LIT> , if_true , if_false ) ; tmp = gen_rtx_UNSPEC ( mode , v , u ) ;


<s> enum machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; enum machine_mode mode1 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( VECTOR_MODE_P ( mode1 ) ) op1 = safe_vector_operand ( op1 , mode1 ) ; op0 = gen_rtx_MEM ( mode0 , copy_to_mode_reg ( Pmode , op0 ) ) ; op1 = copy_to_mode_reg ( mode1 , op1 ) ; pat = GEN_FCN ( icode ) ( op0 , op1 ) ; if ( pat ) emit_insn ( pat ) ; return <NUM_LIT> ;


<s> addr = force_reg ( Pmode , XEXP ( src , <NUM_LIT> ) ) ; scratch1 = gen_reg_rtx ( Pmode ) ; if ( TARGET_UNROLL_STRLEN && eoschar == const0_rtx && optimize > <NUM_LIT> && ! optimize_size ) { emit_move_insn ( out , addr ) ; ix86_expand_strlensi_unroll_1 ( out , src , align ) ; if ( TARGET_64BIT ) emit_insn ( gen_subdi3 ( out , out , addr ) ) ; else emit_insn ( gen_subsi3 ( out , out , addr ) ) ; } else { rtx unspec ; scratch2 = gen_reg_rtx ( Pmode ) ; scratch3 = gen_reg_rtx ( Pmode ) ; scratch4 = force_reg ( Pmode , constm1_rtx ) ; emit_move_insn ( scratch3 , addr ) ; eoschar = force_reg ( QImode , eoschar ) ; emit_insn ( gen_cld ( ) ) ; src = replace_equiv_address_nv ( src , scratch3 ) ; unspec = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , src , eoschar , align , scratch4 ) , UNSPEC_SCAS ) ; emit_insn ( gen_strlenqi_1 ( scratch1 , scratch3 , unspec ) ) ; if ( TARGET_64BIT ) { emit_insn ( gen_one_cmpldi2 ( scratch2 , scratch1 ) ) ; emit_insn ( gen_adddi3 ( out , scratch2 , constm1_rtx ) ) ; } else { emit_insn ( gen_one_cmplsi2 ( scratch2 , scratch1 ) ) ; emit_insn ( gen_addsi3 ( out , scratch2 , constm1_rtx ) ) ; } } return <NUM_LIT> ;


<s> emit_move_insn ( scratch , mem ) ; if ( TARGET_64BIT ) emit_insn ( gen_adddi3 ( out , out , GEN_INT ( <NUM_LIT> ) ) ) ; else emit_insn ( gen_addsi3 ( out , out , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_addsi3 ( tmpreg , scratch , GEN_INT ( - <NUM_LIT> ) ) ) ; emit_insn ( gen_one_cmplsi2 ( scratch , scratch ) ) ; emit_insn ( gen_andsi3 ( tmpreg , tmpreg , scratch ) ) ; emit_insn ( gen_andsi3 ( tmpreg , tmpreg , gen_int_mode ( <NUM_LIT> , SImode ) ) ) ; emit_cmp_and_jump_insns ( tmpreg , const0_rtx , EQ , <NUM_LIT> , SImode , <NUM_LIT> , align_4_label ) ; if ( TARGET_CMOVE ) { rtx reg = gen_reg_rtx ( SImode ) ; rtx reg2 = gen_reg_rtx ( Pmode ) ; emit_move_insn ( reg , tmpreg ) ; emit_insn ( gen_lshrsi3 ( reg , reg , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_testsi_ccno_1 ( tmpreg , GEN_INT ( <NUM_LIT> ) ) ) ; tmp = gen_rtx_REG ( CCNOmode , FLAGS_REG ) ; tmp = gen_rtx_EQ ( VOIDmode , tmp , const0_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmpreg , gen_rtx_IF_THEN_ELSE ( SImode , tmp , reg , tmpreg ) ) ) ; emit_insn ( gen_rtx_SET ( SImode , reg2 , gen_rtx_PLUS ( Pmode , out , const2_rtx ) ) ) ; tmp = gen_rtx_REG ( CCNOmode , FLAGS_REG ) ; tmp = gen_rtx_EQ ( VOIDmode , tmp , const0_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , out , gen_rtx_IF_THEN_ELSE ( Pmode , tmp , reg2 , out ) ) ) ; } else { rtx end_2_label = gen_label_rtx ( ) ; emit_insn ( gen_testsi_ccno_1 ( tmpreg , GEN_INT ( <NUM_LIT> ) ) ) ; tmp = gen_rtx_REG ( CCNOmode , FLAGS_REG ) ; tmp = gen_rtx_NE ( VOIDmode , tmp , const0_rtx ) ; tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , end_2_label ) , pc_rtx ) ; tmp = emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , tmp ) ) ; JUMP_LABEL ( tmp ) = end_2_label ; emit_insn ( gen_lshrsi3 ( tmpreg , tmpreg , GEN_INT ( <NUM_LIT> ) ) ) ; if ( TARGET_64BIT ) emit_insn ( gen_adddi3 ( out , out , const2_rtx ) ) ; else emit_insn ( gen_addsi3 ( out , out , const2_rtx ) ) ; emit_label ( end_2_label ) ; } tmpreg = gen_lowpart ( QImode , tmpreg ) ; emit_insn ( gen_addqi3_cc ( tmpreg , tmpreg , tmpreg ) ) ;

cmp = gen_rtx_LTU ( Pmode , gen_rtx_REG ( CCmode , <NUM_LIT> ) , const0_rtx ) ;


<s> if ( MEM_P ( src ) && ! matching_memory ) src = force_reg ( mode , src ) ; op = gen_rtx_SET ( VOIDmode , dst , gen_rtx_fmt_e ( code , mode , src ) ) ; if ( reload_in_progress || code == NOT ) { gcc_assert ( code == NOT ) ; emit_insn ( op ) ; } else { clob = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCmode , FLAGS_REG ) ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , op , clob ) ) ) ; } if ( dst != operands [ <NUM_LIT> ] ) emit_move_insn ( operands [ <NUM_LIT> ] , dst ) ;


<s> enum machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( optimize || ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( ( optimize && ! register_operand ( op0 , mode0 ) ) || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; op1 = op0 ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op1 , mode0 ) ) op1 = copy_to_mode_reg ( mode0 , op1 ) ;

pat = GEN_FCN ( icode ) ( target , op0 , op1 ) ;


<s> rtx op0 = expand_expr ( arg0 , NULL_RTX , VOIDmode , <NUM_LIT> ) ; enum machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; enum machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( optimize || ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; if ( do_load ) op0 = gen_rtx_MEM ( mode0 , copy_to_mode_reg ( Pmode , op0 ) ) ; else { if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ;

if ( ( optimize && ! register_operand ( op0 , mode0 ) ) || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ;


<s> tree arg0 = TREE_VALUE ( arglist ) ; rtx op0 = expand_expr ( arg0 , NULL_RTX , VOIDmode , <NUM_LIT> ) ; enum machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; enum machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ;

if ( optimize || ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ;


<s> case V4SFmode : switch ( elt ) { case <NUM_LIT> : tmp = vec ; break ; case <NUM_LIT> : case <NUM_LIT> : tmp = gen_reg_rtx ( mode ) ; emit_insn ( gen_sse_shufps_1 ( tmp , vec , vec , GEN_INT ( elt ) , GEN_INT ( elt ) , GEN_INT ( elt + <NUM_LIT> ) , GEN_INT ( elt + <NUM_LIT> ) ) ) ; break ; case <NUM_LIT> : tmp = gen_reg_rtx ( mode ) ; emit_insn ( gen_sse_unpckhps ( tmp , vec , vec ) ) ; break ; default : gcc_unreachable ( ) ; } vec = tmp ; use_vec_extr = true ; elt = <NUM_LIT> ; break ; case V4SImode : if ( TARGET_SSE2 ) { switch ( elt ) { case <NUM_LIT> : tmp = vec ; break ; case <NUM_LIT> : case <NUM_LIT> : tmp = gen_reg_rtx ( mode ) ; emit_insn ( gen_sse2_pshufd_1 ( tmp , vec , GEN_INT ( elt ) , GEN_INT ( elt ) , GEN_INT ( elt ) , GEN_INT ( elt ) ) ) ; break ; case <NUM_LIT> : tmp = gen_reg_rtx ( mode ) ; emit_insn ( gen_sse2_punpckhdq ( tmp , vec , vec ) ) ; break ; default : gcc_unreachable ( ) ; } vec = tmp ; use_vec_extr = true ; elt = <NUM_LIT> ; } else { ix86_expand_vector_extract ( false , gen_lowpart ( SFmode , target ) , gen_lowpart ( V4SFmode , vec ) , elt ) ; return ; } break ; case V8HImode : use_vec_extr = TARGET_SSE2 ; break ; case V4HImode : use_vec_extr = mmx_ok && ( TARGET_SSE || TARGET_3DNOW_A ) ; break ; case V16QImode : case V8QImode : default : break ; } if ( use_vec_extr ) { tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , GEN_INT ( elt ) ) ) ; tmp = gen_rtx_VEC_SELECT ( inner_mode , vec , tmp ) ; if ( inner_mode == HImode ) { tmp = gen_rtx_ZERO_EXTEND ( SImode , tmp ) ; target = gen_lowpart ( SImode , target ) ; } emit_insn ( gen_rtx_SET ( VOIDmode , target , tmp ) ) ; } else { rtx mem = assign_stack_temp ( mode , GET_MODE_SIZE ( mode ) , false ) ; emit_move_insn ( mem , vec ) ;

tmp = adjust_address ( mem , inner_mode , elt * GET_MODE_SIZE ( inner_mode ) ) ;


<s> enum machine_mode inner_mode = GET_MODE_INNER ( mode ) ; int n_elts = GET_MODE_NUNITS ( mode ) ; int n_var = <NUM_LIT> , one_var = - <NUM_LIT> ; bool all_same = true , all_const_zero = true ; int i ; rtx x ; for ( i = <NUM_LIT> ; i < n_elts ; ++ i ) { x = XVECEXP ( vals , <NUM_LIT> , i ) ; if ( ! CONSTANT_P ( x ) ) n_var ++ , one_var = i ;

else if ( x != CONST0_RTX ( inner_mode ) ) all_const_zero = false ;


<s> x = gen_rtx_VEC_DUPLICATE ( mode , val ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , x ) ) ; return true ; case V4HImode : if ( ! mmx_ok ) return false ; if ( TARGET_SSE || TARGET_3DNOW_A ) { val = gen_lowpart ( SImode , val ) ; x = gen_rtx_TRUNCATE ( HImode , val ) ; x = gen_rtx_VEC_DUPLICATE ( mode , x ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , x ) ) ; return true ; } else { smode = HImode ; wsmode = SImode ; wvmode = V2SImode ; goto widen ; } case V8QImode : if ( ! mmx_ok ) return false ; smode = QImode ; wsmode = HImode ; wvmode = V4HImode ; goto widen ; case V8HImode : smode = HImode ; wsmode = SImode ; wvmode = V4SImode ; goto widen ; case V16QImode : smode = QImode ; wsmode = HImode ; wvmode = V8HImode ; goto widen ; widen : val = convert_modes ( wsmode , smode , val , true ) ; x = expand_simple_binop ( wsmode , ASHIFT , val , GEN_INT ( GET_MODE_BITSIZE ( smode ) ) , NULL_RTX , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; val = expand_simple_binop ( wsmode , IOR , val , x , x , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; x = gen_reg_rtx ( wvmode ) ; if ( ! ix86_expand_vector_init_duplicate ( mmx_ok , wvmode , x , val ) ) gcc_unreachable ( ) ; emit_move_insn ( target , gen_lowpart ( mode , x ) ) ; return true ;


<s> n_words = GET_MODE_SIZE ( mode ) / UNITS_PER_WORD ; n_elt_per_word = n_elts / n_words ; shift = GEN_INT ( GET_MODE_BITSIZE ( inner_mode ) ) ; for ( i = <NUM_LIT> ; i < n_words ; ++ i ) { rtx word = NULL_RTX ; for ( j = <NUM_LIT> ; j < n_elt_per_word ; ++ j ) { rtx elt = XVECEXP ( vals , <NUM_LIT> , ( i + <NUM_LIT> ) * n_elt_per_word - j - <NUM_LIT> ) ; elt = convert_modes ( word_mode , inner_mode , elt , true ) ; if ( j == <NUM_LIT> ) word = elt ; else { word = expand_simple_binop ( word_mode , ASHIFT , word , shift , word , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; word = expand_simple_binop ( word_mode , IOR , word , elt , word , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; } } words [ i ] = word ; } if ( n_words == <NUM_LIT> ) emit_move_insn ( target , gen_lowpart ( mode , words [ <NUM_LIT> ] ) ) ; else if ( n_words == <NUM_LIT> ) { rtx tmp = gen_reg_rtx ( mode ) ;

emit_insn ( gen_rtx_CLOBBER ( VOIDmode , tmp ) ) ;


<s> } break ; case V8HImode : case V16QImode : case V4HImode : case V8QImode : break ; default : gcc_unreachable ( ) ; } if ( use_vec_concat ) { if ( ! register_operand ( op0 , half_mode ) ) op0 = force_reg ( half_mode , op0 ) ; if ( ! register_operand ( op1 , half_mode ) ) op1 = force_reg ( half_mode , op1 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , gen_rtx_VEC_CONCAT ( mode , op0 , op1 ) ) ) ; } else { int i , j , n_elts , n_words , n_elt_per_word ; enum machine_mode inner_mode ; rtx words [ <NUM_LIT> ] , shift ; inner_mode = GET_MODE_INNER ( mode ) ; n_elts = GET_MODE_NUNITS ( mode ) ; n_words = GET_MODE_SIZE ( mode ) / UNITS_PER_WORD ; n_elt_per_word = n_elts / n_words ; shift = GEN_INT ( GET_MODE_BITSIZE ( inner_mode ) ) ; for ( i = <NUM_LIT> ; i < n_words ; ++ i ) { rtx word = NULL_RTX ; for ( j = <NUM_LIT> ; j < n_elt_per_word ; ++ j ) { rtx elt = XVECEXP ( vals , <NUM_LIT> , ( i + <NUM_LIT> ) * n_elt_per_word - j - <NUM_LIT> ) ; elt = convert_modes ( word_mode , inner_mode , elt , true ) ; if ( j == <NUM_LIT> ) word = elt ; else { word = expand_simple_binop ( word_mode , ASHIFT , word , shift , word , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; word = expand_simple_binop ( word_mode , IOR , word , elt , word , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; } } words [ i ] = word ; } if ( n_words == <NUM_LIT> ) emit_move_insn ( target , gen_lowpart ( mode , words [ <NUM_LIT> ] ) ) ;


<s> x = gen_rtx_VEC_MERGE ( mode , x , CONST0_RTX ( mode ) , const1_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , x ) ) ; return true ; case V8HImode : case V16QImode : vsimode = V4SImode ; goto widen ; case V4HImode : case V8QImode : if ( ! mmx_ok ) return false ; vsimode = V2SImode ; goto widen ; widen :

var = convert_modes ( SImode , GET_MODE_INNER ( mode ) , var , true ) ;


<s> rtx var = XVECEXP ( vals , <NUM_LIT> , one_var ) ; enum machine_mode wmode ; rtx const_vec , x ; const_vec = copy_rtx ( vals ) ; XVECEXP ( const_vec , <NUM_LIT> , one_var ) = CONST0_RTX ( GET_MODE_INNER ( mode ) ) ; const_vec = gen_rtx_CONST_VECTOR ( mode , XVEC ( const_vec , <NUM_LIT> ) ) ; switch ( mode ) { case V2DFmode : case V2DImode : case V2SFmode : case V2SImode : return false ; case V4SFmode : case V4SImode : case V8HImode : case V4HImode : break ; case V16QImode : wmode = V8HImode ; goto widen ; case V8QImode : wmode = V4HImode ; goto widen ; widen : x = XVECEXP ( vals , <NUM_LIT> , one_var ^ <NUM_LIT> ) ; if ( one_var & <NUM_LIT> ) { var = convert_modes ( HImode , QImode , var , true ) ; var = expand_simple_binop ( HImode , ASHIFT , var , GEN_INT ( <NUM_LIT> ) , NULL_RTX , <NUM_LIT> , OPTAB_LIB_WIDEN ) ;

x = GEN_INT ( INTVAL ( x ) & <NUM_LIT> ) ;


<s> if ( ( reload_in_progress | reload_completed ) == <NUM_LIT> && register_operand ( op0 , mode ) && CONSTANT_P ( op1 ) && op1 != CONST0_RTX ( mode ) ) op1 = validize_mem ( force_const_mem ( mode , op1 ) ) ; if ( ! no_new_pseudos && ! register_operand ( op0 , mode ) && ! register_operand ( op1 , mode ) ) {


<s> } if ( TARGET_SSE2 && GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) { op0 = gen_lowpart ( V16QImode , op0 ) ; op1 = gen_lowpart ( V16QImode , op1 ) ; emit_insn ( gen_sse2_movdqu ( op0 , op1 ) ) ; return ; } if ( TARGET_SSE2 && mode == V2DFmode ) { rtx zero ; if ( TARGET_SSE_SPLIT_REGS ) { emit_insn ( gen_rtx_CLOBBER ( VOIDmode , op0 ) ) ; zero = op0 ; } else { zero = CONST0_RTX ( V2DFmode ) ; } m = adjust_address ( op1 , DFmode , <NUM_LIT> ) ; emit_insn ( gen_sse2_loadlpd ( op0 , zero , m ) ) ; m = adjust_address ( op1 , DFmode , <NUM_LIT> ) ; emit_insn ( gen_sse2_loadhpd ( op0 , op0 , m ) ) ; } else { if ( TARGET_SSE_PARTIAL_REG_DEPENDENCY ) emit_move_insn ( op0 , CONST0_RTX ( mode ) ) ; else emit_insn ( gen_rtx_CLOBBER ( VOIDmode , op0 ) ) ; if ( mode != V4SFmode ) op0 = gen_lowpart ( V4SFmode , op0 ) ; m = adjust_address ( op1 , V2SFmode , <NUM_LIT> ) ; emit_insn ( gen_sse_loadlps ( op0 , op0 , m ) ) ; m = adjust_address ( op1 , V2SFmode , <NUM_LIT> ) ; emit_insn ( gen_sse_loadhps ( op0 , op0 , m ) ) ; } } else if ( MEM_P ( op0 ) ) { if ( optimize_size ) { op0 = gen_lowpart ( V4SFmode , op0 ) ; op1 = gen_lowpart ( V4SFmode , op1 ) ;


<s> case V2SFmode : case V2SImode : if ( mmx_ok ) { tmp = gen_reg_rtx ( GET_MODE_INNER ( mode ) ) ; ix86_expand_vector_extract ( true , tmp , target , <NUM_LIT> - elt ) ; if ( elt == <NUM_LIT> ) tmp = gen_rtx_VEC_CONCAT ( mode , tmp , val ) ; else tmp = gen_rtx_VEC_CONCAT ( mode , val , tmp ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , tmp ) ) ; return ; } break ; case V2DFmode : case V2DImode : { rtx op0 , op1 ; tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , GEN_INT ( <NUM_LIT> - elt ) ) ) ; tmp = gen_rtx_VEC_SELECT ( inner_mode , target , tmp ) ; if ( elt == <NUM_LIT> ) op0 = val , op1 = tmp ; else op0 = tmp , op1 = val ; tmp = gen_rtx_VEC_CONCAT ( mode , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , tmp ) ) ; } return ; case V4SFmode : switch ( elt ) { case <NUM_LIT> : use_vec_merge = true ; break ; case <NUM_LIT> : tmp = copy_to_reg ( target ) ; emit_insn ( gen_sse_unpcklps ( target , target , target ) ) ; ix86_expand_vector_set ( false , target , val , <NUM_LIT> ) ; emit_insn ( gen_sse_shufps_1 ( target , target , tmp , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) ) ) ; return ; case <NUM_LIT> : tmp = copy_to_reg ( target ) ; ix86_expand_vector_set ( false , tmp , val , <NUM_LIT> ) ; emit_insn ( gen_sse_shufps_1 ( target , target , tmp , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) ) ) ; return ; case <NUM_LIT> : tmp = copy_to_reg ( target ) ; ix86_expand_vector_set ( false , tmp , val , <NUM_LIT> ) ; emit_insn ( gen_sse_shufps_1 ( target , target , tmp , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) ) ) ; return ; default : gcc_unreachable ( ) ; } break ; case V4SImode : if ( elt == <NUM_LIT> ) { use_vec_merge = true ; break ; } if ( TARGET_SSE2 ) { rtx order [ <NUM_LIT> ] ; order [ <NUM_LIT> ] = GEN_INT ( elt ) ; order [ <NUM_LIT> ] = const1_rtx ; order [ <NUM_LIT> ] = const2_rtx ; order [ <NUM_LIT> ] = GEN_INT ( <NUM_LIT> ) ; order [ elt ] = const0_rtx ;

emit_insn ( gen_sse2_pshufd_1 ( target , target , order [ <NUM_LIT> ] , order [ <NUM_LIT> ] , order [ <NUM_LIT> ] , order [ <NUM_LIT> ] ) ) ;


<s> switch ( mode ) { case V2SFmode : case V2SImode : if ( mmx_ok ) { tmp = gen_reg_rtx ( GET_MODE_INNER ( mode ) ) ; ix86_expand_vector_extract ( true , tmp , target , <NUM_LIT> - elt ) ; if ( elt == <NUM_LIT> ) tmp = gen_rtx_VEC_CONCAT ( mode , tmp , val ) ; else tmp = gen_rtx_VEC_CONCAT ( mode , val , tmp ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , tmp ) ) ; return ; } break ; case V2DFmode : case V2DImode : { rtx op0 , op1 ; tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , GEN_INT ( <NUM_LIT> - elt ) ) ) ; tmp = gen_rtx_VEC_SELECT ( inner_mode , target , tmp ) ; if ( elt == <NUM_LIT> ) op0 = val , op1 = tmp ; else op0 = tmp , op1 = val ; tmp = gen_rtx_VEC_CONCAT ( mode , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , target , tmp ) ) ; } return ; case V4SFmode : switch ( elt ) { case <NUM_LIT> : use_vec_merge = true ; break ; case <NUM_LIT> : tmp = copy_to_reg ( target ) ; emit_insn ( gen_sse_unpcklps ( target , target , target ) ) ; ix86_expand_vector_set ( false , target , val , <NUM_LIT> ) ; emit_insn ( gen_sse_shufps_1 ( target , target , tmp , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) ) ) ; return ; case <NUM_LIT> : tmp = copy_to_reg ( target ) ; ix86_expand_vector_set ( false , tmp , val , <NUM_LIT> ) ; emit_insn ( gen_sse_shufps_1 ( target , target , tmp , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) ) ) ; return ; case <NUM_LIT> : tmp = copy_to_reg ( target ) ; ix86_expand_vector_set ( false , tmp , val , <NUM_LIT> ) ; emit_insn ( gen_sse_shufps_1 ( target , target , tmp , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) , GEN_INT ( <NUM_LIT> + <NUM_LIT> ) ) ) ; return ; default : gcc_unreachable ( ) ; } break ;


<s> tree arg0 , arg1 ; int elt ; rtx op0 ; arg0 = TREE_VALUE ( arglist ) ; arg1 = TREE_VALUE ( TREE_CHAIN ( arglist ) ) ; op0 = expand_expr ( arg0 , NULL_RTX , VOIDmode , <NUM_LIT> ) ; elt = get_element_number ( TREE_TYPE ( arg0 ) , arg1 ) ; tmode = TYPE_MODE ( TREE_TYPE ( TREE_TYPE ( arg0 ) ) ) ; mode0 = TYPE_MODE ( TREE_TYPE ( arg0 ) ) ; gcc_assert ( VECTOR_MODE_P ( mode0 ) ) ; op0 = force_reg ( mode0 , op0 ) ; if ( optimize || ! target || ! register_operand ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; ix86_expand_vector_extract ( true , target , op0 , elt ) ;


<s> RTVEC_ELT ( v , i ) = gen_lowpart ( inner_mode , x ) ; } gcc_assert ( arglist == NULL ) ; if ( ! target || ! register_operand ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ;

ix86_expand_vector_init ( true , target , gen_rtx_PARALLEL ( tmode , v ) ) ;


elt = get_element_number ( TREE_TYPE ( arg0 ) , arg2 ) ;


<s> int regno ; for ( regno = <NUM_LIT> ; regno < <NUM_LIT> ; ++ regno ) { char name [ <NUM_LIT> ] ; if ( ! ( ( pic_labels_used >> regno ) & <NUM_LIT> ) ) continue ; get_pc_thunk_name ( name , regno ) ; if ( USE_HIDDEN_LINKONCE ) { tree decl ; decl = build_decl ( FUNCTION_DECL , get_identifier ( name ) , error_mark_node ) ; TREE_PUBLIC ( decl ) = <NUM_LIT> ; TREE_STATIC ( decl ) = <NUM_LIT> ; DECL_ONE_ONLY ( decl ) = <NUM_LIT> ; ( * targetm . asm_out . unique_section ) ( decl , <NUM_LIT> ) ; 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 ) ; fputc ( '\n' , asm_out_file ) ;

ASM_DECLARE_FUNCTION_NAME ( asm_out_file , name , decl ) ;


<s> rtx xops [ <NUM_LIT> ] ; int regno ; for ( regno = <NUM_LIT> ; regno < <NUM_LIT> ; ++ regno ) { char name [ <NUM_LIT> ] ; if ( ! ( ( pic_labels_used >> regno ) & <NUM_LIT> ) ) continue ; get_pc_thunk_name ( name , regno ) ; if ( USE_HIDDEN_LINKONCE ) { tree decl ; decl = build_decl ( FUNCTION_DECL , get_identifier ( name ) , error_mark_node ) ; TREE_PUBLIC ( decl ) = <NUM_LIT> ; TREE_STATIC ( decl ) = <NUM_LIT> ; DECL_ONE_ONLY ( decl ) = <NUM_LIT> ; ( * targetm . asm_out . unique_section ) ( decl , <NUM_LIT> ) ; 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 ) ;


<s> if ( TARGET_64BIT ) { if ( GET_CODE ( x ) != CONST ) return x ; term = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( term ) == PLUS && ( GET_CODE ( XEXP ( term , <NUM_LIT> ) ) == CONST_INT || GET_CODE ( XEXP ( term , <NUM_LIT> ) ) == CONST_DOUBLE ) ) term = XEXP ( term , <NUM_LIT> ) ; if ( GET_CODE ( term ) != UNSPEC || XINT ( term , <NUM_LIT> ) != UNSPEC_GOTPCREL ) return x ; term = XVECEXP ( term , <NUM_LIT> , <NUM_LIT> ) ;

if ( GET_CODE ( term ) != SYMBOL_REF && GET_CODE ( term ) != LABEL_REF ) return x ;


<s> } if ( GET_CODE ( src1 ) == MEM && GET_CODE ( src2 ) == MEM ) { if ( matching_memory != <NUM_LIT> ) src2 = force_reg ( mode , src2 ) ; else src1 = force_reg ( mode , src1 ) ; }

if ( ( CONSTANT_P ( src1 ) || ( ! matching_memory && GET_CODE ( src1 ) == MEM ) ) && GET_RTX_CLASS ( code ) != RTX_COMM_ARITH ) src1 = force_reg ( mode , src1 ) ;


<s> else dst = gen_reg_rtx ( mode ) ; } if ( GET_CODE ( src1 ) == MEM && GET_CODE ( src2 ) == MEM ) { if ( matching_memory != <NUM_LIT> ) src2 = force_reg ( mode , src2 ) ; else src1 = force_reg ( mode , src1 ) ; } if ( ( CONSTANT_P ( src1 ) || ( ! matching_memory && GET_CODE ( src1 ) == MEM ) ) && GET_RTX_CLASS ( code ) != RTX_COMM_ARITH ) src1 = force_reg ( mode , src1 ) ;


<s> rtx dst = ix86_fixup_binary_operands ( code , mode , operands ) ;

gcc_assert ( dst == operands [ <NUM_LIT> ] ) ;


<s> set = SET_DEST ( XVECEXP ( PATTERN ( dep_insn ) , <NUM_LIT> , <NUM_LIT> ) ) ; set2 = SET_DEST ( XVECEXP ( PATTERN ( dep_insn ) , <NUM_LIT> , <NUM_LIT> ) ) ; } else return <NUM_LIT> ; if ( GET_CODE ( set ) != REG || REGNO ( set ) != FLAGS_REG ) return <NUM_LIT> ; if ( ! reg_overlap_mentioned_p ( set , PATTERN ( insn ) ) ) return <NUM_LIT> ;

if ( set2 && reg_overlap_mentioned_p ( set2 , PATTERN ( insn ) ) ) return <NUM_LIT> ;


<s> { rtx operands [ <NUM_LIT> ] ; split_di ( & operand , <NUM_LIT> , operands , operands + <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( SImode , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) , operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( SImode , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) , operands [ <NUM_LIT> ] ) ) ; } break ; case HImode : operand = gen_lowpart ( SImode , operand ) ;


<s> return GEU ; case ORDERED : case UNORDERED : return code ; break ; case UNEQ : return EQ ; break ; case UNLT :


<s> case GE : return GEU ; case ORDERED : case UNORDERED : return code ; break ; case UNEQ : return EQ ; break ; case UNLT : return LTU ; break ; case UNLE : return LEU ; break ; case LTGT :


<s> enum machine_mode ix86_fp_compare_mode ( enum rtx_code code ATTRIBUTE_UNUSED ) { return TARGET_IEEE_FP ? CCFPUmode : CCFPmode ;


<s> if ( ! TARGET_IEEE_FP ) return <NUM_LIT> ; switch ( code ) { case UNLE : case UNLT : case LTGT : case GT : case GE : case UNORDERED : case ORDERED : case UNEQ : return <NUM_LIT> ; break ; case LT :


<s> * second_code = UNKNOWN ; switch ( code ) { case GT : case GE : case ORDERED : case UNORDERED : case UNEQ : case UNLT : case UNLE : case LTGT : break ; case LT : * first_code = UNLT ; * bypass_code = UNORDERED ; break ; case LE : * first_code = UNLE ; * bypass_code = UNORDERED ; break ; case EQ :


<s> int min ; fcomi_cost = ix86_fp_comparison_fcomi_cost ( code ) ; sahf_cost = ix86_fp_comparison_sahf_cost ( code ) ;

min = arithmetics_cost = ix86_fp_comparison_arithmetics_cost ( code ) ;


<s> fcomi_cost = ix86_fp_comparison_fcomi_cost ( code ) ; sahf_cost = ix86_fp_comparison_sahf_cost ( code ) ; min = arithmetics_cost = ix86_fp_comparison_arithmetics_cost ( code ) ; if ( min > sahf_cost ) min = sahf_cost ; if ( min > fcomi_cost ) min = fcomi_cost ;


<s> if ( ! TARGET_CMOVE ) return <NUM_LIT> ; ix86_fp_comparison_codes ( code , & bypass_code , & first_code , & second_code ) ;

return ( bypass_code != UNKNOWN || second_code != UNKNOWN ) + <NUM_LIT> ;


<s> if ( ! TARGET_CMOVE ) return <NUM_LIT> ;

ix86_fp_comparison_codes ( code , & bypass_code , & first_code , & second_code ) ;


<s> if ( ! TARGET_USE_SAHF && ! optimize_size ) return <NUM_LIT> ;


<s> bool ix86_fp_jump_nontrivial_p ( enum rtx_code code ) { enum rtx_code bypass_code , first_code , second_code ; if ( ! TARGET_CMOVE ) return true ; ix86_fp_comparison_codes ( code , & bypass_code , & first_code , & second_code ) ;

return bypass_code != UNKNOWN || second_code != UNKNOWN ;


<s> if ( ! TARGET_CMOVE ) return true ; ix86_fp_comparison_codes ( code , & bypass_code , & first_code , & second_code ) ; return bypass_code != UNKNOWN || second_code != UNKNOWN ;


<s> int ix86_frame_pointer_required ( void ) {

if ( cfun -> machine -> accesses_prev_frame ) return <NUM_LIT> ;


<s> if ( ! TARGET_RED_ZONE ) { int size ; if ( mode == DImode || TARGET_64BIT ) size = <NUM_LIT> ; else size = <NUM_LIT> ;

emit_insn ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( size ) ) ) ) ;


<s> int size ; if ( mode == DImode || TARGET_64BIT ) size = <NUM_LIT> ;


<s> if ( TARGET_SSE && SSE_REGNO_P ( regno ) && ( regno < FIRST_SSE_REG + SSE_REGPARM_MAX ) ) return true ; if ( ! regno ) return true ;

for ( i = <NUM_LIT> ; i < REGPARM_MAX ; i ++ ) if ( regno == x86_64_int_parameter_registers [ i ] ) return true ;


<s> if ( ! regno ) return true ; for ( i = <NUM_LIT> ; i < REGPARM_MAX ; i ++ ) if ( regno == x86_64_int_parameter_registers [ i ] ) return true ; return false ;


<s> else if ( ! rtx_equal_p ( a , b ) ) return false ; if ( ! decl && ! TARGET_64BIT ) { tree type ; type = TREE_OPERAND ( exp , <NUM_LIT> ) ; type = TREE_TYPE ( type ) ; type = TREE_TYPE ( type ) ; if ( ix86_function_regparm ( type , NULL ) >= <NUM_LIT> ) { return false ; } }

if ( decl && DECL_DLLIMPORT_P ( decl ) && ix86_function_regparm ( TREE_TYPE ( decl ) , NULL ) >= <NUM_LIT> ) return false ;


<s> int local_regparm , globals = <NUM_LIT> , regno ; for ( local_regparm = <NUM_LIT> ; local_regparm < <NUM_LIT> ; local_regparm ++ ) if ( global_regs [ local_regparm ] ) break ; if ( local_regparm == <NUM_LIT> && decl_function_context ( decl ) && ! DECL_NO_STATIC_CHAIN ( decl ) ) local_regparm = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) if ( global_regs [ regno ] ) globals ++ ; local_regparm = globals < local_regparm ? local_regparm - globals : <NUM_LIT> ; if ( local_regparm > regparm ) regparm = local_regparm ; } } }


<s> if ( ! TARGET_64BIT && decl && TARGET_SSE_MATH && flag_unit_at_a_time && ! profile_flag ) { struct cgraph_local_info * i = cgraph_local_info ( decl ) ; if ( i && i -> local ) return TARGET_SSE2 ? <NUM_LIT> : <NUM_LIT> ; } return <NUM_LIT> ;


<s> if ( TARGET_64BIT ) { rtx ret = construct_container ( natmode , TYPE_MODE ( valtype ) , valtype , <NUM_LIT> , REGPARM_MAX , SSE_REGPARM_MAX , x86_64_int_return_registers , <NUM_LIT> ) ; if ( ! ret ) ret = gen_rtx_REG ( TYPE_MODE ( valtype ) , <NUM_LIT> ) ; return ret ;


<s> if ( regno == <NUM_LIT> || ( regno == FIRST_FLOAT_REG && TARGET_FLOAT_RETURNS_IN_80387 ) || ( regno == FIRST_SSE_REG && TARGET_SSE ) ) return true ; if ( ! TARGET_64BIT && ( regno == FIRST_MMX_REG && TARGET_MMX ) ) return true ;


<s> if ( ! TARGET_64BIT && ( regno == FIRST_MMX_REG && TARGET_MMX ) ) return true ; return false ;


<s> static HOST_WIDE_INT ix86_GOT_alias_set ( void ) { static HOST_WIDE_INT set = - <NUM_LIT> ;

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


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


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


<s> case OPT_m3dnow : if ( ! value ) { target_flags &= ~ MASK_3DNOW_A ; target_flags_explicit |= MASK_3DNOW_A ; } return true ; case OPT_mmmx : if ( ! value ) { target_flags &= ~ ( MASK_3DNOW | MASK_3DNOW_A ) ; target_flags_explicit |= MASK_3DNOW | MASK_3DNOW_A ; } return true ; case OPT_msse : if ( ! value ) {

target_flags &= ~ ( MASK_SSE2 | MASK_SSE3 ) ;


<s> * no_add_attrs = true ; } else if ( ( is_attribute_p ( <STR_LIT> , name ) && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * type ) ) ) || ( ( is_attribute_p ( <STR_LIT> , name ) && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * type ) ) ) ) ) {

warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ;


<s> static tree ix86_handle_struct_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { tree * type = NULL ; if ( DECL_P ( * node ) ) { if ( TREE_CODE ( * node ) == TYPE_DECL ) type = & TREE_TYPE ( * node ) ; } else type = node ; if ( ! ( type && ( TREE_CODE ( * type ) == RECORD_TYPE || TREE_CODE ( * type ) == UNION_TYPE ) ) ) { warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ; * no_add_attrs = true ; } else if ( ( is_attribute_p ( <STR_LIT> , name ) && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * type ) ) ) || ( ( is_attribute_p ( <STR_LIT> , name ) && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * type ) ) ) ) ) { warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ; * no_add_attrs = true ; } return NULL_TREE ;


<s> return ( 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 ( regno < <NUM_LIT> || TARGET_64BIT ) return <NUM_LIT> ; if ( ! TARGET_PARTIAL_REG_STALL ) return <NUM_LIT> ; return reload_in_progress || reload_completed ; } else if ( VALID_INT_MODE_P ( mode ) ) return <NUM_LIT> ; else if ( VALID_FP_MODE_P ( mode ) ) return <NUM_LIT> ; else if ( VALID_MMX_REG_MODE_3DNOW ( mode ) || VALID_MMX_REG_MODE ( mode ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> HOST_WIDE_INT ix86_initial_elimination_offset ( int from , int to ) { struct ix86_frame frame ; ix86_compute_frame_layout ( & 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> gcc_assert ( to == STACK_POINTER_REGNUM ) ; if ( from == ARG_POINTER_REGNUM ) return frame . stack_pointer_offset ; gcc_assert ( from == FRAME_POINTER_REGNUM ) ;

return frame . stack_pointer_offset - frame . frame_pointer_offset ;


<s> if ( TARGET_MMX ) ix86_init_mmx_sse_builtins ( ) ;


f = ggc_alloc_cleared ( sizeof ( struct machine_function ) ) ;


<s> cfun -> machine -> force_align_arg_pointer = gen_rtx_REG ( Pmode , <NUM_LIT> ) ;

return copy_to_reg ( cfun -> machine -> force_align_arg_pointer ) ;


<s> if ( FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN && DECL_NAME ( current_function_decl ) && MAIN_NAME_P ( DECL_NAME ( current_function_decl ) ) && DECL_FILE_SCOPE_P ( current_function_decl ) ) { cfun -> machine -> force_align_arg_pointer = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; return copy_to_reg ( cfun -> machine -> force_align_arg_pointer ) ; }


<s> static bool ix86_in_large_data_p ( tree exp ) { if ( ix86_cmodel != CM_MEDIUM && ix86_cmodel != CM_MEDIUM_PIC ) return false ; if ( TREE_CODE ( exp ) == FUNCTION_DECL ) return false ; if ( TREE_CODE ( exp ) == VAR_DECL && DECL_SECTION_NAME ( exp ) ) { const char * section = TREE_STRING_POINTER ( DECL_SECTION_NAME ( exp ) ) ; if ( strcmp ( section , <STR_LIT> ) == <NUM_LIT> || strcmp ( section , <STR_LIT> ) == <NUM_LIT> ) return true ; return false ;


<s> if ( TREE_CODE ( exp ) == FUNCTION_DECL ) return false ; if ( TREE_CODE ( exp ) == VAR_DECL && DECL_SECTION_NAME ( exp ) ) { const char * section = TREE_STRING_POINTER ( 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 ) ) ; if ( ! size || size > ix86_section_threshold ) return true ;


<s> case PROCESSOR_K6 : return <NUM_LIT> ; case PROCESSOR_PENTIUMPRO : case PROCESSOR_PENTIUM4 : case PROCESSOR_ATHLON : case PROCESSOR_K8 :


<s> case XCmode : return gen_rtx_REG ( mode , FIRST_FLOAT_REG ) ; case TCmode : return NULL ; default : return gen_rtx_REG ( mode , <NUM_LIT> ) ; } } else return gen_rtx_REG ( mode , ix86_value_regno ( mode , NULL , NULL ) ) ;


<s> if ( TARGET_64BIT ) { if ( AGGREGATE_TYPE_P ( type ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && ( TREE_INT_CST_LOW ( TYPE_SIZE ( type ) ) >= <NUM_LIT> || TREE_INT_CST_HIGH ( TYPE_SIZE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; } if ( TREE_CODE ( type ) == ARRAY_TYPE ) { if ( TYPE_MODE ( TREE_TYPE ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; } else if ( TREE_CODE ( type ) == COMPLEX_TYPE ) { if ( TYPE_MODE ( type ) == DCmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( TYPE_MODE ( type ) == XCmode && 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> ;


<s> int ix86_local_alignment ( tree type , int align ) { if ( TARGET_64BIT ) { if ( AGGREGATE_TYPE_P ( type ) && TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && ( TREE_INT_CST_LOW ( TYPE_SIZE ( type ) ) >= <NUM_LIT> || TREE_INT_CST_HIGH ( TYPE_SIZE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; } if ( TREE_CODE ( type ) == ARRAY_TYPE ) { if ( TYPE_MODE ( TREE_TYPE ( type ) ) == DFmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( ALIGN_MODE_128 ( TYPE_MODE ( TREE_TYPE ( type ) ) ) && align < <NUM_LIT> ) return <NUM_LIT> ; } else if ( TREE_CODE ( type ) == COMPLEX_TYPE ) { if ( TYPE_MODE ( type ) == DCmode && align < <NUM_LIT> ) return <NUM_LIT> ; if ( TYPE_MODE ( type ) == XCmode && 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> static const char * ix86_mangle_fundamental_type ( tree type ) { switch ( TYPE_MODE ( type ) ) { case TFmode : return <STR_LIT> ; case XFmode : return <STR_LIT> ; default :


<s> case CCNOmode : if ( req_mode != CCNOmode && ( req_mode != CCmode || XEXP ( SET_SRC ( set ) , <NUM_LIT> ) != const0_rtx ) ) return <NUM_LIT> ; break ; case CCmode : if ( req_mode == CCGCmode ) return <NUM_LIT> ; case CCGCmode : if ( req_mode == CCGOCmode || req_mode == CCNOmode ) return <NUM_LIT> ;


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


<s> static tree ix86_md_asm_clobbers ( tree outputs ATTRIBUTE_UNUSED , tree inputs ATTRIBUTE_UNUSED , tree clobbers ) {


<s> bool ix86_modes_tieable_p ( enum machine_mode mode1 , enum machine_mode mode2 ) { if ( mode1 == mode2 ) return true ; if ( ix86_tieable_integer_mode_p ( mode1 ) && ix86_tieable_integer_mode_p ( mode2 ) ) return true ; if ( mode2 == XFmode ) return mode1 == SFmode || mode1 == DFmode ; if ( mode2 == DFmode ) return mode1 == SFmode ; if ( GET_MODE_SIZE ( mode2 ) >= <NUM_LIT> && ix86_hard_regno_mode_ok ( FIRST_SSE_REG , mode2 ) ) return ix86_hard_regno_mode_ok ( FIRST_SSE_REG , mode1 ) ; if ( GET_MODE_SIZE ( mode2 ) == <NUM_LIT> && ix86_hard_regno_mode_ok ( FIRST_MMX_REG , mode2 ) ) return ix86_hard_regno_mode_ok ( FIRST_MMX_REG , mode1 ) ;


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


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


<s> static bool ix86_ms_bitfield_layout_p ( tree record_type ) { return ( TARGET_MS_BITFIELD_LAYOUT && ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( record_type ) ) ) || lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( record_type ) ) ;


<s> static bool ix86_ms_bitfield_layout_p ( tree record_type ) {


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


<s> for ( regno = FIRST_PSEUDO_REGISTER - <NUM_LIT> ; regno >= <NUM_LIT> ; regno -- ) if ( ix86_save_reg ( regno , true ) ) nregs ++ ;


<s> void ix86_output_addr_diff_elt ( FILE * file , int value , int rel ) { if ( TARGET_64BIT ) fprintf ( file , <STR_LIT> , ASM_LONG , LPREFIX , value , LPREFIX , rel ) ; else if ( HAVE_AS_GOTOFF_IN_DATA ) fprintf ( file , <STR_LIT> , ASM_LONG , LPREFIX , value ) ; else if ( TARGET_MACHO ) { fprintf ( file , <STR_LIT> , ASM_LONG , LPREFIX , value ) ; machopic_output_function_base_name ( file ) ; fprintf ( file , <STR_LIT> ) ; } else asm_fprintf ( file , <STR_LIT> , ASM_LONG , GOT_SYMBOL_NAME , LPREFIX , value ) ;


<s> void ix86_output_addr_diff_elt ( FILE * file , int value , int rel ) {

if ( TARGET_64BIT ) fprintf ( file , <STR_LIT> , ASM_LONG , LPREFIX , value , LPREFIX , rel ) ;


<s> const char * directive = ASM_LONG ; if ( TARGET_64BIT ) directive = ASM_QUAD ; gcc_assert ( ! TARGET_64BIT ) ; fprintf ( file , <STR_LIT> , directive , LPREFIX , value ) ;


<s> const char * directive = ASM_LONG ; if ( TARGET_64BIT ) directive = ASM_QUAD ;


<s> static void ix86_pad_returns ( void ) { edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , EXIT_BLOCK_PTR -> preds ) { basic_block bb = e -> src ; rtx ret = BB_END ( bb ) ; rtx prev ; bool replace = false ; if ( GET_CODE ( ret ) != JUMP_INSN || GET_CODE ( PATTERN ( ret ) ) != RETURN || ! maybe_hot_bb_p ( bb ) ) continue ; for ( prev = PREV_INSN ( ret ) ; prev ; prev = PREV_INSN ( prev ) ) if ( active_insn_p ( prev ) || GET_CODE ( prev ) == CODE_LABEL ) break ; if ( prev && GET_CODE ( prev ) == CODE_LABEL ) { edge e ; edge_iterator ei ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( EDGE_FREQUENCY ( e ) && e -> src -> index >= <NUM_LIT> && ! ( e -> flags & EDGE_FALLTHRU ) ) replace = true ; } if ( ! replace ) { prev = prev_active_insn ( ret ) ; if ( prev && ( ( GET_CODE ( prev ) == JUMP_INSN && any_condjump_p ( prev ) ) || GET_CODE ( prev ) == CALL_INSN ) ) replace = true ; if ( ! prev && cfun -> function_frequency > FUNCTION_FREQUENCY_UNLIKELY_EXECUTED ) replace = true ; } if ( replace ) {

emit_insn_before ( gen_return_internal_long ( ) , ret ) ;


<s> basic_block bb = e -> src ; rtx ret = BB_END ( bb ) ; rtx prev ; bool replace = false ; if ( GET_CODE ( ret ) != JUMP_INSN || GET_CODE ( PATTERN ( ret ) ) != RETURN || ! maybe_hot_bb_p ( bb ) ) continue ; for ( prev = PREV_INSN ( ret ) ; prev ; prev = PREV_INSN ( prev ) ) if ( active_insn_p ( prev ) || GET_CODE ( prev ) == CODE_LABEL ) break ;

if ( prev && GET_CODE ( prev ) == CODE_LABEL ) {


<s> if ( MAYBE_MMX_CLASS_P ( class ) && CONSTANT_P ( x ) ) return NO_REGS ; if ( MAYBE_SSE_CLASS_P ( class ) && CONSTANT_P ( x ) ) return NO_REGS ; if ( GET_CODE ( x ) == PLUS ) return reg_class_subset_p ( class , GENERAL_REGS ) ? class : NO_REGS ; if ( GET_MODE ( x ) == QImode && ! CONSTANT_P ( x ) ) { if ( reg_class_subset_p ( class , Q_REGS ) ) return class ;

if ( reg_class_subset_p ( Q_REGS , class ) ) return Q_REGS ;


<s> if ( reg_class_subset_p ( class , GENERAL_REGS ) ) return class ; if ( TARGET_80387 && ( TARGET_MIX_SSE_I387 || ! ( TARGET_SSE_MATH && SSE_FLOAT_MODE_P ( GET_MODE ( x ) ) ) ) && standard_80387_constant_p ( x ) ) { if ( class == FLOAT_SSE_REGS ) return FLOAT_REGS ; if ( class == FP_TOP_SSE_REGS ) return FP_TOP_REG ; if ( class == FP_SECOND_SSE_REGS ) return FP_SECOND_REG ; if ( class == FLOAT_INT_REGS || class == FLOAT_REGS ) return class ; } return NO_REGS ; } if ( MAYBE_MMX_CLASS_P ( class ) && CONSTANT_P ( x ) ) return NO_REGS ; if ( MAYBE_SSE_CLASS_P ( class ) && CONSTANT_P ( x ) ) return NO_REGS ; if ( GET_CODE ( x ) == PLUS ) return reg_class_subset_p ( class , GENERAL_REGS ) ? class : NO_REGS ; if ( GET_MODE ( x ) == QImode && ! CONSTANT_P ( x ) ) { if ( reg_class_subset_p ( class , Q_REGS ) ) return class ; if ( reg_class_subset_p ( Q_REGS , class ) ) return Q_REGS ; return NO_REGS ; } return class ;


<s> op1 = force_reg ( op_mode , op1 ) ; } else { if ( standard_80387_constant_p ( op0 ) == <NUM_LIT> || ( GET_CODE ( op0 ) == MEM && ! ( standard_80387_constant_p ( op1 ) == <NUM_LIT> || GET_CODE ( op1 ) == MEM ) ) ) { rtx tmp ; tmp = op0 , op0 = op1 , op1 = tmp ; code = swap_condition ( code ) ; } if ( GET_CODE ( op0 ) != REG ) op0 = force_reg ( op_mode , op0 ) ; if ( CONSTANT_P ( op1 ) ) { int tmp = standard_80387_constant_p ( op1 ) ; if ( tmp == <NUM_LIT> ) op1 = validize_mem ( force_const_mem ( op_mode , op1 ) ) ; else if ( tmp == <NUM_LIT> ) { if ( TARGET_CMOVE ) op1 = force_reg ( op_mode , op1 ) ;


<s> enum machine_mode fpcmp_mode = ix86_fp_compare_mode ( code ) ; rtx op0 = * pop0 , op1 = * pop1 ; enum machine_mode op_mode = GET_MODE ( op0 ) ; int is_sse = TARGET_SSE_MATH && SSE_FLOAT_MODE_P ( op_mode ) ; if ( ! is_sse && ( fpcmp_mode == CCFPUmode || ( op_mode == XFmode && ! ( standard_80387_constant_p ( op0 ) == <NUM_LIT> || standard_80387_constant_p ( op1 ) == <NUM_LIT> ) && GET_CODE ( op1 ) != FLOAT ) || ix86_use_fcomi_compare ( code ) ) ) { op0 = force_reg ( op_mode , op0 ) ; op1 = force_reg ( op_mode , op1 ) ; } else { if ( standard_80387_constant_p ( op0 ) == <NUM_LIT> || ( GET_CODE ( op0 ) == MEM && ! ( standard_80387_constant_p ( op1 ) == <NUM_LIT> || GET_CODE ( op1 ) == MEM ) ) ) { rtx tmp ; tmp = op0 , op0 = op1 , op1 = tmp ; code = swap_condition ( code ) ; } if ( GET_CODE ( op0 ) != REG ) op0 = force_reg ( op_mode , op0 ) ; if ( CONSTANT_P ( op1 ) ) { int tmp = standard_80387_constant_p ( op1 ) ; if ( tmp == <NUM_LIT> ) op1 = validize_mem ( force_const_mem ( op_mode , op1 ) ) ; else if ( tmp == <NUM_LIT> ) { if ( TARGET_CMOVE ) op1 = force_reg ( op_mode , op1 ) ; } else op1 = force_reg ( op_mode , op1 ) ; } } if ( ix86_fp_comparison_cost ( code ) > ix86_fp_comparison_cost ( swap_condition ( code ) ) && ( GET_CODE ( op1 ) == REG || ! no_new_pseudos ) ) { rtx tmp ; tmp = op0 , op0 = op1 , op1 = tmp ; code = swap_condition ( code ) ; if ( GET_CODE ( op0 ) != REG ) op0 = force_reg ( op_mode , op0 ) ; } * pop0 = op0 ;


<s> static enum rtx_code ix86_prepare_sse_fp_compare_args ( rtx dest , enum rtx_code code , rtx * pop0 , rtx * pop1 ) { rtx tmp ; switch ( code ) { case LTGT : case UNEQ : return UNKNOWN ; case LT : case LE : case UNGT : case UNGE : break ; case EQ : case NE : case UNORDERED :


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


<s> if ( TARGET_FOUR_JUMP_LIMIT && optimize && ! optimize_size ) ix86_avoid_jump_misspredicts ( ) ;


<s> size = int_size_in_bytes ( type ) ; if ( MS_AGGREGATE_RETURN && AGGREGATE_TYPE_P ( type ) && size <= <NUM_LIT> ) return <NUM_LIT> ; if ( VECTOR_MODE_P ( mode ) || mode == TImode ) { if ( size < <NUM_LIT> ) return <NUM_LIT> ; if ( size == <NUM_LIT> ) return ( TARGET_MMX ? <NUM_LIT> : <NUM_LIT> ) ; if ( size == <NUM_LIT> ) return ( TARGET_SSE ? <NUM_LIT> : <NUM_LIT> ) ; } if ( mode == XFmode ) return <NUM_LIT> ; if ( size > <NUM_LIT> ) return <NUM_LIT> ;


<s> if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( funtype ) ) || lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( funtype ) ) ) rtd = <NUM_LIT> ; if ( rtd && ( TYPE_ARG_TYPES ( funtype ) == NULL_TREE || ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( funtype ) ) ) == void_type_node ) ) ) return size ; } if ( aggregate_value_p ( TREE_TYPE ( funtype ) , fundecl ) && ! TARGET_64BIT && ! KEEP_AGGREGATE_RETURN_POINTER ) { int nregs = ix86_function_regparm ( funtype , fundecl ) ;

if ( ! nregs ) return GET_MODE_SIZE ( Pmode ) ;


<s> enum rtx_code ix86_reverse_condition ( enum rtx_code code , enum machine_mode mode ) { return ( mode != CCFPmode && mode != CCFPUmode ? reverse_condition ( code ) : reverse_condition_maybe_unordered ( code ) ) ;


<s> return ( mode != CCFPmode && mode != CCFPUmode ? reverse_condition ( code ) : reverse_condition_maybe_unordered ( code ) ) ;


<s> if ( pic_offset_table_rtx && regno == REAL_PIC_OFFSET_TABLE_REGNUM && ( regs_ever_live [ REAL_PIC_OFFSET_TABLE_REGNUM ] || current_function_profile || current_function_calls_eh_return || current_function_uses_const_pool ) ) { if ( ix86_select_alt_pic_regnum ( ) != INVALID_REGNUM ) return <NUM_LIT> ; return <NUM_LIT> ; } if ( current_function_calls_eh_return && maybe_eh_return ) { unsigned i ; for ( i = <NUM_LIT> ; ; i ++ ) { unsigned test = EH_RETURN_DATA_REGNO ( i ) ;


<s> return true ; } if ( FLOAT_CLASS_P ( class1 ) != FLOAT_CLASS_P ( class2 ) ) return true ; if ( MMX_CLASS_P ( class1 ) != MMX_CLASS_P ( class2 ) ) return true ; if ( SSE_CLASS_P ( class1 ) != SSE_CLASS_P ( class2 ) ) { if ( ! TARGET_SSE2 ) return true ; if ( ! TARGET_INTER_UNIT_MOVES && ! optimize_size ) return true ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return true ;

if ( mode == SFmode || mode == DFmode ) return true ;


<s> gcc_assert ( ! strict ) ; return true ; } if ( FLOAT_CLASS_P ( class1 ) != FLOAT_CLASS_P ( class2 ) ) return true ; if ( MMX_CLASS_P ( class1 ) != MMX_CLASS_P ( class2 ) ) return true ; if ( SSE_CLASS_P ( class1 ) != SSE_CLASS_P ( class2 ) ) { if ( ! TARGET_SSE2 ) return true ; if ( ! TARGET_INTER_UNIT_MOVES && ! optimize_size ) return true ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return true ; if ( mode == SFmode || mode == DFmode ) return true ; } return false ;


<s> int i ; for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) if ( ! regs_ever_live [ i ] ) return i ; }


<s> rtx nsse_reg ; int set ; tree fntype ; int stdarg_p ; int i ; if ( ! TARGET_64BIT ) return ; if ( ! cfun -> va_list_gpr_size && ! cfun -> va_list_fpr_size ) return ; ix86_save_varrargs_registers = <NUM_LIT> ; cfun -> stack_alignment_needed = <NUM_LIT> ; fntype = TREE_TYPE ( current_function_decl ) ; stdarg_p = ( TYPE_ARG_TYPES ( fntype ) != <NUM_LIT> && ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( fntype ) ) ) != void_type_node ) ) ; next_cum = * cum ; if ( stdarg_p ) function_arg_advance ( & next_cum , mode , type , <NUM_LIT> ) ; if ( ! no_rtl ) save_area = frame_pointer_rtx ; set = get_varargs_alias_set ( ) ; for ( i = next_cum . regno ; i < ix86_regparm && i < next_cum . regno + cfun -> va_list_gpr_size / UNITS_PER_WORD ; i ++ ) { mem = gen_rtx_MEM ( Pmode , plus_constant ( save_area , i * UNITS_PER_WORD ) ) ; MEM_NOTRAP_P ( mem ) = <NUM_LIT> ; set_mem_alias_set ( mem , set ) ; emit_move_insn ( mem , gen_rtx_REG ( Pmode , x86_64_int_parameter_registers [ i ] ) ) ; } if ( next_cum . sse_nregs && cfun -> va_list_fpr_size ) { label = gen_label_rtx ( ) ; label_ref = gen_rtx_LABEL_REF ( Pmode , label ) ; tmp_reg = gen_reg_rtx ( Pmode ) ; nsse_reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_zero_extendqidi2 ( nsse_reg , gen_rtx_REG ( QImode , <NUM_LIT> ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmp_reg , gen_rtx_MULT ( Pmode , nsse_reg , GEN_INT ( <NUM_LIT> ) ) ) ) ; if ( next_cum . sse_regno ) emit_move_insn ( nsse_reg , gen_rtx_CONST ( DImode , gen_rtx_PLUS ( DImode , label_ref , GEN_INT ( next_cum . sse_regno * <NUM_LIT> ) ) ) ) ;


<s> if ( count > single_width ) emit_insn ( ( mode == DImode ? gen_ashrsi3 : gen_ashrdi3 ) ( low [ <NUM_LIT> ] , low [ <NUM_LIT> ] , GEN_INT ( count - single_width ) ) ) ; } else { if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( ( mode == DImode ? gen_x86_shrd_1 : gen_x86_64_shrd ) ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; emit_insn ( ( mode == DImode ? gen_ashrsi3 : gen_ashrdi3 ) ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; } } else { if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; ( mode == DImode ? split_di : split_ti ) ( operands , <NUM_LIT> , low , high ) ; emit_insn ( ( mode == DImode ? gen_x86_shrd_1 : gen_x86_64_shrd ) ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; emit_insn ( ( mode == DImode ? gen_ashrsi3 : gen_ashrdi3 ) ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; if ( TARGET_CMOVE && scratch ) { emit_move_insn ( scratch , high [ <NUM_LIT> ] ) ; emit_insn ( ( mode == DImode ? gen_ashrsi3 : gen_ashrdi3 ) ( scratch , scratch , GEN_INT ( single_width - <NUM_LIT> ) ) ) ; emit_insn ( ( mode == DImode ? gen_x86_shift_adj_1 : gen_x86_64_shift_adj ) ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , scratch ) ) ; } else emit_insn ( gen_x86_shift_adj_3 ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ;


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

x = gen_rtx_IOR ( vmode , dest , op0 ) ;


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


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

op1 = simplify_gen_subreg ( vmode , op1 , mode , <NUM_LIT> ) ;


<s> if ( split_branch_probability >= <NUM_LIT> ) { probability = split_branch_probability ; if ( bypass ) bypass_probability = <NUM_LIT> ; if ( second ) second_probability = <NUM_LIT> ; } if ( bypass != NULL_RTX ) { label = gen_label_rtx ( ) ; i = emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , bypass , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ) ) ; if ( bypass_probability >= <NUM_LIT> ) REG_NOTES ( i ) = gen_rtx_EXPR_LIST ( REG_BR_PROB , GEN_INT ( bypass_probability ) , REG_NOTES ( i ) ) ; } i = emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , condition , target1 , target2 ) ) ) ; if ( probability >= <NUM_LIT> ) REG_NOTES ( i ) = gen_rtx_EXPR_LIST ( REG_BR_PROB , GEN_INT ( probability ) , REG_NOTES ( i ) ) ; if ( second != NULL_RTX ) { i = emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , second , target1 , target2 ) ) ) ;

if ( second_probability >= <NUM_LIT> ) REG_NOTES ( i ) = gen_rtx_EXPR_LIST ( REG_BR_PROB , GEN_INT ( second_probability ) , REG_NOTES ( i ) ) ;


<s> void ix86_split_fp_branch ( enum rtx_code code , rtx op1 , rtx op2 , rtx target1 , rtx target2 , rtx tmp , rtx pushed ) { rtx second , bypass ; rtx label = NULL_RTX ; rtx condition ; int bypass_probability = - <NUM_LIT> , second_probability = - <NUM_LIT> , probability = - <NUM_LIT> ; rtx i ; if ( target2 != pc_rtx ) { rtx tmp = target2 ; code = reverse_condition_maybe_unordered ( code ) ; target2 = target1 ; target1 = tmp ; } condition = ix86_expand_fp_compare ( code , op1 , op2 , tmp , & second , & bypass ) ; if ( pushed ) ix86_free_from_memory ( GET_MODE ( pushed ) ) ; if ( split_branch_probability >= <NUM_LIT> ) { probability = split_branch_probability ; if ( bypass ) bypass_probability = <NUM_LIT> ; if ( second ) second_probability = <NUM_LIT> ; } if ( bypass != NULL_RTX ) { label = gen_label_rtx ( ) ; i = emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , bypass , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ) ) ;

if ( bypass_probability >= <NUM_LIT> ) REG_NOTES ( i ) = gen_rtx_EXPR_LIST ( REG_BR_PROB , GEN_INT ( bypass_probability ) , REG_NOTES ( i ) ) ;


<s> const int single_width = mode == DImode ? <NUM_LIT> : <NUM_LIT> ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { ( mode == DImode ? split_di : split_ti ) ( operands , <NUM_LIT> , low , high ) ; count = INTVAL ( operands [ <NUM_LIT> ] ) & ( single_width * <NUM_LIT> - <NUM_LIT> ) ; if ( count >= single_width ) { emit_move_insn ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] ) ; ix86_expand_clear ( high [ <NUM_LIT> ] ) ; if ( count > single_width ) emit_insn ( ( mode == DImode ? gen_lshrsi3 : gen_lshrdi3 ) ( low [ <NUM_LIT> ] , low [ <NUM_LIT> ] , GEN_INT ( count - single_width ) ) ) ; } else { if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( ( mode == DImode ? gen_x86_shrd_1 : gen_x86_64_shrd ) ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; emit_insn ( ( mode == DImode ? gen_lshrsi3 : gen_lshrdi3 ) ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; } } else { if ( ! rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; ( mode == DImode ? split_di : split_ti ) ( operands , <NUM_LIT> , low , high ) ; emit_insn ( ( mode == DImode ? gen_x86_shrd_1 : gen_x86_64_shrd ) ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; emit_insn ( ( mode == DImode ? gen_lshrsi3 : gen_lshrdi3 ) ( high [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; if ( TARGET_CMOVE && scratch ) { ix86_expand_clear ( scratch ) ; emit_insn ( ( mode == DImode ? gen_x86_shift_adj_1 : gen_x86_64_shift_adj ) ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , scratch ) ) ; }

else emit_insn ( gen_x86_shift_adj_2 ( low [ <NUM_LIT> ] , high [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ;


<s> parts [ <NUM_LIT> ] = gen_rtx_REG ( upper_mode , REGNO ( operand ) + <NUM_LIT> ) ; } else if ( offsettable_memref_p ( operand ) ) { operand = adjust_address ( operand , DImode , <NUM_LIT> ) ; parts [ <NUM_LIT> ] = operand ; parts [ <NUM_LIT> ] = adjust_address ( operand , upper_mode , <NUM_LIT> ) ; } else if ( GET_CODE ( operand ) == CONST_DOUBLE ) { REAL_VALUE_TYPE r ; long l [ <NUM_LIT> ] ; REAL_VALUE_FROM_CONST_DOUBLE ( r , operand ) ; real_to_target ( l , & r , mode ) ; if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> ) parts [ <NUM_LIT> ] = gen_int_mode ( ( l [ <NUM_LIT> ] & ( ( ( HOST_WIDE_INT ) <NUM_LIT> << <NUM_LIT> ) - <NUM_LIT> ) ) + ( ( ( ( HOST_WIDE_INT ) l [ <NUM_LIT> ] ) << <NUM_LIT> ) << <NUM_LIT> ) , DImode ) ; else parts [ <NUM_LIT> ] = immed_double_const ( l [ <NUM_LIT> ] , l [ <NUM_LIT> ] , DImode ) ; if ( upper_mode == SImode ) parts [ <NUM_LIT> ] = gen_int_mode ( l [ <NUM_LIT> ] , SImode ) ; else if ( HOST_BITS_PER_WIDE_INT >= <NUM_LIT> ) parts [ <NUM_LIT> ] = gen_int_mode ( ( l [ <NUM_LIT> ] & ( ( ( HOST_WIDE_INT ) <NUM_LIT> << <NUM_LIT> ) - <NUM_LIT> ) ) + ( ( ( ( HOST_WIDE_INT ) l [ <NUM_LIT> ] ) << <NUM_LIT> ) << <NUM_LIT> ) , DImode ) ; else parts [ <NUM_LIT> ] = immed_double_const ( l [ <NUM_LIT> ] , l [ <NUM_LIT> ] , DImode ) ; }


<s> enum machine_mode mode = TYPE_MODE ( TREE_TYPE ( type ) ) ; if ( ! TARGET_SSE && ! warnedsse ) { if ( mode == TImode || ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) ) { warnedsse = true ; warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> ) ; } } if ( ! TARGET_MMX && ! warnedmmx ) {

if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) {


<s> } } if ( ! TARGET_MMX && ! warnedmmx ) { if ( VECTOR_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) { warnedmmx = true ; warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> ) ; } } }


<s> case HImode : case SImode : return true ; case QImode : return TARGET_64BIT || ! TARGET_PARTIAL_REG_STALL ; case DImode :


<s> ix86_tls_symbol = gen_rtx_SYMBOL_REF ( Pmode , ( TARGET_GNU_TLS && ! TARGET_64BIT ) ? <STR_LIT> : <STR_LIT> ) ; }


<s> if ( GET_MODE_CLASS ( mode ) != MODE_FLOAT || ! TARGET_FLOAT_RETURNS_IN_80387 ) return <NUM_LIT> ; if ( ( func || fntype ) && ( mode == SFmode || mode == DFmode ) ) {

int sse_level = ix86_function_sseregparm ( fntype , func ) ;


<s> if ( ( func || fntype ) && ( mode == SFmode || mode == DFmode ) ) { int sse_level = ix86_function_sseregparm ( fntype , func ) ; if ( ( sse_level >= <NUM_LIT> && mode == SFmode ) || ( sse_level == <NUM_LIT> && mode == DFmode ) ) return FIRST_SSE_REG ;


<s> HOST_WIDE_INT words , n_gpr , n_fpr ; tree f_gpr , f_fpr , f_ovf , f_sav ; tree gpr , fpr , ovf , sav , t ; if ( ! TARGET_64BIT ) { std_expand_builtin_va_start ( valist , nextarg ) ; return ; } f_gpr = TYPE_FIELDS ( TREE_TYPE ( va_list_type_node ) ) ; f_fpr = TREE_CHAIN ( f_gpr ) ; f_ovf = TREE_CHAIN ( f_fpr ) ; f_sav = TREE_CHAIN ( f_ovf ) ; valist = build1 ( INDIRECT_REF , TREE_TYPE ( TREE_TYPE ( valist ) ) , valist ) ; gpr = build ( COMPONENT_REF , TREE_TYPE ( f_gpr ) , valist , f_gpr , NULL_TREE ) ; fpr = build ( COMPONENT_REF , TREE_TYPE ( f_fpr ) , valist , f_fpr , NULL_TREE ) ; ovf = build ( COMPONENT_REF , TREE_TYPE ( f_ovf ) , valist , f_ovf , NULL_TREE ) ; sav = build ( COMPONENT_REF , TREE_TYPE ( f_sav ) , valist , f_sav , NULL_TREE ) ; words = current_function_args_info . words ; n_gpr = current_function_args_info . regno ; n_fpr = current_function_args_info . sse_regno ; if ( TARGET_DEBUG_ARG ) fprintf ( stderr , <STR_LIT> , ( int ) words , ( int ) n_gpr , ( int ) n_fpr ) ; if ( cfun -> va_list_gpr_size ) { t = build ( MODIFY_EXPR , TREE_TYPE ( gpr ) , gpr , build_int_cst ( NULL_TREE , n_gpr * <NUM_LIT> ) ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; }


<s> static bool ix86_vector_mode_supported_p ( enum machine_mode mode ) { if ( TARGET_SSE && VALID_SSE_REG_MODE ( mode ) ) return true ;

if ( TARGET_SSE2 && VALID_SSE2_REG_MODE ( mode ) ) return true ;


<s> r = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_zero_extendsidi2 ( r , exp ) ) ; return r ;


<s> reason = <STR_LIT> ; goto report_error ; } if ( GET_MODE ( base ) != Pmode ) { reason = <STR_LIT> ; goto report_error ; } if ( ( strict && ! REG_OK_FOR_BASE_STRICT_P ( reg ) ) || ( ! strict && ! REG_OK_FOR_BASE_NONSTRICT_P ( reg ) ) ) { reason = <STR_LIT> ; goto report_error ; } } if ( index ) { rtx reg ; reason_rtx = index ; if ( REG_P ( index ) ) reg = index ; else if ( GET_CODE ( index ) == SUBREG && REG_P ( SUBREG_REG ( index ) ) && GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( index ) ) ) <= UNITS_PER_WORD ) reg = SUBREG_REG ( index ) ; else { reason = <STR_LIT> ; goto report_error ; } if ( GET_MODE ( index ) != Pmode ) { reason = <STR_LIT> ; goto report_error ; } if ( ( strict && ! REG_OK_FOR_INDEX_STRICT_P ( reg ) ) || ( ! strict && ! REG_OK_FOR_INDEX_NONSTRICT_P ( reg ) ) ) { reason = <STR_LIT> ; goto report_error ; } } if ( scale != <NUM_LIT> ) { reason_rtx = GEN_INT ( scale ) ; if ( ! index ) { reason = <STR_LIT> ; goto report_error ; } if ( scale != <NUM_LIT> && scale != <NUM_LIT> && scale != <NUM_LIT> ) { reason = <STR_LIT> ; goto report_error ; } } if ( disp ) { reason_rtx = disp ; if ( GET_CODE ( disp ) == CONST && GET_CODE ( XEXP ( disp , <NUM_LIT> ) ) == UNSPEC ) switch ( XINT ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ) { case UNSPEC_GOT : case UNSPEC_GOTOFF : gcc_assert ( flag_pic ) ; if ( ! TARGET_64BIT ) goto is_legitimate_pic ; reason = <STR_LIT> ; goto report_error ; case UNSPEC_GOTPCREL : gcc_assert ( flag_pic ) ; goto is_legitimate_pic ; case UNSPEC_GOTTPOFF : case UNSPEC_GOTNTPOFF : case UNSPEC_INDNTPOFF : case UNSPEC_NTPOFF : case UNSPEC_DTPOFF : break ; default : reason = <STR_LIT> ; goto report_error ; } else if ( flag_pic && ( SYMBOLIC_CONST ( disp ) && ! machopic_operand_p ( disp ) ) ) { is_legitimate_pic : if ( TARGET_64BIT && ( index || base ) ) { if ( GET_CODE ( disp ) != CONST || GET_CODE ( XEXP ( disp , <NUM_LIT> ) ) != PLUS || GET_CODE ( XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ) != UNSPEC || GET_CODE ( XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ) != CONST_INT || ( XINT ( XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) != UNSPEC_DTPOFF && XINT ( XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) != UNSPEC_NTPOFF ) ) { reason = <STR_LIT> ; goto report_error ;


<s> if ( GET_CODE ( x ) == PLUS ) { if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT ) 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> ) ) {


<s> bool saw_plus ; if ( TARGET_64BIT ) { rtx op0 = disp , op1 ; switch ( GET_CODE ( disp ) ) { case LABEL_REF : return true ; case CONST : if ( GET_CODE ( XEXP ( disp , <NUM_LIT> ) ) != PLUS ) break ; op0 = XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ; op1 = XEXP ( XEXP ( disp , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( op1 ) != CONST_INT || INTVAL ( op1 ) >= <NUM_LIT> * <NUM_LIT> * <NUM_LIT> || INTVAL ( op1 ) < - <NUM_LIT> * <NUM_LIT> * <NUM_LIT> ) break ; if ( GET_CODE ( op0 ) == LABEL_REF ) return true ; if ( GET_CODE ( op0 ) != SYMBOL_REF ) break ; case SYMBOL_REF : if ( SYMBOL_REF_TLS_MODEL ( op0 ) ) return false ; if ( ! SYMBOL_REF_FAR_ADDR_P ( op0 ) && SYMBOL_REF_LOCAL_P ( op0 ) ) return true ; break ; default : break ; } } if ( GET_CODE ( disp ) != CONST ) return <NUM_LIT> ; disp = XEXP ( disp , <NUM_LIT> ) ; if ( TARGET_64BIT ) { if ( GET_CODE ( disp ) != UNSPEC || ( XINT ( disp , <NUM_LIT> ) != UNSPEC_GOTPCREL && XINT ( disp , <NUM_LIT> ) != UNSPEC_GOTOFF ) ) return <NUM_LIT> ; if ( GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) != SYMBOL_REF && GET_CODE ( XVECEXP ( disp , <NUM_LIT> , <NUM_LIT> ) ) != LABEL_REF ) return <NUM_LIT> ; return <NUM_LIT> ; } saw_plus = false ; if ( GET_CODE ( disp ) == PLUS ) { if ( GET_CODE ( XEXP ( disp , <NUM_LIT> ) ) != CONST_INT ) return <NUM_LIT> ; disp = XEXP ( disp , <NUM_LIT> ) ; saw_plus = true ; } if ( TARGET_MACHO && darwin_local_data_pic ( disp ) ) return <NUM_LIT> ;

if ( GET_CODE ( disp ) != UNSPEC ) return <NUM_LIT> ;


<s> inner = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( inner ) == PLUS && GET_CODE ( XEXP ( inner , <NUM_LIT> ) ) == CONST_INT ) inner = XEXP ( inner , <NUM_LIT> ) ; if ( GET_CODE ( inner ) == UNSPEC ) switch ( XINT ( inner , <NUM_LIT> ) ) { case UNSPEC_GOTOFF : return TARGET_64BIT ; case UNSPEC_TPOFF : x = XVECEXP ( inner , <NUM_LIT> , <NUM_LIT> ) ; return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_LOCAL_EXEC ) ; default : return false ;


<s> new = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , new ) ; new = gen_const_mem ( Pmode , new ) ; set_mem_alias_set ( new , ix86_GOT_alias_set ( ) ) ; if ( reg == <NUM_LIT> ) reg = gen_reg_rtx ( Pmode ) ; emit_move_insn ( reg , new ) ; new = reg ; } } else { if ( GET_CODE ( addr ) == CONST_INT && ! x86_64_immediate_operand ( addr , VOIDmode ) ) { if ( reg ) { emit_move_insn ( reg , addr ) ; new = reg ; } else new = force_reg ( Pmode , addr ) ; } else if ( GET_CODE ( addr ) == CONST ) { addr = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == UNSPEC || ( GET_CODE ( addr ) == PLUS && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == UNSPEC ) ) return orig ; gcc_assert ( GET_CODE ( addr ) == PLUS ) ; } if ( GET_CODE ( addr ) == PLUS ) { rtx op0 = XEXP ( addr , <NUM_LIT> ) , op1 = XEXP ( addr , <NUM_LIT> ) ; if ( local_symbolic_operand ( op0 , Pmode ) && GET_CODE ( op1 ) == CONST_INT ) { if ( ! TARGET_64BIT ) { if ( reload_in_progress ) regs_ever_live [ PIC_OFFSET_TABLE_REGNUM ] = <NUM_LIT> ; new = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , op0 ) , UNSPEC_GOTOFF ) ; new = gen_rtx_PLUS ( Pmode , new , op1 ) ; new = gen_rtx_CONST ( Pmode , new ) ; new = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , new ) ; if ( reg != <NUM_LIT> ) { emit_move_insn ( reg , new ) ; new = reg ; } } else { if ( INTVAL ( op1 ) < - <NUM_LIT> * <NUM_LIT> * <NUM_LIT> || INTVAL ( op1 ) >= <NUM_LIT> * <NUM_LIT> * <NUM_LIT> ) { if ( ! x86_64_immediate_operand ( op1 , Pmode ) ) op1 = force_reg ( Pmode , op1 ) ; new = gen_rtx_PLUS ( Pmode , force_reg ( Pmode , op0 ) , op1 ) ; } } }


<s> else { pic = NULL ; type = UNSPEC_INDNTPOFF ; } off = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x ) , type ) ; off = gen_rtx_CONST ( Pmode , off ) ; if ( pic ) off = gen_rtx_PLUS ( Pmode , pic , off ) ; off = gen_const_mem ( Pmode , off ) ; set_mem_alias_set ( off , ix86_GOT_alias_set ( ) ) ; if ( TARGET_64BIT || TARGET_GNU_TLS ) { base = get_thread_pointer ( for_mov || ! TARGET_TLS_DIRECT_SEG_REFS ) ; off = force_reg ( Pmode , off ) ; return gen_rtx_PLUS ( Pmode , base , off ) ; } else { base = get_thread_pointer ( true ) ; dest = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_subsi3 ( dest , base , off ) ) ; } break ; case TLS_MODEL_LOCAL_EXEC : off = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x ) , ( TARGET_64BIT || TARGET_GNU_TLS ) ? UNSPEC_NTPOFF : UNSPEC_TPOFF ) ; off = gen_rtx_CONST ( Pmode , off ) ; if ( TARGET_64BIT || TARGET_GNU_TLS ) { base = get_thread_pointer ( for_mov || ! TARGET_TLS_DIRECT_SEG_REFS ) ; return gen_rtx_PLUS ( Pmode , base , off ) ; }


<s> length = strlen ( symb ) ; symbol_name = alloca ( length + <NUM_LIT> ) ; GEN_SYMBOL_NAME_FOR_SYMBOL ( symbol_name , symb , length ) ; sprintf ( lazy_ptr_name , <STR_LIT> , label ) ; if ( MACHOPIC_PURE ) machopic_picsymbol_stub_section ( ) ; else machopic_symbol_stub_section ( ) ; fprintf ( file , <STR_LIT> , stub ) ; fprintf ( file , <STR_LIT> , symbol_name ) ; if ( MACHOPIC_PURE ) { fprintf ( file , <STR_LIT> , label , label ) ; fprintf ( file , <STR_LIT> , lazy_ptr_name , label ) ; fprintf ( file , <STR_LIT> ) ; } else fprintf ( file , <STR_LIT> , lazy_ptr_name ) ; fprintf ( file , <STR_LIT> , binder_name ) ; if ( MACHOPIC_PURE ) { fprintf ( file , <STR_LIT> , lazy_ptr_name , label ) ; fprintf ( file , <STR_LIT> ) ; } else fprintf ( file , <STR_LIT> , lazy_ptr_name ) ; fprintf ( file , <STR_LIT> ) ; machopic_lazy_symbol_ptr_section ( ) ;


<s> if ( GET_CODE ( x ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) ) return get_pool_constant ( x ) ; return NULL_RTX ;


<s> gcc_assert ( ok ) ; if ( parts . base && GET_CODE ( parts . base ) == SUBREG ) parts . base = SUBREG_REG ( parts . base ) ; if ( parts . index && GET_CODE ( parts . index ) == SUBREG ) parts . index = SUBREG_REG ( parts . index ) ; base = parts . base ; index = parts . index ; disp = parts . disp ; len = <NUM_LIT> ; if ( base && ! index && ! disp ) { if ( addr == stack_pointer_rtx || addr == arg_pointer_rtx || addr == frame_pointer_rtx || addr == hard_frame_pointer_rtx ) len = <NUM_LIT> ; } else if ( disp && ! base && ! index ) len = <NUM_LIT> ; else { if ( disp ) {

if ( GET_CODE ( disp ) == CONST_INT && CONST_OK_FOR_LETTER_P ( INTVAL ( disp ) , 'K' ) && base ) len = <NUM_LIT> ;


<s> if ( TARGET_MACHO ) flag_errno_math = <NUM_LIT> ; if ( optimize >= <NUM_LIT> ) flag_omit_frame_pointer = <NUM_LIT> ;


<s> break ; case DIV : if ( GET_MODE_CLASS ( GET_MODE ( operands [ <NUM_LIT> ] ) ) == MODE_INT || GET_MODE_CLASS ( GET_MODE ( operands [ <NUM_LIT> ] ) ) == MODE_INT ) p = <STR_LIT> ; else p = <STR_LIT> ; ssep = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } if ( is_sse ) { strcpy ( buf , ssep ) ; if ( GET_MODE ( operands [ <NUM_LIT> ] ) == SFmode ) strcat ( buf , <STR_LIT> ) ; else strcat ( buf , <STR_LIT> ) ; return buf ; } strcpy ( buf , p ) ; switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { case MULT : case PLUS : if ( REG_P ( operands [ <NUM_LIT> ] ) && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) ) { rtx temp = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = temp ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) { p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; case MINUS : case DIV : if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) { p = <STR_LIT> ; break ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) { p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } if ( find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) { if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) p = <STR_LIT> ; else p = <STR_LIT> ; break ; } else if ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) { p = <STR_LIT> ; p = <STR_LIT> ; }


<s> const char * output_387_reg_move ( rtx insn , rtx * operands ) {

if ( REG_P ( operands [ <NUM_LIT> ] ) && find_regno_note ( insn , REG_DEAD , REGNO ( operands [ <NUM_LIT> ] ) ) ) {


<s> bool output_addr_const_extra ( FILE * file , rtx x ) { rtx op ; if ( GET_CODE ( x ) != UNSPEC ) return false ; op = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; switch ( XINT ( x , <NUM_LIT> ) ) { case UNSPEC_GOTTPOFF : output_addr_const ( file , op ) ; fputs ( <STR_LIT> , file ) ; break ; case UNSPEC_TPOFF : output_addr_const ( file , op ) ;


<s> else { if ( round_mode != I387_CW_ANY ) output_asm_insn ( <STR_LIT> , operands ) ; if ( stack_top_dies || dimode_p ) output_asm_insn ( <STR_LIT> , operands ) ; else output_asm_insn ( <STR_LIT> , operands ) ; if ( round_mode != I387_CW_ANY ) output_asm_insn ( <STR_LIT> , operands ) ;


<s> int dimode_p = GET_MODE ( operands [ <NUM_LIT> ] ) == DImode ; int round_mode = get_attr_i387_cw ( insn ) ; if ( ( dimode_p || fisttp ) && ! stack_top_dies ) output_asm_insn ( <STR_LIT> , operands ) ; gcc_assert ( STACK_TOP_P ( operands [ <NUM_LIT> ] ) ) ; gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) ;

if ( fisttp ) output_asm_insn ( <STR_LIT> , operands ) ;


<s> rtx cmp_op0 , cmp_op1 ; int is_sse = SSE_REG_P ( operands [ <NUM_LIT> ] ) || SSE_REG_P ( operands [ <NUM_LIT> ] ) ; if ( eflags_p ) { cmp_op0 = operands [ <NUM_LIT> ] ; cmp_op1 = operands [ <NUM_LIT> ] ; } else { cmp_op0 = operands [ <NUM_LIT> ] ; cmp_op1 = operands [ <NUM_LIT> ] ; } if ( is_sse ) { if ( GET_MODE ( operands [ <NUM_LIT> ] ) == SFmode ) if ( unordered_p ) return <STR_LIT> ; else return <STR_LIT> ; else if ( unordered_p ) return <STR_LIT> ; else return <STR_LIT> ; } gcc_assert ( STACK_TOP_P ( cmp_op0 ) ) ; stack_top_dies = find_regno_note ( insn , REG_DEAD , FIRST_STACK_REG ) != <NUM_LIT> ;

if ( cmp_op1 == CONST0_RTX ( GET_MODE ( cmp_op1 ) ) ) {