<s> static bool use_rsqrt_p ( machine_mode mode ) {

return ( ( mode == HFmode || ( TARGET_SSE && TARGET_SSE_MATH ) ) && flag_finite_math_only && ! flag_trapping_math && flag_unsafe_math_optimizations ) ;


<s> void warn_once_call_ms2sysv_xlogues ( const char * feature ) { static bool warned_once = false ; if ( ! warned_once ) { warning ( <NUM_LIT> , <STR_LIT> , feature ) ; warned_once = true ; }


<s> if ( decl == NULL_TREE && ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || strcmp ( name , <STR_LIT> ) == <NUM_LIT> ) ) flags |= SECTION_RELRO ; if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || startswith ( name , <STR_LIT> ) || startswith ( name , <STR_LIT> ) ) flags |= SECTION_BSS ;


<s> unsigned int flags = default_section_type_flags ( decl , name , reloc ) ; if ( ix86_in_large_data_p ( decl ) ) flags |= SECTION_LARGE ; if ( decl == NULL_TREE && ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || strcmp ( name , <STR_LIT> ) == <NUM_LIT> ) ) flags |= SECTION_RELRO ; if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || startswith ( name , <STR_LIT> ) || startswith ( name , <STR_LIT> ) ) flags |= SECTION_BSS ;


<s> case SECCAT_RODATA_MERGE_STR : case SECCAT_RODATA_MERGE_STR_INIT : case SECCAT_RODATA_MERGE_CONST : prefix = one_only ? <STR_LIT> : <STR_LIT> ; break ; case SECCAT_SRODATA : case SECCAT_SDATA : case SECCAT_SBSS : gcc_unreachable ( ) ; case SECCAT_TEXT : case SECCAT_TDATA : case SECCAT_TBSS : break ; } if ( prefix ) { const char * name , * linkonce ; char * string ; name = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ; name = targetm . strip_name_encoding ( name ) ; linkonce = one_only ? <STR_LIT> : <STR_LIT> ; string = ACONCAT ( ( linkonce , prefix , <STR_LIT> , name , NULL ) ) ; set_decl_section_name ( decl , string ) ; return ; } }

default_unique_section ( decl , reloc ) ;


<s> if ( vcall_offset ) return false ; if ( flag_pic && ! targetm . binds_local_p ( function ) ) return false ; return true ;


if ( ix86_function_regparm ( TREE_TYPE ( function ) , function ) < <NUM_LIT> ) return true ;


