02007d7c <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 2007d7c: 9d e3 bf a0 save %sp, -96, %sp Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 2007d80: e0 06 60 14 ld [ %i1 + 0x14 ], %l0 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2007d84: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; 2007d88: c0 26 60 3c clr [ %i1 + 0x3c ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2007d8c: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2007d90: 82 06 60 38 add %i1, 0x38, %g1 2007d94: c2 26 60 40 st %g1, [ %i1 + 0x40 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 2007d98: 2d 00 80 6a sethi %hi(0x201a800), %l6 _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 2007d9c: 83 34 20 06 srl %l0, 6, %g1 block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 2007da0: 80 8c 20 20 btst 0x20, %l0 _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 2007da4: a7 28 60 04 sll %g1, 4, %l3 the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 2007da8: ac 15 a3 14 or %l6, 0x314, %l6 _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 2007dac: 83 28 60 02 sll %g1, 2, %g1 block_state = the_thread_queue->state; 2007db0: ea 06 20 38 ld [ %i0 + 0x38 ], %l5 _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 2007db4: a6 24 c0 01 sub %l3, %g1, %l3 block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 2007db8: 12 80 00 28 bne 2007e58 <_Thread_queue_Enqueue_priority+0xdc> 2007dbc: a6 06 00 13 add %i0, %l3, %l3 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2007dc0: ac 04 e0 04 add %l3, 4, %l6 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 2007dc4: 7f ff e7 ce call 2001cfc 2007dc8: 01 00 00 00 nop 2007dcc: a4 10 00 08 mov %o0, %l2 search_thread = (Thread_Control *) header->first; 2007dd0: a8 10 3f ff mov -1, %l4 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 2007dd4: 10 80 00 10 b 2007e14 <_Thread_queue_Enqueue_priority+0x98> 2007dd8: e2 04 c0 00 ld [ %l3 ], %l1 search_priority = search_thread->current_priority; if ( priority <= search_priority ) 2007ddc: 80 a4 00 14 cmp %l0, %l4 2007de0: 28 80 00 11 bleu,a 2007e24 <_Thread_queue_Enqueue_priority+0xa8> 2007de4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 2007de8: 7f ff e7 c9 call 2001d0c 2007dec: 90 10 00 12 mov %l2, %o0 2007df0: 7f ff e7 c3 call 2001cfc 2007df4: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2007df8: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 2007dfc: 80 8d 40 01 btst %l5, %g1 2007e00: 32 80 00 05 bne,a 2007e14 <_Thread_queue_Enqueue_priority+0x98> 2007e04: e2 04 40 00 ld [ %l1 ], %l1 _ISR_Enable( level ); 2007e08: 7f ff e7 c1 call 2001d0c <== NOT EXECUTED 2007e0c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED goto restart_forward_search; 2007e10: 30 bf ff ed b,a 2007dc4 <_Thread_queue_Enqueue_priority+0x48> <== NOT EXECUTED restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 2007e14: 80 a4 40 16 cmp %l1, %l6 2007e18: 32 bf ff f1 bne,a 2007ddc <_Thread_queue_Enqueue_priority+0x60> 2007e1c: e8 04 60 14 ld [ %l1 + 0x14 ], %l4 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 2007e20: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2007e24: 80 a0 60 01 cmp %g1, 1 2007e28: 12 80 00 3c bne 2007f18 <_Thread_queue_Enqueue_priority+0x19c> 2007e2c: 90 10 00 12 mov %l2, %o0 THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( priority == search_priority ) 2007e30: 80 a4 00 14 cmp %l0, %l4 2007e34: 02 80 00 2e be 2007eec <_Thread_queue_Enqueue_priority+0x170> 2007e38: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 2007e3c: c2 04 60 04 ld [ %l1 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2007e40: e2 26 40 00 st %l1, [ %i1 ] the_node->previous = previous_node; 2007e44: c2 26 60 04 st %g1, [ %i1 + 4 ] previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 2007e48: f0 26 60 44 st %i0, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 2007e4c: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 2007e50: f2 24 60 04 st %i1, [ %l1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2007e54: 30 80 00 2d b,a 2007f08 <_Thread_queue_Enqueue_priority+0x18c> return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 2007e58: 7f ff e7 a9 call 2001cfc 2007e5c: e8 0d 80 00 ldub [ %l6 ], %l4 the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 2007e60: a8 05 20 01 inc %l4 _ISR_Disable( level ); 2007e64: a4 10 00 08 mov %o0, %l2 search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 2007e68: 10 80 00 10 b 2007ea8 <_Thread_queue_Enqueue_priority+0x12c> 2007e6c: e2 04 e0 08 ld [ %l3 + 8 ], %l1 search_priority = search_thread->current_priority; if ( priority >= search_priority ) 2007e70: 80 a4 00 14 cmp %l0, %l4 2007e74: 3a 80 00 11 bcc,a 2007eb8 <_Thread_queue_Enqueue_priority+0x13c> 2007e78: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 2007e7c: 7f ff e7 a4 call 2001d0c 2007e80: 90 10 00 12 mov %l2, %o0 2007e84: 7f ff e7 9e call 2001cfc 2007e88: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2007e8c: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 2007e90: 80 8d 40 01 btst %l5, %g1 2007e94: 32 80 00 05 bne,a 2007ea8 <_Thread_queue_Enqueue_priority+0x12c> 2007e98: e2 04 60 04 ld [ %l1 + 4 ], %l1 _ISR_Enable( level ); 2007e9c: 7f ff e7 9c call 2001d0c 2007ea0: 90 10 00 12 mov %l2, %o0 goto restart_reverse_search; 2007ea4: 30 bf ff ed b,a 2007e58 <_Thread_queue_Enqueue_priority+0xdc> restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 2007ea8: 80 a4 40 13 cmp %l1, %l3 2007eac: 32 bf ff f1 bne,a 2007e70 <_Thread_queue_Enqueue_priority+0xf4> 2007eb0: e8 04 60 14 ld [ %l1 + 0x14 ], %l4 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 2007eb4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2007eb8: 80 a0 60 01 cmp %g1, 1 2007ebc: 12 80 00 17 bne 2007f18 <_Thread_queue_Enqueue_priority+0x19c> 2007ec0: 90 10 00 12 mov %l2, %o0 THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( priority == search_priority ) 2007ec4: 80 a4 00 14 cmp %l0, %l4 2007ec8: 02 80 00 09 be 2007eec <_Thread_queue_Enqueue_priority+0x170> 2007ecc: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 2007ed0: c2 04 40 00 ld [ %l1 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 2007ed4: e2 26 60 04 st %l1, [ %i1 + 4 ] search_node = (Chain_Node *) search_thread; next_node = search_node->next; the_node = (Chain_Node *) the_thread; the_node->next = next_node; 2007ed8: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = search_node; search_node->next = the_node; next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 2007edc: f0 26 60 44 st %i0, [ %i1 + 0x44 ] next_node = search_node->next; the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; search_node->next = the_node; 2007ee0: f2 24 40 00 st %i1, [ %l1 ] next_node->previous = the_node; 2007ee4: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2007ee8: 30 80 00 08 b,a 2007f08 <_Thread_queue_Enqueue_priority+0x18c> 2007eec: a2 04 60 3c add %l1, 0x3c, %l1 return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 2007ef0: c2 04 60 04 ld [ %l1 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2007ef4: e2 26 40 00 st %l1, [ %i1 ] the_node->previous = previous_node; 2007ef8: c2 26 60 04 st %g1, [ %i1 + 4 ] previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 2007efc: f0 26 60 44 st %i0, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 2007f00: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 2007f04: f2 24 60 04 st %i1, [ %l1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2007f08: 7f ff e7 81 call 2001d0c 2007f0c: b0 10 20 01 mov 1, %i0 return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 2007f10: 81 c7 e0 08 ret 2007f14: 81 e8 00 00 restore * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; 2007f18: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 2007f1c: d0 26 80 00 st %o0, [ %i2 ] return the_thread_queue->sync_state; } 2007f20: 81 c7 e0 08 ret 2007f24: 81 e8 00 00 restore 02014bcc <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 2014bcc: 9d e3 bf 88 save %sp, -120, %sp static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 2014bd0: 35 00 80 ec sethi %hi(0x203b000), %i2 2014bd4: b2 07 bf f4 add %fp, -12, %i1 2014bd8: ac 07 bf f8 add %fp, -8, %l6 2014bdc: a2 07 bf e8 add %fp, -24, %l1 2014be0: a6 07 bf ec add %fp, -20, %l3 static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 2014be4: 37 00 80 ec sethi %hi(0x203b000), %i3 2014be8: 2b 00 80 ec sethi %hi(0x203b000), %l5 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2014bec: c0 27 bf f8 clr [ %fp + -8 ] 2014bf0: c0 27 bf ec clr [ %fp + -20 ] the_chain->last = _Chain_Head(the_chain); 2014bf4: f2 27 bf fc st %i1, [ %fp + -4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2014bf8: ec 27 bf f4 st %l6, [ %fp + -12 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2014bfc: e2 27 bf f0 st %l1, [ %fp + -16 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2014c00: e6 27 bf e8 st %l3, [ %fp + -24 ] static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 2014c04: b4 16 a1 54 or %i2, 0x154, %i2 static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 2014c08: b6 16 e0 94 or %i3, 0x94, %i3 2014c0c: aa 15 60 00 mov %l5, %l5 */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 2014c10: a8 06 20 30 add %i0, 0x30, %l4 /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 2014c14: a4 06 20 68 add %i0, 0x68, %l2 static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 2014c18: b8 06 20 08 add %i0, 8, %i4 static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 2014c1c: ba 06 20 40 add %i0, 0x40, %i5 _Thread_Set_state( ts->thread, STATES_DELAYING ); _Timer_server_Reset_interval_system_watchdog( ts ); _Timer_server_Reset_tod_system_watchdog( ts ); _Thread_Enable_dispatch(); ts->active = true; 2014c20: ae 10 20 01 mov 1, %l7 { /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; 2014c24: f2 26 20 78 st %i1, [ %i0 + 0x78 ] static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 2014c28: c2 06 80 00 ld [ %i2 ], %g1 /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 2014c2c: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 2014c30: 94 10 00 11 mov %l1, %o2 /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; 2014c34: c2 26 20 3c st %g1, [ %i0 + 0x3c ] _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 2014c38: 92 20 40 09 sub %g1, %o1, %o1 2014c3c: 40 00 11 91 call 2019280 <_Watchdog_Adjust_to_chain> 2014c40: 90 10 00 14 mov %l4, %o0 Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 2014c44: d4 06 20 74 ld [ %i0 + 0x74 ], %o2 static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 2014c48: e0 06 c0 00 ld [ %i3 ], %l0 /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the watchdogs->Chain to indicate this. */ if ( snapshot > last_snapshot ) { 2014c4c: 80 a4 00 0a cmp %l0, %o2 2014c50: 08 80 00 06 bleu 2014c68 <_Timer_server_Body+0x9c> 2014c54: 92 24 00 0a sub %l0, %o2, %o1 /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 2014c58: 90 10 00 12 mov %l2, %o0 2014c5c: 40 00 11 89 call 2019280 <_Watchdog_Adjust_to_chain> 2014c60: 94 10 00 11 mov %l1, %o2 2014c64: 30 80 00 06 b,a 2014c7c <_Timer_server_Body+0xb0> } else if ( snapshot < last_snapshot ) { 2014c68: 1a 80 00 05 bcc 2014c7c <_Timer_server_Body+0xb0> 2014c6c: 94 22 80 10 sub %o2, %l0, %o2 /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 2014c70: 90 10 00 12 mov %l2, %o0 2014c74: 40 00 11 5c call 20191e4 <_Watchdog_Adjust> 2014c78: 92 10 20 01 mov 1, %o1 } watchdogs->last_snapshot = snapshot; 2014c7c: e0 26 20 74 st %l0, [ %i0 + 0x74 ] } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 2014c80: d0 06 20 78 ld [ %i0 + 0x78 ], %o0 2014c84: 40 00 02 7e call 201567c <_Chain_Get> 2014c88: 01 00 00 00 nop if ( timer == NULL ) { 2014c8c: 80 a2 20 00 cmp %o0, 0 2014c90: 02 80 00 0f be 2014ccc <_Timer_server_Body+0x100> 2014c94: 01 00 00 00 nop static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 2014c98: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 2014c9c: 80 a0 60 01 cmp %g1, 1 2014ca0: 12 80 00 05 bne 2014cb4 <_Timer_server_Body+0xe8> 2014ca4: 80 a0 60 03 cmp %g1, 3 _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 2014ca8: 92 02 20 10 add %o0, 0x10, %o1 2014cac: 10 80 00 05 b 2014cc0 <_Timer_server_Body+0xf4> 2014cb0: 90 10 00 14 mov %l4, %o0 } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 2014cb4: 12 bf ff f3 bne 2014c80 <_Timer_server_Body+0xb4> 2014cb8: 92 02 20 10 add %o0, 0x10, %o1 _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 2014cbc: 90 10 00 12 mov %l2, %o0 2014cc0: 40 00 11 a5 call 2019354 <_Watchdog_Insert> 2014cc4: 01 00 00 00 nop 2014cc8: 30 bf ff ee b,a 2014c80 <_Timer_server_Body+0xb4> * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 2014ccc: 7f ff e5 00 call 200e0cc 2014cd0: 01 00 00 00 nop if ( _Chain_Is_empty( insert_chain ) ) { 2014cd4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2014cd8: 80 a0 40 16 cmp %g1, %l6 2014cdc: 12 80 00 0a bne 2014d04 <_Timer_server_Body+0x138> 2014ce0: 01 00 00 00 nop ts->insert_chain = NULL; 2014ce4: c0 26 20 78 clr [ %i0 + 0x78 ] _ISR_Enable( level ); 2014ce8: 7f ff e4 fd call 200e0dc 2014cec: 01 00 00 00 nop _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); if ( !_Chain_Is_empty( &fire_chain ) ) { 2014cf0: c2 07 bf e8 ld [ %fp + -24 ], %g1 2014cf4: 80 a0 40 13 cmp %g1, %l3 2014cf8: 12 80 00 06 bne 2014d10 <_Timer_server_Body+0x144> 2014cfc: 01 00 00 00 nop 2014d00: 30 80 00 1a b,a 2014d68 <_Timer_server_Body+0x19c> ts->insert_chain = NULL; _ISR_Enable( level ); break; } else { _ISR_Enable( level ); 2014d04: 7f ff e4 f6 call 200e0dc <== NOT EXECUTED 2014d08: 01 00 00 00 nop <== NOT EXECUTED 2014d0c: 30 bf ff c7 b,a 2014c28 <_Timer_server_Body+0x5c> <== NOT EXECUTED /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 2014d10: 7f ff e4 ef call 200e0cc 2014d14: 01 00 00 00 nop 2014d18: 84 10 00 08 mov %o0, %g2 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2014d1c: e0 07 bf e8 ld [ %fp + -24 ], %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 2014d20: 80 a4 00 13 cmp %l0, %l3 2014d24: 02 80 00 0e be 2014d5c <_Timer_server_Body+0x190> 2014d28: 80 a4 20 00 cmp %l0, 0 { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 2014d2c: c2 04 00 00 ld [ %l0 ], %g1 the_chain->first = new_first; 2014d30: c2 27 bf e8 st %g1, [ %fp + -24 ] watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { 2014d34: 02 80 00 0a be 2014d5c <_Timer_server_Body+0x190> 2014d38: e2 20 60 04 st %l1, [ %g1 + 4 ] watchdog->state = WATCHDOG_INACTIVE; 2014d3c: c0 24 20 08 clr [ %l0 + 8 ] _ISR_Enable( level ); 2014d40: 7f ff e4 e7 call 200e0dc 2014d44: 01 00 00 00 nop /* * The timer server may block here and wait for resources or time. * The system watchdogs are inactive and will remain inactive since * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); 2014d48: d2 04 20 24 ld [ %l0 + 0x24 ], %o1 2014d4c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 2014d50: 9f c0 40 00 call %g1 2014d54: d0 04 20 20 ld [ %l0 + 0x20 ], %o0 } 2014d58: 30 bf ff ee b,a 2014d10 <_Timer_server_Body+0x144> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 2014d5c: 7f ff e4 e0 call 200e0dc 2014d60: 90 10 00 02 mov %g2, %o0 2014d64: 30 bf ff b0 b,a 2014c24 <_Timer_server_Body+0x58> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 2014d68: c0 2e 20 7c clrb [ %i0 + 0x7c ] 2014d6c: c2 05 40 00 ld [ %l5 ], %g1 2014d70: 82 00 60 01 inc %g1 2014d74: c2 25 40 00 st %g1, [ %l5 ] /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 2014d78: d0 06 00 00 ld [ %i0 ], %o0 2014d7c: 40 00 0e 78 call 201875c <_Thread_Set_state> 2014d80: 92 10 20 08 mov 8, %o1 _Timer_server_Reset_interval_system_watchdog( ts ); 2014d84: 7f ff ff 68 call 2014b24 <_Timer_server_Reset_interval_system_watchdog> 2014d88: 90 10 00 18 mov %i0, %o0 _Timer_server_Reset_tod_system_watchdog( ts ); 2014d8c: 7f ff ff 7b call 2014b78 <_Timer_server_Reset_tod_system_watchdog> 2014d90: 90 10 00 18 mov %i0, %o0 _Thread_Enable_dispatch(); 2014d94: 40 00 0b a4 call 2017c24 <_Thread_Enable_dispatch> 2014d98: 01 00 00 00 nop static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 2014d9c: 90 10 00 1c mov %i4, %o0 _Thread_Set_state( ts->thread, STATES_DELAYING ); _Timer_server_Reset_interval_system_watchdog( ts ); _Timer_server_Reset_tod_system_watchdog( ts ); _Thread_Enable_dispatch(); ts->active = true; 2014da0: ee 2e 20 7c stb %l7, [ %i0 + 0x7c ] static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 2014da4: 40 00 11 c9 call 20194c8 <_Watchdog_Remove> 2014da8: 01 00 00 00 nop static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 2014dac: 40 00 11 c7 call 20194c8 <_Watchdog_Remove> 2014db0: 90 10 00 1d mov %i5, %o0 2014db4: 30 bf ff 9c b,a 2014c24 <_Timer_server_Body+0x58> 0200e33c : int killinfo( pid_t pid, int sig, const union sigval *value ) { 200e33c: 9d e3 bf 90 save %sp, -112, %sp POSIX_signals_Siginfo_node *psiginfo; /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 200e340: 7f ff fb c7 call 200d25c 200e344: 01 00 00 00 nop 200e348: 80 a6 00 08 cmp %i0, %o0 200e34c: 02 80 00 06 be 200e364 200e350: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 200e354: 40 00 01 97 call 200e9b0 <__errno> 200e358: 01 00 00 00 nop 200e35c: 10 80 00 07 b 200e378 200e360: 82 10 20 03 mov 3, %g1 ! 3 /* * Validate the signal passed. */ if ( !sig ) 200e364: 12 80 00 08 bne 200e384 200e368: 82 06 7f ff add %i1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); 200e36c: 40 00 01 91 call 200e9b0 <__errno> 200e370: 01 00 00 00 nop 200e374: 82 10 20 16 mov 0x16, %g1 ! 16 200e378: c2 22 00 00 st %g1, [ %o0 ] 200e37c: 10 80 00 a5 b 200e610 200e380: 90 10 3f ff mov -1, %o0 if ( !is_valid_signo(sig) ) 200e384: 80 a0 60 1f cmp %g1, 0x1f 200e388: 18 bf ff f9 bgu 200e36c 200e38c: 85 2e 60 02 sll %i1, 2, %g2 rtems_set_errno_and_return_minus_one( EINVAL ); /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) 200e390: 87 2e 60 04 sll %i1, 4, %g3 200e394: 86 20 c0 02 sub %g3, %g2, %g3 200e398: 05 00 80 6e sethi %hi(0x201b800), %g2 200e39c: 84 10 a2 f4 or %g2, 0x2f4, %g2 ! 201baf4 <_POSIX_signals_Vectors> 200e3a0: 84 00 80 03 add %g2, %g3, %g2 200e3a4: c4 00 a0 08 ld [ %g2 + 8 ], %g2 200e3a8: 80 a0 a0 01 cmp %g2, 1 200e3ac: 02 80 00 99 be 200e610 200e3b0: 90 10 20 00 clr %o0 /* * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 200e3b4: 80 a6 60 04 cmp %i1, 4 200e3b8: 02 80 00 06 be 200e3d0 200e3bc: 80 a6 60 08 cmp %i1, 8 200e3c0: 02 80 00 04 be 200e3d0 200e3c4: 80 a6 60 0b cmp %i1, 0xb 200e3c8: 12 80 00 08 bne 200e3e8 200e3cc: a0 10 20 01 mov 1, %l0 return pthread_kill( pthread_self(), sig ); 200e3d0: 40 00 01 4f call 200e90c 200e3d4: 01 00 00 00 nop 200e3d8: 40 00 01 11 call 200e81c 200e3dc: 92 10 00 19 mov %i1, %o1 200e3e0: 81 c7 e0 08 ret 200e3e4: 91 e8 00 08 restore %g0, %o0, %o0 /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 200e3e8: f2 27 bf f4 st %i1, [ %fp + -12 ] siginfo->si_code = SI_USER; 200e3ec: e0 27 bf f8 st %l0, [ %fp + -8 ] if ( !value ) { 200e3f0: 80 a6 a0 00 cmp %i2, 0 200e3f4: 12 80 00 04 bne 200e404 200e3f8: a1 2c 00 01 sll %l0, %g1, %l0 siginfo->si_value.sival_int = 0; 200e3fc: 10 80 00 04 b 200e40c 200e400: c0 27 bf fc clr [ %fp + -4 ] } else { siginfo->si_value = *value; 200e404: c2 06 80 00 ld [ %i2 ], %g1 200e408: c2 27 bf fc st %g1, [ %fp + -4 ] 200e40c: 03 00 80 6d sethi %hi(0x201b400), %g1 200e410: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 201b560 <_Thread_Dispatch_disable_level> 200e414: 84 00 a0 01 inc %g2 200e418: c4 20 61 60 st %g2, [ %g1 + 0x160 ] /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 200e41c: 03 00 80 6d sethi %hi(0x201b400), %g1 200e420: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 201b620 <_Thread_Executing> api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200e424: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 200e428: c4 00 a0 c4 ld [ %g2 + 0xc4 ], %g2 200e42c: 80 ac 00 02 andncc %l0, %g2, %g0 200e430: 12 80 00 4e bne 200e568 200e434: 07 00 80 6f sethi %hi(0x201bc00), %g3 /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = the_chain->first ; 200e438: 03 00 80 6f sethi %hi(0x201bc00), %g1 200e43c: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 201bc80 <_POSIX_signals_Wait_queue> 200e440: 10 80 00 0b b 200e46c 200e444: 86 10 e0 84 or %g3, 0x84, %g3 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200e448: c8 00 a1 6c ld [ %g2 + 0x16c ], %g4 #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 200e44c: 80 8c 00 01 btst %l0, %g1 200e450: 12 80 00 46 bne 200e568 200e454: 82 10 00 02 mov %g2, %g1 /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 200e458: c8 01 20 c4 ld [ %g4 + 0xc4 ], %g4 200e45c: 80 ac 00 04 andncc %l0, %g4, %g0 200e460: 32 80 00 43 bne,a 200e56c 200e464: 84 10 20 01 mov 1, %g2 the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 200e468: c4 00 80 00 ld [ %g2 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200e46c: 80 a0 80 03 cmp %g2, %g3 200e470: 32 bf ff f6 bne,a 200e448 200e474: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 200e478: 03 00 80 6a sethi %hi(0x201a800), %g1 200e47c: c8 08 63 14 ldub [ %g1 + 0x314 ], %g4 ! 201ab14 200e480: 05 00 80 6d sethi %hi(0x201b400), %g2 200e484: 88 01 20 01 inc %g4 200e488: 84 10 a0 c8 or %g2, 0xc8, %g2 */ #define _POSIX_signals_Is_interested( _api, _mask ) \ ( ~(_api)->signals_blocked & (_mask) ) int killinfo( 200e48c: 82 10 20 00 clr %g1 200e490: 90 00 a0 0c add %g2, 0xc, %o0 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 200e494: 17 04 00 00 sethi %hi(0x10000000), %o3 for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { /* * This can occur when no one is interested and ITRON is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 200e498: c6 00 80 00 ld [ %g2 ], %g3 200e49c: 80 a0 e0 00 cmp %g3, 0 200e4a0: 22 80 00 2c be,a 200e550 200e4a4: 84 00 a0 04 add %g2, 4, %g2 continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 200e4a8: c6 00 e0 04 ld [ %g3 + 4 ], %g3 if ( !the_info ) continue; #endif maximum = the_info->maximum; object_table = the_info->local_table; 200e4ac: 9a 10 20 01 mov 1, %o5 200e4b0: f4 00 e0 1c ld [ %g3 + 0x1c ], %i2 for ( index = 1 ; index <= maximum ; index++ ) { 200e4b4: 10 80 00 23 b 200e540 200e4b8: de 10 e0 10 lduh [ %g3 + 0x10 ], %o7 the_thread = (Thread_Control *) object_table[ index ]; 200e4bc: c6 06 80 03 ld [ %i2 + %g3 ], %g3 if ( !the_thread ) 200e4c0: 80 a0 e0 00 cmp %g3, 0 200e4c4: 02 80 00 1d be 200e538 200e4c8: 98 10 00 04 mov %g4, %o4 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 200e4cc: d8 00 e0 14 ld [ %g3 + 0x14 ], %o4 200e4d0: 80 a3 00 04 cmp %o4, %g4 200e4d4: 38 80 00 19 bgu,a 200e538 200e4d8: 98 10 00 04 mov %g4, %o4 DEBUG_STEP("2"); /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200e4dc: d4 00 e1 6c ld [ %g3 + 0x16c ], %o2 200e4e0: d4 02 a0 c4 ld [ %o2 + 0xc4 ], %o2 200e4e4: 80 ac 00 0a andncc %l0, %o2, %g0 200e4e8: 22 80 00 14 be,a 200e538 200e4ec: 98 10 00 04 mov %g4, %o4 * * NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1 * so we never have to worry about deferencing a NULL * interested thread. */ if ( the_thread->current_priority < interested_priority ) { 200e4f0: 80 a3 00 04 cmp %o4, %g4 200e4f4: 2a 80 00 11 bcs,a 200e538 200e4f8: 82 10 00 03 mov %g3, %g1 * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( !_States_Is_ready( interested->current_state ) ) { 200e4fc: d2 00 60 10 ld [ %g1 + 0x10 ], %o1 200e500: 80 a2 60 00 cmp %o1, 0 200e504: 22 80 00 0d be,a 200e538 200e508: 98 10 00 04 mov %g4, %o4 <== NOT EXECUTED /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 200e50c: d4 00 e0 10 ld [ %g3 + 0x10 ], %o2 200e510: 80 a2 a0 00 cmp %o2, 0 200e514: 22 80 00 09 be,a 200e538 200e518: 82 10 00 03 mov %g3, %g1 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 200e51c: 80 8a 40 0b btst %o1, %o3 200e520: 32 80 00 06 bne,a 200e538 200e524: 98 10 00 04 mov %g4, %o4 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 200e528: 80 8a 80 0b btst %o2, %o3 200e52c: 32 80 00 03 bne,a 200e538 200e530: 82 10 00 03 mov %g3, %g1 200e534: 98 10 00 04 mov %g4, %o4 #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 200e538: 9a 03 60 01 inc %o5 200e53c: 88 10 00 0c mov %o4, %g4 200e540: 80 a3 40 0f cmp %o5, %o7 200e544: 28 bf ff de bleu,a 200e4bc 200e548: 87 2b 60 02 sll %o5, 2, %g3 200e54c: 84 00 a0 04 add %g2, 4, %g2 * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 200e550: 80 a0 80 08 cmp %g2, %o0 200e554: 32 bf ff d2 bne,a 200e49c 200e558: c6 00 80 00 ld [ %g2 ], %g3 } } } } if ( interested ) { 200e55c: 80 a0 60 00 cmp %g1, 0 200e560: 02 80 00 0b be 200e58c 200e564: 01 00 00 00 nop * thread needs to do the post context switch extension so it can * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 200e568: 84 10 20 01 mov 1, %g2 ! 1 /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 200e56c: 90 10 00 01 mov %g1, %o0 * thread needs to do the post context switch extension so it can * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 200e570: c4 28 60 74 stb %g2, [ %g1 + 0x74 ] /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 200e574: 92 10 00 19 mov %i1, %o1 200e578: 40 00 00 5d call 200e6ec <_POSIX_signals_Unblock_thread> 200e57c: 94 07 bf f4 add %fp, -12, %o2 200e580: 80 8a 20 ff btst 0xff, %o0 200e584: 12 80 00 20 bne 200e604 200e588: 01 00 00 00 nop /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 200e58c: 40 00 00 47 call 200e6a8 <_POSIX_signals_Set_process_signals> 200e590: 90 10 00 10 mov %l0, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 200e594: 83 2e 60 04 sll %i1, 4, %g1 200e598: b3 2e 60 02 sll %i1, 2, %i1 200e59c: b2 20 40 19 sub %g1, %i1, %i1 200e5a0: 03 00 80 6e sethi %hi(0x201b800), %g1 200e5a4: 82 10 62 f4 or %g1, 0x2f4, %g1 ! 201baf4 <_POSIX_signals_Vectors> 200e5a8: c2 00 40 19 ld [ %g1 + %i1 ], %g1 200e5ac: 80 a0 60 02 cmp %g1, 2 200e5b0: 12 80 00 15 bne 200e604 200e5b4: 11 00 80 6f sethi %hi(0x201bc00), %o0 psiginfo = (POSIX_signals_Siginfo_node *) 200e5b8: 7f ff f4 77 call 200b794 <_Chain_Get> 200e5bc: 90 12 20 74 or %o0, 0x74, %o0 ! 201bc74 <_POSIX_signals_Inactive_siginfo> _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 200e5c0: a0 92 20 00 orcc %o0, 0, %l0 200e5c4: 12 80 00 08 bne 200e5e4 200e5c8: 92 07 bf f4 add %fp, -12, %o1 _Thread_Enable_dispatch(); 200e5cc: 7f ff e4 6a call 2007774 <_Thread_Enable_dispatch> 200e5d0: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EAGAIN ); 200e5d4: 40 00 00 f7 call 200e9b0 <__errno> 200e5d8: 01 00 00 00 nop 200e5dc: 10 bf ff 67 b 200e378 200e5e0: 82 10 20 0b mov 0xb, %g1 ! b } psiginfo->Info = *siginfo; 200e5e4: 90 04 20 08 add %l0, 8, %o0 200e5e8: 40 00 03 2d call 200f29c 200e5ec: 94 10 20 0c mov 0xc, %o2 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 200e5f0: 11 00 80 6f sethi %hi(0x201bc00), %o0 200e5f4: 92 10 00 10 mov %l0, %o1 200e5f8: 90 12 20 c4 or %o0, 0xc4, %o0 200e5fc: 7f ff de 79 call 2005fe0 <_Chain_Append> 200e600: 90 02 00 19 add %o0, %i1, %o0 } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 200e604: 7f ff e4 5c call 2007774 <_Thread_Enable_dispatch> 200e608: 01 00 00 00 nop 200e60c: 90 10 20 00 clr %o0 ! 0 return 0; } 200e610: b0 10 00 08 mov %o0, %i0 200e614: 81 c7 e0 08 ret 200e618: 81 e8 00 00 restore