<s> rws_sum [ regno ] . written_by_fp |= flags . is_fp ; rws_sum [ regno ] . written_by_and = flags . is_and ; rws_sum [ regno ] . written_by_or = flags . is_or ;


<s> if ( pred ) rws_sum [ regno ] . write_count ++ ; else rws_sum [ regno ] . write_count = <NUM_LIT> ; rws_sum [ regno ] . written_by_fp |= flags . is_fp ;

rws_sum [ regno ] . written_by_and = flags . is_and ;


<s> int t ; saved_first_instruction = first_instruction ; in_safe_group_barrier = <NUM_LIT> ; t = group_barrier_needed ( insn ) ; first_instruction = saved_first_instruction ; in_safe_group_barrier = <NUM_LIT> ; return t ;


<s> if ( last && recog_memoized ( last ) >= <NUM_LIT> ) return <NUM_LIT> ; for ( ;

last != NULL && ! NOTE_INSN_BASIC_BLOCK_P ( last ) && ! stops_p [ INSN_UID ( last ) ] ;


<s> last != NULL && ! NOTE_INSN_BASIC_BLOCK_P ( last ) && ! stops_p [ INSN_UID ( last ) ] ; last = PREV_INSN ( last ) ) if ( INSN_P ( last ) && recog_memoized ( last ) >= <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> spill_fill_data . save_gr_used_mask = current_frame_info . gr_used_mask ; spill_fill_data . n_iter = <NUM_LIT> + ( n_spills > <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < spill_fill_data . n_iter ; ++ i ) { int regno = next_scratch_gr_reg ( ) ; spill_fill_data . iter_reg [ i ] = gen_rtx_REG ( DImode , regno ) ; current_frame_info . gr_used_mask |= <NUM_LIT> << regno ;


<s> if ( ! ia64_spec_check_src_p ( src ) ) flags . is_branch = <NUM_LIT> ; return rtx_needs_barrier ( src , flags , pred ) ; } if ( ia64_spec_check_src_p ( src ) ) { gcc_assert ( REG_P ( XEXP ( src , <NUM_LIT> ) ) ) ; need_barrier = rtx_needs_barrier ( XEXP ( src , <NUM_LIT> ) , flags , pred ) ; src = XEXP ( src , <NUM_LIT> ) ; } need_barrier |= rtx_needs_barrier ( src , flags , pred ) ; dst = SET_DEST ( x ) ; if ( GET_CODE ( dst ) == ZERO_EXTRACT ) { need_barrier |= rtx_needs_barrier ( XEXP ( dst , <NUM_LIT> ) , flags , pred ) ;


<s> need_barrier = rtx_needs_barrier ( XEXP ( src , <NUM_LIT> ) , flags , pred ) ; src = XEXP ( src , <NUM_LIT> ) ; } need_barrier |= rtx_needs_barrier ( src , flags , pred ) ; dst = SET_DEST ( x ) ; if ( GET_CODE ( dst ) == ZERO_EXTRACT ) { need_barrier |= rtx_needs_barrier ( XEXP ( dst , <NUM_LIT> ) , flags , pred ) ; need_barrier |= rtx_needs_barrier ( XEXP ( dst , <NUM_LIT> ) , flags , pred ) ;


<s> HOST_WIDE_INT disp = spill_fill_data . prev_off [ iter ] - cfa_off ; rtx disp_rtx = GEN_INT ( disp ) ; rtx mem ; if ( spill_fill_data . prev_addr [ iter ] ) { if ( satisfies_constraint_N ( disp_rtx ) ) { * spill_fill_data . prev_addr [ iter ] = gen_rtx_POST_MODIFY ( DImode , spill_fill_data . iter_reg [ iter ] , gen_rtx_PLUS ( DImode , spill_fill_data . iter_reg [ iter ] , disp_rtx ) ) ; add_reg_note ( spill_fill_data . prev_insn [ iter ] , REG_INC , spill_fill_data . iter_reg [ iter ] ) ; } else { if ( ! satisfies_constraint_I ( disp_rtx ) ) { rtx tmp = gen_rtx_REG ( DImode , next_scratch_gr_reg ( ) ) ; emit_move_insn ( tmp , disp_rtx ) ; disp_rtx = tmp ; } emit_insn ( gen_adddi3 ( spill_fill_data . iter_reg [ iter ] , spill_fill_data . iter_reg [ iter ] , disp_rtx ) ) ; } } else if ( disp == <NUM_LIT> && spill_fill_data . init_reg [ iter ] == stack_pointer_rtx && frame_pointer_needed ) { mem = gen_rtx_MEM ( GET_MODE ( reg ) , hard_frame_pointer_rtx ) ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; return mem ; } else { rtx seq ; rtx_insn * insn ; if ( disp == <NUM_LIT> ) seq = gen_movdi ( spill_fill_data . iter_reg [ iter ] , spill_fill_data . init_reg [ iter ] ) ; else { start_sequence ( ) ;


<s> rtx memt = assign_stack_temp ( TImode , <NUM_LIT> ) ; emit_move_insn ( memt , SUBREG_REG ( in ) ) ; return adjust_address ( memt , mode , <NUM_LIT> ) ; } else if ( force && GET_CODE ( in ) == REG ) {

rtx memx = assign_stack_temp ( mode , <NUM_LIT> ) ;


<s> static enum tls_model tls_symbolic_operand_type ( rtx addr ) { enum tls_model tls_kind = TLS_MODEL_NONE ; if ( GET_CODE ( addr ) == CONST ) { if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) tls_kind = SYMBOL_REF_TLS_MODEL ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ; } else if ( GET_CODE ( addr ) == SYMBOL_REF ) tls_kind = SYMBOL_REF_TLS_MODEL ( addr ) ; return tls_kind ;


if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) tls_kind = SYMBOL_REF_TLS_MODEL ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ) ;


<s> static int try_issue_nops ( struct bundle_state * curr_state , int nops_num ) { int i ; for ( i = <NUM_LIT> ; i < nops_num ; i ++ ) if ( state_transition ( curr_state -> dfa_state , ia64_nop ) >= <NUM_LIT> ) { free_bundle_state ( curr_state ) ; return FALSE ; } return TRUE ;


<s> return ( INSN_P ( insn ) && ia64_safe_itanium_class ( insn ) == ITANIUM_CLASS_UNKNOWN && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER ) ;


<s> static bool unknown_for_bundling_p ( rtx_insn * insn ) {

return ( INSN_P ( insn ) && ia64_safe_itanium_class ( insn ) == ITANIUM_CLASS_UNKNOWN && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER ) ;


<s> else if ( GET_CODE ( src ) == AND ) pflags -> is_and = <NUM_LIT> ; else if ( GET_CODE ( src ) == IOR ) pflags -> is_or = <NUM_LIT> ;


<s> struct sigcontext * sc ; } * frame_ = ( struct sigframe * ) context -> psp ; struct sigcontext * sc = frame_ -> sc ; { int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) context -> ireg [ i - <NUM_LIT> ] . loc = & sc -> sc_gr [ i ] ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) context -> ireg [ i - <NUM_LIT> ] . loc = & sc -> sc_gr [ i ] ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) context -> ireg [ i - <NUM_LIT> ] . loc = & sc -> sc_gr [ i ] ; } context -> fpsr_loc = & ( sc -> sc_ar_fpsr ) ; context -> pfs_loc = & ( sc -> sc_ar_pfs ) ; context -> lc_loc = & ( sc -> sc_ar_lc ) ; context -> unat_loc = & ( sc -> sc_ar_unat ) ; context -> br_loc [ <NUM_LIT> ] = & ( sc -> sc_br [ <NUM_LIT> ] ) ;