<s> void x86_elf_aligned_decl_common ( FILE * file , tree decl , const char * name , unsigned HOST_WIDE_INT size , unsigned align ) { if ( ( ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC ) && size > ( unsigned int ) ix86_section_threshold ) { switch_to_section ( get_named_section ( decl , <STR_LIT> , <NUM_LIT> ) ) ; fputs ( LARGECOMM_SECTION_ASM_OP , file ) ; } else fputs ( COMMON_ASM_OP , file ) ;


<s> expand_float ( out , in , <NUM_LIT> ) ; emit_jump_insn ( gen_jump ( donelab ) ) ; emit_barrier ( ) ; emit_label ( neglab ) ; i0 = expand_simple_binop ( inmode , LSHIFTRT , in , const1_rtx , NULL , <NUM_LIT> , OPTAB_DIRECT ) ; i1 = expand_simple_binop ( inmode , AND , in , const1_rtx , NULL , <NUM_LIT> , OPTAB_DIRECT ) ; i0 = expand_simple_binop ( inmode , IOR , i0 , i1 , i0 , <NUM_LIT> , OPTAB_DIRECT ) ; expand_float ( f0 , i0 , <NUM_LIT> ) ;

emit_insn ( gen_rtx_SET ( out , gen_rtx_PLUS ( mode , f0 , f0 ) ) ) ;


<s> rtx_code_label * neglab , * donelab ; rtx i0 , i1 , f0 , in , out ; machine_mode mode , inmode ; inmode = GET_MODE ( operands [ <NUM_LIT> ] ) ; gcc_assert ( inmode == SImode || inmode == DImode ) ; out = operands [ <NUM_LIT> ] ; in = force_reg ( inmode , operands [ <NUM_LIT> ] ) ; mode = GET_MODE ( out ) ; neglab = gen_label_rtx ( ) ; donelab = gen_label_rtx ( ) ; f0 = gen_reg_rtx ( mode ) ;

emit_cmp_and_jump_insns ( in , const0_rtx , LT , const0_rtx , inmode , <NUM_LIT> , neglab ) ;


for ( i = <NUM_LIT> ; i < recog_data . n_operands ; i ++ ) if ( GENERAL_REG_P ( recog_data . operand [ i ] ) && ! QI_REGNO_P ( REGNO ( recog_data . operand [ i ] ) ) ) return true ;


<s> if ( REG_P ( x ) && ( REX_INT_REGNO_P ( REGNO ( x ) ) || REX_SSE_REGNO_P ( REGNO ( x ) ) ) ) return true ;


<s> bool x86_extended_reg_mentioned_p ( rtx insn ) { subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , INSN_P ( insn ) ? PATTERN ( insn ) : insn , NONCONST ) {


<s> if ( ! warned && warn_psabi ) { const char * url = CHANGES_ROOT_URL <STR_LIT> ; warned = true ; inform ( input_location , <STR_LIT> <STR_LIT> , TYPE_MAIN_VARIANT ( type ) , url ) ; } }

else return MIN ( <NUM_LIT> , computed ) ;


<s> if ( TARGET_16BIT ) fputs ( <STR_LIT> , asm_out_file ) ; darwin_file_start ( ) ; if ( X86_FILE_START_VERSION_DIRECTIVE ) fputs ( <STR_LIT> , asm_out_file ) ; if ( X86_FILE_START_FLTUSED ) fputs ( <STR_LIT> , asm_out_file ) ; if ( ix86_asm_dialect == ASM_INTEL ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> darwin_file_start ( ) ; if ( X86_FILE_START_VERSION_DIRECTIVE ) fputs ( <STR_LIT> , asm_out_file ) ;

if ( X86_FILE_START_FLTUSED ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> fprintf ( file , <STR_LIT> PROFILE_COUNT_REGISTER <STR_LIT> , LPREFIX , labelno ) ; fprintf ( file , <STR_LIT> , mcount_name ) ; } else { fprintf ( file , <STR_LIT> PROFILE_COUNT_REGISTER <STR_LIT> , LPREFIX , labelno ) ; x86_print_call_or_nop ( file , mcount_name ) ; } if ( flag_record_mcount || lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( current_function_decl ) ) ) { const char * sname = <STR_LIT> ; if ( current_fentry_section ( & sname ) ) ; else if ( fentry_section ) sname = fentry_section ; fprintf ( file , <STR_LIT> , sname ) ; fprintf ( file , <STR_LIT> , TARGET_64BIT ? <STR_LIT> : <STR_LIT> ) ;


<s> break ; case E_SImode : case E_HImode : case E_QImode : break ; default : gcc_unreachable ( ) ; } if ( mode_signbit_p ( mode , * loc ) ) return false ; val = INTVAL ( * loc ) ;

if ( ( val < <NUM_LIT> && val != - <NUM_LIT> ) || val == <NUM_LIT> ) {


<s> mode = SImode ; break ; case E_SImode : case E_HImode : case E_QImode : break ; default : gcc_unreachable ( ) ; } if ( mode_signbit_p ( mode , * loc ) ) return false ; val = INTVAL ( * loc ) ; if ( ( val < <NUM_LIT> && val != - <NUM_LIT> ) || val == <NUM_LIT> ) { * loc = GEN_INT ( - val ) ; return true ;


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

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


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


<s> void x86_output_aligned_bss ( FILE * file , tree decl , const char * name , unsigned HOST_WIDE_INT size , unsigned align ) { if ( ( ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_MEDIUM_PIC ) && size > ( unsigned int ) ix86_section_threshold ) switch_to_section ( get_named_section ( decl , <STR_LIT> , <NUM_LIT> ) ) ; else switch_to_section ( bss_section ) ; ASM_OUTPUT_ALIGN ( file , floor_log2 ( align / BITS_PER_UNIT ) ) ; last_assemble_variable_decl = decl ; ASM_DECLARE_OBJECT_NAME ( file , name , decl ) ;


<s> ASM_OUTPUT_ALIGN ( file , floor_log2 ( align / BITS_PER_UNIT ) ) ; last_assemble_variable_decl = decl ; ASM_DECLARE_OBJECT_NAME ( file , name , decl ) ;


<s> rtx_insn * insn ; if ( TARGET_64BIT ) tmp_regno = R10_REG ; else { unsigned int ccvt = ix86_get_callcvt ( TREE_TYPE ( function ) ) ; if ( ( ccvt & IX86_CALLCVT_FASTCALL ) != <NUM_LIT> ) tmp_regno = AX_REG ; else if ( ( ccvt & IX86_CALLCVT_THISCALL ) != <NUM_LIT> ) tmp_regno = DX_REG ; else tmp_regno = CX_REG ; } emit_note ( NOTE_INSN_PROLOGUE_END ) ; if ( ( flag_cf_protection & CF_BRANCH ) ) emit_insn ( gen_nop_endbr ( ) ) ; if ( REG_P ( this_param ) ) this_reg = this_param ; else if ( vcall_offset ) { this_reg = gen_rtx_REG ( Pmode , AX_REG ) ; emit_move_insn ( this_reg , this_param ) ; } else this_reg = NULL_RTX ; if ( delta ) { rtx delta_rtx = GEN_INT ( delta ) ; rtx delta_dst = this_reg ? this_reg : this_param ; if ( TARGET_64BIT ) { if ( ! x86_64_general_operand ( delta_rtx , Pmode ) ) { tmp = gen_rtx_REG ( Pmode , tmp_regno ) ; emit_move_insn ( tmp , delta_rtx ) ; delta_rtx = tmp ; } } ix86_emit_binop ( PLUS , Pmode , delta_dst , delta_rtx ) ; } if ( vcall_offset ) { rtx vcall_addr , vcall_mem , this_mem ; tmp = gen_rtx_REG ( Pmode , tmp_regno ) ; this_mem = gen_rtx_MEM ( ptr_mode , this_reg ) ; if ( Pmode != ptr_mode ) this_mem = gen_rtx_ZERO_EXTEND ( Pmode , this_mem ) ; emit_move_insn ( tmp , this_mem ) ; vcall_addr = plus_constant ( Pmode , tmp , vcall_offset ) ; if ( TARGET_64BIT && ! ix86_legitimate_address_p ( ptr_mode , vcall_addr , true ) ) { rtx tmp2 = gen_rtx_REG ( Pmode , R11_REG ) ; emit_move_insn ( tmp2 , GEN_INT ( vcall_offset ) ) ;

vcall_addr = gen_rtx_PLUS ( Pmode , tmp , tmp2 ) ;


<s> if ( flag_nop_mcount || ! strcmp ( target , <STR_LIT> ) ) fprintf ( file , <STR_LIT> ASM_BYTE <STR_LIT> ) ; else fprintf ( file , <STR_LIT> , target ) ;


<s> } nregs = ix86_function_regparm ( type , function ) ; if ( nregs > <NUM_LIT> && ! stdarg_p ( type ) ) { int regno ; unsigned int ccvt = ix86_get_callcvt ( type ) ; if ( ( ccvt & IX86_CALLCVT_FASTCALL ) != <NUM_LIT> ) regno = aggr ? DX_REG : CX_REG ; else if ( ( ccvt & IX86_CALLCVT_THISCALL ) != <NUM_LIT> ) { regno = CX_REG ; if ( aggr ) return gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> ) ) ; } else { regno = AX_REG ; if ( aggr ) { regno = DX_REG ; if ( nregs == <NUM_LIT> ) return gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> ) ) ; }


<s> else parm_regs = x86_64_int_parameter_registers ; return gen_rtx_REG ( Pmode , parm_regs [ aggr ] ) ; } nregs = ix86_function_regparm ( type , function ) ; if ( nregs > <NUM_LIT> && ! stdarg_p ( type ) ) { int regno ; unsigned int ccvt = ix86_get_callcvt ( type ) ; if ( ( ccvt & IX86_CALLCVT_FASTCALL ) != <NUM_LIT> ) regno = aggr ? DX_REG : CX_REG ; else if ( ( ccvt & IX86_CALLCVT_THISCALL ) != <NUM_LIT> ) { regno = CX_REG ; if ( aggr ) return gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> ) ) ; } else { regno = AX_REG ;


<s> if ( ! need_zero_all_mm ) return false ; rtx zero_mmx = NULL_RTX ; machine_mode mode = V4HImode ; for ( unsigned int regno = FIRST_MMX_REG ; regno <= LAST_MMX_REG ; regno ++ ) if ( regno != ret_mmx_regno ) { rtx reg = gen_rtx_REG ( mode , regno ) ; if ( zero_mmx == NULL_RTX ) { zero_mmx = reg ; emit_insn ( gen_rtx_SET ( reg , CONST0_RTX ( mode ) ) ) ; } else emit_move_insn ( reg , zero_mmx ) ;


<s> for ( unsigned int i = <NUM_LIT> ; i < num_of_st ; i ++ ) emit_insn ( gen_rtx_SET ( st_reg , CONST0_RTX ( XFmode ) ) ) ; for ( unsigned int i = <NUM_LIT> ; i < num_of_st ; i ++ ) { rtx insn ; insn = emit_insn ( gen_rtx_SET ( st_reg , st_reg ) ) ; add_reg_note ( insn , REG_DEAD , st_reg ) ; }


<s> for ( unsigned int regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( ( LEGACY_SSE_REGNO_P ( regno ) || ( TARGET_64BIT && ( REX_SSE_REGNO_P ( regno ) || ( TARGET_AVX512F && EXT_REX_SSE_REGNO_P ( regno ) ) ) ) ) && ! TEST_HARD_REG_BIT ( need_zeroed_hardregs , regno ) ) return NULL ;


<s> else if ( MASK_REGNO_P ( regno ) ) return HImode ;

else if ( MMX_REGNO_P ( regno ) ) return V4HImode ;


<s> static machine_mode zero_call_used_regno_mode ( const unsigned int regno ) { if ( GENERAL_REGNO_P ( regno ) ) return SImode ; else if ( SSE_REGNO_P ( regno ) ) return V4SFmode ;

else if ( MASK_REGNO_P ( regno ) ) return HImode ;


<s> return GENERAL_REGNO_P ( regno ) || ( ! all_sse_zeroed && SSE_REGNO_P ( regno ) ) || MASK_REGNO_P ( regno ) || ( need_zero_mmx && MMX_REGNO_P ( regno ) ) ;


<s> static bool zero_call_used_regno_p ( const unsigned int regno , bool all_sse_zeroed , bool need_zero_mmx ) { return GENERAL_REGNO_P ( regno ) || ( ! all_sse_zeroed && SSE_REGNO_P ( regno ) ) || MASK_REGNO_P ( regno ) || ( need_zero_mmx && MMX_REGNO_P ( regno ) ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __rold ( unsigned int __X , int __C ) { return ( __X << __C ) | ( __X >> ( <NUM_LIT> - __C ) ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __rord ( unsigned int __X , int __C ) { return ( __X >> __C ) | ( __X << ( <NUM_LIT> - __C ) ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __rorq ( unsigned long long __X , int __C ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __writeeflags ( unsigned int X ) { __builtin_ia32_writeeflags_u32 ( X ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __bsfq ( long long __X ) {


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __bsrq ( long long __X ) { return __builtin_ia32_bsrdi ( __X ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __bswapq ( long long __X ) { return __builtin_bswap64 ( __X ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __crc32b ( unsigned int __C , unsigned char __V ) { return __builtin_ia32_crc32qi ( __C , __V ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __crc32d ( unsigned int __C , unsigned int __V ) { return __builtin_ia32_crc32si ( __C , __V ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __crc32q ( unsigned long long __C , unsigned long long __V ) {


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __crc32w ( unsigned int __C , unsigned short __V ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __pause ( void ) {


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __popcntd ( unsigned int __X ) {


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __popcntq ( unsigned long long __X ) { return __builtin_popcountll ( __X ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __rdpmc ( int __S ) {


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __rdpmc ( int __S ) { return __builtin_ia32_rdpmc ( __S ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __rdtscp ( unsigned int * __A ) { return __builtin_ia32_rdtscp ( __A ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __readeflags ( void ) {

return __builtin_ia32_readeflags_u32 ( ) ;


<s> return __builtin_ia32_rolqi ( __X , __C ) ;


<s> return __builtin_ia32_rolhi ( __X , __C ) ;


<s> return __builtin_ia32_rorqi ( __X , __C ) ;


<s> return __builtin_ia32_rorhi ( __X , __C ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdpid_u32 ( void ) { return __builtin_ia32_rdpid ( ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdrand16_step ( unsigned short * __P ) {

return __builtin_ia32_rdrand16_step ( __P ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdrand16_step ( unsigned short * __P ) { return __builtin_ia32_rdrand16_step ( __P ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdrand32_step ( unsigned int * __P ) {

return __builtin_ia32_rdrand32_step ( __P ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _readfsbase_u32 ( void ) {


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _readfsbase_u32 ( void ) { return __builtin_ia32_rdfsbase32 ( ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _readfsbase_u64 ( void ) { return __builtin_ia32_rdfsbase64 ( ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _readgsbase_u32 ( void ) { return __builtin_ia32_rdgsbase32 ( ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _writefsbase_u64 ( unsigned long long __B ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _writegsbase_u64 ( unsigned long long __B ) {


<s> obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; switch ( offload_abi ) { case OFFLOAD_ABI_LP64 : obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; break ; case OFFLOAD_ABI_ILP32 : obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; break ; default : gcc_unreachable ( ) ; } obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , host_descr_filename ) ; obstack_ptr_grow ( & argv_obstack , target_so_filename ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , out_obj_filename ) ; obstack_ptr_grow ( & argv_obstack , NULL ) ; char * * new_argv = XOBFINISH ( & argv_obstack , char * * ) ; fork_execute ( new_argv [ <NUM_LIT> ] , new_argv , false , NULL ) ; obstack_free ( & argv_obstack , NULL ) ; obstack_init ( & argv_obstack ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , symbols [ <NUM_LIT> ] ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , symbols [ <NUM_LIT> ] ) ;


<s> if ( ! out_obj_filename ) fatal_error ( input_location , <STR_LIT> ) ; if ( ! dumppfx ) dumppfx = out_obj_filename ; const char * target_so_filename = prepare_target_image ( target_compiler , argc , argv ) ; const char * host_descr_filename = generate_host_descr_file ( host_compiler ) ; struct obstack argv_obstack ; obstack_init ( & argv_obstack ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; switch ( offload_abi ) { case OFFLOAD_ABI_LP64 : obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; break ; case OFFLOAD_ABI_ILP32 : obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; break ; default : gcc_unreachable ( ) ; } obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , host_descr_filename ) ; obstack_ptr_grow ( & argv_obstack , target_so_filename ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , out_obj_filename ) ; obstack_ptr_grow ( & argv_obstack , NULL ) ; char * * new_argv = XOBFINISH ( & argv_obstack , char * * ) ; fork_execute ( new_argv [ <NUM_LIT> ] , new_argv , false , NULL ) ; obstack_free ( & argv_obstack , NULL ) ; obstack_init ( & argv_obstack ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ;


<s> unsetenv ( <STR_LIT> ) ; unsetenv ( <STR_LIT> ) ; unsetenv ( <STR_LIT> ) ; fork_execute ( argv [ <NUM_LIT> ] , argv , false ) ; obstack_free ( argv_obstack , NULL ) ; xputenv ( concat ( <STR_LIT> , epath , NULL ) ) ;

xputenv ( concat ( <STR_LIT> , cpath , NULL ) ) ;


fork_execute ( new_argv [ <NUM_LIT> ] , CONST_CAST ( char * * , new_argv ) , false ) ;


<s> if ( target_compiler == NULL ) fatal_error ( input_location , <STR_LIT> , target_driver_name ) ; expandargv ( & argc , & argv ) ; for ( int i = argc - <NUM_LIT> ; i > <NUM_LIT> ; i -- ) if ( strncmp ( argv [ i ] , <STR_LIT> , sizeof ( <STR_LIT> ) - <NUM_LIT> ) == <NUM_LIT> ) { if ( strstr ( argv [ i ] , <STR_LIT> ) ) target_ilp32 = true ; else if ( ! strstr ( argv [ i ] , <STR_LIT> ) ) fatal_error ( input_location , <STR_LIT> ) ; break ; } const char * target_so_filename = prepare_target_image ( target_compiler , argc , argv ) ; const char * host_descr_filename = generate_host_descr_file ( host_compiler ) ; unsigned new_argc = <NUM_LIT> ; const char * new_argv [ <NUM_LIT> ] ; new_argv [ new_argc ++ ] = <STR_LIT> ; new_argv [ new_argc ++ ] = <STR_LIT> ; if ( target_ilp32 ) new_argv [ new_argc ++ ] = <STR_LIT> ; else new_argv [ new_argc ++ ] = <STR_LIT> ; new_argv [ new_argc ++ ] = <STR_LIT> ; new_argv [ new_argc ++ ] = host_descr_filename ; new_argv [ new_argc ++ ] = target_so_filename ; new_argv [ new_argc ++ ] = <STR_LIT> ; new_argv [ new_argc ++ ] = out_obj_filename ; new_argv [ new_argc ++ ] = NULL ; fork_execute ( new_argv [ <NUM_LIT> ] , CONST_CAST ( char * * , new_argv ) , false ) ; new_argv [ <NUM_LIT> ] = <STR_LIT> ; new_argv [ <NUM_LIT> ] = <STR_LIT> ; new_argv [ <NUM_LIT> ] = symbols [ <NUM_LIT> ] ;


<s> if ( strstr ( argv [ i ] , <STR_LIT> ) ) target_ilp32 = true ; else if ( ! strstr ( argv [ i ] , <STR_LIT> ) ) fatal_error ( input_location , <STR_LIT> ) ; break ; } const char * target_so_filename = prepare_target_image ( target_compiler , argc , argv ) ; const char * host_descr_filename = generate_host_descr_file ( host_compiler ) ; unsigned new_argc = <NUM_LIT> ; const char * new_argv [ <NUM_LIT> ] ; new_argv [ new_argc ++ ] = <STR_LIT> ; new_argv [ new_argc ++ ] = <STR_LIT> ; if ( target_ilp32 ) new_argv [ new_argc ++ ] = <STR_LIT> ; else new_argv [ new_argc ++ ] = <STR_LIT> ; new_argv [ new_argc ++ ] = <STR_LIT> ; new_argv [ new_argc ++ ] = host_descr_filename ; new_argv [ new_argc ++ ] = target_so_filename ; new_argv [ new_argc ++ ] = <STR_LIT> ; new_argv [ new_argc ++ ] = out_obj_filename ; new_argv [ new_argc ++ ] = NULL ; fork_execute ( new_argv [ <NUM_LIT> ] , CONST_CAST ( char * * , new_argv ) , false ) ; new_argv [ <NUM_LIT> ] = <STR_LIT> ; new_argv [ <NUM_LIT> ] = <STR_LIT> ; new_argv [ <NUM_LIT> ] = symbols [ <NUM_LIT> ] ; new_argv [ <NUM_LIT> ] = <STR_LIT> ;


<s> if ( debug ) notice ( <STR_LIT> , file ) ; else unlink_if_ordinary ( file ) ;


<s> char * opt2 = XALLOCAVEC ( char , sizeof ( <STR_LIT> ) + strlen ( target_offloadend_filename ) ) ; sprintf ( opt1 , <STR_LIT> , target_descr_filename ) ; sprintf ( opt2 , <STR_LIT> , target_offloadend_filename ) ; const char * target_so_filename = make_temp_file ( <STR_LIT> ) ; temp_files [ num_temps ++ ] = target_so_filename ; struct obstack argv_obstack ; obstack_init ( & argv_obstack ) ; obstack_ptr_grow ( & argv_obstack , target_compiler ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , opt1 ) ; for ( int i = <NUM_LIT> ; i < argc ; i ++ ) { if ( ! strcmp ( argv [ i ] , <STR_LIT> ) && i + <NUM_LIT> != argc ) out_obj_filename = argv [ ++ i ] ; else obstack_ptr_grow ( & argv_obstack , argv [ i ] ) ; } if ( ! out_obj_filename ) fatal_error ( input_location , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , opt2 ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , target_so_filename ) ; compile_for_target ( & argv_obstack ) ; char * rename_section_opt = XALLOCAVEC ( char , sizeof ( <STR_LIT> ) + strlen ( image_section_name ) ) ; sprintf ( rename_section_opt , <STR_LIT> , image_section_name ) ; const char * objcopy_argv [ <NUM_LIT> ] ; objcopy_argv [ <NUM_LIT> ] = <STR_LIT> ; objcopy_argv [ <NUM_LIT> ] = <STR_LIT> ; objcopy_argv [ <NUM_LIT> ] = <STR_LIT> ; objcopy_argv [ <NUM_LIT> ] = <STR_LIT> ; objcopy_argv [ <NUM_LIT> ] = <STR_LIT> ; objcopy_argv [ <NUM_LIT> ] = <STR_LIT> ; if ( target_ilp32 ) objcopy_argv [ <NUM_LIT> ] = <STR_LIT> ; else objcopy_argv [ <NUM_LIT> ] = <STR_LIT> ; objcopy_argv [ <NUM_LIT> ] = target_so_filename ; objcopy_argv [ <NUM_LIT> ] = <STR_LIT> ; objcopy_argv [ <NUM_LIT> ] = rename_section_opt ; objcopy_argv [ <NUM_LIT> ] = NULL ;

fork_execute ( objcopy_argv [ <NUM_LIT> ] , CONST_CAST ( char * * , objcopy_argv ) , false ) ;


<s> obstack_free ( & argv_obstack , NULL ) ; size_t symbol_name_len = strlen ( target_so_filename ) ; char * symbol_name = XALLOCAVEC ( char , symbol_name_len + <NUM_LIT> ) ; for ( size_t i = <NUM_LIT> ; i < symbol_name_len ; i ++ ) { char c = target_so_filename [ i ] ; if ( ! ISALNUM ( c ) ) c = '_' ; symbol_name [ i ] = c ; } symbol_name [ symbol_name_len ] = '\0' ; char * opt_for_objcopy [ <NUM_LIT> ] ; opt_for_objcopy [ <NUM_LIT> ] = XALLOCAVEC ( char , sizeof ( <STR_LIT> ) + symbol_name_len + strlen ( symbols [ <NUM_LIT> ] ) ) ; opt_for_objcopy [ <NUM_LIT> ] = XALLOCAVEC ( char , sizeof ( <STR_LIT> ) + symbol_name_len + strlen ( symbols [ <NUM_LIT> ] ) ) ; opt_for_objcopy [ <NUM_LIT> ] = XALLOCAVEC ( char , sizeof ( <STR_LIT> ) + symbol_name_len + strlen ( symbols [ <NUM_LIT> ] ) ) ; sprintf ( opt_for_objcopy [ <NUM_LIT> ] , <STR_LIT> , symbol_name , symbols [ <NUM_LIT> ] ) ; sprintf ( opt_for_objcopy [ <NUM_LIT> ] , <STR_LIT> , symbol_name , symbols [ <NUM_LIT> ] ) ; sprintf ( opt_for_objcopy [ <NUM_LIT> ] , <STR_LIT> , symbol_name , symbols [ <NUM_LIT> ] ) ; obstack_init ( & argv_obstack ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , target_so_filename ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , opt_for_objcopy [ <NUM_LIT> ] ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , opt_for_objcopy [ <NUM_LIT> ] ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , opt_for_objcopy [ <NUM_LIT> ] ) ; obstack_ptr_grow ( & argv_obstack , NULL ) ; new_argv = XOBFINISH ( & argv_obstack , char * * ) ;

fork_execute ( new_argv [ <NUM_LIT> ] , new_argv , false ) ;


<s> obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; switch ( offload_abi ) { case OFFLOAD_ABI_LP64 : obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; break ; case OFFLOAD_ABI_ILP32 : obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; break ; default : gcc_unreachable ( ) ; } obstack_ptr_grow ( & argv_obstack , target_so_filename ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , rename_section_opt ) ; obstack_ptr_grow ( & argv_obstack , NULL ) ; char * * new_argv = XOBFINISH ( & argv_obstack , char * * ) ; fork_execute ( new_argv [ <NUM_LIT> ] , new_argv , false ) ; obstack_free ( & argv_obstack , NULL ) ; size_t symbol_name_len = strlen ( target_so_filename ) ; char * symbol_name = XALLOCAVEC ( char , symbol_name_len + <NUM_LIT> ) ; for ( size_t i = <NUM_LIT> ; i < symbol_name_len ; i ++ ) { char c = target_so_filename [ i ] ; if ( ! ISALNUM ( c ) ) c = '_' ; symbol_name [ i ] = c ; } symbol_name [ symbol_name_len ] = '\0' ; char * opt_for_objcopy [ <NUM_LIT> ] ; opt_for_objcopy [ <NUM_LIT> ] = XALLOCAVEC ( char , sizeof ( <STR_LIT> ) + symbol_name_len + strlen ( symbols [ <NUM_LIT> ] ) ) ; opt_for_objcopy [ <NUM_LIT> ] = XALLOCAVEC ( char , sizeof ( <STR_LIT> ) + symbol_name_len + strlen ( symbols [ <NUM_LIT> ] ) ) ; opt_for_objcopy [ <NUM_LIT> ] = XALLOCAVEC ( char , sizeof ( <STR_LIT> ) + symbol_name_len + strlen ( symbols [ <NUM_LIT> ] ) ) ; sprintf ( opt_for_objcopy [ <NUM_LIT> ] , <STR_LIT> , symbol_name , symbols [ <NUM_LIT> ] ) ; sprintf ( opt_for_objcopy [ <NUM_LIT> ] , <STR_LIT> , symbol_name , symbols [ <NUM_LIT> ] ) ; sprintf ( opt_for_objcopy [ <NUM_LIT> ] , <STR_LIT> , symbol_name , symbols [ <NUM_LIT> ] ) ; obstack_init ( & argv_obstack ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , target_so_filename ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , opt_for_objcopy [ <NUM_LIT> ] ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ;


if ( stat ( name , & st ) < <NUM_LIT> || S_ISDIR ( st . st_mode ) ) return - <NUM_LIT> ;


<s> if ( stat ( name , & st ) < <NUM_LIT> || S_ISDIR ( st . st_mode ) ) return - <NUM_LIT> ;


<s> const char * cpath = getenv ( <STR_LIT> ) ; const char * lpath = getenv ( <STR_LIT> ) ; const char * rpath = getenv ( <STR_LIT> ) ; unsetenv ( <STR_LIT> ) ; unsetenv ( <STR_LIT> ) ; unsetenv ( <STR_LIT> ) ; unsetenv ( <STR_LIT> ) ; fork_execute ( argv [ <NUM_LIT> ] , argv , false , NULL ) ; obstack_free ( argv_obstack , NULL ) ; xputenv ( concat ( <STR_LIT> , epath , NULL ) ) ; xputenv ( concat ( <STR_LIT> , cpath , NULL ) ) ; xputenv ( concat ( <STR_LIT> , lpath , NULL ) ) ; xputenv ( concat ( <STR_LIT> , rpath , NULL ) ) ;


<s> static void compile_for_target ( struct obstack * argv_obstack ) { switch ( offload_abi ) { case OFFLOAD_ABI_LP64 : obstack_ptr_grow ( argv_obstack , <STR_LIT> ) ; break ; case OFFLOAD_ABI_ILP32 : obstack_ptr_grow ( argv_obstack , <STR_LIT> ) ; break ; default : gcc_unreachable ( ) ; } obstack_ptr_grow ( argv_obstack , NULL ) ; char * * argv = XOBFINISH ( argv_obstack , char * * ) ; const char * epath = getenv ( <STR_LIT> ) ; const char * cpath = getenv ( <STR_LIT> ) ; const char * lpath = getenv ( <STR_LIT> ) ; const char * rpath = getenv ( <STR_LIT> ) ; unsetenv ( <STR_LIT> ) ; unsetenv ( <STR_LIT> ) ;


<s> if ( strcmp ( gcc_exec , collect_gcc ) == <NUM_LIT> ) { target_compiler = XDUPVEC ( char , name , strlen ( name ) + <NUM_LIT> ) ; found = true ; goto out ; } target_compiler = concat ( gcc_path , <STR_LIT> , name , NULL ) ; if ( access_check ( target_compiler , X_OK ) == <NUM_LIT> ) { found = true ; goto out ; } n_paths = parse_env_var ( getenv ( <STR_LIT> ) , & paths ) ;

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


<s> unsigned i ; if ( ! ptr ) return ; for ( i = <NUM_LIT> ; i < n ; i ++ ) { if ( ! ptr [ i ] ) break ;


<s> progname = <STR_LIT> ; gcc_init_libintl ( ) ; diagnostic_initialize ( global_dc , <NUM_LIT> ) ; if ( atexit ( mkoffload_cleanup ) != <NUM_LIT> ) fatal_error ( input_location , <STR_LIT> ) ; const char * host_compiler = getenv ( <STR_LIT> ) ; if ( ! host_compiler ) fatal_error ( input_location , <STR_LIT> ) ; const char * target_driver_name = GCC_INSTALL_NAME ; char * target_compiler = find_target_compiler ( target_driver_name ) ; if ( target_compiler == NULL ) fatal_error ( input_location , <STR_LIT> , target_driver_name ) ; expandargv ( & argc , & argv ) ; for ( int i = <NUM_LIT> ; i < argc ; i ++ ) { if ( startswith ( argv [ i ] , STR ) ) { if ( strcmp ( argv [ i ] + strlen ( STR ) , <STR_LIT> ) == <NUM_LIT> ) offload_abi = OFFLOAD_ABI_LP64 ; else if ( strcmp ( argv [ i ] + strlen ( STR ) , <STR_LIT> ) == <NUM_LIT> ) offload_abi = OFFLOAD_ABI_ILP32 ; else fatal_error ( input_location , <STR_LIT> STR ) ; } else if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> ) save_temps = true ; else if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> ) verbose = true ; else if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> && i + <NUM_LIT> < argc ) dumppfx = argv [ ++ i ] ; else if ( strcmp ( argv [ i ] , <STR_LIT> ) == <NUM_LIT> && i + <NUM_LIT> < argc ) out_obj_filename = argv [ ++ i ] ; } if ( ! out_obj_filename ) fatal_error ( input_location , <STR_LIT> ) ; if ( ! dumppfx ) dumppfx = out_obj_filename ; const char * target_so_filename = prepare_target_image ( target_compiler , argc , argv ) ; const char * host_descr_filename = generate_host_descr_file ( host_compiler ) ; struct obstack argv_obstack ; obstack_init ( & argv_obstack ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; switch ( offload_abi ) { case OFFLOAD_ABI_LP64 : obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; break ; case OFFLOAD_ABI_ILP32 : obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; break ; default : gcc_unreachable ( ) ; } obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , host_descr_filename ) ; obstack_ptr_grow ( & argv_obstack , target_so_filename ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , out_obj_filename ) ; obstack_ptr_grow ( & argv_obstack , NULL ) ; char * * new_argv = XOBFINISH ( & argv_obstack , char * * ) ; fork_execute ( new_argv [ <NUM_LIT> ] , new_argv , false , NULL ) ; obstack_free ( & argv_obstack , NULL ) ; obstack_init ( & argv_obstack ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , <STR_LIT> ) ; obstack_ptr_grow ( & argv_obstack , symbols [ <NUM_LIT> ] ) ;


<s> } else if ( verbose ) fprintf ( stderr , <STR_LIT> , file ) ;


<s> static void mkoffload_cleanup ( void ) { tool_cleanup ( false ) ;


<s> } values = ( char * * ) xmalloc ( num * sizeof ( char * ) ) ; curval = str ; nextval = strchr ( curval , ':' ) ; if ( nextval == NULL ) nextval = strchr ( curval , '\0' ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { int l = nextval - curval ; values [ i ] = ( char * ) xmalloc ( l + <NUM_LIT> ) ; memcpy ( values [ i ] , curval , l ) ; values [ i ] [ l ] = <NUM_LIT> ; curval = nextval + <NUM_LIT> ; nextval = strchr ( curval , ':' ) ;


<s> curval = strchr ( curval + <NUM_LIT> , ':' ) ; } values = ( char * * ) xmalloc ( num * sizeof ( char * ) ) ; curval = str ; nextval = strchr ( curval , ':' ) ; if ( nextval == NULL ) nextval = strchr ( curval , '\0' ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { int l = nextval - curval ; values [ i ] = ( char * ) xmalloc ( l + <NUM_LIT> ) ; memcpy ( values [ i ] , curval , l ) ; values [ i ] [ l ] = <NUM_LIT> ; curval = nextval + <NUM_LIT> ; nextval = strchr ( curval , ':' ) ; if ( nextval == NULL ) nextval = strchr ( curval , '\0' ) ;


<s> for ( int i = <NUM_LIT> ; i < num_temps ; i ++ ) maybe_unlink ( temp_files [ i ] ) ;


<s> void tool_cleanup ( bool from_signal ATTRIBUTE_UNUSED ) {

for ( int i = <NUM_LIT> ; i < num_temps ; i ++ ) maybe_unlink ( temp_files [ i ] ) ;


<s> static void xputenv ( const char * string ) {

if ( verbose ) fprintf ( stderr , <STR_LIT> , string ) ;


<s> if ( verbose ) fprintf ( stderr , <STR_LIT> , string ) ;

putenv ( CONST_CAST ( char * , string ) ) ;


<s> return __builtin_ia32_aesdecwide128kl_u8 ( ( __v2di * ) __A , ( __v2di * ) __B , __P ) ;


return __builtin_ia32_aesdecwide256kl_u8 ( ( __v2di * ) __A , ( __v2di * ) __B , __P ) ;


<s> fs -> regs . reg [ <NUM_LIT> ] . loc . offset = ( long ) & sc -> REG_NAME ( ebx ) - new_cfa ; fs -> regs . reg [ <NUM_LIT> ] . how = REG_SAVED_OFFSET ; fs -> regs . reg [ <NUM_LIT> ] . loc . offset = ( long ) & sc -> REG_NAME ( ecx ) - new_cfa ; fs -> regs . reg [ <NUM_LIT> ] . how = REG_SAVED_OFFSET ; fs -> regs . reg [ <NUM_LIT> ] . loc . offset = ( long ) & sc -> REG_NAME ( edx ) - new_cfa ; fs -> regs . reg [ <NUM_LIT> ] . how = REG_SAVED_OFFSET ; fs -> regs . reg [ <NUM_LIT> ] . loc . offset = ( long ) & sc -> REG_NAME ( esi ) - new_cfa ; fs -> regs . reg [ <NUM_LIT> ] . how = REG_SAVED_OFFSET ; fs -> regs . reg [ <NUM_LIT> ] . loc . offset = ( long ) & sc -> REG_NAME ( edi ) - new_cfa ; fs -> regs . reg [ <NUM_LIT> ] . how = REG_SAVED_OFFSET ; fs -> regs . reg [ <NUM_LIT> ] . loc . offset = ( long ) & sc -> REG_NAME ( ebp ) - new_cfa ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __llwpcb ( void * pcbAddress ) {


<s> return __builtin_ia32_lwpins32 ( data2 , data1 , flags ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lwpins32 ( unsigned int data2 , unsigned int data1 , unsigned int flags ) {

return __builtin_ia32_lwpins32 ( data2 , data1 , flags ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lwpval32 ( unsigned int data2 , unsigned int data1 , unsigned int flags ) {

__builtin_ia32_lwpval32 ( data2 , data1 , flags ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lwpval64 ( unsigned long long data2 , unsigned int data1 , unsigned int flags ) { __builtin_ia32_lwpval64 ( data2 , data1 , flags ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lwpins32 ( unsigned int __data2 , unsigned int __data1 , unsigned int __flags ) { return __builtin_ia32_lwpins32 ( __data2 , __data1 , __flags ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lwpins64 ( unsigned long long __data2 , unsigned int __data1 , unsigned int __flags ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lwpval32 ( unsigned int __data2 , unsigned int __data1 , unsigned int __flags ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lwpval64 ( unsigned long long __data2 , unsigned int __data1 , unsigned int __flags ) { __builtin_ia32_lwpval64 ( __data2 , __data1 , __flags ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _lzcnt_u32 ( unsigned int __X ) {


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _lzcnt_u32 ( unsigned int __X ) { return __builtin_clz ( __X ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _lzcnt_u64 ( unsigned long long __X ) {


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lzcnt16 ( unsigned short __X ) { return __builtin_clzs ( __X ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lzcnt16 ( unsigned short __X ) {


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lzcnt32 ( unsigned int __X ) {


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lzcnt32 ( unsigned int __X ) { return __builtin_clz ( __X ) ;


return __builtin_ia32_lzcnt_u32 ( __X ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _lzcnt_u32 ( unsigned int __X ) { return __builtin_ia32_lzcnt_u32 ( __X ) ;


return __builtin_ia32_lzcnt_u64 ( __X ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lzcnt16 ( unsigned short __X ) { return __builtin_ia32_lzcnt_u16 ( __X ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __lzcnt64 ( unsigned long long __X ) { return __builtin_ia32_lzcnt_u64 ( __X ) ;


<s> static __inline void _m_femms ( void ) { __builtin_ia32_femms ( ) ;


return ( __m64 ) __builtin_ia32_pf2id ( ( __v2sf ) __A ) ;


<s> return ( __m64 ) __builtin_ia32_pf2iw ( ( __v2sf ) __A ) ;


<s> return ( __m64 ) __builtin_ia32_pfcmpeq ( ( __v2sf ) __A , ( __v2sf ) __B ) ;


<s> return ( __m64 ) __builtin_ia32_pfpnacc ( ( __v2sf ) __A , ( __v2sf ) __B ) ;


return ( __m64 ) __builtin_ia32_pfrcp ( ( __v2sf ) __A ) ;


return ( __m64 ) __builtin_ia32_pfrsqrt ( ( __v2sf ) __A ) ;


<s> return ( __m64 ) __builtin_ia32_pfrsqrt ( ( __v2sf ) __A ) ;


<s> return ( __m64 ) __builtin_ia32_pmulhrw ( ( __v4hi ) __A , ( __v4hi ) __B ) ;


<s> static __inline void _m_prefetch ( void * __P ) {


<s> static __inline void _m_prefetchw ( void * __P ) {


union { __v2sf v ; float a [ <NUM_LIT> ] ; } __tmp = { ( __v2sf ) __A } ;


<s> return ( __m64 ) __builtin_ia32_pf2id ( ( __v2sf ) __A ) ;


return ( __m64 ) __builtin_ia32_pf2iw ( ( __v2sf ) __A ) ;


<s> return ( __m64 ) __builtin_ia32_pfcmpge ( ( __v2sf ) __A , ( __v2sf ) __B ) ;


<s> return ( __m64 ) __builtin_ia32_pfrcp ( ( __v2sf ) __A ) ;


<s> return ( __m64 ) __builtin_ia32_pi2fd ( ( __v2si ) __A ) ;


<s> return ( __m64 ) __builtin_ia32_pi2fw ( ( __v2si ) __A ) ;


<s> extern __inline float __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _m_to_float ( __m64 __A ) { union { __v2sf v ; float a [ <NUM_LIT> ] ; } __tmp ; __tmp . v = ( __v2sf ) __A ;


<s> static __inline __m64 _mm_cvtsi32_si64 ( int __i ) { return ( unsigned int ) __i ;


<s> static __inline void _mm_empty ( void ) { __builtin_ia32_emms ( ) ;


<s> static __inline void _mm_empty ( void ) {


<s> return __builtin_ia32_por ( __m1 , __m2 ) ;


<s> unsigned int __i = ( unsigned short ) __w << <NUM_LIT> | ( unsigned short ) __w ;


<s> static __inline __m64 _mm_set1_pi8 ( char __b ) { unsigned int __w = ( unsigned char ) __b << <NUM_LIT> | ( unsigned char ) __b ; unsigned int __i = __w << <NUM_LIT> | __w ;


<s> return __builtin_ia32_mmx_zero ( ) ;


<s> static __inline __m64 _mm_setzero_si64 ( void ) {


unsigned int __i1 = ( unsigned short ) __w3 << <NUM_LIT> | ( unsigned short ) __w2 ;


<s> static __inline __m64 _mm_set_pi16 ( short __w3 , short __w2 , short __w1 , short __w0 ) { unsigned int __i1 = ( unsigned short ) __w3 << <NUM_LIT> | ( unsigned short ) __w2 ; unsigned int __i0 = ( unsigned short ) __w1 << <NUM_LIT> | ( unsigned short ) __w0 ; return _mm_set_pi32 ( __i1 , __i0 ) ;


<s> __i1 = __i1 << <NUM_LIT> | ( unsigned char ) __b5 ; __i1 = __i1 << <NUM_LIT> | ( unsigned char ) __b4 ; __i0 = ( unsigned char ) __b3 ; __i0 = __i0 << <NUM_LIT> | ( unsigned char ) __b2 ; __i0 = __i0 << <NUM_LIT> | ( unsigned char ) __b1 ; __i0 = __i0 << <NUM_LIT> | ( unsigned char ) __b0 ; return _mm_set_pi32 ( __i1 , __i0 ) ;


<s> return ( __m64 ) __builtin_ia32_pslld ( ( __v2si ) __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_psllq ( __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_psraw ( ( __v4hi ) __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_psrad ( ( __v2si ) __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_psrlw ( ( __v4hi ) __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_psrlq ( __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_punpckhbw ( ( __v8qi ) __m1 , ( __v8qi ) __m2 ) ;


<s> return ( __m64 ) __builtin_ia32_punpcklwd ( ( __v4hi ) __m1 , ( __v4hi ) __m2 ) ;


<s> return ( __m64 ) __builtin_ia32_vec_init_v2si ( __i , <NUM_LIT> ) ;


<s> static __inline void __attribute__ ( ( __always_inline__ ) ) _mm_empty ( void ) { __builtin_ia32_emms ( ) ;


<s> static __inline __m64 __attribute__ ( ( __always_inline__ ) ) _mm_setzero_si64 ( void ) {


<s> return ( __m64 ) __builtin_ia32_vec_init_v2si ( __i0 , __i1 ) ;


<s> static __inline __m64 __attribute__ ( ( __always_inline__ ) ) _mm_slli_si64 ( __m64 __m , int __count ) { return ( __m64 ) __builtin_ia32_psllq ( ( long long ) __m , ( long long ) __count ) ;


<s> return ( __m64 ) __builtin_ia32_psllq ( ( long long ) __m , ( long long ) __count ) ;


<s> return ( __m64 ) __builtin_ia32_psllw ( ( __v4hi ) __m , ( long long ) __count ) ;


return ( __m64 ) __builtin_ia32_pslld ( ( __v2si ) __m , ( long long ) __count ) ;


return ( __m64 ) __builtin_ia32_psllq ( ( long long ) __m , ( long long ) __count ) ;


<s> return ( __m64 ) __builtin_ia32_psraw ( ( __v4hi ) __m , ( long long ) __count ) ;


return ( __m64 ) __builtin_ia32_psrad ( ( __v2si ) __m , ( long long ) __count ) ;


<s> return ( __m64 ) __builtin_ia32_psrlq ( ( long long ) __m , ( long long ) __count ) ;


<s> return ( __m64 ) __builtin_ia32_psrld ( ( __v2si ) __m , ( long long ) __count ) ;


return ( __m64 ) __builtin_ia32_psrld ( ( __v2si ) __m , ( long long ) __count ) ;


return ( __m64 ) __builtin_ia32_psubq ( ( long long ) __m1 , ( long long ) __m2 ) ;


<s> return ( __m64 ) __builtin_ia32_punpckhdq ( ( __v2si ) __m1 , ( __v2si ) __m2 ) ;


<s> return ( __m64 ) __builtin_ia32_punpckldq ( ( __v2si ) __m1 , ( __v2si ) __m2 ) ;


<s> return ( __m64 ) __builtin_ia32_punpcklbw ( ( __v8qi ) __m1 , ( __v8qi ) __m2 ) ;


<s> static __inline void __attribute__ ( ( __always_inline__ ) ) _m_empty ( void ) {


<s> return _mm_adds_pu8 ( __m1 , __m2 ) ;


<s> return _mm_adds_pu16 ( __m1 , __m2 ) ;


<s> return _mm_andnot_si64 ( __m1 , __m2 ) ;


<s> return _mm_cmpeq_pi8 ( __m1 , __m2 ) ;


<s> return _mm_cmpeq_pi16 ( __m1 , __m2 ) ;


<s> return _mm_cmpgt_pi32 ( __m1 , __m2 ) ;


<s> return _mm_madd_pi16 ( __m1 , __m2 ) ;


<s> return _mm_slli_pi32 ( __m , __count ) ;


<s> return _mm_slli_si64 ( __m , __count ) ;


<s> return _mm_slli_pi16 ( __m , __count ) ;


<s> return _mm_sra_pi32 ( __m , __count ) ;


<s> return _mm_sra_pi16 ( __m , __count ) ;


<s> return _mm_srli_pi32 ( __m , __count ) ;


<s> return _mm_srl_si64 ( __m , __count ) ;


<s> return _mm_srli_si64 ( __m , __count ) ;


<s> return _mm_srli_pi16 ( __m , __count ) ;


<s> return _mm_sub_pi8 ( __m1 , __m2 ) ;


<s> return _mm_subs_pi8 ( __m1 , __m2 ) ;


<s> return _mm_subs_pu16 ( __m1 , __m2 ) ;


<s> return _mm_unpacklo_pi8 ( __m1 , __m2 ) ;


<s> return _mm_unpacklo_pi32 ( __m1 , __m2 ) ;


<s> return _mm_unpacklo_pi16 ( __m1 , __m2 ) ;


<s> return ( __m64 ) __builtin_ia32_vec_init_v2si ( __i , <NUM_LIT> ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_empty ( void ) {


<s> return ( __m64 ) __builtin_ia32_pslldi ( ( __v2si ) __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_pslld ( ( __v2si ) __m , ( __v2si ) __count ) ;


<s> return ( __m64 ) __builtin_ia32_psrawi ( ( __v4hi ) __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_psradi ( ( __v2si ) __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_psrlqi ( ( __v1di ) __m , __count ) ;


<s> return ( __m64 ) __builtin_ia32_psrlq ( ( __v1di ) __m , ( __v1di ) __count ) ;


<s> return ( __m64 ) __builtin_ia32_punpckhwd ( ( __v4hi ) __m1 , ( __v4hi ) __m2 ) ;


<s> return ( __m64 ) __builtin_ia32_punpckhdq ( ( __v2si ) __m1 , ( __v2si ) __m2 ) ;


<s> return ( __m64 ) __builtin_ia32_punpckhbw ( ( __v8qi ) __m1 , ( __v8qi ) __m2 ) ;


<s> return ( __m64 ) __builtin_ia32_punpckldq ( ( __v2si ) __m1 , ( __v2si ) __m2 ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _m_empty ( void ) { _mm_empty ( ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _directstoreu_u32 ( void * __P , unsigned int __A ) {

__builtin_ia32_directstoreu_u32 ( ( unsigned int * ) __P , __A ) ;


<s> __builtin_ia32_directstoreu_u64 ( ( unsigned long long * ) __P , __A ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _movdir64b ( void * __P , const void * __Q ) { __builtin_ia32_movdir64b ( __P , __Q ) ;


<s> ms_printf_length_specs [ <NUM_LIT> ] . std = C89_OR_EXT ; ms_printf_length_specs [ <NUM_LIT> ] . std = C89_OR_EXT ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_monitor ( void const * __P , unsigned int __E , unsigned int __H ) { __builtin_ia32_monitor ( __P , __E , __H ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_mwaitx ( unsigned int __E , unsigned int __H , unsigned int __C ) {


<s> while ( pdtor < & __DTOR_END__ ) if ( * pdtor ++ != NULL ) pdtor [ - <NUM_LIT> ] ( ) ; if ( __deregister_frame_info ) __deregister_frame_info ( __EH_FRAME_BEGIN__ ) ;


<s> static void ( * const * pdtor ) ( void ) = & __DTOR_LIST__ + <NUM_LIT> ; while ( pdtor < & __DTOR_END__ ) if ( * pdtor ++ != NULL ) pdtor [ - <NUM_LIT> ] ( ) ; if ( __deregister_frame_info ) __deregister_frame_info ( __EH_FRAME_BEGIN__ ) ;


<s> int __init_environment ( void * unused __attribute__ ( ( __unused__ ) ) ) { void ( * const * pctor ) ( void ) ; static struct object object ; if ( __register_frame_info ) __register_frame_info ( __EH_FRAME_BEGIN__ , & object ) ;

for ( pctor = & __CTOR_END__ - <NUM_LIT> ; pctor > & __CTOR_LIST__ ; -- pctor ) if ( * pctor != NULL ) ( * pctor ) ( ) ;


<s> int __init_environment ( void * unused __attribute__ ( ( __unused__ ) ) ) { void ( * const * pctor ) ( void ) ;


<s> BOOL DllMain ( HINSTANCE libraryId __attribute__ ( ( __unused__ ) ) , DWORD reason , void * hModule ) { switch ( reason ) { case DLL_NLM_STARTUP : allocRTag = AllocateResourceTag ( hModule , <STR_LIT> , AllocSignature ) ; return allocRTag != NULL ; case DLL_NLM_SHUTDOWN : break ; }


<s> allocRTag = AllocateResourceTag ( hModule , <STR_LIT> , AllocSignature ) ; return allocRTag != NULL ; case DLL_NLM_SHUTDOWN :


<s> void * malloc ( size_t size ) { return AllocSleepOK ( size , allocRTag , NULL ) ;


<s> return AllocSleepOK ( size , allocRTag , NULL ) ;


<s> const char * asmname = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ; char * newsym ; tree formal_type = TYPE_ARG_TYPES ( TREE_TYPE ( decl ) ) ; if ( formal_type != NULL_TREE ) { if ( TREE_VALUE ( tree_last ( formal_type ) ) != void_type_node ) return NULL_TREE ;

while ( TREE_VALUE ( formal_type ) != void_type_node && COMPLETE_TYPE_P ( TREE_VALUE ( formal_type ) ) ) {


<s> char * newsym ; tree formal_type = TYPE_ARG_TYPES ( TREE_TYPE ( decl ) ) ; if ( formal_type != NULL_TREE ) { if ( TREE_VALUE ( tree_last ( formal_type ) ) != void_type_node ) return NULL_TREE ; while ( TREE_VALUE ( formal_type ) != void_type_node && COMPLETE_TYPE_P ( TREE_VALUE ( formal_type ) ) ) { unsigned parm_size = TREE_INT_CST_LOW ( TYPE_SIZE ( TREE_VALUE ( formal_type ) ) ) ; parm_size = ( ( parm_size + PARM_BOUNDARY - <NUM_LIT> ) / PARM_BOUNDARY * PARM_BOUNDARY ) ;


<s> while ( TREE_VALUE ( formal_type ) != void_type_node && COMPLETE_TYPE_P ( TREE_VALUE ( formal_type ) ) ) { unsigned parm_size = TREE_INT_CST_LOW ( TYPE_SIZE ( TREE_VALUE ( formal_type ) ) ) ; parm_size = ( ( parm_size + PARM_BOUNDARY - <NUM_LIT> ) / PARM_BOUNDARY * PARM_BOUNDARY ) ; total += parm_size ; formal_type = TREE_CHAIN ( formal_type ) ; } } newsym = alloca ( <NUM_LIT> + strlen ( asmname ) + <NUM_LIT> + <NUM_LIT> + <NUM_LIT> ) ;

return get_identifier_with_length ( newsym , sprintf ( newsym , <STR_LIT> , prefix , asmname , total / BITS_PER_UNIT ) ) ;


<s> ++ name ; if ( ISDIGIT ( p [ <NUM_LIT> ] ) ) name = ggc_alloc_string ( name , p - name ) ; else { gcc_assert ( ISDIGIT ( * name ) ) ; name ++ ;


<s> void nwld_named_section_asm_out_constructor ( rtx symbol , int priority ) { const char section [ ] = <STR_LIT> TARGET_SUB_SECTION_SEPARATOR ; char section [ <NUM_LIT> ] ; sprintf ( section , <STR_LIT> TARGET_SUB_SECTION_SEPARATOR <STR_LIT> , MAX_INIT_PRIORITY - priority ) ; named_section_flags ( section , <NUM_LIT> ) ;


<s> sprintf ( section , <STR_LIT> TARGET_SUB_SECTION_SEPARATOR <STR_LIT> , MAX_INIT_PRIORITY - priority ) ; named_section_flags ( section , <NUM_LIT> ) ;


<s> void nwld_named_section_asm_out_destructor ( rtx symbol , int priority ) { const char section [ ] = <STR_LIT> TARGET_SUB_SECTION_SEPARATOR ; char section [ <NUM_LIT> ] ;

sprintf ( section , <STR_LIT> TARGET_SUB_SECTION_SEPARATOR <STR_LIT> , MAX_INIT_PRIORITY - priority ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_pcommit ( void ) { __builtin_ia32_pcommit ( ) ;


<s> case __PCONFIG_KEY_PROGRAM : __pconfig_b ( __L , __D [ <NUM_LIT> ] , __R ) ; break ; default :


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdpkru_u32 ( void ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _wrpkru ( unsigned int key ) {


<s> static __inline __m128d __attribute__ ( ( __always_inline__ ) ) _mm_loaddup_pd ( double const * __P ) {


<s> static __inline void __attribute__ ( ( __always_inline__ ) ) _mm_monitor ( void const * __P , unsigned int __E , unsigned int __H ) { __builtin_ia32_monitor ( __P , __E , __H ) ;


<s> return ( __m128 ) __builtin_ia32_movshdup ( ( __v4sf ) __X ) ;


<s> return ( __m128 ) __builtin_ia32_movsldup ( ( __v4sf ) __X ) ;


<s> return ( __m128 ) __builtin_ia32_addsubps ( ( __v4sf ) __X , ( __v4sf ) __Y ) ;


<s> static __inline void _mm_free ( void * ptr ) { free ( ptr ) ;


<s> static __inline void * _mm_malloc ( size_t size , size_t alignment ) { void * ptr ; if ( alignment == <NUM_LIT> ) return malloc ( size ) ; if ( alignment == <NUM_LIT> || ( sizeof ( void * ) == <NUM_LIT> && alignment == <NUM_LIT> ) ) alignment = sizeof ( void * ) ; if ( posix_memalign ( & ptr , alignment , size ) == <NUM_LIT> ) return ptr ;


<s> if ( alignment == <NUM_LIT> || ( sizeof ( void * ) == <NUM_LIT> && alignment == <NUM_LIT> ) ) alignment = sizeof ( void * ) ;

if ( posix_memalign ( & ptr , alignment , size ) == <NUM_LIT> ) return ptr ;


<s> static __inline void _mm_free ( void * __ptr ) {


<s> static __inline void _mm_free ( void * __ptr ) { free ( __ptr ) ;


<s> if ( __alignment == <NUM_LIT> || ( sizeof ( void * ) == <NUM_LIT> && __alignment == <NUM_LIT> ) ) __alignment = sizeof ( void * ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_popcnt_u32 ( unsigned int __X ) {


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_popcnt_u32 ( unsigned int __X ) { return __builtin_popcount ( __X ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_popcnt_u64 ( unsigned long long __X ) { return __builtin_popcountll ( __X ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _m_prefetchit0 ( void * __P ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _aadd_i32 ( int * __A , int __B ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _aadd_i64 ( long long * __A , long long __B ) {

__builtin_ia32_aadd64 ( ( long long * ) __A , __B ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _aand_i32 ( int * __A , int __B ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _aor_i32 ( int * __A , int __B ) {


<s> __builtin_ia32_aor64 ( ( long long * ) __A , __B ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _axor_i32 ( int * __A , int __B ) { __builtin_ia32_axor32 ( ( int * ) __A , __B ) ;


<s> __builtin_ia32_axor64 ( ( long long * ) __A , __B ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdseed32_step ( unsigned int * p ) { return __builtin_ia32_rdseed_si_step ( p ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdseed64_step ( unsigned long long * p ) { return __builtin_ia32_rdseed_di_step ( p ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdseed64_step ( unsigned long long * p ) {

return __builtin_ia32_rdseed_di_step ( p ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdseed16_step ( unsigned short * __p ) {

return __builtin_ia32_rdseed_hi_step ( __p ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdseed16_step ( unsigned short * __p ) { return __builtin_ia32_rdseed_hi_step ( __p ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdseed32_step ( unsigned int * __p ) { return __builtin_ia32_rdseed_si_step ( __p ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _rdseed64_step ( unsigned long long * __p ) { return __builtin_ia32_rdseed_di_step ( __p ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _xabort ( const unsigned int __imm ) { __builtin_ia32_xabort ( __imm ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _xbegin ( void ) { return __builtin_ia32_xbegin ( ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _serialize ( void ) { __builtin_ia32_serialize ( ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _serialize ( void ) {


<s> return ( __m128i ) __builtin_ia32_sha1nexte ( ( __v4si ) __A , ( __v4si ) __B ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_crc32_u16 ( unsigned int __C , unsigned short __V ) { return __builtin_ia32_crc32hi ( __C , __V ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_crc32_u32 ( unsigned int __C , unsigned int __V ) {


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_crc32_u64 ( unsigned long long __C , unsigned long long __V ) {


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_crc32_u8 ( unsigned int __C , unsigned char __V ) {


return ( __m128i ) __builtin_ia32_pmovsxwd128 ( ( __v8hi ) __X ) ;


return ( __m128i ) __builtin_ia32_pmovsxwq128 ( ( __v8hi ) __X ) ;


<s> return ( __m128i ) __builtin_ia32_pmovsxdq128 ( ( __v4si ) __X ) ;


<s> return ( __m128i ) __builtin_ia32_pmovsxbw128 ( ( __v16qi ) __X ) ;


<s> return ( __m128i ) __builtin_ia32_pmovsxbd128 ( ( __v16qi ) __X ) ;


<s> return ( __m128i ) __builtin_ia32_pmovsxbq128 ( ( __v16qi ) __X ) ;


return ( __m128i ) __builtin_ia32_pmovzxwd128 ( ( __v8hi ) __X ) ;


<s> return ( __m128i ) __builtin_ia32_pmovzxbw128 ( ( __v16qi ) __X ) ;


return ( __m128i ) __builtin_ia32_pmovzxbd128 ( ( __v16qi ) __X ) ;


<s> return ( __m128i ) __builtin_ia32_pmovzxbq128 ( ( __v16qi ) __X ) ;


return ( __m128i ) __builtin_ia32_pmovzxbq128 ( ( __v16qi ) __X ) ;


<s> return __builtin_ia32_vec_ext_v4si ( ( __v4si ) __X , __N ) ;


<s> return __builtin_ia32_vec_ext_v2di ( ( __v2di ) __X , __N ) ;


<s> return ( unsigned char ) __builtin_ia32_vec_ext_v16qi ( ( __v16qi ) __X , __N ) ;


<s> __tmp . f = __builtin_ia32_vec_ext_v4sf ( ( __v4sf ) __X , __N ) ;


<s> extern __inline int __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _mm_extract_ps ( __m128 __X , const int __N ) { union { int i ; float f ; } __tmp ; __tmp . f = __builtin_ia32_vec_ext_v4sf ( ( __v4sf ) __X , __N ) ; return __tmp . i ;


return ( __m128i ) __builtin_ia32_phminposuw128 ( ( __v8hi ) __X ) ;


<s> return __builtin_ia32_ptestnzc128 ( ( __v2di ) __M , ( __v2di ) __V ) ;


<s> return __builtin_ia32_ptestz128 ( ( __v2di ) __M , ( __v2di ) __V ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __bextri_u32 ( unsigned int __X , const unsigned int __I ) {


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __bextri_u64 ( unsigned long long __X , const unsigned int __I ) { return __builtin_ia32_bextri_u64 ( __X , __I ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __blcfill_u32 ( unsigned int __X ) { return __X & ( __X + <NUM_LIT> ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __blcfill_u64 ( unsigned long long __X ) { return __X & ( __X + <NUM_LIT> ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __blcic_u64 ( unsigned long long __X ) { return ~ __X & ( __X + <NUM_LIT> ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __blci_u32 ( unsigned int __X ) {


<s> return __X | ~ ( __X + <NUM_LIT> ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __blcmsk_u32 ( unsigned int __X ) { return __X ^ ( __X + <NUM_LIT> ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __blcmsk_u64 ( unsigned long long __X ) { return __X ^ ( __X + <NUM_LIT> ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __blsfill_u64 ( unsigned long long __X ) {


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __blsic_u64 ( unsigned long long __X ) {


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __t1mskc_u64 ( unsigned long long __X ) { return ~ __X | ( __X + <NUM_LIT> ) ;


<s> return ~ __X | ( __X + <NUM_LIT> ) ;


<s> return ~ __X & ( __X - <NUM_LIT> ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __tzmsk_u32 ( unsigned int __X ) { return ~ __X & ( __X - <NUM_LIT> ) ;


<s> long __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) __tzmsk_u64 ( unsigned long long __X ) {


<s> return ( __m64 ) __builtin_ia32_pabsw ( ( __v4hi ) __X ) ;


return ( __m64 ) __builtin_ia32_pabsd ( ( __v2si ) __X ) ;


<s> return ( __m64 ) __builtin_ia32_pabsd ( ( __v2si ) __X ) ;


<s> return ( __m64 ) __builtin_ia32_phsubsw ( ( __v4hi ) __X , ( __v4hi ) __Y ) ;


<s> return ( __m64 ) __builtin_ia32_pmaddubsw ( ( __v8qi ) __X , ( __v8qi ) __Y ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _xresldtrk ( void ) { __builtin_ia32_xresldtrk ( ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _xsusldtrk ( void ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _clui ( void ) {


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _senduipi ( unsigned long long __R ) { __builtin_ia32_senduipi ( __R ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _stui ( void ) { __builtin_ia32_stui ( ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _testui ( void ) { return __builtin_ia32_testui ( ) ;


<s> return ( __m128i ) __builtin_ia32_vaesdeclast_v16qi ( ( __v16qi ) __A , ( __v16qi ) __B ) ;


<s> return ( __m128i ) __builtin_ia32_vaesenclast_v16qi ( ( __v16qi ) __A , ( __v16qi ) __B ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _tpause ( unsigned int __A , unsigned long long __B ) { return __builtin_ia32_tpause ( __A , __B ) ;


<s> __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _umwait ( unsigned int __A , unsigned long long __B ) { return __builtin_ia32_umwait ( __A , __B ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _wbnoinvd ( void ) { __builtin_ia32_wbnoinvd ( ) ;


<s> extern __inline void __attribute__ ( ( __gnu_inline__ , __always_inline__ , __artificial__ ) ) _wbnoinvd ( void ) {


<s> void i386_pe_adjust_class_at_definition ( tree t ) { tree member ; gcc_assert ( CLASS_TYPE_P ( t ) ) ; if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( t ) ) == NULL_TREE ) return ; for ( member = TYPE_FIELDS ( t ) ; member ; member = TREE_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllimport ( member ) ; for ( member = TYPE_METHODS ( t ) ; member ; member = TREE_CHAIN ( member ) ) if ( TREE_CODE ( member ) == FUNCTION_DECL ) maybe_add_dllimport ( member ) ;

for ( member = CLASSTYPE_VTABLES ( t ) ; member ; member = TREE_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllimport ( member ) ;


<s> gcc_assert ( CLASS_TYPE_P ( t ) ) ; if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( t ) ) == NULL_TREE ) return ; for ( member = TYPE_FIELDS ( t ) ; member ; member = TREE_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllimport ( member ) ; for ( member = TYPE_METHODS ( t ) ; member ; member = TREE_CHAIN ( member ) ) if ( TREE_CODE ( member ) == FUNCTION_DECL ) maybe_add_dllimport ( member ) ; for ( member = CLASSTYPE_VTABLES ( t ) ; member ; member = TREE_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllimport ( member ) ;


<s> bool i386_pe_type_dllexport_p ( tree decl ) { gcc_assert ( TREE_CODE ( decl ) == VAR_DECL || TREE_CODE ( decl ) == FUNCTION_DECL ) ;

if ( TREE_CODE ( TREE_TYPE ( decl ) ) == METHOD_TYPE && DECL_ARTIFICIAL ( decl ) && ! DECL_THUNK_P ( decl ) ) return false ;


<s> bool i386_pe_type_dllexport_p ( tree decl ) { gcc_assert ( TREE_CODE ( decl ) == VAR_DECL || TREE_CODE ( decl ) == FUNCTION_DECL ) ; if ( TREE_CODE ( TREE_TYPE ( decl ) ) == METHOD_TYPE && DECL_ARTIFICIAL ( decl ) && ! DECL_THUNK_P ( decl ) ) return false ; return true ;


<s> bool i386_pe_type_dllimport_p ( tree decl ) { gcc_assert ( TREE_CODE ( decl ) == VAR_DECL || TREE_CODE ( decl ) == FUNCTION_DECL ) ; if ( TARGET_NOP_FUN_DLLIMPORT && TREE_CODE ( decl ) == FUNCTION_DECL ) return false ; if ( TREE_CODE ( decl ) == FUNCTION_DECL && ( DECL_DECLARED_INLINE_P ( decl ) || DECL_TEMPLATE_INSTANTIATION ( decl ) || DECL_ARTIFICIAL ( decl ) ) ) return false ; else if ( TREE_CODE ( TREE_TYPE ( decl ) ) == METHOD_TYPE && DECL_VIRTUAL_P ( decl ) ) { if ( DECL_INITIAL ( decl ) ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , decl ) ;

if ( decl == CLASSTYPE_KEY_METHOD ( DECL_CONTEXT ( decl ) ) ) warning ( OPT_Wattributes , <STR_LIT> decl ) ;


<s> if ( tmv != NULL_TREE && CLASSTYPE_TYPEINFO_VAR ( tmv ) != NULL_TREE ) { tree na , ti_decl = CLASSTYPE_TYPEINFO_VAR ( tmv ) ; na = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , NULL_TREE ) ; decl_attributes ( & ti_decl , na , <NUM_LIT> ) ; } for ( member = TYPE_FIELDS ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllexport ( member ) ; for ( member = TYPE_METHODS ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == FUNCTION_DECL ) { tree thunk ; maybe_add_dllexport ( member ) ; for ( thunk = DECL_THUNKS ( member ) ; thunk ; thunk = TREE_CHAIN ( thunk ) ) maybe_add_dllexport ( thunk ) ; } for ( member = CLASSTYPE_VTABLES ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllexport ( member ) ; } else if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( t ) ) != NULL_TREE ) { for ( member = TYPE_FIELDS ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllimport ( member ) ; for ( member = TYPE_METHODS ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == FUNCTION_DECL ) {


<s> void i386_pe_adjust_class_at_definition ( tree t ) { tree member ; gcc_assert ( CLASS_TYPE_P ( t ) ) ; if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( t ) ) != NULL_TREE ) { tree tmv = TYPE_MAIN_VARIANT ( t ) ; if ( tmv != NULL_TREE && CLASSTYPE_TYPEINFO_VAR ( tmv ) != NULL_TREE ) { tree na , ti_decl = CLASSTYPE_TYPEINFO_VAR ( tmv ) ; na = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , NULL_TREE ) ; decl_attributes ( & ti_decl , na , <NUM_LIT> ) ; } for ( member = TYPE_FIELDS ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllexport ( member ) ;

for ( member = TYPE_METHODS ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == FUNCTION_DECL ) {


<s> tree na , ti_decl = CLASSTYPE_TYPEINFO_VAR ( tmv ) ; na = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , NULL_TREE ) ; decl_attributes ( & ti_decl , na , <NUM_LIT> ) ; } for ( member = TYPE_FIELDS ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllexport ( member ) ; else if ( TREE_CODE ( member ) == FUNCTION_DECL ) { tree thunk ; maybe_add_dllexport ( member ) ; for ( thunk = DECL_THUNKS ( member ) ; thunk ; thunk = TREE_CHAIN ( thunk ) ) maybe_add_dllexport ( thunk ) ; } for ( member = CLASSTYPE_VTABLES ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllexport ( member ) ; }

else if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( t ) ) != NULL_TREE ) {


<s> for ( thunk = DECL_THUNKS ( member ) ; thunk ; thunk = TREE_CHAIN ( thunk ) ) maybe_add_dllexport ( thunk ) ; } for ( member = CLASSTYPE_VTABLES ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllexport ( member ) ; } else if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( t ) ) != NULL_TREE ) { for ( member = TYPE_FIELDS ( t ) ; member ; member = DECL_CHAIN ( member ) ) if ( TREE_CODE ( member ) == VAR_DECL ) maybe_add_dllimport ( member ) ; else if ( TREE_CODE ( member ) == FUNCTION_DECL ) { tree thunk ; maybe_add_dllimport ( member ) ; for ( thunk = DECL_THUNKS ( member ) ; thunk ; thunk = DECL_CHAIN ( thunk ) ) maybe_add_dllimport ( thunk ) ; } for ( member = CLASSTYPE_VTABLES ( t ) ;


<s> gcc_assert ( TREE_CODE ( decl ) == VAR_DECL || TREE_CODE ( decl ) == FUNCTION_DECL ) ; if ( TREE_CODE ( TREE_TYPE ( decl ) ) == METHOD_TYPE && DECL_ARTIFICIAL ( decl ) && ! DECL_THUNK_P ( decl ) ) return false ; if ( TREE_CODE ( decl ) == FUNCTION_DECL && DECL_DECLARED_INLINE_P ( decl ) ) { if ( DECL_REALLY_EXTERN ( decl ) || ! flag_keep_inline_dllexport ) return false ; }


<s> bool i386_pe_type_dllimport_p ( tree decl ) { gcc_assert ( TREE_CODE ( decl ) == VAR_DECL || TREE_CODE ( decl ) == FUNCTION_DECL ) ; if ( TARGET_NOP_FUN_DLLIMPORT && TREE_CODE ( decl ) == FUNCTION_DECL ) return false ; if ( TREE_CODE ( decl ) == FUNCTION_DECL && ( DECL_DECLARED_INLINE_P ( decl ) || DECL_TEMPLATE_INSTANTIATION ( decl ) || DECL_ARTIFICIAL ( decl ) ) ) return false ;


<s> bool i386_pe_type_dllimport_p ( tree decl ) {

gcc_assert ( TREE_CODE ( decl ) == VAR_DECL || TREE_CODE ( decl ) == FUNCTION_DECL ) ;


<s> if ( i386_pe_type_dllexport_p ( decl ) ) { tree decl_attrs = DECL_ATTRIBUTES ( decl ) ; if ( lookup_attribute ( <STR_LIT> , decl_attrs ) != NULL_TREE ) return ; DECL_ATTRIBUTES ( decl ) = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , decl_attrs ) ; }


<s> static inline void maybe_add_dllexport ( tree decl ) { if ( i386_pe_type_dllexport_p ( decl ) ) { tree decl_attrs = DECL_ATTRIBUTES ( decl ) ; if ( lookup_attribute ( <STR_LIT> , decl_attrs ) != NULL_TREE ) return ;


<s> static inline void maybe_add_dllimport ( tree decl ) { if ( i386_pe_type_dllimport_p ( decl ) ) DECL_DLLIMPORT_P ( decl ) = <NUM_LIT> ;


else if ( ! TARGET_64BIT ) d_add_builtin_version ( <STR_LIT> ) ;


<s> d_add_builtin_version ( <STR_LIT> ) ; EXTRA_TARGET_D_OS_VERSIONS ( ) ;


<s> { <STR_LIT> , winnt_d_handle_target_object_format } , { NULL , NULL } , } ;

d_add_target_info_handlers ( handlers ) ;


<s> const struct d_target_info_spec handlers [ ] = { { <STR_LIT> , winnt_d_handle_target_object_format } , { NULL , NULL } , } ; d_add_target_info_handlers ( handlers ) ;


<s> void i386_pe_adjust_class_at_definition ( tree t ATTRIBUTE_UNUSED ) {


<s> bool i386_pe_type_dllimport_p ( tree decl ATTRIBUTE_UNUSED ) { return false ;


<s> void i386_pe_adjust_class_at_definition ( tree ) {


<s> bool i386_pe_type_dllexport_p ( tree ) {


<s> bool i386_pe_type_dllimport_p ( tree ) {


<s> bool handled_one = false ; struct seh_frame_state * seh ; if ( ! TARGET_SEH ) return ; seh = cfun -> machine -> seh ; if ( NOTE_P ( insn ) && NOTE_KIND ( insn ) == NOTE_INSN_SWITCH_TEXT_SECTIONS ) { rtx_insn * prev = prev_active_insn ( insn ) ; if ( prev && ! insn_nothrow_p ( prev ) ) fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; seh -> in_cold_section = true ; return ; } if ( NOTE_P ( insn ) || ! RTX_FRAME_RELATED_P ( insn ) ) return ; if ( seh -> after_prologue ) return ; for ( note = REG_NOTES ( insn ) ; note ; note = XEXP ( note , <NUM_LIT> ) ) { switch ( REG_NOTE_KIND ( note ) ) { case REG_FRAME_RELATED_EXPR : pat = XEXP ( note , <NUM_LIT> ) ; goto found ;


<s> pat = XEXP ( note , <NUM_LIT> ) ; if ( pat == NULL ) { pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; } seh_cfa_adjust_cfa ( asm_out_file , seh , pat ) ; handled_one = true ; break ; case REG_CFA_OFFSET : pat = XEXP ( note , <NUM_LIT> ) ; if ( pat == NULL ) pat = single_set ( insn ) ; seh_cfa_offset ( asm_out_file , seh , pat ) ; handled_one = true ; break ; default :


<s> static tree associated_type ( tree decl ) { return ( DECL_CONTEXT ( decl ) && TYPE_P ( DECL_CONTEXT ( decl ) ) ) ? DECL_CONTEXT ( decl ) : NULL_TREE ;


<s> char * newsym ; char * p ; tree formal_type ; if ( * asmname == '*' || strchr ( asmname , '@' ) ) return DECL_ASSEMBLER_NAME ( decl ) ; formal_type = TYPE_ARG_TYPES ( TREE_TYPE ( decl ) ) ; if ( formal_type != NULL_TREE ) { if ( TREE_VALUE ( tree_last ( formal_type ) ) != void_type_node ) return DECL_ASSEMBLER_NAME ( decl ) ; while ( TREE_VALUE ( formal_type ) != void_type_node && COMPLETE_TYPE_P ( TREE_VALUE ( formal_type ) ) ) { int parm_size = TREE_INT_CST_LOW ( TYPE_SIZE ( TREE_VALUE ( formal_type ) ) ) ; parm_size = ( ( parm_size + PARM_BOUNDARY - <NUM_LIT> ) / PARM_BOUNDARY * PARM_BOUNDARY ) ;


<s> } else { if ( flags & SECTION_CODE ) * f ++ = 'x' ; if ( flags & SECTION_WRITE ) * f ++ = 'w' ; if ( flags & SECTION_PE_SHARED ) * f ++ = 's' ; } * f = '\0' ; fprintf ( asm_out_file , <STR_LIT> , name , flagchars ) ; if ( flags & SECTION_LINKONCE ) { bool discard = ( flags & SECTION_CODE ) || lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ;

fprintf ( asm_out_file , <STR_LIT> , ( discard ? <STR_LIT> : <STR_LIT> ) ) ;


<s> fprintf ( file , <STR_LIT> ) ; assemble_name ( file , name ) ; fprintf ( file , <STR_LIT> , public ? ( int ) C_EXT : ( int ) C_STAT , ( int ) DT_FCN << N_BTSHFT ) ;


<s> int i386_pe_dllexport_name_p ( const char * symbol ) { return ( strncmp ( DLL_EXPORT_PREFIX , symbol , strlen ( DLL_EXPORT_PREFIX ) ) == <NUM_LIT> ) ;


<s> return ( strncmp ( DLL_EXPORT_PREFIX , symbol , strlen ( DLL_EXPORT_PREFIX ) ) == <NUM_LIT> ) ;


<s> static bool i386_pe_dllexport_p ( tree decl ) { if ( TREE_CODE ( decl ) != VAR_DECL && TREE_CODE ( decl ) != FUNCTION_DECL ) return false ; if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) return true ;

if ( associated_type ( decl ) && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( associated_type ( decl ) ) ) ) return i386_pe_type_dllexport_p ( decl ) ;


<s> if ( TREE_CODE ( decl ) != VAR_DECL && TREE_CODE ( decl ) != FUNCTION_DECL ) return false ; if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) return true ; if ( associated_type ( decl ) && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( associated_type ( decl ) ) ) ) return i386_pe_type_dllexport_p ( decl ) ; return false ;


<s> int i386_pe_dllimport_name_p ( const char * symbol ) {

return ( strncmp ( DLL_IMPORT_PREFIX , symbol , strlen ( DLL_IMPORT_PREFIX ) ) == <NUM_LIT> ) ;


<s> if ( associated_type ( decl ) && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( associated_type ( decl ) ) ) ) return i386_pe_type_dllimport_p ( decl ) ;


<s> else if ( i386_pe_dllimport_p ( decl ) ) i386_pe_mark_dllimport ( decl ) ; else gcc_assert ( ! ( ( TREE_CODE ( decl ) == FUNCTION_DECL || TREE_CODE ( decl ) == VAR_DECL ) && rtl != NULL_RTX && GET_CODE ( rtl ) == MEM && GET_CODE ( XEXP ( rtl , <NUM_LIT> ) ) == MEM && GET_CODE ( XEXP ( XEXP ( rtl , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && i386_pe_dllimport_name_p ( XSTR ( XEXP ( XEXP ( rtl , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ;


<s> } } if ( i386_pe_dllexport_p ( decl ) ) i386_pe_mark_dllexport ( decl ) ; else if ( i386_pe_dllimport_p ( decl ) ) i386_pe_mark_dllimport ( decl ) ;

else gcc_assert ( ! ( ( TREE_CODE ( decl ) == FUNCTION_DECL || TREE_CODE ( decl ) == VAR_DECL ) && rtl != NULL_RTX && GET_CODE ( rtl ) == MEM && GET_CODE ( XEXP ( rtl , <NUM_LIT> ) ) == MEM && GET_CODE ( XEXP ( XEXP ( rtl , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && i386_pe_dllimport_name_p ( XSTR ( XEXP ( XEXP ( rtl , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ;


<s> tree decl ; decl = p -> decl ; if ( ! TREE_ASM_WRITTEN ( decl ) && TREE_SYMBOL_REFERENCED ( DECL_ASSEMBLER_NAME ( decl ) ) ) { TREE_ASM_WRITTEN ( decl ) = <NUM_LIT> ;

i386_pe_declare_function_type ( asm_out_file , p -> name , TREE_PUBLIC ( decl ) ) ;


<s> newname = alloca ( strlen ( DLL_EXPORT_PREFIX ) + strlen ( oldname ) + <NUM_LIT> ) ; sprintf ( newname , <STR_LIT> , DLL_EXPORT_PREFIX , oldname ) ; idp = get_identifier ( newname ) ; symref = gen_rtx_SYMBOL_REF ( Pmode , IDENTIFIER_POINTER ( idp ) ) ; SYMBOL_REF_DECL ( symref ) = decl ;

XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) = symref ;


<s> if ( i386_pe_dllimport_name_p ( oldname ) ) { warning ( <NUM_LIT> , <STR_LIT> , decl ) ; oldname += strlen ( DLL_IMPORT_PREFIX ) ; } else if ( i386_pe_dllexport_name_p ( oldname ) ) return ; newname = alloca ( strlen ( DLL_EXPORT_PREFIX ) + strlen ( oldname ) + <NUM_LIT> ) ; sprintf ( newname , <STR_LIT> , DLL_EXPORT_PREFIX , oldname ) ; idp = get_identifier ( newname ) ; symref = gen_rtx_SYMBOL_REF ( Pmode , IDENTIFIER_POINTER ( idp ) ) ; SYMBOL_REF_DECL ( symref ) = decl ;


<s> tree idp ; rtx rtlname , newrtl ; rtx symref ; rtlname = XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) ; if ( GET_CODE ( rtlname ) == MEM ) rtlname = XEXP ( rtlname , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( rtlname ) == SYMBOL_REF ) ; oldname = XSTR ( rtlname , <NUM_LIT> ) ; if ( i386_pe_dllexport_name_p ( oldname ) ) { error ( <STR_LIT> , IDENTIFIER_POINTER ( DECL_NAME ( decl ) ) ) ; return ; } else if ( i386_pe_dllimport_name_p ( oldname ) ) { gcc_assert ( DECL_EXTERNAL ( decl ) && TREE_PUBLIC ( decl ) && DECL_DLLIMPORT_P ( decl ) ) ; return ; }

newname = alloca ( strlen ( DLL_IMPORT_PREFIX ) + strlen ( oldname ) + <NUM_LIT> ) ;


<s> } else if ( ( name [ <NUM_LIT> ] == FASTCALL_PREFIX ) || ( strncmp ( name , DLL_EXPORT_PREFIX , strlen ( DLL_EXPORT_PREFIX ) ) == <NUM_LIT> && name [ strlen ( DLL_EXPORT_PREFIX ) ] == FASTCALL_PREFIX ) ) { fprintf ( stream , <STR_LIT> , i386_pe_strip_name_encoding ( name ) ) ; } else { fprintf ( stream , <STR_LIT> , USER_LABEL_PREFIX , i386_pe_strip_name_encoding ( name ) ) ; }


<s> p -> next = export_head ; p -> name = name ;


<s> p = ( struct export_list * ) ggc_alloc ( sizeof * p ) ;


<s> struct extern_list * p ; p = ( struct extern_list * ) ggc_alloc ( sizeof * p ) ; p -> next = extern_head ; p -> decl = decl ; p -> name = name ; extern_head = p ;


<s> p -> next = extern_head ; p -> decl = decl ;


<s> static htab_t htab ; unsigned int flags ; unsigned int * * slot ; if ( ! htab ) htab = htab_create ( <NUM_LIT> , htab_hash_pointer , htab_eq_pointer , NULL ) ; if ( decl && TREE_CODE ( decl ) == FUNCTION_DECL ) flags = SECTION_CODE ; else if ( decl && decl_readonly_section ( decl , reloc ) ) flags = <NUM_LIT> ; else { flags = SECTION_WRITE ; if ( decl && TREE_CODE ( decl ) == VAR_DECL && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) flags |= SECTION_PE_SHARED ; } if ( decl && DECL_ONE_ONLY ( decl ) ) flags |= SECTION_LINKONCE ;

slot = ( unsigned int * * ) htab_find_slot ( htab , name , INSERT ) ;


<s> else if ( strncmp ( str , DLL_EXPORT_PREFIX , strlen ( DLL_EXPORT_PREFIX ) ) == <NUM_LIT> ) str += strlen ( DLL_EXPORT_PREFIX ) ;


<s> else if ( strncmp ( str , DLL_EXPORT_PREFIX , strlen ( DLL_EXPORT_PREFIX ) ) == <NUM_LIT> ) str += strlen ( DLL_EXPORT_PREFIX ) ; if ( * str == '*' ) str += <NUM_LIT> ; return str ;


<s> const char * name = i386_pe_strip_name_encoding ( str ) ; if ( * name == '@' ) name ++ ;


<s> const char * name = i386_pe_strip_name_encoding ( str ) ; if ( * name == '@' ) name ++ ; p = strchr ( name , '@' ) ;

if ( p ) return ggc_alloc_string ( name , p - name ) ;


<s> const char * name , * prefix ; char * string ; name = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ; name = i386_pe_strip_name_encoding_full ( name ) ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) prefix = <STR_LIT> ; else if ( decl_readonly_section ( decl , reloc ) ) prefix = <STR_LIT> ; else prefix = <STR_LIT> ;

len = strlen ( name ) + strlen ( prefix ) ;


<s> name = IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) ; name = i386_pe_strip_name_encoding_full ( name ) ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) prefix = <STR_LIT> ; else if ( decl_readonly_section ( decl , reloc ) ) prefix = <STR_LIT> ; else prefix = <STR_LIT> ; len = strlen ( name ) + strlen ( prefix ) ; string = alloca ( len + <NUM_LIT> ) ; sprintf ( string , <STR_LIT> , prefix , name ) ;

DECL_SECTION_NAME ( decl ) = build_string ( len , string ) ;


<s> if ( TARGET_NOP_FUN_DLLIMPORT && TREE_CODE ( decl ) == FUNCTION_DECL ) return false ; return true ;


<s> tree ix86_handle_selectany_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { if ( TREE_CODE ( * node ) == VAR_DECL && TREE_PUBLIC ( * node ) && ( DECL_INITIAL ( * node ) || TYPE_NEEDS_CONSTRUCTING ( TREE_TYPE ( * node ) ) ) ) make_decl_one_only ( * node ) ; else {

error ( <STR_LIT> <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ;


<s> tree ix86_handle_shared_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) {

if ( TREE_CODE ( * node ) != VAR_DECL ) {


<s> tree ix86_handle_shared_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { if ( TREE_CODE ( * node ) != VAR_DECL ) {

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


<s> inline hashval_t wrapped_symbol_hasher :: hash ( const value_type * v ) {


<s> inline hashval_t wrapped_symbol_hasher :: hash ( const value_type * v ) { return htab_hash_string ( v ) ;


<s> wrappers = new hash_table < wrapped_symbol_hasher > ( <NUM_LIT> ) ; for ( bufptr = wrapper_list_buffer ; * bufptr ; ++ bufptr ) { char * found = NULL ; if ( ISSPACE ( * bufptr ) ) continue ; if ( * bufptr == '_' ) found = bufptr ;

while ( * bufptr && ! ISSPACE ( * bufptr ) ) ++ bufptr ;


<s> HOST_WIDE_INT rounded ; rounded = size ? size : <NUM_LIT> ; rounded += ( BIGGEST_ALIGNMENT / BITS_PER_UNIT ) - <NUM_LIT> ; rounded = ( rounded / ( BIGGEST_ALIGNMENT / BITS_PER_UNIT ) * ( BIGGEST_ALIGNMENT / BITS_PER_UNIT ) ) ; i386_pe_maybe_record_exported_symbol ( decl , name , <NUM_LIT> ) ; fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , name ) ; if ( use_pe_aligned_common ) fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , size ? size : ( HOST_WIDE_INT ) <NUM_LIT> , exact_log2 ( align ) - exact_log2 ( CHAR_BIT ) ) ;


<s> if ( ( TREE_CODE ( exp ) == VAR_DECL || TREE_CODE ( exp ) == FUNCTION_DECL ) && DECL_DLLIMPORT_P ( exp ) ) return false ;

if ( DECL_P ( exp ) && ! lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( exp ) ) && TREE_PUBLIC ( exp ) && DECL_EXTERNAL ( exp ) ) return true ;


<s> void i386_pe_end_function ( FILE * f , const char * , tree ) { i386_pe_seh_fini ( f ) ;


<s> if ( ! TARGET_SEH ) return ; if ( cfun -> is_thunk ) return ;


<s> if ( decl != NULL_TREE ) switch_to_section ( function_section ( decl ) ) ;

ASM_OUTPUT_FUNCTION_LABEL ( f , name , decl ) ;


<s> if ( write_symbols != SDB_DEBUG ) i386_pe_declare_function_type ( f , name , TREE_PUBLIC ( decl ) ) ; if ( decl != NULL_TREE ) switch_to_section ( function_section ( decl ) ) ; ASM_OUTPUT_FUNCTION_LABEL ( f , name , decl ) ;


<s> error ( <STR_LIT> <STR_LIT> , name ) ; * no_add_attrs = true ; } return NULL_TREE ;


<s> static void seh_emit_push ( FILE * f , struct seh_frame_state * seh , rtx reg ) { unsigned int regno = REGNO ( reg ) ; gcc_checking_assert ( GENERAL_REGNO_P ( regno ) ) ; seh -> sp_offset += UNITS_PER_WORD ; if ( seh -> cfa_reg == stack_pointer_rtx ) seh -> cfa_offset += UNITS_PER_WORD ; fputs ( <STR_LIT> , f ) ; print_reg ( reg , <NUM_LIT> , f ) ;


<s> fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , alloc_offset - seh -> reg_offset [ regno ] ) ; } if ( seh -> cfa_reg != stack_pointer_rtx ) { offset = alloc_offset - seh -> cfa_offset ; gcc_assert ( ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; gcc_assert ( IN_RANGE ( offset , <NUM_LIT> , <NUM_LIT> ) ) ; fputs ( <STR_LIT> , f ) ; print_reg ( seh -> cfa_reg , <NUM_LIT> , f ) ; fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ; }


<s> print_reg ( gen_rtx_REG ( DImode , regno ) , <NUM_LIT> , f ) ; fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , alloc_offset - seh -> reg_offset [ regno ] ) ; } if ( seh -> cfa_reg != stack_pointer_rtx ) { offset = alloc_offset - seh -> cfa_offset ; gcc_assert ( ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; gcc_assert ( IN_RANGE ( offset , <NUM_LIT> , <NUM_LIT> ) ) ; fputs ( <STR_LIT> , f ) ; print_reg ( seh -> cfa_reg , <NUM_LIT> , f ) ; fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ; } if ( crtl -> accesses_prior_frames ) { offset = seh -> sp_offset - alloc_offset ; if ( offset > <NUM_LIT> && offset < SEH_MAX_FRAME_SIZE ) fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ; }


<s> if ( * bufptr == '_' ) found = bufptr ; while ( * bufptr && ! ISSPACE ( * bufptr ) ) ++ bufptr ; if ( * bufptr ) * bufptr = <NUM_LIT> ;

if ( found ) * wrappers -> find_slot ( found , INSERT ) = found ;


<s> void i386_pe_asm_named_section ( const char * name , unsigned int flags , tree decl ) { char flagchars [ <NUM_LIT> ] , * f = flagchars ; if ( ( flags & SECTION_EXCLUDE ) != <NUM_LIT> ) * f ++ = 'e' ; if ( ( flags & ( SECTION_CODE | SECTION_WRITE ) ) == <NUM_LIT> ) { * f ++ = 'd' ; * f ++ = 'r' ; } else { if ( flags & SECTION_CODE ) * f ++ = 'x' ; if ( flags & SECTION_WRITE ) * f ++ = 'w' ; if ( flags & SECTION_PE_SHARED ) * f ++ = 's' ; if ( ( flags & SECTION_EXCLUDE ) != <NUM_LIT> ) * f ++ = 'n' ; } if ( startswith ( name , LTO_SECTION_NAME_PREFIX ) ) * f ++ = '0' ; * f = '\0' ; fprintf ( asm_out_file , <STR_LIT> , name , flagchars ) ;


<s> i386_pe_maybe_record_exported_symbol ( decl , name , <NUM_LIT> ) ; fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , name ) ; if ( use_pe_aligned_common ) fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , size ? size : HOST_WIDE_INT_1 , exact_log2 ( align ) - exact_log2 ( CHAR_BIT ) ) ;


<s> if ( ! decl || ! lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) return ;

if ( ! DECL_ARTIFICIAL ( decl ) ) warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> ) ;


<s> if ( ! DECL_ARTIFICIAL ( decl ) ) warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> ) ;


<s> if ( ( TREE_CODE ( exp ) == VAR_DECL || TREE_CODE ( exp ) == FUNCTION_DECL ) && DECL_DLLIMPORT_P ( exp ) ) return false ; if ( DECL_P ( exp ) && ! lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( exp ) ) && TREE_PUBLIC ( exp ) && DECL_EXTERNAL ( exp ) ) return true ;

if ( DECL_P ( exp ) && TREE_CODE ( exp ) == FUNCTION_DECL && TREE_PUBLIC ( exp ) && DECL_ONE_ONLY ( exp ) && ! DECL_EXTERNAL ( exp ) && DECL_DECLARED_INLINE_P ( exp ) ) return false ;


<s> if ( DECL_P ( exp ) && TREE_CODE ( exp ) == FUNCTION_DECL && TREE_PUBLIC ( exp ) && DECL_ONE_ONLY ( exp ) && ! DECL_EXTERNAL ( exp ) && DECL_DECLARED_INLINE_P ( exp ) ) return false ;

return default_binds_local_p_1 ( exp , <NUM_LIT> ) ;


<s> fprintf ( file , <STR_LIT> , pub ? ( int ) C_EXT : ( int ) C_STAT , ( int ) DT_FCN << N_BTSHFT ) ;


<s> if ( ! TREE_PUBLIC ( decl ) ) return false ; if ( TREE_CODE ( decl ) == FUNCTION_DECL && DECL_DECLARED_INLINE_P ( decl ) && ! flag_keep_inline_dllexport ) return false ; if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) return true ;


<s> if ( TREE_CODE ( decl ) == FUNCTION_DECL && DECL_DECLARED_INLINE_P ( decl ) && ! flag_keep_inline_dllexport ) return false ; if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) return true ; return false ;


if ( assoc && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( assoc ) ) && TREE_CODE ( decl ) == VAR_DECL && TREE_STATIC ( decl ) && TREE_PUBLIC ( decl ) && ! DECL_EXTERNAL ( decl ) && ! DECL_VIRTUAL_P ( decl ) ) error ( <STR_LIT> <STR_LIT> , decl ) ;


<s> void i386_pe_encode_section_info ( tree decl , rtx rtl , int first ) { rtx symbol ; int flags ; default_encode_section_info ( decl , rtl , first ) ; if ( ! MEM_P ( rtl ) ) return ; symbol = XEXP ( rtl , <NUM_LIT> ) ;

gcc_assert ( GET_CODE ( symbol ) == SYMBOL_REF ) ;


<s> default : return ; } flags = ( SYMBOL_REF_FLAGS ( symbol ) & ~ ( SYMBOL_FLAG_DLLIMPORT | SYMBOL_FLAG_DLLEXPORT ) ) ; if ( i386_pe_determine_dllexport_p ( decl ) ) flags |= SYMBOL_FLAG_DLLEXPORT ; else if ( i386_pe_determine_dllimport_p ( decl ) ) flags |= SYMBOL_FLAG_DLLIMPORT ; SYMBOL_REF_FLAGS ( symbol ) = flags ;


<s> void i386_pe_end_cold_function ( FILE * f , const char * , tree ) { i386_pe_seh_fini ( f , true ) ;


<s> } if ( stub_head ) { struct stub_list * q ; for ( q = stub_head ; q != NULL ; q = q -> next ) { const char * name = q -> name ; const char * oname ; if ( name [ <NUM_LIT> ] == '*' ) ++ name ; oname = name ; if ( name [ <NUM_LIT> ] == '.' ) ++ name ; if ( ! startswith ( name , <STR_LIT> ) ) continue ; name += <NUM_LIT> ;

fprintf ( asm_out_file , <STR_LIT> <STR_LIT> <STR_LIT> , oname , oname ) ;


<s> const char * stripped = targetm . strip_name_encoding ( skipped ) ; if ( * name != '*' && * user_label_prefix && * stripped != FASTCALL_PREFIX ) stripped = ACONCAT ( ( user_label_prefix , stripped , NULL ) ) ; return get_identifier ( stripped ) ;


new_id = gen_stdcall_or_fastcall_suffix ( decl , id , false ) ;


<s> tree new_id = NULL_TREE ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { unsigned int ccvt = ix86_get_callcvt ( TREE_TYPE ( decl ) ) ; if ( ( ccvt & IX86_CALLCVT_STDCALL ) != <NUM_LIT> ) { if ( TARGET_RTD ) return NULL_TREE ; new_id = gen_stdcall_or_fastcall_suffix ( decl , id , false ) ;


<s> if ( ! SYMBOL_REF_DLLEXPORT_P ( symbol ) ) return ; gcc_assert ( TREE_PUBLIC ( decl ) ) ; p = ggc_alloc < export_list > ( ) ; p -> next = export_head ; p -> name = name ; p -> is_data = is_data ; export_head = p ;


<s> void i386_pe_record_external_function ( tree decl , const char * name ) {


<s> void i386_pe_record_stub ( const char * name ) { struct stub_list * p ; if ( ! name || * name == <NUM_LIT> ) return ; p = stub_head ;


<s> p = stub_head ; while ( p != NULL ) { if ( p -> name [ <NUM_LIT> ] == * name && ! strcmp ( p -> name , name ) ) return ; p = p -> next ; } p = ggc_alloc < stub_list > ( ) ; p -> next = stub_head ;


<s> if ( decl && TREE_CODE ( decl ) == VAR_DECL && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) flags |= SECTION_PE_SHARED ; } if ( decl && DECL_P ( decl ) && DECL_ONE_ONLY ( decl ) ) flags |= SECTION_LINKONCE ;


<s> } if ( seh -> cfa_reg != stack_pointer_rtx ) { offset = alloc_offset - seh -> cfa_offset ; gcc_assert ( ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; gcc_assert ( IN_RANGE ( offset , <NUM_LIT> , <NUM_LIT> ) ) ; fputs ( <STR_LIT> , f ) ; print_reg ( seh -> cfa_reg , <NUM_LIT> , f ) ; fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ; } if ( alloc_offset != seh -> sp_offset ) { offset = seh -> sp_offset - alloc_offset ; if ( offset > <NUM_LIT> && offset < SEH_MAX_FRAME_SIZE ) fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ; for ( int regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( seh -> reg_offset [ regno ] > alloc_offset ) { if ( SSE_REGNO_P ( regno ) ) fputs ( <STR_LIT> , f ) ; else if ( GENERAL_REGNO_P ( regno ) ) fputs ( <STR_LIT> , f ) ; else gcc_unreachable ( ) ; print_reg ( gen_rtx_REG ( DImode , regno ) , <NUM_LIT> , f ) ; fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , seh -> sp_offset - seh -> reg_offset [ regno ] ) ; }


<s> else alloc_offset = MIN ( seh -> cfa_offset + <NUM_LIT> , seh -> sp_offset ) ; offset = alloc_offset - INCOMING_FRAME_SP_OFFSET ; if ( offset > <NUM_LIT> ) fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ; for ( int regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( seh -> reg_offset [ regno ] > <NUM_LIT> && seh -> reg_offset [ regno ] <= alloc_offset ) { if ( SSE_REGNO_P ( regno ) ) fputs ( <STR_LIT> , f ) ; else if ( GENERAL_REGNO_P ( regno ) ) fputs ( <STR_LIT> , f ) ; else gcc_unreachable ( ) ; print_reg ( gen_rtx_REG ( DImode , regno ) , <NUM_LIT> , f ) ; fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , alloc_offset - seh -> reg_offset [ regno ] ) ; } if ( seh -> cfa_reg != stack_pointer_rtx ) { offset = alloc_offset - seh -> cfa_offset ; gcc_assert ( ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; gcc_assert ( IN_RANGE ( offset , <NUM_LIT> , <NUM_LIT> ) ) ; fputs ( <STR_LIT> , f ) ; print_reg ( seh -> cfa_reg , <NUM_LIT> , f ) ; fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ; } if ( alloc_offset != seh -> sp_offset ) { offset = seh -> sp_offset - alloc_offset ; if ( offset > <NUM_LIT> && offset < SEH_MAX_FRAME_SIZE ) fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ; for ( int regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( seh -> reg_offset [ regno ] > alloc_offset ) { if ( SSE_REGNO_P ( regno ) ) fputs ( <STR_LIT> , f ) ; else if ( GENERAL_REGNO_P ( regno ) ) fputs ( <STR_LIT> , f ) ; else gcc_unreachable ( ) ; print_reg ( gen_rtx_REG ( DImode , regno ) , <NUM_LIT> , f ) ; fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , seh -> sp_offset - seh -> reg_offset [ regno ] ) ; } }


<s> int flags = <NUM_LIT> ; if ( ! TARGET_SEH ) return ; fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , personality ) ; eh_region r ; FOR_ALL_EH_REGION ( r ) { if ( r -> type == ERT_CLEANUP ) flags |= <NUM_LIT> ; else flags |= <NUM_LIT> ;


<s> if ( r -> type == ERT_CLEANUP ) flags |= <NUM_LIT> ; else flags |= <NUM_LIT> ; } flags = <NUM_LIT> ; if ( flags & <NUM_LIT> ) fputs ( <STR_LIT> , asm_out_file ) ; if ( flags & <NUM_LIT> ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> cfun -> machine -> seh -> after_prologue = true ;


<s> if ( ! TARGET_SEH ) return ; if ( cfun -> is_thunk ) return ; cfun -> machine -> seh -> after_prologue = true ; fputs ( <STR_LIT> , f ) ;


<s> if ( ! TARGET_SEH ) return ; if ( cfun -> is_thunk ) return ; seh = cfun -> machine -> seh ; if ( cold != seh -> in_cold_section ) return ; XDELETE ( seh ) ; cfun -> machine -> seh = NULL ; fputs ( <STR_LIT> , f ) ;


<s> if ( ! TARGET_SEH ) return ; if ( cfun -> is_thunk ) return ; gcc_assert ( ! stack_realign_drap ) ; seh = XCNEW ( struct seh_frame_state ) ; cfun -> machine -> seh = seh ;

seh -> sp_offset = INCOMING_FRAME_SP_OFFSET ;


<s> fputs ( <STR_LIT> , f ) ; assemble_name ( f , IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( cfun -> decl ) ) ) ; fputc ( '\n' , f ) ;


<s> void i386_pe_seh_init_sections ( void ) {


<s> pat = XEXP ( note , <NUM_LIT> ) ; if ( pat == NULL ) { pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; } seh_cfa_adjust_cfa ( out_file , seh , pat ) ; handled_one = true ; break ; case REG_CFA_OFFSET : pat = XEXP ( note , <NUM_LIT> ) ; if ( pat == NULL ) pat = single_set ( insn ) ; seh_cfa_offset ( out_file , seh , pat ) ; handled_one = true ; break ;


<s> if ( ! TARGET_SEH ) return ; seh = cfun -> machine -> seh ; if ( NOTE_P ( insn ) && NOTE_KIND ( insn ) == NOTE_INSN_SWITCH_TEXT_SECTIONS ) { rtx_insn * prev = prev_active_insn ( insn ) ; if ( prev && ( CALL_P ( prev ) || ! insn_nothrow_p ( prev ) ) ) fputs ( <STR_LIT> , out_file ) ; fputs ( <STR_LIT> , out_file ) ; seh -> in_cold_section = true ; return ; } if ( NOTE_P ( insn ) || ! RTX_FRAME_RELATED_P ( insn ) ) return ; if ( seh -> after_prologue ) return ;

for ( note = REG_NOTES ( insn ) ; note ; note = XEXP ( note , <NUM_LIT> ) ) {


<s> i386_pe_declare_function_type ( f , name , TREE_PUBLIC ( decl ) ) ; if ( decl != NULL_TREE ) switch_to_section ( function_section ( decl ) ) ;


<s> const char * p ; const char * name = default_strip_name_encoding ( str ) ; if ( * name == '@' ) name ++ ; p = strchr ( name , '@' ) ; if ( p ) return ggc_alloc_string ( name , p - name ) ; return name ;


<s> p = strchr ( name , '@' ) ; if ( p ) return ggc_alloc_string ( name , p - name ) ; return name ;


<s> if ( TREE_CODE ( decl ) == FUNCTION_DECL ) prefix = <STR_LIT> ; else if ( decl_readonly_section ( decl , reloc ) ) prefix = <STR_LIT> ; else prefix = <STR_LIT> ; len = strlen ( name ) + strlen ( prefix ) ; string = XALLOCAVEC ( char , len + <NUM_LIT> ) ; sprintf ( string , <STR_LIT> , prefix , name ) ; set_decl_section_name ( decl , string ) ;


<s> bool i386_pe_valid_dllimport_attribute_p ( const_tree decl ) { if ( TARGET_NOP_FUN_DLLIMPORT && TREE_CODE ( decl ) == FUNCTION_DECL ) return false ;


<s> if ( TREE_CODE ( decl ) != VAR_DECL || ! TREE_PUBLIC ( decl ) ) error ( <STR_LIT> <STR_LIT> , name ) ; else { make_decl_one_only ( decl , DECL_ASSEMBLER_NAME ( decl ) ) ; DECL_COMMON ( decl ) = <NUM_LIT> ; } * no_add_attrs = true ; return NULL_TREE ;


<s> tree ix86_handle_shared_attribute ( tree * node , tree name , tree , int , bool * no_add_attrs ) { if ( TREE_CODE ( * node ) != VAR_DECL ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; } return NULL_TREE ;


<s> } gcc_assert ( src == stack_pointer_rtx ) ; gcc_assert ( seh -> cfa_reg == stack_pointer_rtx ) ; dest_regno = REGNO ( dest ) ; if ( dest_regno == STACK_POINTER_REGNUM ) seh_emit_stackalloc ( f , seh , reg_offset ) ; else if ( dest_regno == HARD_FRAME_POINTER_REGNUM ) { HOST_WIDE_INT offset ; seh -> cfa_reg = dest ; seh -> cfa_offset -= reg_offset ; offset = seh -> sp_offset - seh -> cfa_offset ;

gcc_assert ( ( offset & <NUM_LIT> ) == <NUM_LIT> ) ;


<s> } gcc_assert ( src == stack_pointer_rtx ) ; gcc_assert ( seh -> cfa_reg == stack_pointer_rtx ) ; dest_regno = REGNO ( dest ) ; if ( dest_regno == STACK_POINTER_REGNUM ) seh_emit_stackalloc ( f , seh , reg_offset ) ; else if ( dest_regno == HARD_FRAME_POINTER_REGNUM ) { HOST_WIDE_INT offset ; seh -> cfa_reg = dest ; seh -> cfa_offset -= reg_offset ; offset = seh -> sp_offset - seh -> cfa_offset ; gcc_assert ( ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; gcc_assert ( IN_RANGE ( offset , <NUM_LIT> , <NUM_LIT> ) ) ; fputs ( <STR_LIT> , f ) ; print_reg ( seh -> cfa_reg , <NUM_LIT> , f ) ; fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ;


<s> dest = SET_DEST ( pat ) ; src = SET_SRC ( pat ) ; gcc_assert ( MEM_P ( dest ) ) ; dest = XEXP ( dest , <NUM_LIT> ) ; if ( REG_P ( dest ) ) reg_offset = <NUM_LIT> ; else { gcc_assert ( GET_CODE ( dest ) == PLUS ) ; reg_offset = INTVAL ( XEXP ( dest , <NUM_LIT> ) ) ; dest = XEXP ( dest , <NUM_LIT> ) ; } gcc_assert ( dest == seh -> cfa_reg ) ; seh_emit_save ( f , seh , src , seh -> cfa_offset - reg_offset ) ;


<s> seh -> sp_offset += UNITS_PER_WORD ; seh -> reg_offset [ regno ] = seh -> sp_offset ; if ( seh -> cfa_reg == stack_pointer_rtx ) seh -> cfa_offset += UNITS_PER_WORD ; fputs ( <STR_LIT> , f ) ; print_reg ( reg , <NUM_LIT> , f ) ; fputc ( '\n' , f ) ;


<s> static void seh_emit_save ( FILE * f , struct seh_frame_state * seh , rtx reg , HOST_WIDE_INT cfa_offset ) { const unsigned int regno = REGNO ( reg ) ; HOST_WIDE_INT offset ; seh -> reg_offset [ regno ] = cfa_offset ; gcc_assert ( seh -> sp_offset >= cfa_offset ) ;

offset = seh -> sp_offset - cfa_offset ;


<s> static void seh_emit_stackalloc ( FILE * f , struct seh_frame_state * seh , HOST_WIDE_INT offset ) { gcc_assert ( offset < <NUM_LIT> ) ;


<s> seh -> sp_offset += offset ; if ( offset < SEH_MAX_FRAME_SIZE ) fprintf ( f , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , offset ) ;