<s> } context -> fpsr_loc = & ( sc -> sc_ar_fpsr ) ; context -> pfs_loc = & ( sc -> sc_ar_pfs ) ; context -> lc_loc = & ( sc -> sc_ar_lc ) ; context -> unat_loc = & ( sc -> sc_ar_unat ) ; context -> br_loc [ <NUM_LIT> ] = & ( sc -> sc_br [ <NUM_LIT> ] ) ; context -> br_loc [ <NUM_LIT> ] = & ( sc -> sc_br [ <NUM_LIT> ] ) ; context -> br_loc [ <NUM_LIT> ] = & ( sc -> sc_br [ <NUM_LIT> ] ) ; context -> pr = sc -> sc_pr ; context -> psp = sc -> sc_gr [ <NUM_LIT> ] ; context -> gp = sc -> sc_gr [ <NUM_LIT> ] ; fs -> no_reg_stack_frame = <NUM_LIT> ; if ( sc -> sc_rbs_base ) { long ndirty , loadrs = sc -> sc_loadrs >> <NUM_LIT> ; unsigned long alt_bspstore = context -> bsp - loadrs ; unsigned long bspstore ; unsigned long * ar_bsp = ( unsigned long * ) ( sc -> sc_ar_bsp ) ;

ndirty = ia64_rse_num_regs ( ( unsigned long * ) alt_bspstore , ( unsigned long * ) context -> bsp ) ;


<s> int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) context -> ireg [ i - <NUM_LIT> ] . loc = & sc -> sc_gr [ i ] ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) context -> ireg [ i - <NUM_LIT> ] . loc = & sc -> sc_gr [ i ] ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) context -> ireg [ i - <NUM_LIT> ] . loc = & sc -> sc_gr [ i ] ; } context -> pfs_loc = & ( sc -> sc_ar_pfs ) ; context -> lc_loc = & ( sc -> sc_ar_lc ) ; context -> unat_loc = & ( sc -> sc_ar_unat ) ; context -> br_loc [ <NUM_LIT> ] = & ( sc -> sc_br [ <NUM_LIT> ] ) ; context -> br_loc [ <NUM_LIT> ] = & ( sc -> sc_br [ <NUM_LIT> ] ) ; context -> br_loc [ <NUM_LIT> ] = & ( sc -> sc_br [ <NUM_LIT> ] ) ; context -> pr = sc -> sc_pr ; context -> gp = sc -> sc_gr [ <NUM_LIT> ] ; fs -> no_reg_stack_frame = <NUM_LIT> ; if ( sc -> sc_rbs_base ) { long ndirty , loadrs = sc -> sc_loadrs >> <NUM_LIT> ; unsigned long alt_bspstore = context -> bsp - loadrs ; unsigned long bspstore ; unsigned long * ar_bsp = ( unsigned long * ) ( sc -> sc_ar_bsp ) ; ndirty = ia64_rse_num_regs ( ( unsigned long * ) alt_bspstore , ( unsigned long * ) context -> bsp ) ; bspstore = ( unsigned long ) ia64_rse_skip_regs ( ar_bsp , - ndirty ) ; ia64_copy_rbs ( context , bspstore , alt_bspstore , loadrs , sc -> sc_ar_rnat ) ; } {

unsigned long sof = sc -> sc_cfm & <NUM_LIT> ;


<s> if ( _U_Qfcmp ( a , b , <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; return ( _U_Qfcmp ( a , b , <NUM_LIT> ) != <NUM_LIT> ? <NUM_LIT> : - <NUM_LIT> ) ;


<s> if ( _U_Qfcmp ( a , b , <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ;

return ( _U_Qfcmp ( a , b , <NUM_LIT> ) != <NUM_LIT> ? <NUM_LIT> : - <NUM_LIT> ) ;


<s> int _U_Qfeq ( long double a , long double b ) {

return ( _U_Qfcmp ( a , b , <NUM_LIT> ) != <NUM_LIT> ) ;


<s> return ( _U_Qfcmp ( a , b , <NUM_LIT> ) != <NUM_LIT> ) ;


<s> int _U_Qfge ( long double a , long double b ) {


<s> int _U_Qfgt ( long double a , long double b ) { return ( _U_Qfcmp ( a , b , <NUM_LIT> ) != <NUM_LIT> ) ;


<s> int _U_Qfle ( long double a , long double b ) { return ( _U_Qfcmp ( a , b , <NUM_LIT> ) != <NUM_LIT> ) ;


<s> int _U_Qfle ( long double a , long double b ) {


<s> int _U_Qfne ( long double a , long double b ) { return ( _U_Qfcmp ( a , b , <NUM_LIT> ) == <NUM_LIT> ) ;


<s> long double _U_Qfneg ( long double a ) { return ( <NUM_LIT> - a ) ;


<s> long double _U_Qfneg ( long double a ) {


<s> static struct unw_table_entry * find_fde_for_dso ( Elf64_Addr pc , rt_link_map * map , unsigned long * pseg_base , unsigned long * pgp ) { rt_segment * seg ; Elf64_Addr seg_base ; struct unw_table_entry * f_base ; size_t lo , hi ; for ( seg = map -> l_segments ; seg ; seg = ( rt_segment * ) seg -> s_next ) { if ( pc >= seg -> s_map_addr && pc < seg -> s_map_addr + seg -> s_mapsz ) break ; } if ( ! seg ) return NULL ; f_base = ( struct unw_table_entry * ) ( map -> l_unwind_table ) ; seg_base = ( Elf64_Addr ) seg -> s_map_addr ; lo = <NUM_LIT> ; hi = map -> l_unwind_sz / sizeof ( struct unw_table_entry ) ; while ( lo < hi ) { size_t mid = ( lo + hi ) / <NUM_LIT> ; struct unw_table_entry * f = f_base + mid ; if ( pc < f -> start_offset + seg_base ) hi = mid ; else if ( pc >= f -> end_offset + seg_base ) lo = mid + <NUM_LIT> ; else { Elf64_Dyn * dyn = map -> l_ld ; * pgp = <NUM_LIT> ; for ( ; dyn -> d_tag != DT_NULL ; dyn ++ ) { if ( dyn -> d_tag == DT_PLTGOT ) { * pgp = dyn -> d_un . d_ptr ; break ; } } * pseg_base = seg_base ;


<s> } for ( map = _r_debug . r_map ; map ; map = map -> l_next ) { if ( ! map -> l_name ) continue ; ret = find_fde_for_dso ( ( Elf64_Addr ) pc , map , pseg_base , pgp ) ;


<s> switch ( ireg -> nat . type ) { case UNW_NAT_VAL : if ( write ) { if ( * nat ) { addr [ <NUM_LIT> ] = <NUM_LIT> ; addr [ <NUM_LIT> ] = <NUM_LIT> ; return ; } addr [ <NUM_LIT> ] = <NUM_LIT> ; } else if ( addr [ <NUM_LIT> ] == <NUM_LIT> && addr [ <NUM_LIT> ] == <NUM_LIT> ) { * val = <NUM_LIT> ; * nat = <NUM_LIT> ; return ; } case UNW_NAT_NONE : dummy_nat = <NUM_LIT> ; nat_addr = & dummy_nat ; break ; case UNW_NAT_MEMSTK : nat_mask = <NUM_LIT> << ( ( long ) addr & <NUM_LIT> ) / <NUM_LIT> ; break ; case UNW_NAT_REGSTK : if ( ( unsigned long ) addr >= info -> regstk_top ) nat_addr = & info -> rnat ;

else nat_addr = ia64_rse_rnat_addr ( addr ) ;


<s> static void uw_advance_context ( struct _Unwind_Context * context , _Unwind_FrameState * fs ) {


<s> length = UNW_LENGTH ( header ) ; if ( UNW_FLAG_EHANDLER ( header ) | UNW_FLAG_UHANDLER ( header ) ) { fs -> personality = * ( _Unwind_Personality_Fn * ) ( unw [ length + <NUM_LIT> ] + context -> gp ) ; context -> lsda = unw + length + <NUM_LIT> ; } insn = ( unsigned char * ) ( unw + <NUM_LIT> ) ; insn_end = ( unsigned char * ) ( unw + <NUM_LIT> + length ) ; while ( ! fs -> done && insn < insn_end ) insn = unw_decode ( insn , fs -> in_body , fs ) ; free_label_states ( fs -> labeled_states ) ; free_state_stack ( & fs -> curr ) ; if ( reg_state_alloced || labeled_state_alloced ) abort ( ) ; if ( fs -> when_target > fs -> epilogue_start ) { struct unw_reg_info * r ; fs -> curr . reg [ UNW_REG_PSP ] . where = UNW_WHERE_NONE ; fs -> curr . reg [ UNW_REG_PSP ] . val = <NUM_LIT> ; for ( r = fs -> curr . reg ; r < fs -> curr . reg + UNW_NUM_REGS ; ++ r ) if ( ( r -> where == UNW_WHERE_PSPREL && r -> val <= <NUM_LIT> ) || r -> where == UNW_WHERE_SPREL ) r -> where = UNW_WHERE_NONE ; } if ( fs -> curr . reg [ UNW_REG_RP ] . when >= fs -> when_target ) { fs -> curr . reg [ UNW_REG_RP ] . where = UNW_WHERE_BR ; fs -> curr . reg [ UNW_REG_RP ] . when = - <NUM_LIT> ; fs -> curr . reg [ UNW_REG_RP ] . val = fs -> return_link_reg ;


<s> fs -> curr . reg [ UNW_REG_RP ] . val = <NUM_LIT> ; return _URC_NO_REASON ; } return _URC_END_OF_STACK ; } context -> region_start = ent -> start_offset + segment_base ; fs -> when_target = ( ( context -> rp & - <NUM_LIT> ) - context -> region_start ) / <NUM_LIT> * <NUM_LIT> + ( context -> rp & <NUM_LIT> ) ; unw = ( unsigned long * ) ( ent -> info_offset + segment_base ) ; header = * unw ; length = UNW_LENGTH ( header ) ; if ( UNW_FLAG_EHANDLER ( header ) | UNW_FLAG_UHANDLER ( header ) ) { fs -> personality = * ( _Unwind_Personality_Fn * ) ( unw [ length + <NUM_LIT> ] + context -> gp ) ; context -> lsda = unw + length + <NUM_LIT> ; } insn = ( unsigned char * ) ( unw + <NUM_LIT> ) ; insn_end = ( unsigned char * ) ( unw + <NUM_LIT> + length ) ; while ( ! fs -> done && insn < insn_end ) insn = unw_decode ( insn , fs -> in_body , fs ) ; free_label_states ( fs -> labeled_states ) ;


<s> asm ( <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> : <STR_LIT> ( rnat ) , <STR_LIT> ( tmp1 ) , <STR_LIT> ( tmp2 ) ) ; memset ( context , <NUM_LIT> , sizeof ( struct _Unwind_Context ) ) ; context -> bsp = ( unsigned long ) bsp ;

context -> regstk_top = context -> bsp & ~ <NUM_LIT> ;


<s> asm ( <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> : <STR_LIT> ( rnat ) , <STR_LIT> ( tmp1 ) , <STR_LIT> ( tmp2 ) ) ; memset ( context , <NUM_LIT> , sizeof ( struct _Unwind_Context ) ) ; context -> bsp = ( unsigned long ) bsp ; context -> regstk_top = context -> bsp & ~ <NUM_LIT> ; context -> rnat = rnat ; context -> psp = ( unsigned long ) psp ; context -> rp = ( unsigned long ) rp ; asm ( <STR_LIT> : <STR_LIT> ( context -> sp ) ) ; asm ( <STR_LIT> : <STR_LIT> ( context -> pr ) ) ; context -> pri_unat_loc = & context -> initial_unat ; if ( uw_frame_state_for ( context , & fs ) != _URC_NO_REASON ) abort ( ) ; uw_update_context ( context , & fs ) ;


<s> char nat ; void * t = target -> ireg [ i - <NUM_LIT> ] . loc ; if ( t ) { unw_access_gr ( target , i , & ireg_buf [ i - <NUM_LIT> ] , & nat , <NUM_LIT> ) ; ireg_nat |= ( long ) nat << ( ( ( size_t ) & ireg_buf [ i - <NUM_LIT> ] >> <NUM_LIT> ) & <NUM_LIT> ) ; ireg_pr |= <NUM_LIT> << i ; } } target -> bsp = ( unsigned long ) ia64_rse_skip_regs ( ( unsigned long * ) target -> bsp , ( * target -> pfs_loc >> <NUM_LIT> ) & <NUM_LIT> ) ; if ( target -> bsp < target -> regstk_top ) target -> rnat = * ia64_rse_rnat_addr ( ( unsigned long * ) target -> bsp ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , rnat ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , bsp ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , psp ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , rp ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , pr ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , gp ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , pfs_loc ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , unat_loc ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , lc_loc ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , fpsr_loc ) ) ) ; asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , eh_data ) ) ) ;

asm volatile ( <STR_LIT> : : <STR_LIT> ( offsetof ( struct _Unwind_Context , br_loc ) ) ) ;


<s> uw_update_reg_address ( context , fs , i ) ; } for ( i = UNW_REG_BSP ; i < UNW_NUM_REGS ; ++ i ) uw_update_reg_address ( context , fs , i ) ; if ( ! ( fs -> no_reg_stack_frame ) ) { unsigned long pfs = * context -> pfs_loc ; unsigned long sol = ( pfs >> <NUM_LIT> ) & <NUM_LIT> ; context -> bsp = ( unsigned long ) ia64_rse_skip_regs ( ( unsigned long * ) context -> bsp , - sol ) ;


<s> else if ( rval >= <NUM_LIT> ) { context -> ireg [ regno - UNW_REG_R2 ] . nat = context -> ireg [ rval - <NUM_LIT> ] . nat ; } else if ( rval == <NUM_LIT> ) { context -> ireg [ regno - UNW_REG_R2 ] . nat . type = UNW_NAT_NONE ; context -> ireg [ regno - UNW_REG_R2 ] . nat . off = <NUM_LIT> ; } else abort ( ) ; break ; case UNW_WHERE_FR : context -> ireg [ regno - UNW_REG_R2 ] . nat . type = UNW_NAT_VAL ; context -> ireg [ regno - UNW_REG_R2 ] . nat . off = <NUM_LIT> ; break ; case UNW_WHERE_BR : context -> ireg [ regno - UNW_REG_R2 ] . nat . type = UNW_NAT_NONE ; context -> ireg [ regno - UNW_REG_R2 ] . nat . off = <NUM_LIT> ; break ; case UNW_WHERE_PSPREL : case UNW_WHERE_SPREL : context -> ireg [ regno - UNW_REG_R2 ] . nat . type = UNW_NAT_MEMSTK ; context -> ireg [ regno - UNW_REG_R2 ] . nat . off = context -> pri_unat_loc - ( unsigned long * ) addr ; break ; default : abort ( ) ; } break ; case UNW_REG_F2 ... UNW_REG_F31 : context -> fr_loc [ regno - UNW_REG_F2 ] = addr ; break ; case UNW_REG_B1 ... UNW_REG_B5 : context -> br_loc [ regno - UNW_REG_B0 ] = addr ; break ; case UNW_REG_BSP : context -> bsp_loc = addr ; break ; case UNW_REG_BSPSTORE : context -> bspstore_loc = addr ; break ; case UNW_REG_PFS : context -> pfs_loc = addr ; break ; case UNW_REG_RP : context -> rp = * ( unsigned long * ) addr ; break ; case UNW_REG_UNAT : context -> unat_loc = addr ; break ; case UNW_REG_PR : context -> pr = * ( unsigned long * ) addr ; break ; case UNW_REG_LC : context -> lc_loc = addr ; break ; case UNW_REG_FPSR : context -> fpsr_loc = addr ; break ; case UNW_REG_PSP :

context -> psp = * ( unsigned long * ) addr ;


else return ( void * ) ( segment_base + ent -> start_offset ) ;


<s> struct unw_table_entry * ent ; unsigned long segment_base , gp ;

ent = _Unwind_FindTableEntry ( pc , & segment_base , & gp ) ;


<s> _Unwind_Word _Unwind_GetBSP ( struct _Unwind_Context * context ) {


<s> _Unwind_Word _Unwind_GetCFA ( struct _Unwind_Context * context ) { return ( _Unwind_Ptr ) context -> psp ;


<s> struct unw_labeled_state * ls ; labeled_state_alloced ++ ; ls = malloc ( sizeof ( struct unw_labeled_state ) ) ; if ( ! ls ) {

int n = atomic_alloc ( & emergency_labeled_state_free ) ;


<s> reg_state_alloced ++ ; rs = malloc ( sizeof ( struct unw_reg_state ) ) ; if ( ! rs ) { int n = atomic_alloc ( & emergency_reg_state_free ) ; if ( n >= <NUM_LIT> ) rs = & emergency_reg_state [ n ] ; } return rs ;


<s> struct unw_reg_info * reg ; for ( reg = hi ; reg >= lo ; -- reg ) { if ( reg -> where == UNW_WHERE_SPILL_HOME ) { reg -> where = UNW_WHERE_PSPREL ; * offp -= regsize ; reg -> val = * offp ; } }


<s> unsigned int old = * mask , ret , new ; while ( <NUM_LIT> ) { if ( old == <NUM_LIT> ) return - <NUM_LIT> ; ret = old & - old ; new = old & ~ ret ; new = __sync_val_compare_and_swap ( mask , old , new ) ;


<s> __sync_xor_and_fetch ( mask , <NUM_LIT> << bit ) ;


<s> static inline void desc_abi ( unsigned char abi __attribute__ ( ( unused ) ) , unsigned char context __attribute__ ( ( unused ) ) , struct unw_state_record * sr __attribute__ ( ( unused ) ) ) {


<s> if ( brmask & <NUM_LIT> ) set_reg ( sr -> curr . reg + UNW_REG_B1 + i , UNW_WHERE_GR , sr -> region_start + sr -> region_len - <NUM_LIT> , gr ++ ) ;


<s> set_reg ( sr -> curr . reg + UNW_REG_B1 + i , UNW_WHERE_SPILL_HOME , sr -> region_start + sr -> region_len - <NUM_LIT> , <NUM_LIT> ) ; sr -> any_spills = <NUM_LIT> ; } brmask >>= <NUM_LIT> ; }


<s> static inline void desc_br_mem ( unsigned char brmask , struct unw_state_record * sr ) { int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { if ( brmask & <NUM_LIT> ) { set_reg ( sr -> curr . reg + UNW_REG_B1 + i , UNW_WHERE_SPILL_HOME , sr -> region_start + sr -> region_len - <NUM_LIT> , <NUM_LIT> ) ; sr -> any_spills = <NUM_LIT> ; } brmask >>= <NUM_LIT> ; }


<s> for ( ls = sr -> labeled_states ; ls ; ls = ls -> next ) { if ( ls -> label == label ) { free_state_stack ( & sr -> curr ) ;

memcpy ( & sr -> curr , & ls -> saved_state , sizeof ( sr -> curr ) ) ;


<s> static inline void desc_epilogue ( unw_word t , unw_word ecount , struct unw_state_record * sr ) { sr -> epilogue_start = sr -> region_start + sr -> region_len - <NUM_LIT> - t ; sr -> epilogue_count = ecount + <NUM_LIT> ;


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { if ( ( frmask & <NUM_LIT> ) != <NUM_LIT> ) { set_reg ( sr -> curr . reg + UNW_REG_F2 + i , UNW_WHERE_SPILL_HOME , sr -> region_start + sr -> region_len - <NUM_LIT> , <NUM_LIT> ) ; sr -> any_spills = <NUM_LIT> ; } frmask >>= <NUM_LIT> ;


<s> if ( ( frmask & <NUM_LIT> ) != <NUM_LIT> ) { set_reg ( sr -> curr . reg + UNW_REG_F2 + i , UNW_WHERE_SPILL_HOME , sr -> region_start + sr -> region_len - <NUM_LIT> , <NUM_LIT> ) ; sr -> any_spills = <NUM_LIT> ;


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { if ( ( grmask & <NUM_LIT> ) != <NUM_LIT> ) set_reg ( sr -> curr . reg + UNW_REG_R4 + i , UNW_WHERE_GR , sr -> region_start + sr -> region_len - <NUM_LIT> , gr ++ ) ; grmask >>= <NUM_LIT> ; }


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) { if ( ( grmask & <NUM_LIT> ) != <NUM_LIT> ) { set_reg ( sr -> curr . reg + UNW_REG_R4 + i , UNW_WHERE_SPILL_HOME , sr -> region_start + sr -> region_len - <NUM_LIT> , <NUM_LIT> ) ; sr -> any_spills = <NUM_LIT> ; } grmask >>= <NUM_LIT> ; }


<s> if ( qp > <NUM_LIT> ) { if ( ( sr -> pr_val & ( <NUM_LIT> << qp ) ) == <NUM_LIT> ) return <NUM_LIT> ; sr -> pr_mask |= ( <NUM_LIT> << qp ) ; } return <NUM_LIT> ;


<s> memcpy ( & ls -> saved_state , & sr -> curr , sizeof ( ls -> saved_state ) ) ; ls -> saved_state . next = dup_state_stack ( sr -> curr . next ) ;


<s> static inline void desc_mem_stack_f ( unw_word t , unw_word size , struct unw_state_record * sr ) {

set_reg ( sr -> curr . reg + UNW_REG_PSP , UNW_WHERE_NONE , sr -> region_start + MIN ( ( int ) t , sr -> region_len - <NUM_LIT> ) , <NUM_LIT> * size ) ;


<s> } for ( i = <NUM_LIT> ; i < sr -> epilogue_count ; ++ i ) pop ( sr ) ; sr -> epilogue_count = <NUM_LIT> ; sr -> epilogue_start = UNW_WHEN_NEVER ; if ( ! body ) push ( sr ) ; sr -> region_start += sr -> region_len ; sr -> region_len = rlen ; sr -> in_body = body ;


<s> static inline void desc_reg_gr ( unsigned char reg , unsigned char dst , struct unw_state_record * sr ) {

set_reg ( sr -> curr . reg + reg , UNW_WHERE_GR , sr -> region_start + sr -> region_len - <NUM_LIT> , dst ) ;


<s> static inline void desc_reg_psprel ( unsigned char reg , unw_word pspoff , struct unw_state_record * sr ) { set_reg ( sr -> curr . reg + reg , UNW_WHERE_PSPREL , sr -> region_start + sr -> region_len - <NUM_LIT> , <NUM_LIT> - <NUM_LIT> * pspoff ) ;


<s> if ( reg -> where == UNW_WHERE_NONE ) reg -> where = UNW_WHERE_GR_SAVE ; reg -> when = sr -> region_start + MIN ( ( int ) t , sr -> region_len - <NUM_LIT> ) ;


<s> static inline void desc_reg_when ( unsigned char regnum , unw_word t , struct unw_state_record * sr ) { struct unw_reg_info * reg = sr -> curr . reg + regnum ; if ( reg -> where == UNW_WHERE_NONE ) reg -> where = UNW_WHERE_GR_SAVE ; reg -> when = sr -> region_start + MIN ( ( int ) t , sr -> region_len - <NUM_LIT> ) ;


<s> r = sr -> curr . reg + decode_abreg ( abreg , <NUM_LIT> ) ; r -> where = UNW_WHERE_NONE ;

r -> when = sr -> region_start + MIN ( ( int ) t , sr -> region_len - <NUM_LIT> ) ;


<s> static inline void desc_spill_base ( unw_word pspoff , struct unw_state_record * sr ) {

sr -> spill_offset = <NUM_LIT> - <NUM_LIT> * pspoff ;


<s> static inline unsigned char * desc_spill_mask ( unsigned char * imaskp , struct unw_state_record * sr ) { sr -> imask = imaskp ; return imaskp + ( <NUM_LIT> * sr -> region_len + <NUM_LIT> ) / <NUM_LIT> ;


<s> sr -> imask = imaskp ; return imaskp + ( <NUM_LIT> * sr -> region_len + <NUM_LIT> ) / <NUM_LIT> ;


<s> r -> when = sr -> region_start + MIN ( ( int ) t , sr -> region_len - <NUM_LIT> ) ; r -> val = <NUM_LIT> - <NUM_LIT> * pspoff ;


<s> static inline void desc_spill_psprel_p ( unsigned char qp , unw_word t , unsigned char abreg , unw_word pspoff , struct unw_state_record * sr ) { struct unw_reg_info * r ; if ( ! desc_is_active ( qp , t , sr ) ) return ; r = sr -> curr . reg + decode_abreg ( abreg , <NUM_LIT> ) ; r -> where = UNW_WHERE_PSPREL ;


<s> struct unw_reg_info * r ; if ( ! desc_is_active ( qp , t , sr ) ) return ; if ( x ) where = UNW_WHERE_BR ; else if ( ytreg & <NUM_LIT> ) where = UNW_WHERE_FR ;

r = sr -> curr . reg + decode_abreg ( abreg , <NUM_LIT> ) ;


<s> r = sr -> curr . reg + decode_abreg ( abreg , <NUM_LIT> ) ; r -> where = where ;


<s> r = sr -> curr . reg + decode_abreg ( abreg , <NUM_LIT> ) ; r -> where = UNW_WHERE_SPREL ;


<s> static inline void desc_spill_sprel_p ( unsigned char qp , unw_word t , unsigned char abreg , unw_word spoff , struct unw_state_record * sr ) { struct unw_reg_info * r ; if ( ! desc_is_active ( qp , t , sr ) ) return ;


<s> static struct unw_reg_state * dup_state_stack ( struct unw_reg_state * rs ) { struct unw_reg_state * copy , * prev = NULL , * first = NULL ; while ( rs ) { copy = alloc_reg_state ( ) ;

memcpy ( copy , rs , sizeof ( * copy ) ) ;


<s> unsigned long off ; int i ; for ( i = <NUM_LIT> ; i < ( int ) sizeof ( save_order ) ; ++ i ) { reg = sr -> curr . reg + save_order [ i ] ; if ( reg -> where == UNW_WHERE_GR_SAVE ) { reg -> where = UNW_WHERE_GR ; reg -> val = sr -> gr_save_loc ++ ; } } if ( sr -> imask ) { static unsigned char const limit [ <NUM_LIT> ] = { UNW_REG_F31 , UNW_REG_R7 , UNW_REG_B5 } ; unsigned char kind , mask = <NUM_LIT> , * cp = sr -> imask ; int t ; struct unw_reg_info * ( regs [ <NUM_LIT> ] ) ; regs [ <NUM_LIT> ] = sr -> curr . reg + UNW_REG_F2 ; regs [ <NUM_LIT> ] = sr -> curr . reg + UNW_REG_R4 ; regs [ <NUM_LIT> ] = sr -> curr . reg + UNW_REG_B1 ; for ( t = <NUM_LIT> ; t < sr -> region_len ; ++ t ) { if ( ( t & <NUM_LIT> ) == <NUM_LIT> ) mask = * cp ++ ; kind = ( mask >> <NUM_LIT> * ( <NUM_LIT> - ( t & <NUM_LIT> ) ) ) & <NUM_LIT> ; if ( kind > <NUM_LIT> ) spill_next_when ( & regs [ kind - <NUM_LIT> ] , sr -> curr . reg + limit [ kind - <NUM_LIT> ] , sr -> region_start + t ) ; } } if ( sr -> any_spills ) { off = sr -> spill_offset ; alloc_spill_area ( & off , <NUM_LIT> , sr -> curr . reg + UNW_REG_F2 , sr -> curr . reg + UNW_REG_F31 ) ;

alloc_spill_area ( & off , <NUM_LIT> , sr -> curr . reg + UNW_REG_B1 , sr -> curr . reg + UNW_REG_B5 ) ;


<s> for ( t = <NUM_LIT> ; t < sr -> region_len ; ++ t ) { if ( ( t & <NUM_LIT> ) == <NUM_LIT> ) mask = * cp ++ ; kind = ( mask >> <NUM_LIT> * ( <NUM_LIT> - ( t & <NUM_LIT> ) ) ) & <NUM_LIT> ; if ( kind > <NUM_LIT> ) spill_next_when ( & regs [ kind - <NUM_LIT> ] , sr -> curr . reg + limit [ kind - <NUM_LIT> ] , sr -> region_start + t ) ; } } if ( sr -> any_spills ) { off = sr -> spill_offset ; alloc_spill_area ( & off , <NUM_LIT> , sr -> curr . reg + UNW_REG_F2 , sr -> curr . reg + UNW_REG_F31 ) ; alloc_spill_area ( & off , <NUM_LIT> , sr -> curr . reg + UNW_REG_B1 , sr -> curr . reg + UNW_REG_B5 ) ; alloc_spill_area ( & off , <NUM_LIT> , sr -> curr . reg + UNW_REG_R4 , sr -> curr . reg + UNW_REG_R7 ) ; }


<s> static void free_label_state ( struct unw_labeled_state * ls ) { labeled_state_alloced -- ; if ( PTR_IN ( emergency_labeled_state , ls ) ) atomic_free ( & emergency_labeled_state_free , emergency_labeled_state - ls ) ;


<s> free_state_stack ( & ls -> saved_state ) ; free_label_state ( ls ) ; }


<s> struct unw_reg_state * p , * next ; for ( p = rs -> next ; p != NULL ; p = next ) {


<s> return ia64_rse_slot_num ( addr ) == <NUM_LIT> ;


<s> static inline unsigned long * ia64_rse_rnat_addr ( unsigned long * slot_addr ) { return ( unsigned long * ) ( ( unsigned long ) slot_addr | ( <NUM_LIT> << <NUM_LIT> ) ) ;


<s> long delta = ia64_rse_slot_num ( addr ) + num_regs ; if ( num_regs < <NUM_LIT> ) delta -= <NUM_LIT> ; return addr + num_regs + delta / <NUM_LIT> ;


<s> struct unw_reg_state * rs = alloc_reg_state ( ) ;

memcpy ( rs , & sr -> curr , sizeof ( * rs ) ) ;


<s> memcpy ( rs , & sr -> curr , sizeof ( * rs ) ) ; sr -> curr . next = rs ;


<s> reg -> where = where ; if ( reg -> when == UNW_WHEN_NEVER ) reg -> when = when ;


<s> for ( reg = * regp ; reg <= lim ; ++ reg ) {

if ( reg -> where == UNW_WHERE_SPILL_HOME ) {


<s> case UNW_NAT_NONE : dummy_nat = <NUM_LIT> ; nat_addr = & dummy_nat ; break ; case UNW_NAT_MEMSTK : nat_mask = <NUM_LIT> << ( ( long ) addr & <NUM_LIT> ) / <NUM_LIT> ; break ; case UNW_NAT_REGSTK : nat_addr = ia64_rse_rnat_addr ( addr ) ; if ( ( unsigned long ) nat_addr >= info -> regstk_top ) nat_addr = & info -> rnat ; nat_mask = <NUM_LIT> << ia64_rse_slot_num ( addr ) ; break ; } } } else { addr = ia64_rse_skip_regs ( ( unsigned long * ) info -> bsp , regnum - <NUM_LIT> ) ; nat_addr = ia64_rse_rnat_addr ( addr ) ; if ( ( unsigned long ) nat_addr >= info -> regstk_top ) nat_addr = & info -> rnat ;


<s> nat_addr = ia64_rse_rnat_addr ( addr ) ; if ( ( unsigned long ) nat_addr >= info -> regstk_top ) nat_addr = & info -> rnat ; nat_mask = <NUM_LIT> << ia64_rse_slot_num ( addr ) ; break ; } } } else { addr = ia64_rse_skip_regs ( ( unsigned long * ) info -> bsp , regnum - <NUM_LIT> ) ; nat_addr = ia64_rse_rnat_addr ( addr ) ; if ( ( unsigned long ) nat_addr >= info -> regstk_top ) nat_addr = & info -> rnat ; nat_mask = <NUM_LIT> << ia64_rse_slot_num ( addr ) ; } if ( write ) { * addr = * val ; if ( * nat ) * nat_addr |= nat_mask ; else * nat_addr &= ~ nat_mask ; } else {


<s> code = * dp ++ ; decoder = unw_decode_table [ inside_body ] [ code >> <NUM_LIT> ] ; dp = ( * decoder ) ( dp , code , arg ) ;


<s> unsigned char code ; code = * dp ++ ; decoder = unw_decode_table [ inside_body ] [ code >> <NUM_LIT> ] ; dp = ( * decoder ) ( dp , code , arg ) ;


<s> static unsigned char * unw_decode_b2 ( unsigned char * dp , unsigned char code , void * arg ) { unw_word t ;


<s> t = unw_decode_uleb128 ( & dp ) ; UNW_DEC_EPILOGUE ( B2 , t , ( code & <NUM_LIT> ) , arg ) ; return dp ;


<s> UNW_DEC_EPILOGUE ( B3 , t , ecount , arg ) ; } else if ( ( code & <NUM_LIT> ) == <NUM_LIT> ) { label = unw_decode_uleb128 ( & dp ) ; if ( ( code & <NUM_LIT> ) != <NUM_LIT> ) UNW_DEC_COPY_STATE ( B4 , label , arg ) ; else UNW_DEC_LABEL_STATE ( B4 , label , arg ) ; } else switch ( code & <NUM_LIT> ) {

case <NUM_LIT> : return unw_decode_x1 ( dp , code , arg ) ;


<s> unsigned char brmask = ( code & <NUM_LIT> ) ;


<s> static unsigned char * unw_decode_p1 ( unsigned char * dp , unsigned char code , void * arg ) { unsigned char brmask = ( code & <NUM_LIT> ) ; UNW_DEC_BR_MEM ( P1 , brmask , arg ) ; return dp ;


<s> case <NUM_LIT> : UNW_DEC_REG_GR ( P3 , UNW_REG_BSPSTORE , dst , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_GR ( P3 , UNW_REG_FPSR , dst , arg ) ; break ; case <NUM_LIT> : UNW_DEC_PRIUNAT_GR ( P3 , dst , arg ) ; break ; default : UNW_DEC_BAD_CODE ( r ) ; break ; } } else if ( ( code & <NUM_LIT> ) == <NUM_LIT> ) UNW_DEC_SPILL_MASK ( P4 , dp , arg ) ; else if ( ( code & <NUM_LIT> ) == <NUM_LIT> ) { unw_word grmask , frmask , byte1 , byte2 , byte3 ; byte1 = * dp ++ ; byte2 = * dp ++ ; byte3 = * dp ++ ; grmask = ( ( byte1 >> <NUM_LIT> ) & <NUM_LIT> ) ; frmask = ( ( byte1 & <NUM_LIT> ) << <NUM_LIT> ) | ( byte2 << <NUM_LIT> ) | byte3 ; UNW_DEC_FRGR_MEM ( P5 , grmask , frmask , arg ) ; } else UNW_DEC_BAD_CODE ( code ) ; return dp ;


<s> int gregs = ( code & <NUM_LIT> ) != <NUM_LIT> ; unsigned char mask = ( code & <NUM_LIT> ) ;

if ( gregs ) UNW_DEC_GR_MEM ( P6 , mask , arg ) ;


<s> case <NUM_LIT> : UNW_DEC_REG_SPREL ( P8 , UNW_REG_UNAT , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_SPREL ( P8 , UNW_REG_FPSR , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_WHEN ( P8 , UNW_REG_BSP , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_PSPREL ( P8 , UNW_REG_BSP , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_SPREL ( P8 , UNW_REG_BSP , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_WHEN ( P8 , UNW_REG_BSPSTORE , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_PSPREL ( P8 , UNW_REG_BSPSTORE , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_SPREL ( P8 , UNW_REG_BSPSTORE , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_WHEN ( P8 , UNW_REG_RNAT , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_PSPREL ( P8 , UNW_REG_RNAT , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_REG_SPREL ( P8 , UNW_REG_RNAT , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_PRIUNAT_WHEN_GR ( P8 , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_PRIUNAT_PSPREL ( P8 , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_PRIUNAT_SPREL ( P8 , t , arg ) ; break ; case <NUM_LIT> : UNW_DEC_PRIUNAT_WHEN_MEM ( P8 , t , arg ) ; break ; default : UNW_DEC_BAD_CODE ( r ) ; break ; } } break ; case <NUM_LIT> : byte1 = * dp ++ ; byte2 = * dp ++ ; UNW_DEC_GR_GR ( P9 , ( byte1 & <NUM_LIT> ) , ( byte2 & <NUM_LIT> ) , arg ) ;


<s> int body = ( code & <NUM_LIT> ) != <NUM_LIT> ; unw_word rlen ;


<s> UNW_DEC_PROLOGUE ( R3 , ( ( code & <NUM_LIT> ) == <NUM_LIT> ) , rlen , arg ) ;


<s> static unw_word unw_decode_uleb128 ( unsigned char * * dpp ) { unsigned shift = <NUM_LIT> ; unw_word byte , result = <NUM_LIT> ; unsigned char * bp = * dpp ;


<s> off = unw_decode_uleb128 ( & dp ) ; abreg = ( byte1 & <NUM_LIT> ) ;

if ( byte1 & <NUM_LIT> ) UNW_DEC_SPILL_SPREL ( X1 , t , abreg , off , arg ) ;


<s> if ( ( byte1 & <NUM_LIT> ) == <NUM_LIT> && ytreg == <NUM_LIT> ) UNW_DEC_RESTORE ( X2 , t , abreg , arg ) ; else UNW_DEC_SPILL_REG ( X2 , t , abreg , x , ytreg , arg ) ;


<s> static unsigned char * unw_decode_x3 ( unsigned char * dp , unsigned char code __attribute__ ( ( unused ) ) , void * arg ) { unsigned char byte1 , byte2 , abreg , qp ; unw_word t , off ; byte1 = * dp ++ ; byte2 = * dp ++ ; t = unw_decode_uleb128 ( & dp ) ; off = unw_decode_uleb128 ( & dp ) ;


<s> byte1 = * dp ++ ; byte2 = * dp ++ ; byte3 = * dp ++ ; t = unw_decode_uleb128 ( & dp ) ; qp = ( byte1 & <NUM_LIT> ) ; abreg = ( byte2 & <NUM_LIT> ) ; x = ( byte2 >> <NUM_LIT> ) & <NUM_LIT> ; ytreg = byte3 ; if ( ( byte2 & <NUM_LIT> ) == <NUM_LIT> && byte3 == <NUM_LIT> ) UNW_DEC_RESTORE_P ( X4 , qp , t , abreg , arg ) ; else UNW_DEC_SPILL_REG_P ( X4 , qp , t , abreg , x , ytreg , arg ) ; return dp ;


<s> if ( context -> br_loc [ <NUM_LIT> ] && * context -> br_loc [ <NUM_LIT> ] != context -> rp ) { fs -> curr . reg [ UNW_REG_RP ] . where = UNW_WHERE_BR ; fs -> curr . reg [ UNW_REG_RP ] . when = - <NUM_LIT> ; fs -> curr . reg [ UNW_REG_RP ] . val = <NUM_LIT> ; goto success ; } return _URC_END_OF_STACK ; success : return _URC_NO_REASON ; return _URC_END_OF_STACK ; } context -> region_start = ent -> start_offset + segment_base ; fs -> when_target = ( context -> rp - context -> region_start ) / <NUM_LIT> * <NUM_LIT> ; unw = ( unsigned long * ) ( ent -> info_offset + segment_base ) ; header = * unw ; length = UNW_LENGTH ( header ) ; if ( UNW_FLAG_EHANDLER ( header ) | UNW_FLAG_UHANDLER ( header ) ) { fs -> personality = * ( _Unwind_Personality_Fn * ) ( unw [ length + <NUM_LIT> ] + context -> gp ) ; context -> lsda = unw + length + <NUM_LIT> ; } insn = ( unsigned char * ) ( unw + <NUM_LIT> ) ; insn_end = ( unsigned char * ) ( unw + <NUM_LIT> + length ) ; while ( ! fs -> done && insn < insn_end ) insn = unw_decode ( insn , fs -> in_body , fs ) ; free_label_states ( fs -> labeled_states ) ; free_state_stack ( & fs -> curr ) ; if ( reg_state_alloced || labeled_state_alloced ) abort ( ) ; if ( fs -> when_target > fs -> epilogue_start ) { struct unw_reg_info * r ; fs -> curr . reg [ UNW_REG_PSP ] . where = UNW_WHERE_NONE ; fs -> curr . reg [ UNW_REG_PSP ] . val = <NUM_LIT> ;

for ( r = fs -> curr . reg ; r < fs -> curr . reg + UNW_NUM_REGS ; ++ r ) if ( ( r -> where == UNW_WHERE_PSPREL && r -> val <= <NUM_LIT> ) || r -> where == UNW_WHERE_SPREL ) r -> where = UNW_WHERE_NONE ;


<s> MD_FALLBACK_FRAME_STATE_FOR ( context , fs , success ) ; if ( context -> br_loc [ <NUM_LIT> ] && * context -> br_loc [ <NUM_LIT> ] != context -> rp ) { fs -> curr . reg [ UNW_REG_RP ] . where = UNW_WHERE_BR ; fs -> curr . reg [ UNW_REG_RP ] . when = - <NUM_LIT> ; fs -> curr . reg [ UNW_REG_RP ] . val = <NUM_LIT> ; goto success ; } return _URC_END_OF_STACK ; success : return _URC_NO_REASON ; return _URC_END_OF_STACK ; } context -> region_start = ent -> start_offset + segment_base ; fs -> when_target = ( context -> rp - context -> region_start ) / <NUM_LIT> * <NUM_LIT> ; unw = ( unsigned long * ) ( ent -> info_offset + segment_base ) ; header = * unw ; length = UNW_LENGTH ( header ) ; if ( UNW_FLAG_EHANDLER ( header ) | UNW_FLAG_UHANDLER ( header ) ) { fs -> personality = * ( _Unwind_Personality_Fn * ) ( unw [ length + <NUM_LIT> ] + context -> gp ) ;

context -> lsda = unw + length + <NUM_LIT> ;


<s> context -> bsp = context -> regstk_top = ( unsigned long ) bsp ; context -> psp = ( unsigned long ) psp ; context -> rp = ( unsigned long ) rp ; asm ( <STR_LIT> : <STR_LIT> ( context -> sp ) ) ; asm ( <STR_LIT> : <STR_LIT> ( context -> pr ) ) ; context -> pri_unat_loc = & context -> initial_unat ;

if ( uw_frame_state_for ( context , & fs ) != _URC_NO_REASON ) abort ( ) ;


<s> memset ( context , <NUM_LIT> , sizeof ( struct _Unwind_Context ) ) ; context -> bsp = context -> regstk_top = ( unsigned long ) bsp ; context -> psp = ( unsigned long ) psp ; context -> rp = ( unsigned long ) rp ; asm ( <STR_LIT> : <STR_LIT> ( context -> sp ) ) ; asm ( <STR_LIT> : <STR_LIT> ( context -> pr ) ) ; context -> pri_unat_loc = & context -> initial_unat ; if ( uw_frame_state_for ( context , & fs ) != _URC_NO_REASON ) abort ( ) ;


<s> if ( fs -> curr . reg [ UNW_REG_PSP ] . where == UNW_WHERE_NONE ) context -> psp = context -> psp + fs -> curr . reg [ UNW_REG_PSP ] . val ; else uw_update_reg_address ( context , fs , UNW_REG_PSP ) ; } { int i ; if ( fs -> when_target < fs -> curr . reg [ UNW_REG_PRI_UNAT_GR ] . when ) i = UNW_REG_PRI_UNAT_MEM ; else if ( fs -> when_target < fs -> curr . reg [ UNW_REG_PRI_UNAT_MEM ] . when ) i = UNW_REG_PRI_UNAT_GR ; else if ( fs -> curr . reg [ UNW_REG_PRI_UNAT_MEM ] . when > fs -> curr . reg [ UNW_REG_PRI_UNAT_GR ] . when ) i = UNW_REG_PRI_UNAT_MEM ; else i = UNW_REG_PRI_UNAT_GR ; uw_update_reg_address ( context , fs , i ) ; } for ( i = UNW_REG_BSP ; i < UNW_NUM_REGS ; ++ i ) uw_update_reg_address ( context , fs , i ) ; if ( ! ( fs -> no_reg_stack_frame ) ) { unsigned long pfs = * context -> pfs_loc ; unsigned long sol = ( pfs >> <NUM_LIT> ) & <NUM_LIT> ;

context -> bsp = ( unsigned long ) ia64_rse_skip_regs ( ( unsigned long * ) context -> bsp , - sol ) ;


<s> _Unwind_Word _Unwind_GetGR ( struct _Unwind_Context * context , int index ) { _Unwind_Word ret ; char nat ;

if ( index == <NUM_LIT> ) return context -> gp ;


<s> void * _Unwind_GetLanguageSpecificData ( struct _Unwind_Context * context ) {


<s> char nat = <NUM_LIT> ; if ( index == <NUM_LIT> ) context -> gp = val ;

else if ( index >= <NUM_LIT> && index <= <NUM_LIT> ) context -> eh_data [ index - <NUM_LIT> ] = val ;