RTEMS-5
Annotated Report
Wed Aug 8 20:48:53 2018
4000dbb4 <_Event_Seize>:
Event_Control *event,
Thread_Wait_flags wait_class,
States_Control block_state,
ISR_lock_Context *lock_context
)
{
4000dbb4: 9d e3 bf 98 save %sp, -104, %sp
rtems_event_set pending_events;
bool success;
Thread_Wait_flags intend_to_block;
Per_CPU_Control *cpu_self;
pending_events = event->pending_events;
4000dbb8: c2 07 40 00 ld [ %i5 ], %g1
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
4000dbbc: 84 88 40 18 andcc %g1, %i0, %g2
4000dbc0: 02 80 00 07 be 4000dbdc <_Event_Seize+0x28>
4000dbc4: 80 8e 60 01 btst 1, %i1
4000dbc8: 80 a6 00 02 cmp %i0, %g2
4000dbcc: 02 80 00 3e be 4000dcc4 <_Event_Seize+0x110>
<== NEVER TAKEN
4000dbd0: 80 8e 60 02 btst 2, %i1
(seized_events == event_in || _Options_Is_any( option_set )) ) {
4000dbd4: 12 80 00 3c bne 4000dcc4 <_Event_Seize+0x110>
<== ALWAYS TAKEN
4000dbd8: 80 8e 60 01 btst 1, %i1
_Thread_Wait_release_default( executing, lock_context );
*event_out = seized_events;
return RTEMS_SUCCESSFUL;
}
if ( _Options_Is_no_wait( option_set ) ) {
4000dbdc: 12 80 00 33 bne 4000dca8 <_Event_Seize+0xf4>
4000dbe0: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
_Thread_Wait_release_default( executing, lock_context );
*event_out = seized_events;
return RTEMS_UNSATISFIED;
}
intend_to_block = wait_class | THREAD_WAIT_STATE_INTEND_TO_BLOCK;
4000dbe4: a0 10 60 01 or %g1, 1, %l0
<== NOT EXECUTED
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
4000dbe8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
* set properly when we are marked as in the event critical section.
*
* NOTE: Since interrupts are disabled, this isn't that much of an
* issue but better safe than sorry.
*/
executing->Wait.return_code = STATUS_SUCCESSFUL;
4000dbec: c0 27 20 4c clr [ %i4 + 0x4c ]
<== NOT EXECUTED
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000dbf0: 82 00 60 01 inc %g1
<== NOT EXECUTED
executing->Wait.option = option_set;
4000dbf4: f2 27 20 48 st %i1, [ %i4 + 0x48 ]
<== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(
const ISR_lock_Context *lock_context
)
{
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000dbf8: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
executing->Wait.count = event_in;
4000dbfc: f0 27 20 3c st %i0, [ %i4 + 0x3c ]
<== NOT EXECUTED
executing->Wait.return_argument = event_out;
4000dc00: f6 27 20 40 st %i3, [ %i4 + 0x40 ]
<== NOT EXECUTED
)
{
#if defined(RTEMS_SMP)
_Atomic_Store_uint( &the_thread->Wait.flags, flags, ATOMIC_ORDER_RELAXED );
#else
the_thread->Wait.flags = flags;
4000dc04: e0 27 20 50 st %l0, [ %i4 + 0x50 ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000dc08: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000dc0c: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
<== NOT EXECUTED
4000dc10: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dc14: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dc18: 01 00 00 00 nop
_Thread_Wait_flags_set( executing, intend_to_block );
cpu_self = _Thread_Dispatch_disable_critical( lock_context );
_Thread_Wait_release_default( executing, lock_context );
if ( ticks ) {
4000dc1c: 80 a6 a0 00 cmp %i2, 0
4000dc20: 12 80 00 32 bne 4000dce8 <_Event_Seize+0x134>
4000dc24: 01 00 00 00 nop
_Thread_Add_timeout_ticks( executing, cpu_self, ticks );
}
_Thread_Set_state( executing, block_state );
4000dc28: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
4000dc2c: 40 00 1e 6f call 400155e8 <_Thread_Set_state>
4000dc30: 90 10 00 1c mov %i4, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dc34: 91 d0 20 09 ta 9
<== NOT EXECUTED
desired_flags,
ATOMIC_ORDER_RELEASE,
ATOMIC_ORDER_RELAXED
);
#else
bool success = ( the_thread->Wait.flags == expected_flags );
4000dc38: c6 07 20 50 ld [ %i4 + 0x50 ], %g3
if ( success ) {
4000dc3c: 80 a4 00 03 cmp %l0, %g3
4000dc40: 12 80 00 04 bne 4000dc50 <_Event_Seize+0x9c>
<== NEVER TAKEN
4000dc44: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
<== NOT EXECUTED
success = _Thread_Wait_flags_try_change_acquire(
4000dc48: 84 10 a0 02 or %g2, 2, %g2
<== NOT EXECUTED
the_thread->Wait.flags = desired_flags;
4000dc4c: c4 27 20 50 st %g2, [ %i4 + 0x50 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dc50: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dc54: 01 00 00 00 nop
executing,
intend_to_block,
wait_class | THREAD_WAIT_STATE_BLOCKED
);
if ( !success ) {
4000dc58: 80 a4 00 03 cmp %l0, %g3
4000dc5c: 02 80 00 0e be 4000dc94 <_Event_Seize+0xe0>
<== ALWAYS TAKEN
4000dc60: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dc64: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000dc68: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
)
{
ISR_lock_Context lock_context;
_Watchdog_Per_CPU_acquire_critical( cpu, &lock_context );
_Watchdog_Remove(
4000dc6c: d0 07 20 60 ld [ %i4 + 0x60 ], %o0
<== NOT EXECUTED
4000dc70: 40 00 20 61 call 40015df4 <_Watchdog_Remove>
<== NOT EXECUTED
4000dc74: 92 07 20 68 add %i4, 0x68, %o1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000dc78: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dc7c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dc80: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000dc84: 13 0c 00 57 sethi %hi(0x30015c00), %o1
<== NOT EXECUTED
4000dc88: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000dc8c: 40 00 15 c5 call 400133a0 <_Thread_Clear_state>
<== NOT EXECUTED
4000dc90: 92 12 63 ff or %o1, 0x3ff, %o1
<== NOT EXECUTED
_Thread_Timer_remove( executing );
_Thread_Unblock( executing );
}
_Thread_Dispatch_direct( cpu_self );
4000dc94: 40 00 16 65 call 40013628 <_Thread_Dispatch_direct>
4000dc98: 90 10 00 1d mov %i5, %o0
RTEMS_INLINE_ROUTINE rtems_status_code _Status_Get(
Status_Control status
)
{
return (rtems_status_code) STATUS_GET_CLASSIC( status );
4000dc9c: f0 0f 20 4f ldub [ %i4 + 0x4f ], %i0
return _Status_Get_after_wait( executing );
}
4000dca0: 81 c7 e0 08 ret
4000dca4: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000dca8: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
<== NOT EXECUTED
4000dcac: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dcb0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dcb4: 01 00 00 00 nop
*event_out = seized_events;
4000dcb8: c4 26 c0 00 st %g2, [ %i3 ]
return RTEMS_UNSATISFIED;
4000dcbc: 81 c7 e0 08 ret
4000dcc0: 91 e8 20 0d restore %g0, 0xd, %o0
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
4000dcc4: 82 28 40 02 andn %g1, %g2, %g1
<== NOT EXECUTED
event->pending_events =
4000dcc8: c2 27 40 00 st %g1, [ %i5 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000dccc: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
<== NOT EXECUTED
4000dcd0: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dcd4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dcd8: 01 00 00 00 nop
*event_out = seized_events;
4000dcdc: c4 26 c0 00 st %g2, [ %i3 ]
return RTEMS_SUCCESSFUL;
4000dce0: 81 c7 e0 08 ret
4000dce4: 91 e8 20 00 restore %g0, 0, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000dce8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000dcec: c2 27 bf fc st %g1, [ %fp + -4 ]
_ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock, &lock_context );
the_thread->Timer.header =
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
4000dcf0: 05 10 00 56 sethi %hi(0x40015800), %g2
expire = ticks + cpu->Watchdog.ticks;
4000dcf4: d4 19 a0 30 ldd [ %g6 + 0x30 ], %o2
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
4000dcf8: 90 01 a0 38 add %g6, 0x38, %o0
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
4000dcfc: 84 10 a0 54 or %g2, 0x54, %g2
the_thread->Timer.header =
4000dd00: d0 27 20 60 st %o0, [ %i4 + 0x60 ]
_Watchdog_Insert(header, the_watchdog, expire);
4000dd04: 86 82 c0 1a addcc %o3, %i2, %g3
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
4000dd08: c4 27 20 78 st %g2, [ %i4 + 0x78 ]
4000dd0c: 84 42 a0 00 addx %o2, 0, %g2
4000dd10: 92 07 20 68 add %i4, 0x68, %o1
4000dd14: 94 10 00 02 mov %g2, %o2
4000dd18: 40 00 20 0f call 40015d54 <_Watchdog_Insert>
4000dd1c: 96 10 00 03 mov %g3, %o3
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000dd20: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000dd24: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000dd28: 01 00 00 00 nop
_Thread_Set_state( executing, block_state );
4000dd2c: 10 bf ff c0 b 4000dc2c <_Event_Seize+0x78>
4000dd30: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
4000d878 <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_Wait_flags wait_class,
ISR_lock_Context *lock_context
)
{
4000d878: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE void _Event_sets_Post(
rtems_event_set the_new_events,
rtems_event_set *the_event_set
)
{
*the_event_set |= the_new_events;
4000d87c: c2 06 80 00 ld [ %i2 ], %g1
4000d880: b2 16 40 01 or %i1, %g1, %i1
4000d884: f2 26 80 00 st %i1, [ %i2 ]
return ( wait_flags & wait_mask ) == wait_class;
4000d888: 03 00 00 3f sethi %hi(0xfc00), %g1
4000d88c: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
4000d890: 82 10 63 04 or %g1, 0x304, %g1
4000d894: 82 08 80 01 and %g2, %g1, %g1
_Thread_Wait_acquire_default_critical( the_thread, lock_context );
_Event_sets_Post( event_in, &event->pending_events );
pending_events = event->pending_events;
if (
4000d898: 80 a0 40 1b cmp %g1, %i3
4000d89c: 22 80 00 07 be,a 4000d8b8 <_Event_Surrender+0x40>
4000d8a0: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000d8a4: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000d8a8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000d8ac: 01 00 00 00 nop
} else {
_Thread_Wait_release_default( the_thread, lock_context );
}
return RTEMS_SUCCESSFUL;
}
4000d8b0: 81 c7 e0 08 ret
4000d8b4: 91 e8 20 00 restore %g0, 0, %o0
&& ( *seized_events == event_condition || _Options_Is_any( option_set ) );
4000d8b8: 88 88 c0 19 andcc %g3, %i1, %g4
4000d8bc: 02 bf ff fa be 4000d8a4 <_Event_Surrender+0x2c>
<== NEVER TAKEN
4000d8c0: 80 a0 c0 04 cmp %g3, %g4
4000d8c4: 02 80 00 05 be 4000d8d8 <_Event_Surrender+0x60>
4000d8c8: fa 06 20 48 ld [ %i0 + 0x48 ], %i5
4000d8cc: 80 8f 60 02 btst 2, %i5
4000d8d0: 02 bf ff f5 be 4000d8a4 <_Event_Surrender+0x2c>
<== NEVER TAKEN
4000d8d4: 01 00 00 00 nop
4000d8d8: fa 06 20 40 ld [ %i0 + 0x40 ], %i5
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
4000d8dc: b2 2e 40 04 andn %i1, %g4, %i1
event->pending_events = _Event_sets_Clear( pending_events, seized_events );
4000d8e0: f2 26 80 00 st %i1, [ %i2 ]
success = _Thread_Wait_flags_try_change_release(
4000d8e4: 86 10 60 01 or %g1, 1, %g3
*(rtems_event_set *) the_thread->Wait.return_argument = seized_events;
4000d8e8: c8 27 40 00 st %g4, [ %i5 ]
ready_again = wait_class | THREAD_WAIT_STATE_READY_AGAIN;
4000d8ec: 82 10 60 04 or %g1, 4, %g1
if ( success ) {
4000d8f0: 80 a0 c0 02 cmp %g3, %g2
4000d8f4: 02 bf ff ec be 4000d8a4 <_Event_Surrender+0x2c>
<== NEVER TAKEN
4000d8f8: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000d8fc: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000d900: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000d904: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000d908: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000d90c: c2 07 00 00 ld [ %i4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000d910: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000d914: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000d918: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000d91c: c2 27 bf fc st %g1, [ %fp + -4 ]
_Watchdog_Remove(
4000d920: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
4000d924: 7f ff f9 f4 call 4000c0f4 <_Watchdog_Remove>
4000d928: 92 06 20 68 add %i0, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000d92c: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000d930: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000d934: 01 00 00 00 nop
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000d938: 13 0c 00 57 sethi %hi(0x30015c00), %o1
4000d93c: 90 10 00 18 mov %i0, %o0
4000d940: 40 00 02 7d call 4000e334 <_Thread_Clear_state>
4000d944: 92 12 63 ff or %o1, 0x3ff, %o1
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000d948: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000d94c: 80 a0 60 01 cmp %g1, 1
4000d950: 02 80 00 04 be 4000d960 <_Event_Surrender+0xe8>
<== ALWAYS TAKEN
4000d954: 82 00 7f ff add %g1, -1, %g1
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000d958: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
4000d95c: 30 bf ff d5 b,a 4000d8b0 <_Event_Surrender+0x38>
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000d960: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000d964: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
4000d968: 80 a0 a0 00 cmp %g2, 0
4000d96c: 12 80 00 06 bne 4000d984 <_Event_Surrender+0x10c>
4000d970: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
4000d974: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000d978: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000d97c: 01 00 00 00 nop
4000d980: 30 bf ff cc b,a 4000d8b0 <_Event_Surrender+0x38>
_Thread_Do_dispatch( cpu_self, level );
4000d984: c2 27 bf fc st %g1, [ %fp + -4 ]
4000d988: 7f ff f1 bf call 4000a084 <_Thread_Do_dispatch>
4000d98c: 90 10 00 1d mov %i5, %o0
4000d990: 10 bf ff fa b 4000d978 <_Event_Surrender+0x100>
4000d994: c2 07 bf fc ld [ %fp + -4 ], %g1
4000678c <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
4000678c: 9d e3 bf 98 save %sp, -104, %sp
rtems_task_entry entry_point;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
40006790: 03 10 00 47 sethi %hi(0x40011c00), %g1
40006794: 82 10 61 84 or %g1, 0x184, %g1 ! 40011d84 <Configuration_RTEMS_API>
40006798: fa 00 60 28 ld [ %g1 + 0x28 ], %i5
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
4000679c: 80 a7 60 00 cmp %i5, 0
400067a0: 02 80 00 21 be 40006824 <_RTEMS_tasks_Initialize_user_tasks_body+0x98>
<== NEVER TAKEN
400067a4: 01 00 00 00 nop
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
400067a8: f4 00 60 24 ld [ %g1 + 0x24 ], %i2
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
400067ac: 80 a6 a0 00 cmp %i2, 0
400067b0: 02 80 00 1d be 40006824 <_RTEMS_tasks_Initialize_user_tasks_body+0x98>
<== NEVER TAKEN
400067b4: b8 10 20 00 clr %i4
user_tasks[ index ].argument
);
_Assert( rtems_is_status_successful( return_value ) );
(void) return_value;
if ( _Thread_Global_constructor == 0 ) {
400067b8: 37 10 00 4e sethi %hi(0x40013800), %i3
return_value = rtems_task_create(
400067bc: d8 07 60 0c ld [ %i5 + 0xc ], %o4
400067c0: d6 07 60 14 ld [ %i5 + 0x14 ], %o3
400067c4: d4 07 60 04 ld [ %i5 + 4 ], %o2
400067c8: d2 07 60 08 ld [ %i5 + 8 ], %o1
400067cc: d0 07 40 00 ld [ %i5 ], %o0
400067d0: 7f ff ff 4c call 40006500 <rtems_task_create>
400067d4: 9a 07 bf fc add %fp, -4, %o5
if ( !rtems_is_status_successful( return_value ) ) {
400067d8: 80 a2 20 00 cmp %o0, 0
400067dc: 12 80 00 14 bne 4000682c <_RTEMS_tasks_Initialize_user_tasks_body+0xa0>
<== NEVER TAKEN
400067e0: 01 00 00 00 nop
entry_point = user_tasks[ index ].entry_point;
400067e4: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
if ( entry_point == NULL ) {
400067e8: 80 a2 60 00 cmp %o1, 0
400067ec: 02 80 00 12 be 40006834 <_RTEMS_tasks_Initialize_user_tasks_body+0xa8>
<== NEVER TAKEN
400067f0: 01 00 00 00 nop
return_value = rtems_task_start(
400067f4: d4 07 60 18 ld [ %i5 + 0x18 ], %o2
400067f8: 40 00 00 24 call 40006888 <rtems_task_start>
400067fc: d0 07 bf fc ld [ %fp + -4 ], %o0
if ( _Thread_Global_constructor == 0 ) {
40006800: c2 06 e1 d0 ld [ %i3 + 0x1d0 ], %g1
40006804: 80 a0 60 00 cmp %g1, 0
40006808: 12 80 00 04 bne 40006818 <_RTEMS_tasks_Initialize_user_tasks_body+0x8c>
<== NEVER TAKEN
4000680c: b8 07 20 01 inc %i4
_Thread_Global_constructor = id;
40006810: c2 07 bf fc ld [ %fp + -4 ], %g1
40006814: c2 26 e1 d0 st %g1, [ %i3 + 0x1d0 ]
for ( index=0 ; index < maximum ; index++ ) {
40006818: 80 a6 80 1c cmp %i2, %i4
4000681c: 12 bf ff e8 bne 400067bc <_RTEMS_tasks_Initialize_user_tasks_body+0x30>
<== NEVER TAKEN
40006820: ba 07 60 1c add %i5, 0x1c, %i5
}
}
}
40006824: 81 c7 e0 08 ret
40006828: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_RTEMS_INIT_TASK_CREATE_FAILED );
4000682c: 40 00 02 b0 call 400072ec <_Internal_error>
<== NOT EXECUTED
40006830: 90 10 20 20 mov 0x20, %o0
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_RTEMS_INIT_TASK_ENTRY_IS_NULL );
40006834: 40 00 02 ae call 400072ec <_Internal_error>
<== NOT EXECUTED
40006838: 90 10 20 1a mov 0x1a, %o0
<== NOT EXECUTED
4000683c: 01 00 00 00 nop
<== NOT EXECUTED
40058d30 <_Rate_monotonic_Get_status>:
bool _Rate_monotonic_Get_status(
const Rate_monotonic_Control *the_period,
Timestamp_Control *wall_since_last_period,
Timestamp_Control *cpu_since_last_period
)
{
40058d30: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
40058d34: 7f ff 0b 15 call 4001b988 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
40058d38: fa 06 20 54 ld [ %i0 + 0x54 ], %i5
<== NOT EXECUTED
*_result = *_end - *_start;
40058d3c: c4 1e 20 60 ldd [ %i0 + 0x60 ], %g2
<== NOT EXECUTED
40058d40: 9a a2 40 03 subcc %o1, %g3, %o5
<== NOT EXECUTED
40058d44: 98 62 00 02 subx %o0, %g2, %o4
<== NOT EXECUTED
40058d48: 92 10 00 0d mov %o5, %o1
<== NOT EXECUTED
40058d4c: 90 10 00 0c mov %o4, %o0
<== NOT EXECUTED
40058d50: d0 3e 40 00 std %o0, [ %i1 ]
<== NOT EXECUTED
);
/*
* Determine cpu usage since period initiated.
*/
_Thread_Get_CPU_time_used( owning_thread, &used );
40058d54: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40058d58: 7f ff b1 45 call 4004526c <_Thread_Get_CPU_time_used>
<== NOT EXECUTED
40058d5c: 92 07 bf f8 add %fp, -8, %o1
<== NOT EXECUTED
40058d60: c4 1e 20 58 ldd [ %i0 + 0x58 ], %g2
<== NOT EXECUTED
40058d64: f8 1f bf f8 ldd [ %fp + -8 ], %i4
<== NOT EXECUTED
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if ( _Timestamp_Less_than( &used, &the_period->cpu_usage_period_initiated ) )
40058d68: 80 a0 80 1c cmp %g2, %i4
<== NOT EXECUTED
40058d6c: 14 80 00 0e bg 40058da4 <_Rate_monotonic_Get_status+0x74>
<== NOT EXECUTED
40058d70: b0 10 20 00 clr %i0
<== NOT EXECUTED
40058d74: 02 80 00 09 be 40058d98 <_Rate_monotonic_Get_status+0x68>
<== NOT EXECUTED
40058d78: 80 a0 c0 1d cmp %g3, %i5
<== NOT EXECUTED
40058d7c: 9a a7 40 03 subcc %i5, %g3, %o5
<== NOT EXECUTED
&the_period->cpu_usage_period_initiated,
&used,
cpu_since_last_period
);
return true;
40058d80: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
40058d84: 98 67 00 02 subx %i4, %g2, %o4
<== NOT EXECUTED
}
40058d88: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40058d8c: d8 3e 80 00 std %o4, [ %i2 ]
<== NOT EXECUTED
40058d90: 81 c7 e0 08 ret
<== NOT EXECUTED
40058d94: 81 e8 00 00 restore
<== NOT EXECUTED
if ( _Timestamp_Less_than( &used, &the_period->cpu_usage_period_initiated ) )
40058d98: 08 bf ff fa bleu 40058d80 <_Rate_monotonic_Get_status+0x50>
<== NOT EXECUTED
40058d9c: 9a a7 40 03 subcc %i5, %g3, %o5
<== NOT EXECUTED
return false;
40058da0: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
40058da4: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40058da8: 81 c7 e0 08 ret
<== NOT EXECUTED
40058dac: 81 e8 00 00 restore
<== NOT EXECUTED
4001a374 <_Signal_Action_handler>:
void _Signal_Action_handler(
Thread_Control *executing,
Thread_Action *action,
ISR_lock_Context *lock_context
)
{
4001a374: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
/*
* Signal Processing
*/
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4001a378: fa 06 21 58 ld [ %i0 + 0x158 ], %i5
<== NOT EXECUTED
ASR_Information *asr
)
{
rtems_signal_set signal_set;
signal_set = asr->signals_posted;
4001a37c: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
<== NOT EXECUTED
asr->signals_posted = 0;
4001a380: c0 27 60 14 clr [ %i5 + 0x14 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4001a384: c2 06 80 00 ld [ %i2 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001a388: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4001a38c: 01 00 00 00 nop
<== NOT EXECUTED
asr = &api->Signal;
signal_set = _ASR_Get_posted_signals( asr );
_Thread_State_release( executing, lock_context );
if ( signal_set == 0 ) {
4001a390: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
4001a394: 32 80 00 04 bne,a 4001a3a4 <_Signal_Action_handler+0x30>
<== NOT EXECUTED
4001a398: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
(*asr->handler)( signal_set );
asr->nest_level -= 1;
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
}
4001a39c: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a3a0: 81 e8 00 00 restore
<== NOT EXECUTED
asr->nest_level += 1;
4001a3a4: 82 00 60 01 inc %g1
<== NOT EXECUTED
4001a3a8: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
<== NOT EXECUTED
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
4001a3ac: 94 07 bf fc add %fp, -4, %o2
<== NOT EXECUTED
4001a3b0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
<== NOT EXECUTED
4001a3b4: 37 00 00 3f sethi %hi(0xfc00), %i3
<== NOT EXECUTED
4001a3b8: 7f ff d2 72 call 4000ed80 <rtems_task_mode>
<== NOT EXECUTED
4001a3bc: 92 16 e3 ff or %i3, 0x3ff, %o1 ! ffff <_Configuration_Interrupt_stack_size+0xefff>
<== NOT EXECUTED
(*asr->handler)( signal_set );
4001a3c0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
4001a3c4: 9f c0 40 00 call %g1
<== NOT EXECUTED
4001a3c8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
asr->nest_level -= 1;
4001a3cc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4001a3d0: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4001a3d4: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
<== NOT EXECUTED
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
4001a3d8: 94 07 bf fc add %fp, -4, %o2
<== NOT EXECUTED
4001a3dc: d0 07 bf fc ld [ %fp + -4 ], %o0
<== NOT EXECUTED
4001a3e0: 7f ff d2 68 call 4000ed80 <rtems_task_mode>
<== NOT EXECUTED
4001a3e4: 92 16 e3 ff or %i3, 0x3ff, %o1
<== NOT EXECUTED
}
4001a3e8: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a3ec: 81 e8 00 00 restore
<== NOT EXECUTED
40010ac8 <_Status_Object_name_errors_to_status>:
40010ac8: 00 00 00 00 00 00 00 03 00 00 00 09 00 00 00 04 ................
40010ad8: 00 00 00 15 ....
400838d8 <_TOD_Days_per_month>:
400838d8: 00 00 00 00 00 00 00 1f 00 00 00 1c 00 00 00 1f ................
400838e8: 00 00 00 1e 00 00 00 1f 00 00 00 1e 00 00 00 1f ................
400838f8: 00 00 00 1f 00 00 00 1e 00 00 00 1f 00 00 00 1e ................
40083908: 00 00 00 1f 00 00 00 00 00 00 00 1f 00 00 00 1d ................
40083918: 00 00 00 1f 00 00 00 1e 00 00 00 1f 00 00 00 1e ................
40083928: 00 00 00 1f 00 00 00 1f 00 00 00 1e 00 00 00 1f ................
40083938: 00 00 00 1e 00 00 00 1f 50 65 72 69 6f 64 20 69 ........Period i
40083948: 6e 66 6f 72 6d 61 74 69 6f 6e 20 62 79 20 70 65 nformation by pe
40083958: 72 69 6f 64 0a 00 00 00 2d 2d 2d 20 43 50 55 20 riod....--- CPU
40083968: 74 69 6d 65 73 20 61 72 65 20 69 6e 20 73 65 63 times are in sec
40083978: 6f 6e 64 73 20 2d 2d 2d 0a 00 00 00 00 00 00 00 onds ---........
40083988: 2d 2d 2d 20 57 61 6c 6c 20 74 69 6d 65 73 20 61 --- Wall times a
40083998: 72 65 20 69 6e 20 73 65 63 6f 6e 64 73 20 2d 2d re in seconds --
400839a8: 2d 0a 00 00 00 00 00 00 20 20 20 49 44 20 20 20 -....... ID
400839b8: 20 20 4f 57 4e 45 52 20 43 4f 55 4e 54 20 4d 49 OWNER COUNT MI
400839c8: 53 53 45 44 20 20 20 20 20 20 20 20 20 20 43 50 SSED CP
400839d8: 55 20 54 49 4d 45 20 20 20 20 20 20 20 20 20 20 U TIME
400839e8: 20 20 20 20 20 20 20 20 57 41 4c 4c 20 54 49 4d WALL TIM
400839f8: 45 0a 20 20 20 20 20 20 20 20 20 20 20 20 20 20 E.
40083a08: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20
40083a18: 20 20 20 20 20 20 4d 49 4e 2f 4d 41 58 2f 41 56 MIN/MAX/AV
40083a28: 47 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 G
40083a38: 20 4d 49 4e 2f 4d 41 58 2f 41 56 47 0a 00 00 00 MIN/MAX/AVG....
40083a48: 30 78 25 30 38 6c 78 20 25 34 73 20 25 35 6c 64 0x%08lx %4s %5ld
40083a58: 20 25 36 6c 64 20 00 00 25 6c 6c 64 2e 25 30 36 %6ld ..%lld.%06
40083a68: 6c 64 2f 25 6c 6c 64 2e 25 30 36 6c 64 2f 25 6c ld/%lld.%06ld/%l
40083a78: 6c 64 2e 25 30 36 6c 64 20 00 00 00 00 00 00 00 ld.%06ld .......
40083a88: 25 6c 6c 64 2e 25 30 36 6c 64 2f 25 6c 6c 64 2e %lld.%06ld/%lld.
40083a98: 25 30 36 6c 64 2f 25 6c 6c 64 2e 25 30 36 6c 64 %06ld/%lld.%06ld
40083aa8: 0a 00 00 00 00 00 00 00 35 2e 30 2e 30 2e 32 34 ........5.0.0.24
40083ab8: 38 63 61 37 61 64 34 30 31 39 66 33 38 37 61 32 8ca7ad4019f387a2
40083ac8: 38 62 39 31 61 36 35 32 35 34 30 65 33 30 32 64 8b91a652540e302d
40083ad8: 65 37 66 32 33 65 00 00 5f 54 4f 44 00 00 00 00 e7f23e.._TOD....
4008389a <_TOD_Days_since_last_leap_year>:
4008389a: 00 00 01 6e 02 db 04 48 ...n...H
400838a2 <_TOD_Days_to_date>:
400838a2: 00 00 00 00 00 1f 00 3b 00 5a 00 78 00 97 00 b5 .......;.Z.x....
400838b2: 00 d4 00 f3 01 11 01 30 01 4e 00 00 00 00 00 1f .......0.N......
400838c2: 00 3c 00 5b 00 79 00 98 00 b6 00 d5 00 f4 01 12 .<.[.y..........
400838d2: 01 31 01 4f 00 00 .1.O..
40043f00 <_TOD_To_seconds>:
)
{
uint32_t time;
uint32_t year_mod_4;
time = the_tod->day - 1;
40043f00: c6 02 20 08 ld [ %o0 + 8 ], %g3
year_mod_4 = the_tod->year & 3;
40043f04: c2 02 00 00 ld [ %o0 ], %g1
time = the_tod->day - 1;
40043f08: 86 00 ff ff add %g3, -1, %g3
if ( year_mod_4 == 0 )
40043f0c: 88 88 60 03 andcc %g1, 3, %g4
40043f10: 12 80 00 03 bne 40043f1c <_TOD_To_seconds+0x1c>
40043f14: c4 02 20 04 ld [ %o0 + 4 ], %g2
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
40043f18: 84 00 a0 0d add %g2, 0xd, %g2
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
40043f1c: 85 28 a0 01 sll %g2, 1, %g2
40043f20: 1b 10 02 0e sethi %hi(0x40083800), %o5
40043f24: 9a 13 60 a2 or %o5, 0xa2, %o5 ! 400838a2 <_TOD_Days_to_date>
40043f28: c4 13 40 02 lduh [ %o5 + %g2 ], %g2
40043f2c: 86 00 80 03 add %g2, %g3, %g3
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
40043f30: 1b 10 02 0e sethi %hi(0x40083800), %o5
time *= TOD_SECONDS_PER_DAY;
time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
40043f34: c4 02 20 0c ld [ %o0 + 0xc ], %g2
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
40043f38: 9a 13 60 9a or %o5, 0x9a, %o5
40043f3c: 89 29 20 01 sll %g4, 1, %g4
time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
40043f40: d8 02 20 10 ld [ %o0 + 0x10 ], %o4
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
40043f44: d6 13 40 04 lduh [ %o5 + %g4 ], %o3
* TOD_SECONDS_PER_MINUTE;
time += the_tod->second;
40043f48: da 02 20 14 ld [ %o0 + 0x14 ], %o5
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
40043f4c: 90 00 78 3c add %g1, -1988, %o0
time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
40043f50: 83 28 a0 04 sll %g2, 4, %g1
40043f54: 82 20 40 02 sub %g1, %g2, %g1
40043f58: 83 28 60 02 sll %g1, 2, %g1
40043f5c: 84 00 40 0c add %g1, %o4, %g2
* TOD_SECONDS_PER_MINUTE;
40043f60: 83 28 a0 04 sll %g2, 4, %g1
40043f64: 82 20 40 02 sub %g1, %g2, %g1
40043f68: 83 28 60 02 sll %g1, 2, %g1
time += the_tod->second;
40043f6c: 82 00 40 0d add %g1, %o5, %g1
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
40043f70: 91 32 20 02 srl %o0, 2, %o0
time *= TOD_SECONDS_PER_DAY;
40043f74: 09 00 00 54 sethi %hi(0x15000), %g4
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
40043f78: 90 5a 25 b5 smul %o0, 0x5b5, %o0
time *= TOD_SECONDS_PER_DAY;
40043f7c: 88 11 21 80 or %g4, 0x180, %g4
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
40043f80: 90 02 00 0b add %o0, %o3, %o0
40043f84: 90 02 00 03 add %o0, %g3, %o0
time *= TOD_SECONDS_PER_DAY;
40043f88: 90 5a 00 04 smul %o0, %g4, %o0
time += the_tod->second;
40043f8c: 90 00 40 08 add %g1, %o0, %o0
/* The year 2100 is not a leap year */
if ( time
40043f90: 03 34 be 4b sethi %hi(0xd2f92c00), %g1
40043f94: 82 10 60 6f or %g1, 0x6f, %g1 ! d2f92c6f <RAM_END+0x92b92c6f>
40043f98: 80 a2 00 01 cmp %o0, %g1
40043f9c: 38 80 00 02 bgu,a 40043fa4 <_TOD_To_seconds+0xa4>
<== NEVER TAKEN
40043fa0: 90 22 00 04 sub %o0, %g4, %o0
<== NOT EXECUTED
>= (TOD_SECONDS_AT_2100_03_01_00_00 - TOD_SECONDS_1970_THROUGH_1988)) {
time -= TOD_SECONDS_PER_DAY;
}
time += TOD_SECONDS_1970_THROUGH_1988;
40043fa4: 03 08 76 b9 sethi %hi(0x21dae400), %g1
40043fa8: 82 10 61 00 or %g1, 0x100, %g1 ! 21dae500 <RAM_SIZE+0x219ae500>
return( time );
}
40043fac: 81 c3 e0 08 retl
40043fb0: 90 02 00 01 add %o0, %g1, %o0
40043fb4 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
40043fb4: 9d e3 bf a0 save %sp, -96, %sp
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
40043fb8: 80 a6 20 00 cmp %i0, 0
40043fbc: 02 80 00 1f be 40044038 <_TOD_Validate+0x84>
<== NEVER TAKEN
40043fc0: 84 10 20 00 clr %g2
40043fc4: c8 06 20 18 ld [ %i0 + 0x18 ], %g4
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
40043fc8: 07 10 01 f1 sethi %hi(0x4007c400), %g3
40043fcc: 03 00 03 d0 sethi %hi(0xf4000), %g1
40043fd0: 82 10 62 40 or %g1, 0x240, %g1 ! f4240 <_Configuration_Interrupt_stack_size+0xf3240>
40043fd4: 81 80 20 00 wr %g0, %y
40043fd8: de 00 e1 f0 ld [ %g3 + 0x1f0 ], %o7
40043fdc: 01 00 00 00 nop
40043fe0: 01 00 00 00 nop
40043fe4: 9e 70 40 0f udiv %g1, %o7, %o7
if ((!the_tod) ||
40043fe8: 80 a1 00 0f cmp %g4, %o7
40043fec: 3a 80 00 14 bcc,a 4004403c <_TOD_Validate+0x88>
<== NEVER TAKEN
40043ff0: b0 08 a0 01 and %g2, 1, %i0
<== NOT EXECUTED
(the_tod->ticks >= ticks_per_second) ||
40043ff4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40043ff8: 80 a0 60 3b cmp %g1, 0x3b
40043ffc: 38 80 00 10 bgu,a 4004403c <_TOD_Validate+0x88>
<== NEVER TAKEN
40044000: b0 08 a0 01 and %g2, 1, %i0
<== NOT EXECUTED
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
40044004: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40044008: 80 a0 60 3b cmp %g1, 0x3b
4004400c: 38 80 00 0c bgu,a 4004403c <_TOD_Validate+0x88>
<== NEVER TAKEN
40044010: b0 08 a0 01 and %g2, 1, %i0
<== NOT EXECUTED
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
40044014: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40044018: 80 a0 60 17 cmp %g1, 0x17
4004401c: 38 80 00 08 bgu,a 4004403c <_TOD_Validate+0x88>
<== NEVER TAKEN
40044020: b0 08 a0 01 and %g2, 1, %i0
<== NOT EXECUTED
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
40044024: c2 06 20 04 ld [ %i0 + 4 ], %g1
40044028: 86 00 7f ff add %g1, -1, %g3
4004402c: 80 a0 e0 0b cmp %g3, 0xb
40044030: 28 80 00 05 bleu,a 40044044 <_TOD_Validate+0x90>
<== ALWAYS TAKEN
40044034: c6 06 00 00 ld [ %i0 ], %g3
if ( the_tod->day > days_in_month )
return false;
return true;
}
40044038: b0 08 a0 01 and %g2, 1, %i0
4004403c: 81 c7 e0 08 ret
40044040: 81 e8 00 00 restore
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
40044044: 80 a0 e7 c3 cmp %g3, 0x7c3
40044048: 28 bf ff fd bleu,a 4004403c <_TOD_Validate+0x88>
<== NEVER TAKEN
4004404c: b0 08 a0 01 and %g2, 1, %i0
<== NOT EXECUTED
(the_tod->day == 0) )
40044050: c8 06 20 08 ld [ %i0 + 8 ], %g4
(the_tod->year < TOD_BASE_YEAR) ||
40044054: 80 a1 20 00 cmp %g4, 0
40044058: 02 bf ff f8 be 40044038 <_TOD_Validate+0x84>
<== NEVER TAKEN
4004405c: 80 88 e0 03 btst 3, %g3
if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) ||
40044060: 12 80 00 12 bne 400440a8 <_TOD_Validate+0xf4>
40044064: 05 14 7a e1 sethi %hi(0x51eb8400), %g2
40044068: 84 10 a1 1f or %g2, 0x11f, %g2 ! 51eb851f <RAM_END+0x11ab851f>
4004406c: 80 50 c0 02 umul %g3, %g2, %g0
40044070: 85 40 00 00 rd %y, %g2
40044074: 85 30 a0 05 srl %g2, 5, %g2
40044078: 84 58 a0 64 smul %g2, 0x64, %g2
4004407c: 80 a0 c0 02 cmp %g3, %g2
40044080: 22 80 00 0a be,a 400440a8 <_TOD_Validate+0xf4>
<== NEVER TAKEN
40044084: 05 14 7a e1 sethi %hi(0x51eb8400), %g2
<== NOT EXECUTED
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
40044088: 82 00 60 0d add %g1, 0xd, %g1
4004408c: 05 10 02 0e sethi %hi(0x40083800), %g2
40044090: 83 28 60 02 sll %g1, 2, %g1
40044094: 84 10 a0 d8 or %g2, 0xd8, %g2
40044098: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( the_tod->day > days_in_month )
4004409c: 80 a0 40 04 cmp %g1, %g4
400440a0: 10 bf ff e6 b 40044038 <_TOD_Validate+0x84>
400440a4: 84 60 3f ff subx %g0, -1, %g2
(the_tod->year % 400 == 0))
400440a8: 84 10 a1 1f or %g2, 0x11f, %g2
400440ac: 80 50 c0 02 umul %g3, %g2, %g0
400440b0: 85 40 00 00 rd %y, %g2
400440b4: 85 30 a0 07 srl %g2, 7, %g2
400440b8: 84 58 a1 90 smul %g2, 0x190, %g2
if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) ||
400440bc: 80 a0 c0 02 cmp %g3, %g2
400440c0: 22 bf ff f3 be,a 4004408c <_TOD_Validate+0xd8>
<== NEVER TAKEN
400440c4: 82 00 60 0d add %g1, 0xd, %g1
<== NOT EXECUTED
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
400440c8: 83 28 60 02 sll %g1, 2, %g1
400440cc: 05 10 02 0e sethi %hi(0x40083800), %g2
400440d0: 84 10 a0 d8 or %g2, 0xd8, %g2 ! 400838d8 <_TOD_Days_per_month>
400440d4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( the_tod->day > days_in_month )
400440d8: 80 a0 40 04 cmp %g1, %g4
400440dc: 10 bf ff d7 b 40044038 <_TOD_Validate+0x84>
400440e0: 84 60 3f ff subx %g0, -1, %g2
40043ba0 <rtems_clock_get_tod>:
}
rtems_status_code rtems_clock_get_tod(
rtems_time_of_day *time_buffer
)
{
40043ba0: 9d e3 bf 90 save %sp, -112, %sp
uint32_t day_secs;
uint32_t year;
uint32_t year_days;
uint32_t leap_years;
if ( !time_buffer )
40043ba4: b8 96 20 00 orcc %i0, 0, %i4
40043ba8: 02 80 00 95 be 40043dfc <rtems_clock_get_tod+0x25c>
<== NEVER TAKEN
40043bac: 03 10 02 44 sethi %hi(0x40091000), %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set() )
40043bb0: c2 08 63 58 ldub [ %g1 + 0x358 ], %g1 ! 40091358 <_TOD>
40043bb4: 80 a0 60 00 cmp %g1, 0
40043bb8: 02 80 00 3f be 40043cb4 <rtems_clock_get_tod+0x114>
<== NEVER TAKEN
40043bbc: b0 10 20 0b mov 0xb, %i0
_Timecounter_Microtime( time );
40043bc0: 7f ff 5f d2 call 4001bb08 <_Timecounter_Microtime>
40043bc4: 90 07 bf f0 add %fp, -16, %o0
/* Obtain the current time */
_TOD_Get_timeval( &now );
/* How many days and how many seconds in the day ? */
days = now.tv_sec / RTEMS_SECS_PER_DAY;
40043bc8: f4 1f bf f0 ldd [ %fp + -16 ], %i2
40043bcc: 94 10 20 00 clr %o2
40043bd0: 90 10 00 1a mov %i2, %o0
40043bd4: 92 10 00 1b mov %i3, %o1
40043bd8: 17 00 00 54 sethi %hi(0x15000), %o3
40043bdc: 40 00 d7 da call 40079b44 <__divdi3>
40043be0: 96 12 e1 80 or %o3, 0x180, %o3 ! 15180 <_Configuration_Interrupt_stack_size+0x14180>
day_secs = now.tv_sec % RTEMS_SECS_PER_DAY;
40043be4: 90 10 00 1a mov %i2, %o0
days = now.tv_sec / RTEMS_SECS_PER_DAY;
40043be8: ba 10 00 09 mov %o1, %i5
day_secs = now.tv_sec % RTEMS_SECS_PER_DAY;
40043bec: 94 10 20 00 clr %o2
40043bf0: 92 10 00 1b mov %i3, %o1
40043bf4: 17 00 00 54 sethi %hi(0x15000), %o3
40043bf8: 40 00 d8 5e call 40079d70 <__moddi3>
40043bfc: 96 12 e1 80 or %o3, 0x180, %o3 ! 15180 <_Configuration_Interrupt_stack_size+0x14180>
/* How many non-leap year years ? */
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
40043c00: 03 19 c6 7c sethi %hi(0x6719f000), %g1
40043c04: 82 10 63 61 or %g1, 0x361, %g1 ! 6719f361 <RAM_END+0x26d9f361>
40043c08: 80 57 40 01 umul %i5, %g1, %g0
40043c0c: 89 40 00 00 rd %y, %g4
40043c10: 84 27 40 04 sub %i5, %g4, %g2
40043c14: 85 30 a0 01 srl %g2, 1, %g2
40043c18: 88 01 00 02 add %g4, %g2, %g4
return (year / 4) - (year / 100) + (year / 400);
40043c1c: 05 14 7a e1 sethi %hi(0x51eb8400), %g2
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
40043c20: 89 31 20 08 srl %g4, 8, %g4
return (year / 4) - (year / 100) + (year / 400);
40043c24: 84 10 a1 1f or %g2, 0x11f, %g2
year -= 1;
40043c28: b6 01 27 b1 add %g4, 0x7b1, %i3
return (year / 4) - (year / 100) + (year / 400);
40043c2c: 80 56 c0 02 umul %i3, %g2, %g0
40043c30: 85 40 00 00 rd %y, %g2
40043c34: 87 36 e0 02 srl %i3, 2, %g3
40043c38: b1 30 a0 07 srl %g2, 7, %i0
40043c3c: 85 30 a0 05 srl %g2, 5, %g2
return _Leap_years_before( to ) - _Leap_years_before( from + 1 );
40043c40: 86 00 c0 18 add %g3, %i0, %g3
40043c44: 86 00 fe 23 add %g3, -477, %g3
40043c48: 86 20 c0 02 sub %g3, %g2, %g3
/* Determine the number of leap years. */
leap_years = _Leap_years_between( RTEMS_YEAR_BASE, year );
/* Adjust the remaining number of days based on the leap years. */
year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR;
40043c4c: b4 27 40 03 sub %i5, %g3, %i2
40043c50: 80 56 80 01 umul %i2, %g1, %g0
40043c54: 83 40 00 00 rd %y, %g1
40043c58: b2 26 80 01 sub %i2, %g1, %i1
40043c5c: b3 36 60 01 srl %i1, 1, %i1
40043c60: 82 00 40 19 add %g1, %i1, %g1
/* Adjust the year and days in the year if in the leap year overflow. */
if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) {
40043c64: b2 59 21 6d smul %g4, 0x16d, %i1
year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR;
40043c68: 83 30 60 08 srl %g1, 8, %g1
if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) {
40043c6c: ba 27 40 19 sub %i5, %i1, %i5
year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR;
40043c70: 82 58 61 6d smul %g1, 0x16d, %g1
if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) {
40043c74: 80 a7 40 03 cmp %i5, %g3
40043c78: 1a 80 00 11 bcc 40043cbc <rtems_clock_get_tod+0x11c>
<== NEVER TAKEN
40043c7c: 82 26 80 01 sub %i2, %g1, %g1
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
40043c80: 86 8e e0 03 andcc %i3, 3, %g3
40043c84: 32 80 00 57 bne,a 40043de0 <rtems_clock_get_tod+0x240>
<== NEVER TAKEN
40043c88: b0 5e 21 90 smul %i0, 0x190, %i0
<== NOT EXECUTED
40043c8c: 88 58 a0 64 smul %g2, 0x64, %g4
40043c90: 80 a6 c0 04 cmp %i3, %g4
40043c94: 32 80 00 0c bne,a 40043cc4 <rtems_clock_get_tod+0x124>
<== ALWAYS TAKEN
40043c98: 82 00 60 01 inc %g1
40043c9c: b0 5e 21 90 smul %i0, 0x190, %i0
<== NOT EXECUTED
40043ca0: 80 a6 c0 18 cmp %i3, %i0
<== NOT EXECUTED
40043ca4: 22 80 00 08 be,a 40043cc4 <rtems_clock_get_tod+0x124>
<== NOT EXECUTED
40043ca8: 82 00 60 01 inc %g1
<== NOT EXECUTED
if ( _Leap_year( year ) ) {
year_days += 1;
}
}
time_buffer->year = year;
40043cac: 10 80 00 0e b 40043ce4 <rtems_clock_get_tod+0x144>
<== NOT EXECUTED
40043cb0: f6 27 00 00 st %i3, [ %i4 ]
<== NOT EXECUTED
time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE;
time_buffer->ticks = now.tv_usec /
rtems_configuration_get_microseconds_per_tick( );
return RTEMS_SUCCESSFUL;
}
40043cb4: 81 c7 e0 08 ret
<== NOT EXECUTED
40043cb8: 81 e8 00 00 restore
<== NOT EXECUTED
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
40043cbc: b6 01 27 b2 add %g4, 0x7b2, %i3
<== NOT EXECUTED
40043cc0: 86 0e e0 03 and %i3, 3, %g3
<== NOT EXECUTED
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
40043cc4: 80 a0 e0 00 cmp %g3, 0
40043cc8: 12 80 00 3a bne 40043db0 <rtems_clock_get_tod+0x210>
<== NEVER TAKEN
40043ccc: f6 27 00 00 st %i3, [ %i4 ]
40043cd0: 81 80 20 00 wr %g0, %y
40043cd4: 01 00 00 00 nop
40043cd8: 01 00 00 00 nop
40043cdc: 01 00 00 00 nop
40043ce0: 84 76 e0 64 udiv %i3, 0x64, %g2
40043ce4: 84 58 a0 64 smul %g2, 0x64, %g2
40043ce8: 80 a6 c0 02 cmp %i3, %g2
40043cec: 02 80 00 32 be 40043db4 <rtems_clock_get_tod+0x214>
<== NEVER TAKEN
40043cf0: 05 14 7a e1 sethi %hi(0x51eb8400), %g2
days_to_date = _TOD_Days_to_date[1];
40043cf4: 3b 10 02 0e sethi %hi(0x40083800), %i5
40043cf8: ba 17 60 bc or %i5, 0xbc, %i5 ! 400838bc <_TOD_Days_to_date+0x1a>
days_to_date += 2;
40043cfc: 84 07 60 04 add %i5, 4, %g2
uint32_t month = 0;
40043d00: 86 10 20 00 clr %g3
40043d04: ba 07 60 1a add %i5, 0x1a, %i5
if (*day < *days_to_date)
40043d08: c8 10 80 00 lduh [ %g2 ], %g4
40043d0c: 80 a1 00 01 cmp %g4, %g1
40043d10: 18 80 00 39 bgu 40043df4 <rtems_clock_get_tod+0x254>
<== NEVER TAKEN
40043d14: 86 00 e0 01 inc %g3
++days_to_date;
40043d18: 84 00 a0 02 add %g2, 2, %g2
while (month < 11) {
40043d1c: 80 a0 80 1d cmp %g2, %i5
40043d20: 32 bf ff fb bne,a 40043d0c <rtems_clock_get_tod+0x16c>
40043d24: c8 10 80 00 lduh [ %g2 ], %g4
40043d28: 86 10 20 0c mov 0xc, %g3
time_buffer->day = year_days + 1;
40043d2c: 82 00 60 01 inc %g1
time_buffer->ticks = now.tv_usec /
40043d30: f4 07 bf f8 ld [ %fp + -8 ], %i2
time_buffer->day = year_days + 1;
40043d34: 88 20 40 04 sub %g1, %g4, %g4
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
40043d38: 05 24 68 ac sethi %hi(0x91a2b000), %g2
time_buffer->ticks = now.tv_usec /
40043d3c: 03 10 01 f1 sethi %hi(0x4007c400), %g1
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
40043d40: 84 10 a3 c5 or %g2, 0x3c5, %g2
40043d44: 80 52 40 02 umul %o1, %g2, %g0
40043d48: 85 40 00 00 rd %y, %g2
40043d4c: 85 30 a0 0b srl %g2, 0xb, %g2
time_buffer->ticks = now.tv_usec /
40043d50: 81 80 20 00 wr %g0, %y
40043d54: f6 00 61 f0 ld [ %g1 + 0x1f0 ], %i3
40043d58: 01 00 00 00 nop
40043d5c: 01 00 00 00 nop
40043d60: b6 76 80 1b udiv %i2, %i3, %i3
time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR;
40043d64: ba 58 ae 10 smul %g2, 0xe10, %i5
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
40043d68: c4 27 20 0c st %g2, [ %i4 + 0xc ]
time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR;
40043d6c: 92 22 40 1d sub %o1, %i5, %o1
time_buffer->month = _Year_day_as_month( year, &year_days ) + 1;
40043d70: c6 27 20 04 st %g3, [ %i4 + 4 ]
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
40043d74: 03 22 22 22 sethi %hi(0x88888800), %g1
time_buffer->day = year_days + 1;
40043d78: c8 27 20 08 st %g4, [ %i4 + 8 ]
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
40043d7c: 82 10 60 89 or %g1, 0x89, %g1
time_buffer->ticks = now.tv_usec /
40043d80: f6 27 20 18 st %i3, [ %i4 + 0x18 ]
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
40043d84: 80 52 40 01 umul %o1, %g1, %g0
40043d88: 83 40 00 00 rd %y, %g1
40043d8c: 83 30 60 05 srl %g1, 5, %g1
40043d90: 85 28 60 04 sll %g1, 4, %g2
time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE;
40043d94: c2 27 20 10 st %g1, [ %i4 + 0x10 ]
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
40043d98: 82 20 80 01 sub %g2, %g1, %g1
40043d9c: 83 28 60 02 sll %g1, 2, %g1
40043da0: 92 22 40 01 sub %o1, %g1, %o1
40043da4: d2 27 20 14 st %o1, [ %i4 + 0x14 ]
return RTEMS_SUCCESSFUL;
40043da8: 81 c7 e0 08 ret
40043dac: 91 e8 20 00 restore %g0, 0, %o0
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
40043db0: 05 14 7a e1 sethi %hi(0x51eb8400), %g2
<== NOT EXECUTED
40043db4: 84 10 a1 1f or %g2, 0x11f, %g2 ! 51eb851f <RAM_END+0x11ab851f>
<== NOT EXECUTED
40043db8: 80 56 c0 02 umul %i3, %g2, %g0
<== NOT EXECUTED
40043dbc: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
40043dc0: 85 30 a0 07 srl %g2, 7, %g2
<== NOT EXECUTED
40043dc4: 84 58 a1 90 smul %g2, 0x190, %g2
<== NOT EXECUTED
40043dc8: 80 a6 c0 02 cmp %i3, %g2
<== NOT EXECUTED
40043dcc: 22 bf ff cb be,a 40043cf8 <rtems_clock_get_tod+0x158>
<== NOT EXECUTED
40043dd0: 3b 10 02 0e sethi %hi(0x40083800), %i5
<== NOT EXECUTED
days_to_date = _TOD_Days_to_date[0];
40043dd4: 3b 10 02 0e sethi %hi(0x40083800), %i5
<== NOT EXECUTED
40043dd8: 10 bf ff c9 b 40043cfc <rtems_clock_get_tod+0x15c>
<== NOT EXECUTED
40043ddc: ba 17 60 a2 or %i5, 0xa2, %i5 ! 400838a2 <_TOD_Days_to_date>
<== NOT EXECUTED
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
40043de0: 80 a6 c0 18 cmp %i3, %i0
<== NOT EXECUTED
40043de4: 12 80 00 08 bne 40043e04 <rtems_clock_get_tod+0x264>
<== NOT EXECUTED
40043de8: 3b 10 02 0e sethi %hi(0x40083800), %i5
<== NOT EXECUTED
year_days += 1;
40043dec: 10 bf ff b6 b 40043cc4 <rtems_clock_get_tod+0x124>
<== NOT EXECUTED
40043df0: 82 00 60 01 inc %g1
<== NOT EXECUTED
40043df4: 10 bf ff ce b 40043d2c <rtems_clock_get_tod+0x18c>
<== NOT EXECUTED
40043df8: c8 10 bf fe lduh [ %g2 + -2 ], %g4
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
40043dfc: 81 c7 e0 08 ret
<== NOT EXECUTED
40043e00: 91 e8 20 09 restore %g0, 9, %o0
<== NOT EXECUTED
time_buffer->year = year;
40043e04: f6 27 00 00 st %i3, [ %i4 ]
<== NOT EXECUTED
days_to_date = _TOD_Days_to_date[0];
40043e08: 10 bf ff bd b 40043cfc <rtems_clock_get_tod+0x15c>
<== NOT EXECUTED
40043e0c: ba 17 60 a2 or %i5, 0xa2, %i5
<== NOT EXECUTED
40043e10 <rtems_clock_get_tod_timeval>:
#include <rtems/score/todimpl.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
40043e10: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !time )
40043e14: 90 96 20 00 orcc %i0, 0, %o0
<== NOT EXECUTED
40043e18: 02 80 00 0a be 40043e40 <rtems_clock_get_tod_timeval+0x30>
<== NOT EXECUTED
40043e1c: 03 10 02 44 sethi %hi(0x40091000), %g1
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set() )
40043e20: c2 08 63 58 ldub [ %g1 + 0x358 ], %g1 ! 40091358 <_TOD>
<== NOT EXECUTED
40043e24: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40043e28: 02 80 00 04 be 40043e38 <rtems_clock_get_tod_timeval+0x28>
<== NOT EXECUTED
40043e2c: b0 10 20 0b mov 0xb, %i0
<== NOT EXECUTED
40043e30: 7f ff 5f 36 call 4001bb08 <_Timecounter_Microtime>
<== NOT EXECUTED
40043e34: b0 10 20 00 clr %i0
<== NOT EXECUTED
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
40043e38: 81 c7 e0 08 ret
<== NOT EXECUTED
40043e3c: 81 e8 00 00 restore
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
40043e40: b0 10 20 09 mov 9, %i0
<== NOT EXECUTED
}
40043e44: 81 c7 e0 08 ret
<== NOT EXECUTED
40043e48: 81 e8 00 00 restore
<== NOT EXECUTED
40043e4c <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
40043e4c: 9d e3 bf a0 save %sp, -96, %sp
40043e50: ba 10 00 18 mov %i0, %i5
if ( !uptime )
40043e54: 80 a7 60 00 cmp %i5, 0
40043e58: 02 80 00 09 be 40043e7c <rtems_clock_get_uptime+0x30>
<== NEVER TAKEN
40043e5c: b0 10 20 09 mov 9, %i0
_Timecounter_Nanouptime( time );
40043e60: 7f ff 5e ef call 4001ba1c <_Timecounter_Nanouptime>
40043e64: 90 10 00 1d mov %i5, %o0
--time->tv_sec;
40043e68: f4 1f 40 00 ldd [ %i5 ], %i2
40043e6c: 86 86 ff ff addcc %i3, -1, %g3
40043e70: 84 46 bf ff addx %i2, -1, %g2
40043e74: c4 3f 40 00 std %g2, [ %i5 ]
return RTEMS_INVALID_ADDRESS;
_TOD_Get_zero_based_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
40043e78: b0 10 20 00 clr %i0
}
40043e7c: 81 c7 e0 08 ret
40043e80: 81 e8 00 00 restore
4000dae0 <rtems_clock_get_uptime_nanoseconds>:
#include <rtems/rtems/clock.h>
#include <rtems/score/todimpl.h>
uint64_t rtems_clock_get_uptime_nanoseconds( void )
{
4000dae0: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
*time = _Timecounter_Sbinuptime() - SBT_1S;
4000dae4: 40 00 0d 28 call 40010f84 <_Timecounter_Sbinuptime>
<== NOT EXECUTED
4000dae8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000daec: b2 10 20 00 clr %i1
<== NOT EXECUTED
4000daf0: 86 82 40 19 addcc %o1, %i1, %g3
<== NOT EXECUTED
4000daf4: 84 42 00 18 addx %o0, %i0, %g2
<== NOT EXECUTED
4000daf8: 92 10 00 03 mov %g3, %o1
<== NOT EXECUTED
static __inline struct timespec
sbttots(sbintime_t _sbt)
{
struct timespec _ts;
_ts.tv_sec = _sbt >> 32;
4000dafc: 83 38 a0 1f sra %g2, 0x1f, %g1
<== NOT EXECUTED
4000db00: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
4000db04: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2
<== NOT EXECUTED
4000db08: 84 10 a2 00 or %g2, 0x200, %g2 ! 3b9aca00 <RAM_SIZE+0x3b5aca00>
<== NOT EXECUTED
4000db0c: 86 52 40 02 umul %o1, %g2, %g3
<== NOT EXECUTED
4000db10: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
4000db14: d0 27 bf f4 st %o0, [ %fp + -12 ]
<== NOT EXECUTED
{
struct timespec _ts;
_ts = sbttots( *_time );
return _Timespec_Get_as_nanoseconds( &_ts );
4000db18: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
4000db1c: c2 27 bf f0 st %g1, [ %fp + -16 ]
<== NOT EXECUTED
4000db20: 40 00 1f 65 call 400158b4 <_Timespec_Get_as_nanoseconds>
<== NOT EXECUTED
4000db24: c4 27 bf f8 st %g2, [ %fp + -8 ]
<== NOT EXECUTED
Timestamp_Control snapshot_as_timestamp;
_TOD_Get_zero_based_uptime(&snapshot_as_timestamp);
return _Timestamp_Get_as_nanoseconds(&snapshot_as_timestamp);
}
4000db28: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
4000db2c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db30: 93 e8 00 09 restore %g0, %o1, %o1
<== NOT EXECUTED
40043e84 <rtems_clock_set>:
#include <rtems/config.h>
rtems_status_code rtems_clock_set(
const rtems_time_of_day *tod
)
{
40043e84: 9d e3 bf 88 save %sp, -120, %sp
40043e88: ba 10 00 18 mov %i0, %i5
if ( !tod )
40043e8c: 80 a7 60 00 cmp %i5, 0
40043e90: 02 80 00 1a be 40043ef8 <rtems_clock_set+0x74>
<== NEVER TAKEN
40043e94: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( tod ) ) {
40043e98: 90 10 00 1d mov %i5, %o0
40043e9c: 40 00 00 46 call 40043fb4 <_TOD_Validate>
40043ea0: b0 10 20 14 mov 0x14, %i0
40043ea4: 80 a2 20 00 cmp %o0, 0
40043ea8: 02 80 00 14 be 40043ef8 <rtems_clock_set+0x74>
<== NEVER TAKEN
40043eac: 01 00 00 00 nop
struct timespec tod_as_timespec;
ISR_lock_Context lock_context;
tod_as_timespec.tv_sec = _TOD_To_seconds( tod );
40043eb0: 40 00 00 14 call 40043f00 <_TOD_To_seconds>
40043eb4: 90 10 00 1d mov %i5, %o0
tod_as_timespec.tv_nsec = tod->ticks
* rtems_configuration_get_nanoseconds_per_tick();
40043eb8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40043ebc: 05 10 01 f1 sethi %hi(0x4007c400), %g2
40043ec0: c4 00 a2 1c ld [ %g2 + 0x21c ], %g2 ! 4007c61c <_Watchdog_Nanoseconds_per_tick>
40043ec4: 82 58 40 02 smul %g1, %g2, %g1
tod_as_timespec.tv_sec = _TOD_To_seconds( tod );
40043ec8: c0 27 bf f0 clr [ %fp + -16 ]
40043ecc: d0 27 bf f4 st %o0, [ %fp + -12 ]
_TOD_Lock();
40043ed0: 40 00 02 4b call 400447fc <_TOD_Lock>
40043ed4: c2 27 bf f8 st %g1, [ %fp + -8 ]
40043ed8: 91 d0 20 09 ta 9
<== NOT EXECUTED
_Timecounter_Acquire( lock_context );
40043edc: c2 27 bf ec st %g1, [ %fp + -20 ]
_TOD_Acquire( &lock_context );
_TOD_Set( &tod_as_timespec, &lock_context );
40043ee0: 92 07 bf ec add %fp, -20, %o1
40043ee4: 90 07 bf f0 add %fp, -16, %o0
40043ee8: 40 00 02 4f call 40044824 <_TOD_Set>
40043eec: b0 10 20 00 clr %i0
_TOD_Unlock();
40043ef0: 40 00 02 48 call 40044810 <_TOD_Unlock>
40043ef4: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
40043ef8: 81 c7 e0 08 ret
40043efc: 81 e8 00 00 restore
4000db34 <rtems_event_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
4000db34: 9d e3 bf 88 save %sp, -120, %sp
rtems_status_code sc;
if ( event_out != NULL ) {
4000db38: 80 a6 e0 00 cmp %i3, 0
4000db3c: 02 80 00 1c be 4000dbac <rtems_event_receive+0x78>
<== NEVER TAKEN
4000db40: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000db44: 91 d0 20 09 ta 9
<== NOT EXECUTED
ISR_lock_Context *lock_context
)
{
Thread_Control *executing;
_ISR_lock_ISR_disable( lock_context );
4000db48: c2 27 bf fc st %g1, [ %fp + -4 ]
executing = _Thread_Executing;
4000db4c: d8 01 a0 20 ld [ %g6 + 0x20 ], %o4
executing = _Thread_Wait_acquire_default_for_executing( &lock_context );
api = executing->API_Extensions[ THREAD_API_RTEMS ];
event = &api->Event;
if ( !_Event_sets_Is_empty( event_in ) ) {
4000db50: 80 a6 20 00 cmp %i0, 0
4000db54: 12 80 00 09 bne 4000db78 <rtems_event_receive+0x44>
<== ALWAYS TAKEN
4000db58: da 03 21 58 ld [ %o4 + 0x158 ], %o5
THREAD_WAIT_CLASS_EVENT,
STATES_WAITING_FOR_EVENT,
&lock_context
);
} else {
*event_out = event->pending_events;
4000db5c: c2 03 40 00 ld [ %o5 ], %g1
<== NOT EXECUTED
4000db60: c2 26 c0 00 st %g1, [ %i3 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000db64: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000db68: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000db6c: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Wait_release_default( executing, &lock_context );
sc = RTEMS_SUCCESSFUL;
4000db70: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db74: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
sc = _Event_Seize(
4000db78: 82 07 bf fc add %fp, -4, %g1
4000db7c: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4000db80: 82 10 20 04 mov 4, %g1
4000db84: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
4000db88: 82 10 21 00 mov 0x100, %g1
4000db8c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000db90: 96 10 00 1b mov %i3, %o3
4000db94: 94 10 00 1a mov %i2, %o2
4000db98: 92 10 00 19 mov %i1, %o1
4000db9c: 40 00 00 06 call 4000dbb4 <_Event_Seize>
4000dba0: 90 10 00 18 mov %i0, %o0
4000dba4: 81 c7 e0 08 ret
4000dba8: 91 e8 00 08 restore %g0, %o0, %o0
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
4000dbac: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dbb0: 91 e8 20 09 restore %g0, 9, %o0
<== NOT EXECUTED
4000dd34 <rtems_event_send>:
rtems_status_code rtems_event_send(
rtems_id id,
rtems_event_set event_in
)
{
4000dd34: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
RTEMS_API_Control *api;
ISR_lock_Context lock_context;
the_thread = _Thread_Get( id, &lock_context );
4000dd38: 90 10 00 18 mov %i0, %o0
4000dd3c: 92 07 bf fc add %fp, -4, %o1
4000dd40: 40 00 16 51 call 40013684 <_Thread_Get>
4000dd44: b0 10 20 04 mov 4, %i0
if ( the_thread == NULL ) {
4000dd48: 80 a2 20 00 cmp %o0, 0
4000dd4c: 02 80 00 07 be 4000dd68 <rtems_event_send+0x34>
<== NEVER TAKEN
4000dd50: 98 07 bf fc add %fp, -4, %o4
return RTEMS_INVALID_ID;
#endif
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
return _Event_Surrender(
4000dd54: d4 02 21 58 ld [ %o0 + 0x158 ], %o2
4000dd58: 96 10 21 00 mov 0x100, %o3
4000dd5c: 40 00 00 05 call 4000dd70 <_Event_Surrender>
4000dd60: 92 10 00 19 mov %i1, %o1
4000dd64: b0 10 00 08 mov %o0, %i0
event_in,
&api->Event,
THREAD_WAIT_CLASS_EVENT,
&lock_context
);
}
4000dd68: 81 c7 e0 08 ret
4000dd6c: 81 e8 00 00 restore
40019610 <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
40019610: 9d e3 bf 88 save %sp, -120, %sp
rtems_status_code sc;
if ( event_out != NULL ) {
40019614: 80 a6 e0 00 cmp %i3, 0
40019618: 02 80 00 1d be 4001968c <rtems_event_system_receive+0x7c>
<== NEVER TAKEN
4001961c: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40019620: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( lock_context );
40019624: c2 27 bf fc st %g1, [ %fp + -4 ]
executing = _Thread_Executing;
40019628: d8 01 a0 20 ld [ %g6 + 0x20 ], %o4
executing = _Thread_Wait_acquire_default_for_executing( &lock_context );
api = executing->API_Extensions[ THREAD_API_RTEMS ];
event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
4001962c: 80 a6 20 00 cmp %i0, 0
40019630: 12 80 00 09 bne 40019654 <rtems_event_system_receive+0x44>
<== ALWAYS TAKEN
40019634: da 03 21 58 ld [ %o4 + 0x158 ], %o5
THREAD_WAIT_CLASS_SYSTEM_EVENT,
STATES_WAITING_FOR_SYSTEM_EVENT,
&lock_context
);
} else {
*event_out = event->pending_events;
40019638: c2 03 60 04 ld [ %o5 + 4 ], %g1
<== NOT EXECUTED
4001963c: c2 26 c0 00 st %g1, [ %i3 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40019640: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40019644: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40019648: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Wait_release_default( executing, &lock_context );
sc = RTEMS_SUCCESSFUL;
4001964c: 81 c7 e0 08 ret
<== NOT EXECUTED
40019650: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
sc = _Event_Seize(
40019654: 82 07 bf fc add %fp, -4, %g1
40019658: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4001965c: 82 10 20 08 mov 8, %g1
40019660: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40019664: 82 10 22 00 mov 0x200, %g1
40019668: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4001966c: 9a 03 60 04 add %o5, 4, %o5
40019670: 96 10 00 1b mov %i3, %o3
40019674: 94 10 00 1a mov %i2, %o2
40019678: 92 10 00 19 mov %i1, %o1
4001967c: 7f ff fe ff call 40019278 <_Event_Seize>
40019680: 90 10 00 18 mov %i0, %o0
40019684: 81 c7 e0 08 ret
40019688: 91 e8 00 08 restore %g0, %o0, %o0
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
4001968c: 81 c7 e0 08 ret
<== NOT EXECUTED
40019690: 91 e8 20 09 restore %g0, 9, %o0
<== NOT EXECUTED
400064c0 <rtems_event_system_send>:
rtems_status_code rtems_event_system_send(
rtems_id id,
rtems_event_set event_in
)
{
400064c0: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
RTEMS_API_Control *api;
ISR_lock_Context lock_context;
the_thread = _Thread_Get( id, &lock_context );
400064c4: 90 10 00 18 mov %i0, %o0
400064c8: 92 07 bf fc add %fp, -4, %o1
400064cc: 40 00 0f 4d call 4000a200 <_Thread_Get>
400064d0: b0 10 20 04 mov 4, %i0
if ( the_thread == NULL ) {
400064d4: 80 a2 20 00 cmp %o0, 0
400064d8: 02 80 00 08 be 400064f8 <rtems_event_system_send+0x38>
<== NEVER TAKEN
400064dc: 98 07 bf fc add %fp, -4, %o4
return RTEMS_INVALID_ID;
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
return _Event_Surrender(
400064e0: d4 02 21 58 ld [ %o0 + 0x158 ], %o2
400064e4: 96 10 22 00 mov 0x200, %o3
400064e8: 94 02 a0 04 add %o2, 4, %o2
400064ec: 40 00 1c e3 call 4000d878 <_Event_Surrender>
400064f0: 92 10 00 19 mov %i1, %o1
400064f4: b0 10 00 08 mov %o0, %i0
event_in,
&api->System_event,
THREAD_WAIT_CLASS_SYSTEM_EVENT,
&lock_context
);
}
400064f8: 81 c7 e0 08 ret
400064fc: 81 e8 00 00 restore
4000de90 <rtems_get_current_processor>:
#include <rtems/score/smp.h>
uint32_t rtems_get_current_processor(void)
{
return _SMP_Get_current_processor();
}
4000de90: 81 c3 e0 08 retl
<== NOT EXECUTED
4000de94: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000de98 <rtems_get_processor_count>:
#include <rtems/score/smp.h>
uint32_t rtems_get_processor_count(void)
{
return _SMP_Get_processor_count();
}
4000de98: 81 c3 e0 08 retl
<== NOT EXECUTED
4000de9c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
40006450 <rtems_interrupt_catch>:
rtems_status_code rtems_interrupt_catch(
rtems_isr_entry new_isr_handler,
rtems_vector_number vector,
rtems_isr_entry *old_isr_handler
)
{
40006450: 9d e3 bf a0 save %sp, -96, %sp
if ( !_ISR_Is_vector_number_valid( vector ) )
40006454: 80 a6 61 ff cmp %i1, 0x1ff
40006458: 18 80 00 0b bgu 40006484 <rtems_interrupt_catch+0x34>
<== NEVER TAKEN
4000645c: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) )
return RTEMS_INVALID_ADDRESS;
if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) )
40006460: 80 a6 20 00 cmp %i0, 0
40006464: 02 80 00 0a be 4000648c <rtems_interrupt_catch+0x3c>
<== NEVER TAKEN
40006468: 80 a6 a0 00 cmp %i2, 0
4000646c: 02 80 00 08 be 4000648c <rtems_interrupt_catch+0x3c>
<== NEVER TAKEN
40006470: 94 10 00 1a mov %i2, %o2
return RTEMS_INVALID_ADDRESS;
_ISR_Install_vector(
40006474: 92 10 00 18 mov %i0, %o1
40006478: 7f ff f1 e4 call 40002c08 <_CPU_ISR_install_vector>
4000647c: 90 10 00 19 mov %i1, %o0
vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );
return RTEMS_SUCCESSFUL;
40006480: 82 10 20 00 clr %g1
}
40006484: 81 c7 e0 08 ret
40006488: 91 e8 00 01 restore %g0, %g1, %o0
return RTEMS_INVALID_ADDRESS;
4000648c: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
}
40006490: 81 c7 e0 08 ret
<== NOT EXECUTED
40006494: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
4001a28c <rtems_message_queue_delete>:
#include <rtems/rtems/attrimpl.h>
rtems_status_code rtems_message_queue_delete(
rtems_id id
)
{
4001a28c: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
_RTEMS_Lock_allocator();
4001a290: 7f ff d4 9c call 4000f500 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
4001a294: 39 10 00 d5 sethi %hi(0x40035400), %i4
<== NOT EXECUTED
Objects_Id id,
Thread_queue_Context *queue_context
)
{
_Thread_queue_Context_initialize( queue_context );
return (Message_queue_Control *) _Objects_Get(
4001a298: 92 07 bf dc add %fp, -36, %o1
<== NOT EXECUTED
4001a29c: 94 17 21 b4 or %i4, 0x1b4, %o2
<== NOT EXECUTED
4001a2a0: 7f ff de 04 call 40011ab0 <_Objects_Get>
<== NOT EXECUTED
4001a2a4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
Thread_queue_Context queue_context;
_Objects_Allocator_lock();
the_message_queue = _Message_queue_Get( id, &queue_context );
if ( the_message_queue == NULL ) {
4001a2a8: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4001a2ac: 02 80 00 0f be 4001a2e8 <rtems_message_queue_delete+0x5c>
<== NOT EXECUTED
4001a2b0: 90 17 21 b4 or %i4, 0x1b4, %o0
<== NOT EXECUTED
_CORE_message_queue_Acquire_critical(
&the_message_queue->message_queue,
&queue_context
);
_Objects_Close( &_Message_queue_Information, &the_message_queue->Object );
4001a2b4: 7f ff dc e4 call 40011644 <_Objects_Close>
<== NOT EXECUTED
4001a2b8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
_Thread_queue_Context_set_MP_callout(
&queue_context,
_Message_queue_MP_Send_object_was_deleted
);
_CORE_message_queue_Close(
4001a2bc: 92 07 bf dc add %fp, -36, %o1
<== NOT EXECUTED
4001a2c0: 40 00 00 e6 call 4001a658 <_CORE_message_queue_Close>
<== NOT EXECUTED
4001a2c4: 90 07 60 10 add %i5, 0x10, %o0
<== NOT EXECUTED
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
4001a2c8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4001a2cc: 90 17 21 b4 or %i4, 0x1b4, %o0
<== NOT EXECUTED
4001a2d0: 7f ff dd a9 call 40011974 <_Objects_Free>
<== NOT EXECUTED
4001a2d4: b0 10 20 00 clr %i0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4001a2d8: 7f ff d4 8f call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4001a2dc: 01 00 00 00 nop
<== NOT EXECUTED
#endif
_Message_queue_Free( the_message_queue );
_Objects_Allocator_unlock();
return RTEMS_SUCCESSFUL;
}
4001a2e0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a2e4: 81 e8 00 00 restore
<== NOT EXECUTED
4001a2e8: 7f ff d4 8b call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4001a2ec: b0 10 20 04 mov 4, %i0
<== NOT EXECUTED
return RTEMS_INVALID_ID;
4001a2f0: 81 c7 e0 08 ret
<== NOT EXECUTED
4001a2f4: 81 e8 00 00 restore
<== NOT EXECUTED
4000dee8 <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
4000dee8: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
4000deec: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000def0: 02 80 00 0b be 4000df1c <rtems_object_get_classic_name+0x34>
<== NOT EXECUTED
4000def4: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
4000def8: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
4000defc: 40 00 0f 12 call 40011b44 <_Objects_Id_to_name>
<== NOT EXECUTED
4000df00: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
*name = name_u.name_u32;
4000df04: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
4000df08: c2 26 40 00 st %g1, [ %i1 ]
<== NOT EXECUTED
return _Status_Object_name_errors_to_status[ status ];
4000df0c: 91 2a 20 02 sll %o0, 2, %o0
<== NOT EXECUTED
4000df10: 03 10 00 ba sethi %hi(0x4002e800), %g1
<== NOT EXECUTED
4000df14: 82 10 63 40 or %g1, 0x340, %g1 ! 4002eb40 <_Status_Object_name_errors_to_status>
<== NOT EXECUTED
4000df18: c2 00 40 08 ld [ %g1 + %o0 ], %g1
<== NOT EXECUTED
}
4000df1c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000df20: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
4001a368 <rtems_object_get_name>:
Objects_Id id,
size_t length,
char *name
)
{
return _Objects_Get_name_as_string( id, length, name );
4001a368: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4001a36c: 40 00 01 78 call 4001a94c <_Objects_Get_name_as_string>
<== NOT EXECUTED
4001a370: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40058ae4 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *dst
)
{
40058ae4: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
Rate_monotonic_Control *the_period;
ISR_lock_Context lock_context;
const Rate_monotonic_Statistics *src;
if ( dst == NULL ) {
40058ae8: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40058aec: 02 80 00 43 be 40058bf8 <rtems_rate_monotonic_get_statistics+0x114>
<== NOT EXECUTED
40058af0: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
return (Rate_monotonic_Control *)
40058af4: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40058af8: 15 10 02 45 sethi %hi(0x40091400), %o2
<== NOT EXECUTED
40058afc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40058b00: 7f ff b0 1c call 40044b70 <_Objects_Get>
<== NOT EXECUTED
40058b04: 94 12 a0 38 or %o2, 0x38, %o2
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
the_period = _Rate_monotonic_Get( id, &lock_context );
if ( the_period == NULL ) {
40058b08: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40058b0c: 02 80 00 3d be 40058c00 <rtems_rate_monotonic_get_statistics+0x11c>
<== NOT EXECUTED
40058b10: 82 10 20 04 mov 4, %g1
<== NOT EXECUTED
40058b14: c2 02 20 70 ld [ %o0 + 0x70 ], %g1
<== NOT EXECUTED
40058b18: c4 02 20 74 ld [ %o0 + 0x74 ], %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058b1c: 87 38 60 1f sra %g1, 0x1f, %g3
<== NOT EXECUTED
_Rate_monotonic_Acquire_critical( the_period, &lock_context );
src = &the_period->Statistics;
dst->count = src->count;
dst->missed_count = src->missed_count;
40058b20: f8 1a 20 68 ldd [ %o0 + 0x68 ], %i4
<== NOT EXECUTED
40058b24: c2 26 60 0c st %g1, [ %i1 + 0xc ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058b28: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058b2c: c6 26 60 08 st %g3, [ %i1 + 8 ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058b30: 82 10 62 00 or %g1, 0x200, %g1
<== NOT EXECUTED
40058b34: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
40058b38: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
40058b3c: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
<== NOT EXECUTED
40058b40: c6 02 20 78 ld [ %o0 + 0x78 ], %g3
<== NOT EXECUTED
40058b44: c4 02 20 7c ld [ %o0 + 0x7c ], %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058b48: 89 38 e0 1f sra %g3, 0x1f, %g4
<== NOT EXECUTED
40058b4c: c6 26 60 1c st %g3, [ %i1 + 0x1c ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058b50: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
40058b54: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058b58: c8 26 60 18 st %g4, [ %i1 + 0x18 ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058b5c: c4 26 60 20 st %g2, [ %i1 + 0x20 ]
<== NOT EXECUTED
40058b60: c6 02 20 80 ld [ %o0 + 0x80 ], %g3
<== NOT EXECUTED
40058b64: c4 02 20 84 ld [ %o0 + 0x84 ], %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058b68: 89 38 e0 1f sra %g3, 0x1f, %g4
<== NOT EXECUTED
40058b6c: c6 26 60 2c st %g3, [ %i1 + 0x2c ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058b70: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
40058b74: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058b78: c8 26 60 28 st %g4, [ %i1 + 0x28 ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058b7c: c4 26 60 30 st %g2, [ %i1 + 0x30 ]
<== NOT EXECUTED
40058b80: c6 02 20 88 ld [ %o0 + 0x88 ], %g3
<== NOT EXECUTED
40058b84: c4 02 20 8c ld [ %o0 + 0x8c ], %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058b88: 89 38 e0 1f sra %g3, 0x1f, %g4
<== NOT EXECUTED
40058b8c: c6 26 60 3c st %g3, [ %i1 + 0x3c ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058b90: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
40058b94: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058b98: c8 26 60 38 st %g4, [ %i1 + 0x38 ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058b9c: c4 26 60 40 st %g2, [ %i1 + 0x40 ]
<== NOT EXECUTED
40058ba0: c6 02 20 90 ld [ %o0 + 0x90 ], %g3
<== NOT EXECUTED
40058ba4: c4 02 20 94 ld [ %o0 + 0x94 ], %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058ba8: 89 38 e0 1f sra %g3, 0x1f, %g4
<== NOT EXECUTED
40058bac: c6 26 60 4c st %g3, [ %i1 + 0x4c ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058bb0: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
40058bb4: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058bb8: c8 26 60 48 st %g4, [ %i1 + 0x48 ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058bbc: c4 26 60 50 st %g2, [ %i1 + 0x50 ]
<== NOT EXECUTED
40058bc0: c8 02 20 98 ld [ %o0 + 0x98 ], %g4
<== NOT EXECUTED
40058bc4: c4 02 20 9c ld [ %o0 + 0x9c ], %g2
<== NOT EXECUTED
dst->count = src->count;
40058bc8: f8 26 40 00 st %i4, [ %i1 ]
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058bcc: b9 39 20 1f sra %g4, 0x1f, %i4
<== NOT EXECUTED
dst->missed_count = src->missed_count;
40058bd0: fa 26 60 04 st %i5, [ %i1 + 4 ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058bd4: 86 50 80 01 umul %g2, %g1, %g3
<== NOT EXECUTED
40058bd8: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058bdc: c8 26 60 5c st %g4, [ %i1 + 0x5c ]
<== NOT EXECUTED
40058be0: f8 26 60 58 st %i4, [ %i1 + 0x58 ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058be4: c4 26 60 60 st %g2, [ %i1 + 0x60 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40058be8: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40058bec: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40058bf0: 01 00 00 00 nop
<== NOT EXECUTED
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
_Rate_monotonic_Release( the_period, &lock_context );
return RTEMS_SUCCESSFUL;
40058bf4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
<== NOT EXECUTED
}
40058bf8: 81 c7 e0 08 ret
<== NOT EXECUTED
40058bfc: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
40058c00: 81 c7 e0 08 ret
<== NOT EXECUTED
40058c04: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
40058c08 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *period_status
)
{
40058c08: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
Rate_monotonic_Control *the_period;
ISR_lock_Context lock_context;
rtems_status_code status;
if ( period_status == NULL ) {
40058c0c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40058c10: 02 80 00 1c be 40058c80 <rtems_rate_monotonic_get_status+0x78>
<== NOT EXECUTED
40058c14: 84 10 20 09 mov 9, %g2
<== NOT EXECUTED
40058c18: 92 07 bf ec add %fp, -20, %o1
<== NOT EXECUTED
40058c1c: 15 10 02 45 sethi %hi(0x40091400), %o2
<== NOT EXECUTED
40058c20: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40058c24: 7f ff af d3 call 40044b70 <_Objects_Get>
<== NOT EXECUTED
40058c28: 94 12 a0 38 or %o2, 0x38, %o2
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
the_period = _Rate_monotonic_Get( id, &lock_context );
if ( the_period == NULL ) {
40058c2c: 82 92 20 00 orcc %o0, 0, %g1
<== NOT EXECUTED
40058c30: 02 80 00 30 be 40058cf0 <rtems_rate_monotonic_get_status+0xe8>
<== NOT EXECUTED
40058c34: 84 10 20 04 mov 4, %g2
<== NOT EXECUTED
return RTEMS_INVALID_ID;
}
_Rate_monotonic_Acquire_critical( the_period, &lock_context );
period_status->owner = the_period->owner->Object.id;
40058c38: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
<== NOT EXECUTED
40058c3c: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
period_status->state = the_period->state;
40058c40: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
<== NOT EXECUTED
period_status->postponed_jobs_count = the_period->postponed_jobs;
40058c44: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1
<== NOT EXECUTED
40058c48: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
<== NOT EXECUTED
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
40058c4c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
period_status->owner = the_period->owner->Object.id;
40058c50: c6 26 40 00 st %g3, [ %i1 ]
<== NOT EXECUTED
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
40058c54: 12 80 00 0d bne 40058c88 <rtems_rate_monotonic_get_status+0x80>
<== NOT EXECUTED
40058c58: c4 26 60 04 st %g2, [ %i1 + 4 ]
<== NOT EXECUTED
/*
* If the period is inactive, there is no information.
*/
_Timespec_Set_to_zero( &period_status->since_last_period );
40058c5c: c0 26 60 08 clr [ %i1 + 8 ]
<== NOT EXECUTED
40058c60: c0 26 60 0c clr [ %i1 + 0xc ]
<== NOT EXECUTED
40058c64: c0 26 60 10 clr [ %i1 + 0x10 ]
<== NOT EXECUTED
_Timespec_Set_to_zero( &period_status->executed_since_last_period );
40058c68: c0 26 60 18 clr [ %i1 + 0x18 ]
<== NOT EXECUTED
40058c6c: c0 26 60 1c clr [ %i1 + 0x1c ]
<== NOT EXECUTED
40058c70: c0 26 60 20 clr [ %i1 + 0x20 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40058c74: c2 07 bf ec ld [ %fp + -20 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40058c78: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40058c7c: 01 00 00 00 nop
<== NOT EXECUTED
}
}
_Rate_monotonic_Release( the_period, &lock_context );
return status;
}
40058c80: 81 c7 e0 08 ret
<== NOT EXECUTED
40058c84: 91 e8 00 02 restore %g0, %g2, %o0
<== NOT EXECUTED
valid_status = _Rate_monotonic_Get_status(
40058c88: 94 07 bf f8 add %fp, -8, %o2
<== NOT EXECUTED
40058c8c: 40 00 00 29 call 40058d30 <_Rate_monotonic_Get_status>
<== NOT EXECUTED
40058c90: 92 07 bf f0 add %fp, -16, %o1
<== NOT EXECUTED
if ( valid_status ) {
40058c94: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40058c98: 02 bf ff f7 be 40058c74 <rtems_rate_monotonic_get_status+0x6c>
<== NOT EXECUTED
40058c9c: 84 10 20 0b mov 0xb, %g2
<== NOT EXECUTED
40058ca0: c4 07 bf f0 ld [ %fp + -16 ], %g2
<== NOT EXECUTED
40058ca4: c6 07 bf f8 ld [ %fp + -8 ], %g3
<== NOT EXECUTED
40058ca8: f4 07 bf f4 ld [ %fp + -12 ], %i2
<== NOT EXECUTED
40058cac: f8 07 bf fc ld [ %fp + -4 ], %i4
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058cb0: b1 38 a0 1f sra %g2, 0x1f, %i0
<== NOT EXECUTED
40058cb4: 89 38 e0 1f sra %g3, 0x1f, %g4
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058cb8: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058cbc: c4 26 60 0c st %g2, [ %i1 + 0xc ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058cc0: 82 10 62 00 or %g1, 0x200, %g1
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058cc4: f0 26 60 08 st %i0, [ %i1 + 8 ]
<== NOT EXECUTED
_ts.tv_nsec = ((uint64_t)1000000000 * (uint32_t)_sbt) >> 32;
40058cc8: b6 56 80 01 umul %i2, %g1, %i3
<== NOT EXECUTED
40058ccc: b5 40 00 00 rd %y, %i2
<== NOT EXECUTED
40058cd0: ba 57 00 01 umul %i4, %g1, %i5
<== NOT EXECUTED
40058cd4: b9 40 00 00 rd %y, %i4
<== NOT EXECUTED
status = RTEMS_SUCCESSFUL;
40058cd8: 84 10 20 00 clr %g2
<== NOT EXECUTED
40058cdc: f4 26 60 10 st %i2, [ %i1 + 0x10 ]
<== NOT EXECUTED
_ts.tv_sec = _sbt >> 32;
40058ce0: c6 26 60 1c st %g3, [ %i1 + 0x1c ]
<== NOT EXECUTED
40058ce4: c8 26 60 18 st %g4, [ %i1 + 0x18 ]
<== NOT EXECUTED
40058ce8: 10 bf ff e3 b 40058c74 <rtems_rate_monotonic_get_status+0x6c>
<== NOT EXECUTED
40058cec: f8 26 60 20 st %i4, [ %i1 + 0x20 ]
<== NOT EXECUTED
}
40058cf0: 81 c7 e0 08 ret
<== NOT EXECUTED
40058cf4: 91 e8 00 02 restore %g0, %g2, %o0
<== NOT EXECUTED
400440e4 <rtems_rate_monotonic_report_statistics_with_plugin>:
#define NANOSECONDS_FMT "%06ld"
void rtems_rate_monotonic_report_statistics_with_plugin(
const rtems_printer *printer
)
{
400440e4: 9d e3 be d8 save %sp, -296, %sp
<== NOT EXECUTED
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
rtems_printf( printer, "Period information by period\n" );
400440e8: 13 10 02 0e sethi %hi(0x40083800), %o1
<== NOT EXECUTED
400440ec: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400440f0: 7f ff 21 3a call 4000c5d8 <rtems_printf>
<== NOT EXECUTED
400440f4: 92 12 61 40 or %o1, 0x140, %o1
<== NOT EXECUTED
rtems_printf( printer, "--- CPU times are in seconds ---\n" );
400440f8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400440fc: 13 10 02 0e sethi %hi(0x40083800), %o1
<== NOT EXECUTED
40044100: 7f ff 21 36 call 4000c5d8 <rtems_printf>
<== NOT EXECUTED
40044104: 92 12 61 60 or %o1, 0x160, %o1 ! 40083960 <_TOD_Days_per_month+0x88>
<== NOT EXECUTED
rtems_printf( printer, "--- Wall times are in seconds ---\n" );
40044108: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4004410c: 13 10 02 0e sethi %hi(0x40083800), %o1
<== NOT EXECUTED
40044110: 7f ff 21 32 call 4000c5d8 <rtems_printf>
<== NOT EXECUTED
40044114: 92 12 61 88 or %o1, 0x188, %o1 ! 40083988 <_TOD_Days_per_month+0xb0>
<== NOT EXECUTED
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
rtems_printf( printer,
40044118: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4004411c: 13 10 02 0e sethi %hi(0x40083800), %o1
<== NOT EXECUTED
40044120: 7f ff 21 2e call 4000c5d8 <rtems_printf>
<== NOT EXECUTED
40044124: 92 12 61 b0 or %o1, 0x1b0, %o1 ! 400839b0 <_TOD_Days_per_month+0xd8>
<== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
40044128: 37 10 02 45 sethi %hi(0x40091400), %i3
<== NOT EXECUTED
4004412c: b6 16 e0 38 or %i3, 0x38, %i3 ! 40091438 <_Rate_monotonic_Information>
<== NOT EXECUTED
40044130: fa 06 e0 08 ld [ %i3 + 8 ], %i5
<== NOT EXECUTED
40044134: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
<== NOT EXECUTED
40044138: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
4004413c: 18 80 00 75 bgu 40044310 <rtems_rate_monotonic_report_statistics_with_plugin+0x22c>
<== NOT EXECUTED
40044140: 35 10 02 0e sethi %hi(0x40083800), %i2
<== NOT EXECUTED
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
rtems_printf( printer,
40044144: 39 04 18 93 sethi %hi(0x10624c00), %i4
<== NOT EXECUTED
40044148: 21 10 02 0e sethi %hi(0x40083800), %l0
<== NOT EXECUTED
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
rtems_printf( printer,
4004414c: 33 10 02 0e sethi %hi(0x40083800), %i1
<== NOT EXECUTED
rtems_printf( printer, "\n" );
40044150: 23 10 02 0a sethi %hi(0x40082800), %l1
<== NOT EXECUTED
rtems_printf( printer,
40044154: b4 16 a2 48 or %i2, 0x248, %i2
<== NOT EXECUTED
rtems_printf( printer,
40044158: b8 17 21 d3 or %i4, 0x1d3, %i4
<== NOT EXECUTED
4004415c: a0 14 22 60 or %l0, 0x260, %l0
<== NOT EXECUTED
rtems_printf( printer,
40044160: b2 16 62 88 or %i1, 0x288, %i1
<== NOT EXECUTED
rtems_printf( printer, "\n" );
40044164: 10 80 00 4b b 40044290 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ac>
<== NOT EXECUTED
40044168: a2 14 62 40 or %l1, 0x240, %l1
<== NOT EXECUTED
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
4004416c: 40 00 04 5f call 400452e8 <_Timespec_Divide_by_integer>
<== NOT EXECUTED
40044170: 01 00 00 00 nop
<== NOT EXECUTED
rtems_printf( printer,
40044174: c2 07 bf 60 ld [ %fp + -160 ], %g1
<== NOT EXECUTED
40044178: 89 38 60 1f sra %g1, 0x1f, %g4
<== NOT EXECUTED
4004417c: c6 07 bf b8 ld [ %fp + -72 ], %g3
<== NOT EXECUTED
40044180: 80 58 40 1c smul %g1, %i4, %g0
<== NOT EXECUTED
40044184: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
40044188: 85 38 a0 06 sra %g2, 6, %g2
<== NOT EXECUTED
4004418c: 84 20 80 04 sub %g2, %g4, %g2
<== NOT EXECUTED
40044190: 80 58 c0 1c smul %g3, %i4, %g0
<== NOT EXECUTED
40044194: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
40044198: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
<== NOT EXECUTED
4004419c: 87 38 e0 1f sra %g3, 0x1f, %g3
<== NOT EXECUTED
400441a0: c4 07 bf 58 ld [ %fp + -168 ], %g2
<== NOT EXECUTED
400441a4: 83 38 60 06 sra %g1, 6, %g1
<== NOT EXECUTED
400441a8: 82 20 40 03 sub %g1, %g3, %g1
<== NOT EXECUTED
400441ac: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
<== NOT EXECUTED
400441b0: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
400441b4: c4 07 bf 5c ld [ %fp + -164 ], %g2
<== NOT EXECUTED
400441b8: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
<== NOT EXECUTED
400441bc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400441c0: c2 07 bf b4 ld [ %fp + -76 ], %g1
<== NOT EXECUTED
400441c4: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
<== NOT EXECUTED
400441c8: d8 07 bf a8 ld [ %fp + -88 ], %o4
<== NOT EXECUTED
400441cc: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
<== NOT EXECUTED
400441d0: 80 5b 00 1c smul %o4, %i4, %g0
<== NOT EXECUTED
400441d4: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
400441d8: d4 1f bf a0 ldd [ %fp + -96 ], %o2
<== NOT EXECUTED
400441dc: 83 38 60 06 sra %g1, 6, %g1
<== NOT EXECUTED
400441e0: da 07 bf b0 ld [ %fp + -80 ], %o5
<== NOT EXECUTED
400441e4: 99 3b 20 1f sra %o4, 0x1f, %o4
<== NOT EXECUTED
400441e8: 7f ff 20 fc call 4000c5d8 <rtems_printf>
<== NOT EXECUTED
400441ec: 98 20 40 0c sub %g1, %o4, %o4
<== NOT EXECUTED
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
400441f0: d2 07 bf 98 ld [ %fp + -104 ], %o1
<== NOT EXECUTED
400441f4: 94 07 bf 58 add %fp, -168, %o2
<== NOT EXECUTED
400441f8: 40 00 04 3c call 400452e8 <_Timespec_Divide_by_integer>
<== NOT EXECUTED
400441fc: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
rtems_printf( printer,
40044200: c2 07 bf 60 ld [ %fp + -160 ], %g1
<== NOT EXECUTED
40044204: c6 07 bf e8 ld [ %fp + -24 ], %g3
<== NOT EXECUTED
40044208: 80 58 40 1c smul %g1, %i4, %g0
<== NOT EXECUTED
4004420c: 85 40 00 00 rd %y, %g2
<== NOT EXECUTED
40044210: 89 38 60 1f sra %g1, 0x1f, %g4
<== NOT EXECUTED
40044214: 85 38 a0 06 sra %g2, 6, %g2
<== NOT EXECUTED
40044218: 84 20 80 04 sub %g2, %g4, %g2
<== NOT EXECUTED
4004421c: 80 58 c0 1c smul %g3, %i4, %g0
<== NOT EXECUTED
40044220: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
40044224: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
<== NOT EXECUTED
40044228: 83 38 60 06 sra %g1, 6, %g1
<== NOT EXECUTED
4004422c: c4 07 bf 58 ld [ %fp + -168 ], %g2
<== NOT EXECUTED
40044230: 87 38 e0 1f sra %g3, 0x1f, %g3
<== NOT EXECUTED
40044234: 82 20 40 03 sub %g1, %g3, %g1
<== NOT EXECUTED
40044238: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
<== NOT EXECUTED
4004423c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40044240: c4 07 bf 5c ld [ %fp + -164 ], %g2
<== NOT EXECUTED
40044244: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
<== NOT EXECUTED
40044248: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4004424c: c2 07 bf e4 ld [ %fp + -28 ], %g1
<== NOT EXECUTED
40044250: d8 07 bf d8 ld [ %fp + -40 ], %o4
<== NOT EXECUTED
40044254: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
<== NOT EXECUTED
40044258: 80 5b 00 1c smul %o4, %i4, %g0
<== NOT EXECUTED
4004425c: 83 40 00 00 rd %y, %g1
<== NOT EXECUTED
40044260: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
<== NOT EXECUTED
40044264: 83 38 60 06 sra %g1, 6, %g1
<== NOT EXECUTED
40044268: da 07 bf e0 ld [ %fp + -32 ], %o5
<== NOT EXECUTED
4004426c: d4 1f bf d0 ldd [ %fp + -48 ], %o2
<== NOT EXECUTED
40044270: 99 3b 20 1f sra %o4, 0x1f, %o4
<== NOT EXECUTED
40044274: 7f ff 20 d9 call 4000c5d8 <rtems_printf>
<== NOT EXECUTED
40044278: 98 20 40 0c sub %g1, %o4, %o4
<== NOT EXECUTED
for ( id=_Rate_monotonic_Information.minimum_id ;
4004427c: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
<== NOT EXECUTED
id++ ) {
40044280: ba 07 60 01 inc %i5
<== NOT EXECUTED
for ( id=_Rate_monotonic_Information.minimum_id ;
40044284: 80 a0 40 1d cmp %g1, %i5
<== NOT EXECUTED
40044288: 0a 80 00 22 bcs 40044310 <rtems_rate_monotonic_report_statistics_with_plugin+0x22c>
<== NOT EXECUTED
4004428c: 01 00 00 00 nop
<== NOT EXECUTED
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
40044290: 92 07 bf 98 add %fp, -104, %o1
<== NOT EXECUTED
40044294: 40 00 52 14 call 40058ae4 <rtems_rate_monotonic_get_statistics>
<== NOT EXECUTED
40044298: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
(void) rtems_rate_monotonic_get_status( id, &the_status );
4004429c: 92 07 bf 68 add %fp, -152, %o1
<== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL )
400442a0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400442a4: 12 bf ff f6 bne 4004427c <rtems_rate_monotonic_report_statistics_with_plugin+0x198>
<== NOT EXECUTED
400442a8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
(void) rtems_rate_monotonic_get_status( id, &the_status );
400442ac: 40 00 52 57 call 40058c08 <rtems_rate_monotonic_get_status>
<== NOT EXECUTED
400442b0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_object_get_name( the_status.owner, sizeof(name), name );
400442b4: d0 07 bf 68 ld [ %fp + -152 ], %o0
<== NOT EXECUTED
400442b8: 94 07 bf 50 add %fp, -176, %o2
<== NOT EXECUTED
400442bc: 40 00 00 43 call 400443c8 <rtems_object_get_name>
<== NOT EXECUTED
400442c0: 92 10 20 05 mov 5, %o1
<== NOT EXECUTED
rtems_printf( printer,
400442c4: d8 1f bf 98 ldd [ %fp + -104 ], %o4
<== NOT EXECUTED
400442c8: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
400442cc: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
400442d0: 96 07 bf 50 add %fp, -176, %o3
<== NOT EXECUTED
400442d4: 7f ff 20 c1 call 4000c5d8 <rtems_printf>
<== NOT EXECUTED
400442d8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (the_stats.count == 0) {
400442dc: c2 07 bf 98 ld [ %fp + -104 ], %g1
<== NOT EXECUTED
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
400442e0: 94 07 bf 58 add %fp, -168, %o2
<== NOT EXECUTED
if (the_stats.count == 0) {
400442e4: 92 90 60 00 orcc %g1, 0, %o1
<== NOT EXECUTED
400442e8: 12 bf ff a1 bne 4004416c <rtems_rate_monotonic_report_statistics_with_plugin+0x88>
<== NOT EXECUTED
400442ec: 90 07 bf c0 add %fp, -64, %o0
<== NOT EXECUTED
rtems_printf( printer, "\n" );
400442f0: 92 10 00 11 mov %l1, %o1
<== NOT EXECUTED
400442f4: 7f ff 20 b9 call 4000c5d8 <rtems_printf>
<== NOT EXECUTED
400442f8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
for ( id=_Rate_monotonic_Information.minimum_id ;
400442fc: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
<== NOT EXECUTED
id++ ) {
40044300: ba 07 60 01 inc %i5
<== NOT EXECUTED
for ( id=_Rate_monotonic_Information.minimum_id ;
40044304: 80 a0 40 1d cmp %g1, %i5
<== NOT EXECUTED
40044308: 1a bf ff e3 bcc 40044294 <rtems_rate_monotonic_report_statistics_with_plugin+0x1b0>
<== NOT EXECUTED
4004430c: 92 07 bf 98 add %fp, -104, %o1
<== NOT EXECUTED
_Timespec_Get_seconds( &wall_average ),
_Timespec_Get_nanoseconds( &wall_average ) / NANOSECONDS_DIVIDER
);
}
}
}
40044310: 81 c7 e0 08 ret
<== NOT EXECUTED
40044314: 81 e8 00 00 restore
<== NOT EXECUTED
40044318 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
40044318: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_RTEMS_Lock_allocator();
4004431c: 7f ff 56 d2 call 40019e64 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
40044320: 39 10 02 45 sethi %hi(0x40091400), %i4
<== NOT EXECUTED
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
40044324: b8 17 20 38 or %i4, 0x38, %i4 ! 40091438 <_Rate_monotonic_Information>
<== NOT EXECUTED
40044328: fa 07 20 08 ld [ %i4 + 8 ], %i5
<== NOT EXECUTED
4004432c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
<== NOT EXECUTED
40044330: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
40044334: 18 80 00 09 bgu 40044358 <rtems_rate_monotonic_reset_all_statistics+0x40>
<== NOT EXECUTED
40044338: 01 00 00 00 nop
<== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
4004433c: 40 00 00 09 call 40044360 <rtems_rate_monotonic_reset_statistics>
<== NOT EXECUTED
40044340: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
for ( id=_Rate_monotonic_Information.minimum_id ;
40044344: c2 07 20 0c ld [ %i4 + 0xc ], %g1
<== NOT EXECUTED
id++ ) {
40044348: ba 07 60 01 inc %i5
<== NOT EXECUTED
for ( id=_Rate_monotonic_Information.minimum_id ;
4004434c: 80 a0 40 1d cmp %g1, %i5
<== NOT EXECUTED
40044350: 1a bf ff fb bcc 4004433c <rtems_rate_monotonic_reset_all_statistics+0x24>
<== NOT EXECUTED
40044354: 01 00 00 00 nop
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
40044358: 7f ff 56 c8 call 40019e78 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4004435c: 81 e8 00 00 restore
<== NOT EXECUTED
40044360 <rtems_rate_monotonic_reset_statistics>:
#include <rtems/rtems/ratemonimpl.h>
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
40044360: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get(
Objects_Id id,
ISR_lock_Context *lock_context
)
{
return (Rate_monotonic_Control *)
40044364: 15 10 02 45 sethi %hi(0x40091400), %o2
<== NOT EXECUTED
40044368: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4004436c: 92 07 bf fc add %fp, -4, %o1
<== NOT EXECUTED
40044370: 94 12 a0 38 or %o2, 0x38, %o2
<== NOT EXECUTED
40044374: 40 00 01 ff call 40044b70 <_Objects_Get>
<== NOT EXECUTED
40044378: b0 10 20 04 mov 4, %i0
<== NOT EXECUTED
Rate_monotonic_Control *the_period;
ISR_lock_Context lock_context;
the_period = _Rate_monotonic_Get( id, &lock_context );
if ( the_period == NULL ) {
4004437c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40044380: 02 80 00 10 be 400443c0 <rtems_rate_monotonic_reset_statistics+0x60>
<== NOT EXECUTED
40044384: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
)
{
Rate_monotonic_Statistics *statistics;
statistics = &the_period->Statistics;
memset( statistics, 0, sizeof( *statistics ) );
40044388: 94 10 20 38 mov 0x38, %o2
<== NOT EXECUTED
4004438c: 92 10 20 00 clr %o1
<== NOT EXECUTED
40044390: 40 00 73 9a call 400611f8 <memset>
<== NOT EXECUTED
40044394: 90 02 20 68 add %o0, 0x68, %o0
<== NOT EXECUTED
*_time = tstosbt(_ts);
40044398: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
<== NOT EXECUTED
4004439c: 07 09 70 5f sethi %hi(0x25c17c00), %g3
<== NOT EXECUTED
400443a0: 84 10 a3 ff or %g2, 0x3ff, %g2
<== NOT EXECUTED
400443a4: 86 10 e1 00 or %g3, 0x100, %g3
<== NOT EXECUTED
400443a8: c4 3f 60 88 std %g2, [ %i5 + 0x88 ]
<== NOT EXECUTED
400443ac: c4 3f 60 70 std %g2, [ %i5 + 0x70 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400443b0: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400443b4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400443b8: 01 00 00 00 nop
<== NOT EXECUTED
}
_Rate_monotonic_Acquire_critical( the_period, &lock_context );
_Rate_monotonic_Reset_statistics( the_period );
_Rate_monotonic_Release( the_period, &lock_context );
return RTEMS_SUCCESSFUL;
400443bc: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
}
400443c0: 81 c7 e0 08 ret
<== NOT EXECUTED
400443c4: 81 e8 00 00 restore
<== NOT EXECUTED
4000df24 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
4000df24: 9d e3 bf 70 save %sp, -144, %sp
<== NOT EXECUTED
Semaphore_Variant variant;
const Scheduler_Control *scheduler;
bool valid;
Priority_Control priority;
if ( !rtems_is_name_valid( name ) )
4000df28: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000df2c: 02 80 00 3b be 4000e018 <rtems_semaphore_create+0xf4>
<== NOT EXECUTED
4000df30: 82 10 20 03 mov 3, %g1
<== NOT EXECUTED
return RTEMS_INVALID_NAME;
if ( !id )
4000df34: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
4000df38: 02 80 00 74 be 4000e108 <rtems_semaphore_create+0x1e4>
<== NOT EXECUTED
4000df3c: 84 8e a1 f0 andcc %i2, 0x1f0, %g2
<== NOT EXECUTED
/* Attribute subset defining a mutex variant with a locking protocol */
mutex_with_protocol =
attribute_set & ( SEMAPHORE_KIND_MASK | RTEMS_GLOBAL | RTEMS_PRIORITY );
if ( maybe_global == RTEMS_COUNTING_SEMAPHORE ) {
4000df40: 02 80 00 12 be 4000df88 <rtems_semaphore_create+0x64>
<== NOT EXECUTED
4000df44: 80 a6 60 01 cmp %i1, 1
<== NOT EXECUTED
variant = SEMAPHORE_VARIANT_COUNTING;
} else if ( count > 1 ) {
4000df48: 18 80 00 34 bgu 4000e018 <rtems_semaphore_create+0xf4>
<== NOT EXECUTED
4000df4c: 82 10 20 0a mov 0xa, %g1
<== NOT EXECUTED
/*
* The remaining variants are all binary semphores, thus reject an invalid
* count value.
*/
return RTEMS_INVALID_NUMBER;
} else if ( maybe_global == RTEMS_SIMPLE_BINARY_SEMAPHORE ) {
4000df50: 80 a0 a0 20 cmp %g2, 0x20
<== NOT EXECUTED
4000df54: 02 80 00 33 be 4000e020 <rtems_semaphore_create+0xfc>
<== NOT EXECUTED
4000df58: 80 a0 a0 10 cmp %g2, 0x10
<== NOT EXECUTED
variant = SEMAPHORE_VARIANT_SIMPLE_BINARY;
} else if ( maybe_global == RTEMS_BINARY_SEMAPHORE ) {
4000df5c: 02 80 00 6e be 4000e114 <rtems_semaphore_create+0x1f0>
<== NOT EXECUTED
4000df60: 84 0e a1 f6 and %i2, 0x1f6, %g2
<== NOT EXECUTED
variant = SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL;
} else if (
4000df64: 80 a0 a0 54 cmp %g2, 0x54
<== NOT EXECUTED
4000df68: 02 80 00 71 be 4000e12c <rtems_semaphore_create+0x208>
<== NOT EXECUTED
4000df6c: 80 a0 a0 94 cmp %g2, 0x94
<== NOT EXECUTED
} else if (
mutex_with_protocol
== ( RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING )
) {
variant = SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING;
} else if (
4000df70: 02 80 00 04 be 4000df80 <rtems_semaphore_create+0x5c>
<== NOT EXECUTED
4000df74: 80 a0 a1 10 cmp %g2, 0x110
<== NOT EXECUTED
4000df78: 12 80 00 28 bne 4000e018 <rtems_semaphore_create+0xf4>
<== NOT EXECUTED
4000df7c: 82 10 20 0b mov 0xb, %g1
<== NOT EXECUTED
4000df80: 10 80 00 03 b 4000df8c <rtems_semaphore_create+0x68>
<== NOT EXECUTED
4000df84: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
variant = SEMAPHORE_VARIANT_COUNTING;
4000df88: a0 10 20 04 mov 4, %l0
<== NOT EXECUTED
* This function allocates a semaphore control block from
* the inactive chain of free semaphore control blocks.
*/
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )
{
return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
4000df8c: 23 10 00 d3 sethi %hi(0x40034c00), %l1
<== NOT EXECUTED
4000df90: 40 00 0d a8 call 40011630 <_Objects_Allocate>
<== NOT EXECUTED
4000df94: 90 14 63 58 or %l1, 0x358, %o0 ! 40034f58 <_Semaphore_Information>
<== NOT EXECUTED
return RTEMS_NOT_DEFINED;
}
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
4000df98: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4000df9c: 02 80 00 60 be 4000e11c <rtems_semaphore_create+0x1f8>
<== NOT EXECUTED
4000dfa0: 84 0c 20 07 and %l0, 7, %g2
<== NOT EXECUTED
}
#endif
executing = _Thread_Get_executing();
the_semaphore->variant = variant;
4000dfa4: c2 0f 60 38 ldub [ %i5 + 0x38 ], %g1
<== NOT EXECUTED
4000dfa8: e4 01 a0 20 ld [ %g6 + 0x20 ], %l2
<== NOT EXECUTED
4000dfac: 82 08 60 1f and %g1, 0x1f, %g1
<== NOT EXECUTED
4000dfb0: 87 28 a0 05 sll %g2, 5, %g3
<== NOT EXECUTED
4000dfb4: 82 10 40 03 or %g1, %g3, %g1
<== NOT EXECUTED
if ( _Attributes_Is_priority( attribute_set ) ) {
4000dfb8: 80 8e a0 04 btst 4, %i2
<== NOT EXECUTED
4000dfbc: 02 80 00 1b be 4000e028 <rtems_semaphore_create+0x104>
<== NOT EXECUTED
4000dfc0: c2 2f 60 38 stb %g1, [ %i5 + 0x38 ]
<== NOT EXECUTED
the_semaphore->discipline = SEMAPHORE_DISCIPLINE_PRIORITY;
4000dfc4: 82 08 7f ef and %g1, -17, %g1
<== NOT EXECUTED
} else {
the_semaphore->discipline = SEMAPHORE_DISCIPLINE_FIFO;
}
switch ( the_semaphore->variant ) {
4000dfc8: 84 08 a0 ff and %g2, 0xff, %g2
<== NOT EXECUTED
4000dfcc: 80 a0 a0 01 cmp %g2, 1
<== NOT EXECUTED
4000dfd0: 02 80 00 1b be 4000e03c <rtems_semaphore_create+0x118>
<== NOT EXECUTED
4000dfd4: c2 2f 60 38 stb %g1, [ %i5 + 0x38 ]
<== NOT EXECUTED
4000dfd8: 0a 80 00 45 bcs 4000e0ec <rtems_semaphore_create+0x1c8>
<== NOT EXECUTED
4000dfdc: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
4000dfe0: 02 80 00 43 be 4000e0ec <rtems_semaphore_create+0x1c8>
<== NOT EXECUTED
4000dfe4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
default:
_Assert(
the_semaphore->variant == SEMAPHORE_VARIANT_SIMPLE_BINARY
|| the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING
);
_CORE_semaphore_Initialize(
4000dfe8: 40 00 05 94 call 4000f638 <_CORE_semaphore_Initialize>
<== NOT EXECUTED
4000dfec: 90 07 60 10 add %i5, 0x10, %o0
<== NOT EXECUTED
information->local_table[ index ] = the_object;
4000dff0: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
<== NOT EXECUTED
the_object->name = name;
4000dff4: f0 27 60 0c st %i0, [ %i5 + 0xc ]
<== NOT EXECUTED
information->local_table[ index ] = the_object;
4000dff8: a2 14 63 58 or %l1, 0x358, %l1
<== NOT EXECUTED
4000dffc: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
<== NOT EXECUTED
4000e000: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000e004: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4000e008: fa 20 c0 01 st %i5, [ %g3 + %g1 ]
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4000e00c: 40 00 05 42 call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000e010: c4 27 00 00 st %g2, [ %i4 ]
<== NOT EXECUTED
name,
0 /* Not used */
);
#endif
_Objects_Allocator_unlock();
return RTEMS_SUCCESSFUL;
4000e014: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
4000e018: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e01c: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
variant = SEMAPHORE_VARIANT_SIMPLE_BINARY;
4000e020: 10 bf ff db b 4000df8c <rtems_semaphore_create+0x68>
<== NOT EXECUTED
4000e024: a0 10 20 03 mov 3, %l0
<== NOT EXECUTED
the_semaphore->discipline = SEMAPHORE_DISCIPLINE_FIFO;
4000e028: 82 10 60 10 or %g1, 0x10, %g1
<== NOT EXECUTED
switch ( the_semaphore->variant ) {
4000e02c: 84 08 a0 ff and %g2, 0xff, %g2
<== NOT EXECUTED
4000e030: 80 a0 a0 01 cmp %g2, 1
<== NOT EXECUTED
4000e034: 12 bf ff e9 bne 4000dfd8 <rtems_semaphore_create+0xb4>
<== NOT EXECUTED
4000e038: c2 2f 60 38 stb %g1, [ %i5 + 0x38 ]
<== NOT EXECUTED
const Scheduler_Control *scheduler,
rtems_task_priority priority,
bool *valid
)
{
*valid = ( priority <= scheduler->maximum_priority );
4000e03c: 11 10 00 b5 sethi %hi(0x4002d400), %o0
<== NOT EXECUTED
4000e040: 90 12 20 00 mov %o0, %o0 ! 4002d400 <_Scheduler_Table>
<== NOT EXECUTED
return ( *scheduler->Operations.map_priority )( scheduler, priority );
4000e044: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
<== NOT EXECUTED
4000e048: f4 02 20 40 ld [ %o0 + 0x40 ], %i2
<== NOT EXECUTED
4000e04c: e0 02 20 44 ld [ %o0 + 0x44 ], %l0
<== NOT EXECUTED
4000e050: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000e054: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e058: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
if ( valid ) {
4000e05c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000e060: a8 10 00 08 mov %o0, %l4
<== NOT EXECUTED
4000e064: 02 80 00 34 be 4000e134 <rtems_semaphore_create+0x210>
<== NOT EXECUTED
4000e068: aa 10 00 09 mov %o1, %l5
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex
)
{
_Thread_queue_Object_initialize( &the_mutex->Wait_queue );
4000e06c: 40 00 18 98 call 400142cc <_Thread_queue_Object_initialize>
<== NOT EXECUTED
4000e070: 90 07 60 10 add %i5, 0x10, %o0
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _CORE_recursive_mutex_Initialize(
CORE_recursive_mutex_Control *the_mutex
)
{
_CORE_mutex_Initialize( &the_mutex->Mutex );
the_mutex->nest_level = 0;
4000e074: c0 27 60 1c clr [ %i5 + 0x1c ]
<== NOT EXECUTED
if ( count == 0 ) {
4000e078: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000e07c: 12 bf ff dd bne 4000dff0 <rtems_semaphore_create+0xcc>
<== NOT EXECUTED
4000e080: e8 3f 60 30 std %l4, [ %i5 + 0x30 ]
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
4000e084: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e088: 91 d0 20 09 ta 9
<== NOT EXECUTED
_ISR_lock_ISR_disable( &queue_context.Lock_context.Lock_context );
4000e08c: c2 27 bf dc st %g1, [ %fp + -36 ]
<== NOT EXECUTED
_Thread_Wait_acquire_default_critical( owner, &lock_context );
scheduler_node = _Thread_Scheduler_get_home_node( owner );
if (
4000e090: c2 04 a0 38 ld [ %l2 + 0x38 ], %g1
<== NOT EXECUTED
4000e094: c6 07 60 30 ld [ %i5 + 0x30 ], %g3
<== NOT EXECUTED
4000e098: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
<== NOT EXECUTED
4000e09c: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
4000e0a0: 18 80 00 09 bgu 4000e0c4 <rtems_semaphore_create+0x1a0>
<== NOT EXECUTED
4000e0a4: 01 00 00 00 nop
<== NOT EXECUTED
4000e0a8: 32 80 00 27 bne,a 4000e144 <rtems_semaphore_create+0x220>
<== NOT EXECUTED
4000e0ac: e4 27 60 14 st %l2, [ %i5 + 0x14 ]
<== NOT EXECUTED
4000e0b0: c4 07 60 34 ld [ %i5 + 0x34 ], %g2
<== NOT EXECUTED
4000e0b4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4000e0b8: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4000e0bc: 28 80 00 22 bleu,a 4000e144 <rtems_semaphore_create+0x220>
<== NOT EXECUTED
4000e0c0: e4 27 60 14 st %l2, [ %i5 + 0x14 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e0c4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e0c8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e0cc: 01 00 00 00 nop
<== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
4000e0d0: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000e0d4: 40 00 0e 28 call 40011974 <_Objects_Free>
<== NOT EXECUTED
4000e0d8: 90 14 63 58 or %l1, 0x358, %o0
<== NOT EXECUTED
4000e0dc: 40 00 05 0e call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000e0e0: 01 00 00 00 nop
<== NOT EXECUTED
return _Status_Get( status );
4000e0e4: 10 bf ff cd b 4000e018 <rtems_semaphore_create+0xf4>
<== NOT EXECUTED
4000e0e8: 82 10 20 13 mov 0x13, %g1 ! 13 <_TLS_Alignment+0x12>
<== NOT EXECUTED
_Thread_queue_Object_initialize( &the_mutex->Wait_queue );
4000e0ec: 40 00 18 78 call 400142cc <_Thread_queue_Object_initialize>
<== NOT EXECUTED
4000e0f0: 90 07 60 10 add %i5, 0x10, %o0
<== NOT EXECUTED
if ( count == 0 ) {
4000e0f4: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000e0f8: 12 bf ff be bne 4000dff0 <rtems_semaphore_create+0xcc>
<== NOT EXECUTED
4000e0fc: c0 27 60 1c clr [ %i5 + 0x1c ]
<== NOT EXECUTED
the_mutex->Wait_queue.Queue.owner = owner;
4000e100: 10 bf ff bc b 4000dff0 <rtems_semaphore_create+0xcc>
<== NOT EXECUTED
4000e104: e4 27 60 14 st %l2, [ %i5 + 0x14 ]
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
4000e108: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
}
4000e10c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e110: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
variant = SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL;
4000e114: 10 bf ff 9e b 4000df8c <rtems_semaphore_create+0x68>
<== NOT EXECUTED
4000e118: a0 10 20 02 mov 2, %l0
<== NOT EXECUTED
4000e11c: 40 00 04 fe call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000e120: 01 00 00 00 nop
<== NOT EXECUTED
return RTEMS_TOO_MANY;
4000e124: 10 bf ff bd b 4000e018 <rtems_semaphore_create+0xf4>
<== NOT EXECUTED
4000e128: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
variant = SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY;
4000e12c: 10 bf ff 98 b 4000df8c <rtems_semaphore_create+0x68>
<== NOT EXECUTED
4000e130: a0 10 20 00 clr %l0
<== NOT EXECUTED
if ( valid ) {
4000e134: 80 a6 c0 10 cmp %i3, %l0
<== NOT EXECUTED
4000e138: 08 bf ff cd bleu 4000e06c <rtems_semaphore_create+0x148>
<== NOT EXECUTED
4000e13c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000e140: 30 bf ff e5 b,a 4000e0d4 <rtems_semaphore_create+0x1b0>
<== NOT EXECUTED
return STATUS_MUTEX_CEILING_VIOLATED;
}
_CORE_mutex_Set_owner( &the_mutex->Recursive.Mutex, owner );
_Thread_Resource_count_increment( owner );
_Thread_Priority_add(
4000e144: 92 07 60 20 add %i5, 0x20, %o1
<== NOT EXECUTED
4000e148: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000e14c: 40 00 14 57 call 400132a8 <_Thread_Priority_add>
<== NOT EXECUTED
4000e150: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000e154: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e158: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000e15c: b6 10 00 06 mov %g6, %i3
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e160: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e164: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e168: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e16c: 01 00 00 00 nop
<== NOT EXECUTED
);
_Thread_Wait_release_default_critical( owner, &lock_context );
cpu_self = _Thread_queue_Dispatch_disable( queue_context );
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
_Thread_Priority_update( queue_context );
4000e170: 40 00 14 5f call 400132ec <_Thread_Priority_update>
<== NOT EXECUTED
4000e174: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000e178: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000e17c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000e180: 02 80 00 05 be 4000e194 <rtems_semaphore_create+0x270>
<== NOT EXECUTED
4000e184: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000e188: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
<== NOT EXECUTED
information->local_table[ index ] = the_object;
4000e18c: 10 bf ff 9a b 4000dff4 <rtems_semaphore_create+0xd0>
<== NOT EXECUTED
4000e190: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e194: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000e198: c4 0e e0 1c ldub [ %i3 + 0x1c ], %g2
<== NOT EXECUTED
4000e19c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000e1a0: 12 80 00 07 bne 4000e1bc <rtems_semaphore_create+0x298>
<== NOT EXECUTED
4000e1a4: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000e1a8: c0 26 e0 18 clr [ %i3 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e1ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e1b0: 01 00 00 00 nop
<== NOT EXECUTED
4000e1b4: 10 bf ff 90 b 4000dff4 <rtems_semaphore_create+0xd0>
<== NOT EXECUTED
4000e1b8: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000e1bc: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
4000e1c0: 40 00 14 d2 call 40013508 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000e1c4: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4000e1c8: 10 bf ff f9 b 4000e1ac <rtems_semaphore_create+0x288>
<== NOT EXECUTED
4000e1cc: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000e1d0 <rtems_semaphore_delete>:
#include <rtems/rtems/statusimpl.h>
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
4000e1d0: 9d e3 bf 78 save %sp, -136, %sp
<== NOT EXECUTED
_RTEMS_Lock_allocator();
4000e1d4: 40 00 04 cb call 4000f500 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
4000e1d8: 39 10 00 d3 sethi %hi(0x40034c00), %i4
<== NOT EXECUTED
Objects_Id id,
Thread_queue_Context *queue_context
)
{
_Thread_queue_Context_initialize( queue_context );
return (Semaphore_Control *) _Objects_Get(
4000e1dc: 92 07 bf dc add %fp, -36, %o1
<== NOT EXECUTED
4000e1e0: 94 17 23 58 or %i4, 0x358, %o2
<== NOT EXECUTED
4000e1e4: 40 00 0e 33 call 40011ab0 <_Objects_Get>
<== NOT EXECUTED
4000e1e8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
Status_Control status;
_Objects_Allocator_lock();
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
4000e1ec: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4000e1f0: 02 80 00 43 be 4000e2fc <rtems_semaphore_delete+0x12c>
<== NOT EXECUTED
4000e1f4: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_queue_Acquire_critical(
&the_semaphore->Core_control.Wait_queue,
&queue_context
);
switch ( the_semaphore->variant ) {
4000e1f8: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
<== NOT EXECUTED
4000e1fc: 83 30 60 1d srl %g1, 0x1d, %g1
<== NOT EXECUTED
4000e200: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4000e204: 18 80 00 06 bgu 4000e21c <rtems_semaphore_delete+0x4c>
<== NOT EXECUTED
4000e208: 90 17 23 58 or %i4, 0x358, %o0
<== NOT EXECUTED
case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY:
case SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING:
case SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL:
if (
4000e20c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4000e210: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e214: 12 80 00 26 bne 4000e2ac <rtems_semaphore_delete+0xdc>
<== NOT EXECUTED
4000e218: 01 00 00 00 nop
<== NOT EXECUTED
);
_Objects_Allocator_unlock();
return _Status_Get( status );
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
4000e21c: 40 00 0d 0a call 40011644 <_Objects_Close>
<== NOT EXECUTED
4000e220: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) {
4000e224: c2 0f 60 38 ldub [ %i5 + 0x38 ], %g1
<== NOT EXECUTED
4000e228: 80 88 60 e0 btst 0xe0, %g1
<== NOT EXECUTED
4000e22c: 12 80 00 10 bne 4000e26c <rtems_semaphore_delete+0x9c>
<== NOT EXECUTED
4000e230: 90 07 60 10 add %i5, 0x10, %o0
<== NOT EXECUTED
|| the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING
|| the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL
|| the_semaphore->variant == SEMAPHORE_VARIANT_SIMPLE_BINARY
|| the_semaphore->variant == SEMAPHORE_VARIANT_COUNTING
);
_Thread_queue_Flush_critical(
4000e234: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
return &_Thread_queue_Operations_priority_inherit;
4000e238: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
4000e23c: 15 10 00 50 sethi %hi(0x40014000), %o2
<== NOT EXECUTED
4000e240: 92 12 63 5c or %o1, 0x35c, %o1
<== NOT EXECUTED
4000e244: 40 00 17 b3 call 40014110 <_Thread_queue_Flush_critical>
<== NOT EXECUTED
4000e248: 94 12 a1 00 or %o2, 0x100, %o2
<== NOT EXECUTED
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
4000e24c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000e250: 90 17 23 58 or %i4, 0x358, %o0
<== NOT EXECUTED
4000e254: 40 00 0d c8 call 40011974 <_Objects_Free>
<== NOT EXECUTED
4000e258: b0 10 20 00 clr %i0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4000e25c: 40 00 04 ae call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000e260: 01 00 00 00 nop
<== NOT EXECUTED
#endif
_Semaphore_Free( the_semaphore );
_Objects_Allocator_unlock();
return RTEMS_SUCCESSFUL;
}
4000e264: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e268: 81 e8 00 00 restore
<== NOT EXECUTED
if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000e26c: 80 88 60 10 btst 0x10, %g1
<== NOT EXECUTED
4000e270: 12 80 00 16 bne 4000e2c8 <rtems_semaphore_delete+0xf8>
<== NOT EXECUTED
4000e274: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
return &_Thread_queue_Operations_priority;
4000e278: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
_Thread_queue_Flush_critical(
4000e27c: 15 10 00 50 sethi %hi(0x40014000), %o2
<== NOT EXECUTED
4000e280: 92 12 63 70 or %o1, 0x370, %o1
<== NOT EXECUTED
4000e284: 40 00 17 a3 call 40014110 <_Thread_queue_Flush_critical>
<== NOT EXECUTED
4000e288: 94 12 a1 00 or %o2, 0x100, %o2
<== NOT EXECUTED
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
4000e28c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000e290: 90 17 23 58 or %i4, 0x358, %o0
<== NOT EXECUTED
4000e294: 40 00 0d b8 call 40011974 <_Objects_Free>
<== NOT EXECUTED
4000e298: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000e29c: 40 00 04 9e call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000e2a0: 01 00 00 00 nop
<== NOT EXECUTED
}
4000e2a4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e2a8: 81 e8 00 00 restore
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e2ac: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e2b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e2b4: 01 00 00 00 nop
<== NOT EXECUTED
4000e2b8: 40 00 04 97 call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000e2bc: b0 10 20 0c mov 0xc, %i0 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
return _Status_Get( status );
4000e2c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e2c4: 81 e8 00 00 restore
<== NOT EXECUTED
return &_Thread_queue_Operations_FIFO;
4000e2c8: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
_Thread_queue_Flush_critical(
4000e2cc: 15 10 00 50 sethi %hi(0x40014000), %o2
<== NOT EXECUTED
4000e2d0: 92 12 63 84 or %o1, 0x384, %o1
<== NOT EXECUTED
4000e2d4: 40 00 17 8f call 40014110 <_Thread_queue_Flush_critical>
<== NOT EXECUTED
4000e2d8: 94 12 a1 00 or %o2, 0x100, %o2
<== NOT EXECUTED
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
4000e2dc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000e2e0: 90 17 23 58 or %i4, 0x358, %o0
<== NOT EXECUTED
4000e2e4: 40 00 0d a4 call 40011974 <_Objects_Free>
<== NOT EXECUTED
4000e2e8: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000e2ec: 40 00 04 8a call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000e2f0: 01 00 00 00 nop
<== NOT EXECUTED
}
4000e2f4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e2f8: 81 e8 00 00 restore
<== NOT EXECUTED
4000e2fc: 40 00 04 86 call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000e300: b0 10 20 04 mov 4, %i0
<== NOT EXECUTED
return RTEMS_INVALID_ID;
4000e304: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e308: 81 e8 00 00 restore
<== NOT EXECUTED
4000e344 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
4000e344: 9d e3 bf 70 save %sp, -144, %sp
<== NOT EXECUTED
return (Semaphore_Control *) _Objects_Get(
4000e348: 15 10 00 d3 sethi %hi(0x40034c00), %o2
<== NOT EXECUTED
4000e34c: 92 07 bf dc add %fp, -36, %o1
<== NOT EXECUTED
4000e350: 94 12 a3 58 or %o2, 0x358, %o2
<== NOT EXECUTED
4000e354: 40 00 0d d7 call 40011ab0 <_Objects_Get>
<== NOT EXECUTED
4000e358: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
bool wait;
Status_Control status;
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
4000e35c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e360: 02 80 00 6c be 4000e510 <rtems_semaphore_obtain+0x1cc>
<== NOT EXECUTED
4000e364: 96 38 00 19 xnor %g0, %i1, %o3
<== NOT EXECUTED
#else
return RTEMS_INVALID_ID;
#endif
}
executing = _Thread_Executing;
4000e368: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
<== NOT EXECUTED
wait = !_Options_Is_no_wait( option_set );
if ( wait ) {
4000e36c: b2 8e 60 01 andcc %i1, 1, %i1
<== NOT EXECUTED
4000e370: 02 80 00 21 be 4000e3f4 <rtems_semaphore_obtain+0xb0>
<== NOT EXECUTED
4000e374: 96 0a e0 01 and %o3, 1, %o3
<== NOT EXECUTED
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
4000e378: 03 10 00 4f sethi %hi(0x40013c00), %g1
<== NOT EXECUTED
4000e37c: 82 10 60 d4 or %g1, 0xd4, %g1 ! 40013cd4 <_Thread_queue_Enqueue_do_nothing_extra>
<== NOT EXECUTED
4000e380: c2 27 bf e4 st %g1, [ %fp + -28 ]
<== NOT EXECUTED
_Thread_queue_Context_set_enqueue_timeout_ticks( &queue_context, timeout );
} else {
_Thread_queue_Context_set_enqueue_do_nothing_extra( &queue_context );
}
switch ( the_semaphore->variant ) {
4000e384: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
4000e388: 83 30 60 1d srl %g1, 0x1d, %g1
<== NOT EXECUTED
4000e38c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000e390: 02 80 00 22 be 4000e418 <rtems_semaphore_obtain+0xd4>
<== NOT EXECUTED
4000e394: 84 02 20 10 add %o0, 0x10, %g2
<== NOT EXECUTED
4000e398: 0a 80 00 42 bcs 4000e4a0 <rtems_semaphore_obtain+0x15c>
<== NOT EXECUTED
4000e39c: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4000e3a0: 12 80 00 2d bne 4000e454 <rtems_semaphore_obtain+0x110>
<== NOT EXECUTED
4000e3a4: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) {
4000e3a8: 80 88 60 e0 btst 0xe0, %g1
<== NOT EXECUTED
4000e3ac: 12 80 00 4e bne 4000e4e4 <rtems_semaphore_obtain+0x1a0>
<== NOT EXECUTED
4000e3b0: 80 88 60 10 btst 0x10, %g1
<== NOT EXECUTED
return &_Thread_queue_Operations_priority_inherit;
4000e3b4: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
4000e3b8: 92 12 63 5c or %o1, 0x35c, %o1 ! 4002ef5c <_Thread_queue_Operations_priority_inherit>
<== NOT EXECUTED
4000e3bc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
if ( owner == NULL ) {
4000e3c0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e3c4: 02 80 00 4d be 4000e4f8 <rtems_semaphore_obtain+0x1b4>
<== NOT EXECUTED
4000e3c8: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
if ( owner == executing ) {
4000e3cc: 12 80 00 74 bne 4000e59c <rtems_semaphore_obtain+0x258>
<== NOT EXECUTED
4000e3d0: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
++the_mutex->nest_level;
4000e3d4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
<== NOT EXECUTED
4000e3d8: 82 00 60 01 inc %g1
<== NOT EXECUTED
{
_Assert( _ISR_Get_level() != 0 );
_CORE_semaphore_Acquire_critical( the_semaphore, queue_context );
if ( the_semaphore->count != 0 ) {
the_semaphore->count -= 1;
4000e3dc: c2 22 20 1c st %g1, [ %o0 + 0x1c ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e3e0: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e3e4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e3e8: 01 00 00 00 nop
<== NOT EXECUTED
4000e3ec: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e3f0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks;
4000e3f4: 03 10 00 53 sethi %hi(0x40014c00), %g1
<== NOT EXECUTED
queue_context->Timeout.ticks = ticks;
4000e3f8: f4 27 bf e8 st %i2, [ %fp + -24 ]
<== NOT EXECUTED
queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks;
4000e3fc: 82 10 61 78 or %g1, 0x178, %g1
<== NOT EXECUTED
4000e400: c2 27 bf e4 st %g1, [ %fp + -28 ]
<== NOT EXECUTED
4000e404: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
4000e408: 83 30 60 1d srl %g1, 0x1d, %g1
<== NOT EXECUTED
4000e40c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000e410: 12 bf ff e2 bne 4000e398 <rtems_semaphore_obtain+0x54>
<== NOT EXECUTED
4000e414: 84 02 20 10 add %o0, 0x10, %g2
<== NOT EXECUTED
4000e418: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
_CORE_mutex_Acquire_critical( &the_mutex->Recursive.Mutex, queue_context );
owner = _CORE_mutex_Get_owner( &the_mutex->Recursive.Mutex );
if ( owner == NULL ) {
4000e41c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e420: 02 80 00 4c be 4000e550 <rtems_semaphore_obtain+0x20c>
<== NOT EXECUTED
4000e424: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
executing,
queue_context
);
}
if ( owner == executing ) {
4000e428: 22 bf ff ec be,a 4000e3d8 <rtems_semaphore_obtain+0x94>
<== NOT EXECUTED
4000e42c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
<== NOT EXECUTED
status = ( *nested )( &the_mutex->Recursive );
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
return status;
}
return _CORE_mutex_Seize_slow(
4000e430: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
4000e434: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4000e438: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
4000e43c: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
4000e440: 40 00 04 66 call 4000f5d8 <_CORE_mutex_Seize_slow>
<== NOT EXECUTED
4000e444: 92 12 63 70 or %o1, 0x370, %o1 ! 4002ef70 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
4000e448: b0 0a 60 ff and %o1, 0xff, %i0
<== NOT EXECUTED
4000e44c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e450: 81 e8 00 00 restore
<== NOT EXECUTED
if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) {
4000e454: 80 88 60 e0 btst 0xe0, %g1
<== NOT EXECUTED
4000e458: 02 80 00 21 be 4000e4dc <rtems_semaphore_obtain+0x198>
<== NOT EXECUTED
4000e45c: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000e460: 80 88 60 10 btst 0x10, %g1
<== NOT EXECUTED
4000e464: 12 80 00 37 bne 4000e540 <rtems_semaphore_obtain+0x1fc>
<== NOT EXECUTED
4000e468: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
return &_Thread_queue_Operations_priority;
4000e46c: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
4000e470: 92 12 63 70 or %o1, 0x370, %o1 ! 4002ef70 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
if ( the_semaphore->count != 0 ) {
4000e474: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
<== NOT EXECUTED
4000e478: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e47c: 12 80 00 27 bne 4000e518 <rtems_semaphore_obtain+0x1d4>
<== NOT EXECUTED
4000e480: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
_CORE_semaphore_Release( the_semaphore, queue_context );
return STATUS_SUCCESSFUL;
}
if ( !wait ) {
4000e484: 02 80 00 27 be 4000e520 <rtems_semaphore_obtain+0x1dc>
<== NOT EXECUTED
4000e488: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e48c: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e490: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e494: 01 00 00 00 nop
<== NOT EXECUTED
4000e498: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e49c: 91 e8 20 0d restore %g0, 0xd, %o0
<== NOT EXECUTED
4000e4a0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
if ( owner == NULL ) {
4000e4a4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e4a8: 02 80 00 14 be 4000e4f8 <rtems_semaphore_obtain+0x1b4>
<== NOT EXECUTED
4000e4ac: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
if ( owner == executing ) {
4000e4b0: 22 bf ff ca be,a 4000e3d8 <rtems_semaphore_obtain+0x94>
<== NOT EXECUTED
4000e4b4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
<== NOT EXECUTED
return _CORE_mutex_Seize_slow(
4000e4b8: 98 07 bf dc add %fp, -36, %o4
<== NOT EXECUTED
4000e4bc: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4000e4c0: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
4000e4c4: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
4000e4c8: 40 00 04 44 call 4000f5d8 <_CORE_mutex_Seize_slow>
<== NOT EXECUTED
4000e4cc: 92 12 63 5c or %o1, 0x35c, %o1 ! 4002ef5c <_Thread_queue_Operations_priority_inherit>
<== NOT EXECUTED
4000e4d0: b0 0a 60 ff and %o1, 0xff, %i0
<== NOT EXECUTED
4000e4d4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e4d8: 81 e8 00 00 restore
<== NOT EXECUTED
return &_Thread_queue_Operations_priority_inherit;
4000e4dc: 10 bf ff e6 b 4000e474 <rtems_semaphore_obtain+0x130>
<== NOT EXECUTED
4000e4e0: 92 12 63 5c or %o1, 0x35c, %o1
<== NOT EXECUTED
if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000e4e4: 32 80 00 19 bne,a 4000e548 <rtems_semaphore_obtain+0x204>
<== NOT EXECUTED
4000e4e8: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
return &_Thread_queue_Operations_priority;
4000e4ec: 13 10 00 bb sethi %hi(0x4002ec00), %o1
<== NOT EXECUTED
4000e4f0: 10 bf ff b3 b 4000e3bc <rtems_semaphore_obtain+0x78>
<== NOT EXECUTED
4000e4f4: 92 12 63 70 or %o1, 0x370, %o1 ! 4002ef70 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
the_mutex->Wait_queue.Queue.owner = owner;
4000e4f8: fa 22 20 14 st %i5, [ %o0 + 0x14 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e4fc: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e500: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e504: 01 00 00 00 nop
<== NOT EXECUTED
4000e508: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e50c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
);
break;
}
return _Status_Get( status );
}
4000e510: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e514: 91 e8 20 04 restore %g0, 4, %o0
<== NOT EXECUTED
the_semaphore->count -= 1;
4000e518: 10 bf ff b1 b 4000e3dc <rtems_semaphore_obtain+0x98>
<== NOT EXECUTED
4000e51c: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
_Thread_queue_Context_set_thread_state(
queue_context,
STATES_WAITING_FOR_SEMAPHORE
);
_Thread_queue_Enqueue(
4000e520: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
queue_context->thread_state = thread_state;
4000e524: c2 27 bf e0 st %g1, [ %fp + -32 ]
<== NOT EXECUTED
4000e528: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4000e52c: 40 00 15 f4 call 40013cfc <_Thread_queue_Enqueue>
<== NOT EXECUTED
4000e530: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
4000e534: f0 0f 60 4f ldub [ %i5 + 0x4f ], %i0
<== NOT EXECUTED
return _Status_Get( status );
4000e538: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e53c: 81 e8 00 00 restore
<== NOT EXECUTED
return &_Thread_queue_Operations_FIFO;
4000e540: 10 bf ff cd b 4000e474 <rtems_semaphore_obtain+0x130>
<== NOT EXECUTED
4000e544: 92 12 63 84 or %o1, 0x384, %o1
<== NOT EXECUTED
4000e548: 10 bf ff 9d b 4000e3bc <rtems_semaphore_obtain+0x78>
<== NOT EXECUTED
4000e54c: 92 12 63 84 or %o1, 0x384, %o1
<== NOT EXECUTED
if (
4000e550: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
<== NOT EXECUTED
queue_context->Priority.update_count = 0;
4000e554: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
4000e558: c6 02 20 30 ld [ %o0 + 0x30 ], %g3
<== NOT EXECUTED
4000e55c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
<== NOT EXECUTED
4000e560: 80 a0 c0 02 cmp %g3, %g2
<== NOT EXECUTED
4000e564: 18 80 00 09 bgu 4000e588 <rtems_semaphore_obtain+0x244>
<== NOT EXECUTED
4000e568: 01 00 00 00 nop
<== NOT EXECUTED
4000e56c: 32 80 00 12 bne,a 4000e5b4 <rtems_semaphore_obtain+0x270>
<== NOT EXECUTED
4000e570: fa 22 20 14 st %i5, [ %o0 + 0x14 ]
<== NOT EXECUTED
4000e574: c4 02 20 34 ld [ %o0 + 0x34 ], %g2
<== NOT EXECUTED
4000e578: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4000e57c: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4000e580: 28 80 00 0d bleu,a 4000e5b4 <rtems_semaphore_obtain+0x270>
<== NOT EXECUTED
4000e584: fa 22 20 14 st %i5, [ %o0 + 0x14 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e588: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e58c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e590: 01 00 00 00 nop
<== NOT EXECUTED
4000e594: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e598: 91 e8 20 13 restore %g0, 0x13, %o0
<== NOT EXECUTED
return _CORE_mutex_Seize_slow(
4000e59c: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4000e5a0: 40 00 04 0e call 4000f5d8 <_CORE_mutex_Seize_slow>
<== NOT EXECUTED
4000e5a4: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
4000e5a8: b0 0a 60 ff and %o1, 0xff, %i0
<== NOT EXECUTED
4000e5ac: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e5b0: 81 e8 00 00 restore
<== NOT EXECUTED
_Thread_Priority_add(
4000e5b4: 92 02 20 20 add %o0, 0x20, %o1
<== NOT EXECUTED
4000e5b8: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000e5bc: 40 00 13 3b call 400132a8 <_Thread_Priority_add>
<== NOT EXECUTED
4000e5c0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000e5c4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e5c8: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000e5cc: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e5d0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e5d4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e5d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e5dc: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_Priority_update( queue_context );
4000e5e0: 40 00 13 43 call 400132ec <_Thread_Priority_update>
<== NOT EXECUTED
4000e5e4: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000e5e8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000e5ec: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000e5f0: 02 80 00 06 be 4000e608 <rtems_semaphore_obtain+0x2c4>
<== NOT EXECUTED
4000e5f4: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000e5f8: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000e5fc: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
4000e600: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e604: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e608: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000e60c: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
<== NOT EXECUTED
4000e610: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000e614: 12 80 00 07 bne 4000e630 <rtems_semaphore_obtain+0x2ec>
<== NOT EXECUTED
4000e618: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000e61c: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e620: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e624: 01 00 00 00 nop
<== NOT EXECUTED
4000e628: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e62c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000e630: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
4000e634: 40 00 13 b5 call 40013508 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000e638: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000e63c: 10 bf ff f9 b 4000e620 <rtems_semaphore_obtain+0x2dc>
<== NOT EXECUTED
4000e640: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000e644 <rtems_semaphore_release>:
#include <rtems/rtems/semimpl.h>
#include <rtems/rtems/statusimpl.h>
rtems_status_code rtems_semaphore_release( rtems_id id )
{
4000e644: 9d e3 bf 70 save %sp, -144, %sp
<== NOT EXECUTED
return (Semaphore_Control *) _Objects_Get(
4000e648: 15 10 00 d3 sethi %hi(0x40034c00), %o2
<== NOT EXECUTED
4000e64c: 92 07 bf dc add %fp, -36, %o1
<== NOT EXECUTED
4000e650: 94 12 a3 58 or %o2, 0x358, %o2
<== NOT EXECUTED
4000e654: 40 00 0d 17 call 40011ab0 <_Objects_Get>
<== NOT EXECUTED
4000e658: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
Thread_Control *executing;
Status_Control status;
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
4000e65c: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4000e660: 02 80 00 52 be 4000e7a8 <rtems_semaphore_release+0x164>
<== NOT EXECUTED
4000e664: 01 00 00 00 nop
<== NOT EXECUTED
_Thread_queue_Context_set_MP_callout(
&queue_context,
_Semaphore_Core_mutex_mp_support
);
switch ( the_semaphore->variant ) {
4000e668: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
<== NOT EXECUTED
4000e66c: 83 30 60 1d srl %g1, 0x1d, %g1
<== NOT EXECUTED
executing = _Thread_Executing;
4000e670: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
<== NOT EXECUTED
switch ( the_semaphore->variant ) {
4000e674: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000e678: 02 80 00 24 be 4000e708 <rtems_semaphore_release+0xc4>
<== NOT EXECUTED
4000e67c: b8 07 60 10 add %i5, 0x10, %i4
<== NOT EXECUTED
4000e680: 0a 80 00 36 bcs 4000e758 <rtems_semaphore_release+0x114>
<== NOT EXECUTED
4000e684: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
4000e688: 02 80 00 16 be 4000e6e0 <rtems_semaphore_release+0x9c>
<== NOT EXECUTED
4000e68c: 80 a0 60 03 cmp %g1, 3
<== NOT EXECUTED
4000e690: 12 80 00 0b bne 4000e6bc <rtems_semaphore_release+0x78>
<== NOT EXECUTED
4000e694: c2 0f 60 38 ldub [ %i5 + 0x38 ], %g1
<== NOT EXECUTED
if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) {
4000e698: 80 88 60 e0 btst 0xe0, %g1
<== NOT EXECUTED
4000e69c: 02 80 00 76 be 4000e874 <rtems_semaphore_release+0x230>
<== NOT EXECUTED
4000e6a0: 37 10 00 bb sethi %hi(0x4002ec00), %i3
<== NOT EXECUTED
if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000e6a4: 80 88 60 10 btst 0x10, %g1
<== NOT EXECUTED
4000e6a8: 32 80 00 8a bne,a 4000e8d0 <rtems_semaphore_release+0x28c>
<== NOT EXECUTED
4000e6ac: 37 10 00 bb sethi %hi(0x4002ec00), %i3
<== NOT EXECUTED
return &_Thread_queue_Operations_priority;
4000e6b0: 37 10 00 bb sethi %hi(0x4002ec00), %i3
<== NOT EXECUTED
4000e6b4: 10 80 00 71 b 4000e878 <rtems_semaphore_release+0x234>
<== NOT EXECUTED
4000e6b8: b6 16 e3 70 or %i3, 0x370, %i3 ! 4002ef70 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) {
4000e6bc: 80 88 60 e0 btst 0xe0, %g1
<== NOT EXECUTED
4000e6c0: 02 80 00 4f be 4000e7fc <rtems_semaphore_release+0x1b8>
<== NOT EXECUTED
4000e6c4: 37 10 00 bb sethi %hi(0x4002ec00), %i3
<== NOT EXECUTED
if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000e6c8: 80 88 60 10 btst 0x10, %g1
<== NOT EXECUTED
4000e6cc: 32 80 00 83 bne,a 4000e8d8 <rtems_semaphore_release+0x294>
<== NOT EXECUTED
4000e6d0: 37 10 00 bb sethi %hi(0x4002ec00), %i3
<== NOT EXECUTED
return &_Thread_queue_Operations_priority;
4000e6d4: 37 10 00 bb sethi %hi(0x4002ec00), %i3
<== NOT EXECUTED
4000e6d8: 10 80 00 4a b 4000e800 <rtems_semaphore_release+0x1bc>
<== NOT EXECUTED
4000e6dc: b6 16 e3 70 or %i3, 0x370, %i3 ! 4002ef70 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
if ( the_semaphore->variant == SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY ) {
4000e6e0: c2 0f 60 38 ldub [ %i5 + 0x38 ], %g1
<== NOT EXECUTED
4000e6e4: 80 88 60 e0 btst 0xe0, %g1
<== NOT EXECUTED
4000e6e8: 02 80 00 32 be 4000e7b0 <rtems_semaphore_release+0x16c>
<== NOT EXECUTED
4000e6ec: 19 10 00 bb sethi %hi(0x4002ec00), %o4
<== NOT EXECUTED
if ( the_semaphore->discipline == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000e6f0: 80 88 60 10 btst 0x10, %g1
<== NOT EXECUTED
4000e6f4: 32 80 00 75 bne,a 4000e8c8 <rtems_semaphore_release+0x284>
<== NOT EXECUTED
4000e6f8: 19 10 00 bb sethi %hi(0x4002ec00), %o4
<== NOT EXECUTED
return &_Thread_queue_Operations_priority;
4000e6fc: 19 10 00 bb sethi %hi(0x4002ec00), %o4
<== NOT EXECUTED
4000e700: 10 80 00 2d b 4000e7b4 <rtems_semaphore_release+0x170>
<== NOT EXECUTED
4000e704: 98 13 23 70 or %o4, 0x370, %o4 ! 4002ef70 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
Per_CPU_Control *cpu_self;
Thread_Control *new_owner;
_CORE_mutex_Acquire_critical( &the_mutex->Recursive.Mutex, queue_context );
if ( !_CORE_mutex_Is_owner( &the_mutex->Recursive.Mutex, executing ) ) {
4000e708: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4000e70c: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
4000e710: 12 80 00 0d bne 4000e744 <rtems_semaphore_release+0x100>
<== NOT EXECUTED
4000e714: 01 00 00 00 nop
<== NOT EXECUTED
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
return STATUS_NOT_OWNER;
}
nest_level = the_mutex->Recursive.nest_level;
4000e718: f0 07 60 1c ld [ %i5 + 0x1c ], %i0
<== NOT EXECUTED
if ( nest_level > 0 ) {
4000e71c: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000e720: 22 80 00 70 be,a 4000e8e0 <rtems_semaphore_release+0x29c>
<== NOT EXECUTED
4000e724: c0 27 bf f0 clr [ %fp + -16 ]
<== NOT EXECUTED
the_mutex->nest_level = nest_level - 1;
4000e728: b0 06 3f ff add %i0, -1, %i0
<== NOT EXECUTED
4000e72c: f0 27 60 1c st %i0, [ %i5 + 0x1c ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e730: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e734: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e738: 01 00 00 00 nop
<== NOT EXECUTED
4000e73c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e740: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e744: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e748: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e74c: 01 00 00 00 nop
<== NOT EXECUTED
4000e750: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e754: 91 e8 20 17 restore %g0, 0x17, %o0
<== NOT EXECUTED
if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) {
4000e758: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4000e75c: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
4000e760: 12 bf ff f9 bne 4000e744 <rtems_semaphore_release+0x100>
<== NOT EXECUTED
4000e764: 01 00 00 00 nop
<== NOT EXECUTED
nest_level = the_mutex->nest_level;
4000e768: f0 07 60 1c ld [ %i5 + 0x1c ], %i0
<== NOT EXECUTED
if ( nest_level > 0 ) {
4000e76c: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000e770: 32 bf ff ef bne,a 4000e72c <rtems_semaphore_release+0xe8>
<== NOT EXECUTED
4000e774: b0 06 3f ff add %i0, -1, %i0
<== NOT EXECUTED
the_mutex->Wait_queue.Queue.owner = owner;
4000e778: c0 27 60 14 clr [ %i5 + 0x14 ]
<== NOT EXECUTED
heads = the_mutex->Mutex.Wait_queue.Queue.heads;
4000e77c: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
<== NOT EXECUTED
if ( heads == NULL ) {
4000e780: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
4000e784: 02 80 00 30 be 4000e844 <rtems_semaphore_release+0x200>
<== NOT EXECUTED
4000e788: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
_Thread_queue_Surrender(
4000e78c: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000e790: 19 10 00 bb sethi %hi(0x4002ec00), %o4
<== NOT EXECUTED
4000e794: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000e798: 40 00 16 10 call 40013fd8 <_Thread_queue_Surrender>
<== NOT EXECUTED
4000e79c: 98 13 23 5c or %o4, 0x35c, %o4
<== NOT EXECUTED
4000e7a0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e7a4: 81 e8 00 00 restore
<== NOT EXECUTED
);
break;
}
return _Status_Get( status );
}
4000e7a8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e7ac: 91 e8 20 04 restore %g0, 4, %o0
<== NOT EXECUTED
return &_Thread_queue_Operations_priority_inherit;
4000e7b0: 98 13 23 5c or %o4, 0x35c, %o4
<== NOT EXECUTED
if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) {
4000e7b4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4000e7b8: 80 a2 00 01 cmp %o0, %g1
<== NOT EXECUTED
4000e7bc: 12 bf ff e2 bne 4000e744 <rtems_semaphore_release+0x100>
<== NOT EXECUTED
4000e7c0: 01 00 00 00 nop
<== NOT EXECUTED
nest_level = the_mutex->nest_level;
4000e7c4: f0 07 60 1c ld [ %i5 + 0x1c ], %i0
<== NOT EXECUTED
if ( nest_level > 0 ) {
4000e7c8: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
4000e7cc: 32 bf ff d8 bne,a 4000e72c <rtems_semaphore_release+0xe8>
<== NOT EXECUTED
4000e7d0: b0 06 3f ff add %i0, -1, %i0
<== NOT EXECUTED
the_mutex->Wait_queue.Queue.owner = owner;
4000e7d4: c0 27 60 14 clr [ %i5 + 0x14 ]
<== NOT EXECUTED
heads = the_mutex->Mutex.Wait_queue.Queue.heads;
4000e7d8: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
<== NOT EXECUTED
if ( heads == NULL ) {
4000e7dc: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
4000e7e0: 02 80 00 19 be 4000e844 <rtems_semaphore_release+0x200>
<== NOT EXECUTED
4000e7e4: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
_Thread_queue_Surrender(
4000e7e8: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000e7ec: 40 00 15 fb call 40013fd8 <_Thread_queue_Surrender>
<== NOT EXECUTED
4000e7f0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000e7f4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e7f8: 81 e8 00 00 restore
<== NOT EXECUTED
4000e7fc: b6 16 e3 5c or %i3, 0x35c, %i3
<== NOT EXECUTED
4000e800: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
<== NOT EXECUTED
const Thread_queue_Operations *operations
)
{
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
if ( heads != NULL ) {
4000e804: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e808: 22 80 00 09 be,a 4000e82c <rtems_semaphore_release+0x1e8>
<== NOT EXECUTED
4000e80c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
return ( *operations->first )( heads );
4000e810: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
<== NOT EXECUTED
4000e814: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e818: 01 00 00 00 nop
<== NOT EXECUTED
if ( the_thread != NULL ) {
4000e81c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e820: 12 80 00 0e bne 4000e858 <rtems_semaphore_release+0x214>
<== NOT EXECUTED
4000e824: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
if ( the_semaphore->count < maximum_count )
4000e828: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000e82c: 80 a0 7f ff cmp %g1, -1
<== NOT EXECUTED
4000e830: 02 80 00 05 be 4000e844 <rtems_semaphore_release+0x200>
<== NOT EXECUTED
4000e834: b0 10 20 0d mov 0xd, %i0
<== NOT EXECUTED
the_semaphore->count += 1;
4000e838: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000e83c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
<== NOT EXECUTED
4000e840: b0 10 20 00 clr %i0
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e844: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e848: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e84c: 01 00 00 00 nop
<== NOT EXECUTED
return _Status_Get( status );
4000e850: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e854: 81 e8 00 00 restore
<== NOT EXECUTED
_Thread_queue_Extract_critical(
4000e858: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000e85c: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000e860: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000e864: 40 00 15 9c call 40013ed4 <_Thread_queue_Extract_critical>
<== NOT EXECUTED
4000e868: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000e86c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e870: 81 e8 00 00 restore
<== NOT EXECUTED
4000e874: b6 16 e3 5c or %i3, 0x35c, %i3
<== NOT EXECUTED
4000e878: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
<== NOT EXECUTED
if ( heads != NULL ) {
4000e87c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e880: 22 80 00 09 be,a 4000e8a4 <rtems_semaphore_release+0x260>
<== NOT EXECUTED
4000e884: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
return ( *operations->first )( heads );
4000e888: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
<== NOT EXECUTED
4000e88c: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e890: 01 00 00 00 nop
<== NOT EXECUTED
if ( the_thread != NULL ) {
4000e894: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e898: 12 bf ff f0 bne 4000e858 <rtems_semaphore_release+0x214>
<== NOT EXECUTED
4000e89c: 94 10 00 08 mov %o0, %o2
<== NOT EXECUTED
if ( the_semaphore->count < maximum_count )
4000e8a0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000e8a4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000e8a8: 12 80 00 03 bne 4000e8b4 <rtems_semaphore_release+0x270>
<== NOT EXECUTED
4000e8ac: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
the_semaphore->count += 1;
4000e8b0: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e8b4: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e8b8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e8bc: 01 00 00 00 nop
<== NOT EXECUTED
4000e8c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e8c4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
return &_Thread_queue_Operations_FIFO;
4000e8c8: 10 bf ff bb b 4000e7b4 <rtems_semaphore_release+0x170>
<== NOT EXECUTED
4000e8cc: 98 13 23 84 or %o4, 0x384, %o4
<== NOT EXECUTED
4000e8d0: 10 bf ff ea b 4000e878 <rtems_semaphore_release+0x234>
<== NOT EXECUTED
4000e8d4: b6 16 e3 84 or %i3, 0x384, %i3
<== NOT EXECUTED
4000e8d8: 10 bf ff ca b 4000e800 <rtems_semaphore_release+0x1bc>
<== NOT EXECUTED
4000e8dc: b6 16 e3 84 or %i3, 0x384, %i3
<== NOT EXECUTED
_Thread_Resource_count_decrement( executing );
_Thread_queue_Context_clear_priority_updates( queue_context );
_Thread_Wait_acquire_default_critical( executing, &lock_context );
_Thread_Priority_remove(
4000e8e0: a0 07 60 20 add %i5, 0x20, %l0
<== NOT EXECUTED
4000e8e4: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000e8e8: 40 00 12 75 call 400132bc <_Thread_Priority_remove>
<== NOT EXECUTED
4000e8ec: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
4000e8f0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
<== NOT EXECUTED
if ( heads != NULL ) {
4000e8f4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e8f8: 02 80 00 1f be 4000e974 <rtems_semaphore_release+0x330>
<== NOT EXECUTED
4000e8fc: 35 10 00 bb sethi %hi(0x4002ec00), %i2
<== NOT EXECUTED
return ( *operations->first )( heads );
4000e900: b4 16 a3 70 or %i2, 0x370, %i2 ! 4002ef70 <_Thread_queue_Operations_priority>
<== NOT EXECUTED
4000e904: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
<== NOT EXECUTED
4000e908: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e90c: 01 00 00 00 nop
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000e910: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
the_mutex->Wait_queue.Queue.owner = owner;
4000e914: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e918: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000e91c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
4000e920: b2 10 00 08 mov %o0, %i1
<== NOT EXECUTED
cpu_self = _Thread_Dispatch_disable_critical(
&queue_context->Lock_context.Lock_context
);
if ( new_owner != NULL ) {
4000e924: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e928: 02 80 00 18 be 4000e988 <rtems_semaphore_release+0x344>
<== NOT EXECUTED
4000e92c: b6 10 00 06 mov %g6, %i3
<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( _Objects_Is_local_id( new_owner->Object.id ) )
#endif
{
_Thread_Resource_count_increment( new_owner );
_Thread_Priority_add(
4000e930: 94 07 bf dc add %fp, -36, %o2
<== NOT EXECUTED
4000e934: 40 00 12 5d call 400132a8 <_Thread_Priority_add>
<== NOT EXECUTED
4000e938: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
&the_mutex->Priority_ceiling,
queue_context
);
}
_Thread_queue_Extract_critical(
4000e93c: 96 07 bf dc add %fp, -36, %o3
<== NOT EXECUTED
4000e940: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4000e944: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
4000e948: 40 00 15 63 call 40013ed4 <_Thread_queue_Extract_critical>
<== NOT EXECUTED
4000e94c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
);
} else {
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
}
_Thread_Priority_update( queue_context );
4000e950: 40 00 12 67 call 400132ec <_Thread_Priority_update>
<== NOT EXECUTED
4000e954: 90 07 bf dc add %fp, -36, %o0
<== NOT EXECUTED
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000e958: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1
<== NOT EXECUTED
if ( disable_level == 1 ) {
4000e95c: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000e960: 02 80 00 0e be 4000e998 <rtems_semaphore_release+0x354>
<== NOT EXECUTED
4000e964: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000e968: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
<== NOT EXECUTED
4000e96c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e970: 81 e8 00 00 restore
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000e974: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
the_mutex->Wait_queue.Queue.owner = owner;
4000e978: c0 27 60 14 clr [ %i5 + 0x14 ]
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000e97c: 82 00 60 01 inc %g1
<== NOT EXECUTED
4000e980: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000e984: b6 10 00 06 mov %g6, %i3
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e988: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e98c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e990: 01 00 00 00 nop
<== NOT EXECUTED
4000e994: 30 bf ff ef b,a 4000e950 <rtems_semaphore_release+0x30c>
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e998: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000e99c: c4 0e e0 1c ldub [ %i3 + 0x1c ], %g2
<== NOT EXECUTED
4000e9a0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000e9a4: 12 80 00 07 bne 4000e9c0 <rtems_semaphore_release+0x37c>
<== NOT EXECUTED
4000e9a8: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000e9ac: c0 26 e0 18 clr [ %i3 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e9b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e9b4: 01 00 00 00 nop
<== NOT EXECUTED
4000e9b8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e9bc: 81 e8 00 00 restore
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
4000e9c0: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
4000e9c4: 40 00 12 d1 call 40013508 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000e9c8: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4000e9cc: 10 bf ff f9 b 4000e9b0 <rtems_semaphore_release+0x36c>
<== NOT EXECUTED
4000e9d0: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000d998 <rtems_status_code_to_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_status_code_to_errno(rtems_status_code sc)
{
4000d998: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000d99c: 82 10 00 18 mov %i0, %g1
<== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
4000d9a0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000d9a4: 02 80 00 0c be 4000d9d4 <rtems_status_code_to_errno+0x3c>
<== NOT EXECUTED
4000d9a8: b0 10 20 00 clr %i0
<== NOT EXECUTED
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
4000d9ac: 80 a0 60 1c cmp %g1, 0x1c
<== NOT EXECUTED
4000d9b0: 18 80 00 06 bgu 4000d9c8 <rtems_status_code_to_errno+0x30>
<== NOT EXECUTED
4000d9b4: ba 10 20 16 mov 0x16, %i5
<== NOT EXECUTED
eno = status_code_to_errno [sc];
4000d9b8: 83 28 60 02 sll %g1, 2, %g1
<== NOT EXECUTED
4000d9bc: 05 10 00 42 sethi %hi(0x40010800), %g2
<== NOT EXECUTED
4000d9c0: 84 10 a2 dc or %g2, 0x2dc, %g2 ! 40010adc <status_code_to_errno>
<== NOT EXECUTED
4000d9c4: fa 00 80 01 ld [ %g2 + %g1 ], %i5
<== NOT EXECUTED
}
errno = eno;
4000d9c8: 40 00 03 64 call 4000e758 <__errno>
<== NOT EXECUTED
4000d9cc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000d9d0: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
return -1;
}
}
4000d9d4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d9d8: 81 e8 00 00 restore
<== NOT EXECUTED
40006498 <rtems_status_text>:
const char *rtems_status_text( rtems_status_code code )
{
size_t i = code;
const char *text = "?";
if ( i < RTEMS_ARRAY_SIZE( status_code_text ) ) {
40006498: 80 a2 20 1c cmp %o0, 0x1c
<== NOT EXECUTED
4000649c: 18 80 00 06 bgu 400064b4 <rtems_status_text+0x1c>
<== NOT EXECUTED
400064a0: 03 10 00 41 sethi %hi(0x40010400), %g1
<== NOT EXECUTED
text = status_code_text [i];
400064a4: 91 2a 20 02 sll %o0, 2, %o0
<== NOT EXECUTED
400064a8: 82 10 63 50 or %g1, 0x350, %g1
<== NOT EXECUTED
400064ac: 81 c3 e0 08 retl
<== NOT EXECUTED
400064b0: d0 00 40 08 ld [ %g1 + %o0 ], %o0
<== NOT EXECUTED
const char *text = "?";
400064b4: 11 10 00 41 sethi %hi(0x40010400), %o0
<== NOT EXECUTED
}
return text;
}
400064b8: 81 c3 e0 08 retl
<== NOT EXECUTED
400064bc: 90 12 20 98 or %o0, 0x98, %o0 ! 40010498 <rtems_filesystem_null_handlers+0x40>
<== NOT EXECUTED
40006500 <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
40006500: 9d e3 bf 70 save %sp, -144, %sp
Priority_Control priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
40006504: 80 a7 60 00 cmp %i5, 0
40006508: 02 80 00 50 be 40006648 <rtems_task_create+0x148>
<== NEVER TAKEN
4000650c: 80 a6 20 00 cmp %i0, 0
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
40006510: 02 80 00 3e be 40006608 <rtems_task_create+0x108>
<== NEVER TAKEN
40006514: 82 10 20 03 mov 3, %g1
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_system_task(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_SYSTEM_TASK ) ? true : false;
40006518: 83 37 20 0f srl %i4, 0xf, %g1
4000651c: 82 08 60 01 and %g1, 1, %g1
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
if ( initial_priority == PRIORITY_MINIMUM ) {
40006520: 80 90 40 19 orcc %g1, %i1, %g0
40006524: 02 80 00 3e be 4000661c <rtems_task_create+0x11c>
<== NEVER TAKEN
40006528: 92 10 20 00 clr %o1
const Scheduler_Control *scheduler,
rtems_task_priority priority,
bool *valid
)
{
*valid = ( priority <= scheduler->maximum_priority );
4000652c: 21 10 00 3f sethi %hi(0x4000fc00), %l0
40006530: 90 14 23 10 or %l0, 0x310, %o0 ! 4000ff10 <_Scheduler_Table>
RTEMS_INLINE_ROUTINE Priority_Control _Scheduler_Map_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return ( *scheduler->Operations.map_priority )( scheduler, priority );
40006534: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
40006538: e2 02 20 40 ld [ %o0 + 0x40 ], %l1
4000653c: e8 02 20 44 ld [ %o0 + 0x44 ], %l4
40006540: 9f c0 40 00 call %g1
40006544: 94 10 00 19 mov %i1, %o2
}
scheduler = _Thread_Scheduler_get_home( _Thread_Get_executing() );
priority = _RTEMS_Priority_To_core( scheduler, initial_priority, &valid );
if ( !valid ) {
40006548: 80 a4 60 00 cmp %l1, 0
4000654c: a4 10 00 08 mov %o0, %l2
40006550: 02 80 00 30 be 40006610 <rtems_task_create+0x110>
<== ALWAYS TAKEN
40006554: a6 10 00 09 mov %o1, %l3
_RTEMS_Lock_allocator();
40006558: 40 00 01 48 call 40006a78 <_RTEMS_Lock_allocator>
4000655c: 23 10 00 4d sethi %hi(0x40013400), %l1
_Thread_Kill_zombies();
40006560: 40 00 14 64 call 4000b6f0 <_Thread_Kill_zombies>
40006564: 01 00 00 00 nop
return (Thread_Control *)
40006568: 40 00 08 95 call 400087bc <_Objects_Allocate_unprotected>
4000656c: 90 14 61 18 or %l1, 0x118, %o0
* this results in a lack of control over when memory is allocated
* and can be freed in the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
40006570: b2 92 20 00 orcc %o0, 0, %i1
40006574: 02 80 00 38 be 40006654 <rtems_task_create+0x154>
40006578: 85 36 e0 09 srl %i3, 9, %g2
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
4000657c: e4 3f bf f0 std %l2, [ %fp + -16 ]
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_timeslice (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_TIMESLICE_MASK) == RTEMS_TIMESLICE;
40006580: 84 08 a0 01 and %g2, 1, %g2
40006584: 82 07 bf fc add %fp, -4, %g1
40006588: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
4000658c: 9a 0f 20 01 and %i4, 1, %o5
40006590: c4 07 bf f0 ld [ %fp + -16 ], %g2
40006594: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
40006598: 82 0e e0 0f and %i3, 0xf, %g1
4000659c: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
400065a0: 98 10 00 1a mov %i2, %o4
400065a4: c4 07 bf f4 ld [ %fp + -12 ], %g2
400065a8: c2 23 a0 70 st %g1, [ %sp + 0x70 ]
return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;
400065ac: 83 36 e0 08 srl %i3, 8, %g1
400065b0: c0 23 a0 6c clr [ %sp + 0x6c ]
400065b4: 82 18 60 01 xor %g1, 1, %g1
400065b8: c4 23 a0 60 st %g2, [ %sp + 0x60 ]
400065bc: 82 08 60 01 and %g1, 1, %g1
400065c0: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
400065c4: 96 10 20 00 clr %o3
400065c8: f0 27 bf fc st %i0, [ %fp + -4 ]
400065cc: 94 14 23 10 or %l0, 0x310, %o2
400065d0: 92 10 00 19 mov %i1, %o1
400065d4: 40 00 0f 48 call 4000a2f4 <_Thread_Initialize>
400065d8: 90 14 61 18 or %l1, 0x118, %o0
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
400065dc: 80 a2 20 00 cmp %o0, 0
400065e0: 02 80 00 12 be 40006628 <rtems_task_create+0x128>
<== NEVER TAKEN
400065e4: b7 36 e0 0a srl %i3, 0xa, %i3
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
400065e8: c4 06 61 58 ld [ %i1 + 0x158 ], %g2
*id = the_thread->Object.id;
400065ec: c2 06 60 08 ld [ %i1 + 8 ], %g1
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
400065f0: b6 1e e0 01 xor %i3, 1, %i3
400065f4: b6 0e e0 01 and %i3, 1, %i3
400065f8: f6 28 a0 08 stb %i3, [ %g2 + 8 ]
_RTEMS_Unlock_allocator();
400065fc: 40 00 01 24 call 40006a8c <_RTEMS_Unlock_allocator>
40006600: c2 27 40 00 st %g1, [ %i5 ]
}
#endif
_Objects_Allocator_unlock();
return RTEMS_SUCCESSFUL;
40006604: 82 10 20 00 clr %g1
}
40006608: 81 c7 e0 08 ret
4000660c: 91 e8 00 01 restore %g0, %g1, %o0
if ( !valid ) {
40006610: 80 a6 40 14 cmp %i1, %l4
40006614: 08 bf ff d1 bleu 40006558 <rtems_task_create+0x58>
<== ALWAYS TAKEN
40006618: 01 00 00 00 nop
return RTEMS_INVALID_PRIORITY;
4000661c: 82 10 20 13 mov 0x13, %g1 ! 13 <_TLS_Alignment+0x12>
<== NOT EXECUTED
}
40006620: 81 c7 e0 08 ret
<== NOT EXECUTED
40006624: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
_Objects_Free(
40006628: 40 00 09 91 call 40008c6c <_Objects_Get_information_id>
<== NOT EXECUTED
4000662c: d0 06 60 08 ld [ %i1 + 8 ], %o0
<== NOT EXECUTED
40006630: 40 00 09 63 call 40008bbc <_Objects_Free>
<== NOT EXECUTED
40006634: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40006638: 40 00 01 15 call 40006a8c <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000663c: 01 00 00 00 nop
<== NOT EXECUTED
return RTEMS_UNSATISFIED;
40006640: 10 bf ff f2 b 40006608 <rtems_task_create+0x108>
<== NOT EXECUTED
40006644: 82 10 20 0d mov 0xd, %g1 ! d <_TLS_Alignment+0xc>
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
40006648: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
}
4000664c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006650: 91 e8 00 01 restore %g0, %g1, %o0
<== NOT EXECUTED
40006654: 40 00 01 0e call 40006a8c <_RTEMS_Unlock_allocator>
40006658: 01 00 00 00 nop
return RTEMS_TOO_MANY;
4000665c: 10 bf ff eb b 40006608 <rtems_task_create+0x108>
40006660: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
40006664 <rtems_task_delete>:
#include <rtems/score/threadimpl.h>
rtems_status_code rtems_task_delete(
rtems_id id
)
{
40006664: 9d e3 bf 70 save %sp, -144, %sp
Thread_Control *the_thread;
Thread_Close_context context;
Thread_Control *executing;
_Thread_queue_Context_initialize( &context.Base );
the_thread = _Thread_Get( id, &context.Base.Lock_context.Lock_context );
40006668: 90 10 00 18 mov %i0, %o0
4000666c: 40 00 0e e5 call 4000a200 <_Thread_Get>
40006670: 92 07 bf d8 add %fp, -40, %o1
if ( the_thread == NULL ) {
40006674: 82 92 20 00 orcc %o0, 0, %g1
40006678: 02 80 00 26 be 40006710 <rtems_task_delete+0xac>
<== NEVER TAKEN
4000667c: 01 00 00 00 nop
#endif
return RTEMS_INVALID_ID;
}
executing = _Thread_Executing;
40006680: d2 01 a0 20 ld [ %g6 + 0x20 ], %o1
if ( the_thread == executing ) {
40006684: 80 a0 40 09 cmp %g1, %o1
40006688: 02 80 00 07 be 400066a4 <rtems_task_delete+0x40>
<== ALWAYS TAKEN
4000668c: ba 10 00 06 mov %g6, %i5
THREAD_LIFE_TERMINATING | THREAD_LIFE_DETACHED,
NULL
);
_Thread_Dispatch_enable( cpu_self );
} else {
_Thread_Close( the_thread, executing, &context );
40006690: 94 07 bf d8 add %fp, -40, %o2
<== NOT EXECUTED
40006694: 40 00 14 cd call 4000b9c8 <_Thread_Close>
<== NOT EXECUTED
40006698: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000669c: 81 c7 e0 08 ret
<== NOT EXECUTED
400066a0: 81 e8 00 00 restore
<== NOT EXECUTED
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
400066a4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400066a8: 82 00 60 01 inc %g1
<== NOT EXECUTED
400066ac: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400066b0: c2 07 bf d8 ld [ %fp + -40 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400066b4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400066b8: 01 00 00 00 nop
_Thread_Exit(
400066bc: 94 10 20 00 clr %o2 ! 0 <PROM_START>
400066c0: 40 00 14 d1 call 4000ba04 <_Thread_Exit>
400066c4: 92 10 20 14 mov 0x14, %o1
*
* @param[in] cpu_self The current processor.
*/
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self )
{
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
400066c8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if ( disable_level == 1 ) {
400066cc: 80 a0 60 01 cmp %g1, 1
400066d0: 02 80 00 06 be 400066e8 <rtems_task_delete+0x84>
<== ALWAYS TAKEN
400066d4: 82 00 7f ff add %g1, -1, %g1
}
return RTEMS_SUCCESSFUL;
400066d8: b0 10 20 00 clr %i0
<== NOT EXECUTED
}
_ISR_Local_enable( level );
} else {
_Assert( disable_level > 0 );
cpu_self->thread_dispatch_disable_level = disable_level - 1;
400066dc: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
400066e0: 81 c7 e0 08 ret
<== NOT EXECUTED
400066e4: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400066e8: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
400066ec: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2
400066f0: 80 a0 a0 00 cmp %g2, 0
400066f4: 12 80 00 09 bne 40006718 <rtems_task_delete+0xb4>
<== ALWAYS TAKEN
400066f8: 92 10 00 01 mov %g1, %o1
cpu_self->thread_dispatch_disable_level = 0;
400066fc: c0 27 60 18 clr [ %i5 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006700: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006704: 01 00 00 00 nop
<== NOT EXECUTED
40006708: 81 c7 e0 08 ret
<== NOT EXECUTED
4000670c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
}
40006710: 81 c7 e0 08 ret
<== NOT EXECUTED
40006714: 91 e8 20 04 restore %g0, 4, %o0
<== NOT EXECUTED
_Thread_Do_dispatch( cpu_self, level );
40006718: c2 27 bf d4 st %g1, [ %fp + -44 ]
4000671c: 40 00 0e 5a call 4000a084 <_Thread_Do_dispatch>
40006720: 90 10 00 1d mov %i5, %o0
40006724: 10 bf ff f7 b 40006700 <rtems_task_delete+0x9c>
<== NOT EXECUTED
40006728: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
4000672c <rtems_task_ident>:
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
rtems_id *id
)
{
4000672c: 9d e3 bf a0 save %sp, -96, %sp
Objects_Name_or_id_lookup_errors status;
if ( !id )
40006730: 80 a6 a0 00 cmp %i2, 0
40006734: 02 80 00 14 be 40006784 <rtems_task_ident+0x58>
<== NEVER TAKEN
40006738: 80 a6 20 00 cmp %i0, 0
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
4000673c: 12 80 00 07 bne 40006758 <rtems_task_ident+0x2c>
<== NEVER TAKEN
40006740: 92 10 00 18 mov %i0, %o1
*id = _Thread_Get_executing()->Object.id;
40006744: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
40006748: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000674c: c2 26 80 00 st %g1, [ %i2 ]
return RTEMS_SUCCESSFUL;
40006750: 81 c7 e0 08 ret
40006754: 81 e8 00 00 restore
}
status = _Objects_Name_to_id_u32(
40006758: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
4000675c: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
40006760: 11 10 00 4d sethi %hi(0x40013400), %o0
<== NOT EXECUTED
40006764: 40 00 09 a8 call 40008e04 <_Objects_Name_to_id_u32>
<== NOT EXECUTED
40006768: 90 12 21 18 or %o0, 0x118, %o0 ! 40013518 <_RTEMS_tasks_Information>
<== NOT EXECUTED
name,
node,
id
);
return _Status_Object_name_errors_to_status[ status ];
4000676c: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
40006770: 91 2a 20 02 sll %o0, 2, %o0
<== NOT EXECUTED
40006774: 82 10 62 c8 or %g1, 0x2c8, %g1
<== NOT EXECUTED
40006778: f0 00 40 08 ld [ %g1 + %o0 ], %i0
<== NOT EXECUTED
4000677c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006780: 81 e8 00 00 restore
<== NOT EXECUTED
}
40006784: 81 c7 e0 08 ret
<== NOT EXECUTED
40006788: 91 e8 20 09 restore %g0, 9, %o0
<== NOT EXECUTED
4000ed60 <rtems_task_iterate>:
void rtems_task_iterate(
rtems_task_visitor visitor,
void *arg
)
{
4000ed60: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
_RTEMS_Lock_allocator();
4000ed64: 40 00 01 e7 call 4000f500 <_RTEMS_Lock_allocator>
<== NOT EXECUTED
4000ed68: 01 00 00 00 nop
<== NOT EXECUTED
_Objects_Allocator_lock();
_Thread_Iterate( visitor, arg );
4000ed6c: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000ed70: 40 00 13 42 call 40013a78 <_Thread_Iterate>
<== NOT EXECUTED
4000ed74: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
_RTEMS_Unlock_allocator();
4000ed78: 40 00 01 e7 call 4000f514 <_RTEMS_Unlock_allocator>
<== NOT EXECUTED
4000ed7c: 81 e8 00 00 restore
<== NOT EXECUTED
4000ed80 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
4000ed80: 9d e3 bf 98 save %sp, -104, %sp
ASR_Information *asr;
bool preempt_enabled;
bool needs_asr_dispatching;
rtems_mode old_mode;
if ( !previous_mode_set )
4000ed84: 80 a6 a0 00 cmp %i2, 0
4000ed88: 02 80 00 77 be 4000ef64 <rtems_task_mode+0x1e4>
<== NEVER TAKEN
4000ed8c: 01 00 00 00 nop
4000ed90: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
executing = _Thread_Get_executing();
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4000ed94: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1
4000ed98: 80 a0 00 01 cmp %g0, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4000ed9c: c2 07 20 90 ld [ %i4 + 0x90 ], %g1
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4000eda0: 90 60 3f ff subx %g0, -1, %o0
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4000eda4: e0 07 21 58 ld [ %i4 + 0x158 ], %l0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4000eda8: 80 a0 60 00 cmp %g1, 0
4000edac: 12 80 00 5d bne 4000ef20 <rtems_task_mode+0x1a0>
<== NEVER TAKEN
4000edb0: b7 2a 20 08 sll %o0, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4000edb4: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
4000edb8: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
4000edbc: 7f ff e2 84 call 400077cc <_CPU_ISR_Get_level>
4000edc0: ba 60 3f ff subx %g0, -1, %i5
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4000edc4: bb 2f 60 0a sll %i5, 0xa, %i5
old_mode |= _ISR_Get_level();
4000edc8: 90 17 40 08 or %i5, %o0, %o0
4000edcc: 90 12 00 1b or %o0, %i3, %o0
*previous_mode_set = old_mode;
4000edd0: d0 26 80 00 st %o0, [ %i2 ]
/*
* These are generic thread scheduling characteristics.
*/
preempt_enabled = false;
if ( mask & RTEMS_PREEMPT_MASK ) {
4000edd4: 80 8e 61 00 btst 0x100, %i1
4000edd8: 02 80 00 09 be 4000edfc <rtems_task_mode+0x7c>
<== NEVER TAKEN
4000eddc: 84 10 20 00 clr %g2
bool is_preempt_enabled = _Modes_Is_preempt( mode_set );
preempt_enabled = !executing->is_preemptible && is_preempt_enabled;
4000ede0: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1
4000ede4: 85 36 20 08 srl %i0, 8, %g2
4000ede8: 82 18 60 01 xor %g1, 1, %g1
4000edec: 84 18 a0 01 xor %g2, 1, %g2
4000edf0: 84 08 a0 01 and %g2, 1, %g2
executing->is_preemptible = is_preempt_enabled;
4000edf4: c4 2f 20 89 stb %g2, [ %i4 + 0x89 ]
preempt_enabled = !executing->is_preemptible && is_preempt_enabled;
4000edf8: 84 08 80 01 and %g2, %g1, %g2
}
if ( mask & RTEMS_TIMESLICE_MASK ) {
4000edfc: 80 8e 62 00 btst 0x200, %i1
4000ee00: 02 80 00 0a be 4000ee28 <rtems_task_mode+0xa8>
<== ALWAYS TAKEN
4000ee04: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
4000ee08: 80 8e 22 00 btst 0x200, %i0
<== NOT EXECUTED
4000ee0c: 02 80 00 53 be 4000ef58 <rtems_task_mode+0x1d8>
<== NOT EXECUTED
4000ee10: 80 8e 60 0f btst 0xf, %i1
<== NOT EXECUTED
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget =
rtems_configuration_get_ticks_per_timeslice();
4000ee14: 03 10 00 b4 sethi %hi(0x4002d000), %g1
<== NOT EXECUTED
executing->cpu_time_budget =
4000ee18: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 4002d330 <Configuration+0x18>
<== NOT EXECUTED
4000ee1c: c2 27 20 8c st %g1, [ %i4 + 0x8c ]
<== NOT EXECUTED
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
4000ee20: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
4000ee24: c2 27 20 90 st %g1, [ %i4 + 0x90 ]
<== NOT EXECUTED
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK ) {
4000ee28: 02 80 00 07 be 4000ee44 <rtems_task_mode+0xc4>
<== ALWAYS TAKEN
4000ee2c: 80 8e 64 00 btst 0x400, %i1
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
4000ee30: 83 2e 20 08 sll %i0, 8, %g1
<== NOT EXECUTED
4000ee34: 82 08 6f 00 and %g1, 0xf00, %g1
<== NOT EXECUTED
4000ee38: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ee3c: 01 00 00 00 nop
<== NOT EXECUTED
/*
* This is specific to the RTEMS API
*/
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
4000ee40: 80 8e 64 00 btst 0x400, %i1
<== NOT EXECUTED
4000ee44: 02 80 00 22 be 4000eecc <rtems_task_mode+0x14c>
<== ALWAYS TAKEN
4000ee48: 80 88 a0 ff btst 0xff, %g2
bool is_asr_enabled = !_Modes_Is_asr_disabled( mode_set );
4000ee4c: b1 36 20 0a srl %i0, 0xa, %i0
<== NOT EXECUTED
4000ee50: b0 1e 20 01 xor %i0, 1, %i0
<== NOT EXECUTED
4000ee54: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000ee58: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000ee5c: 88 10 00 01 mov %g1, %g4
<== NOT EXECUTED
_Thread_State_acquire( executing, &lock_context );
if ( is_asr_enabled != asr->is_enabled ) {
4000ee60: c6 0c 20 08 ldub [ %l0 + 8 ], %g3
<== NOT EXECUTED
4000ee64: 80 a6 00 03 cmp %i0, %g3
<== NOT EXECUTED
4000ee68: 02 80 00 15 be 4000eebc <rtems_task_mode+0x13c>
<== NOT EXECUTED
4000ee6c: 01 00 00 00 nop
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE rtems_signal_set _ASR_Swap_signals( ASR_Information *asr )
{
rtems_signal_set new_signals_posted;
new_signals_posted = asr->signals_pending;
4000ee70: c6 04 20 18 ld [ %l0 + 0x18 ], %g3
<== NOT EXECUTED
asr->signals_pending = asr->signals_posted;
4000ee74: fa 04 20 14 ld [ %l0 + 0x14 ], %i5
<== NOT EXECUTED
asr->is_enabled = is_asr_enabled;
4000ee78: f0 2c 20 08 stb %i0, [ %l0 + 8 ]
<== NOT EXECUTED
if ( _ASR_Swap_signals( asr ) != 0 ) {
4000ee7c: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4000ee80: fa 24 20 18 st %i5, [ %l0 + 0x18 ]
<== NOT EXECUTED
4000ee84: 02 80 00 0e be 4000eebc <rtems_task_mode+0x13c>
<== NOT EXECUTED
4000ee88: c6 24 20 14 st %g3, [ %l0 + 0x14 ]
<== NOT EXECUTED
action->handler = handler;
4000ee8c: 05 10 00 68 sethi %hi(0x4001a000), %g2
<== NOT EXECUTED
4000ee90: 84 10 a3 74 or %g2, 0x374, %g2 ! 4001a374 <_Signal_Action_handler>
<== NOT EXECUTED
4000ee94: c4 24 20 28 st %g2, [ %l0 + 0x28 ]
<== NOT EXECUTED
} else {
_Atomic_Fetch_or_ulong( &cpu_target->message, 0, ATOMIC_ORDER_RELEASE );
_CPU_SMP_Send_interrupt( _Per_CPU_Get_index( cpu_target ) );
}
#else
cpu_self->dispatch_necessary = true;
4000ee98: 86 10 20 01 mov 1, %g3
<== NOT EXECUTED
4000ee9c: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Append_if_is_off_chain_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
if ( _Chain_Is_node_off_chain( the_node ) ) {
4000eea0: c4 04 20 20 ld [ %l0 + 0x20 ], %g2
<== NOT EXECUTED
4000eea4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000eea8: 22 80 00 33 be,a 4000ef74 <rtems_task_mode+0x1f4>
<== NOT EXECUTED
4000eeac: c4 07 20 e8 ld [ %i4 + 0xe8 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000eeb0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000eeb4: 01 00 00 00 nop
<== NOT EXECUTED
4000eeb8: 30 80 00 07 b,a 4000eed4 <rtems_task_mode+0x154>
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000eebc: 82 10 00 04 mov %g4, %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000eec0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000eec4: 01 00 00 00 nop
<== NOT EXECUTED
}
_Thread_State_release( executing, &lock_context );
}
if ( preempt_enabled || needs_asr_dispatching ) {
4000eec8: 80 88 a0 ff btst 0xff, %g2
<== NOT EXECUTED
4000eecc: 02 80 00 28 be 4000ef6c <rtems_task_mode+0x1ec>
<== NEVER TAKEN
4000eed0: 01 00 00 00 nop
<== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000eed4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000eed8: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000eedc: ba 10 00 06 mov %g6, %i5
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000eee0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000eee4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000eee8: c2 27 bf fc st %g1, [ %fp + -4 ]
( *scheduler->Operations.schedule )( scheduler, the_thread );
4000eeec: 11 10 00 b5 sethi %hi(0x4002d400), %o0
4000eef0: 90 12 20 00 mov %o0, %o0 ! 4002d400 <_Scheduler_Table>
4000eef4: c4 02 20 08 ld [ %o0 + 8 ], %g2
4000eef8: 9f c0 80 00 call %g2
4000eefc: 92 10 00 1c mov %i4, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ef00: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ef04: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ef08: 01 00 00 00 nop
_Scheduler_Schedule( executing );
_Thread_State_release( executing, &lock_context );
_Thread_Dispatch_direct( cpu_self );
}
return RTEMS_SUCCESSFUL;
4000ef0c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
_Thread_Dispatch_direct( cpu_self );
4000ef10: 40 00 11 c6 call 40013628 <_Thread_Dispatch_direct>
4000ef14: 90 10 00 1d mov %i5, %o0
4000ef18: 81 c7 e0 08 ret
4000ef1c: 81 e8 00 00 restore
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4000ef20: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
<== NOT EXECUTED
4000ef24: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
old_mode |= RTEMS_TIMESLICE;
4000ef28: b6 16 e2 00 or %i3, 0x200, %i3
<== NOT EXECUTED
old_mode |= _ISR_Get_level();
4000ef2c: 7f ff e2 28 call 400077cc <_CPU_ISR_Get_level>
<== NOT EXECUTED
4000ef30: ba 60 3f ff subx %g0, -1, %i5
<== NOT EXECUTED
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4000ef34: bb 2f 60 0a sll %i5, 0xa, %i5
<== NOT EXECUTED
old_mode |= _ISR_Get_level();
4000ef38: 90 17 40 08 or %i5, %o0, %o0
<== NOT EXECUTED
4000ef3c: 90 12 00 1b or %o0, %i3, %o0
<== NOT EXECUTED
*previous_mode_set = old_mode;
4000ef40: d0 26 80 00 st %o0, [ %i2 ]
<== NOT EXECUTED
if ( mask & RTEMS_PREEMPT_MASK ) {
4000ef44: 80 8e 61 00 btst 0x100, %i1
<== NOT EXECUTED
4000ef48: 02 bf ff ad be 4000edfc <rtems_task_mode+0x7c>
<== NOT EXECUTED
4000ef4c: 84 10 20 00 clr %g2
<== NOT EXECUTED
preempt_enabled = !executing->is_preemptible && is_preempt_enabled;
4000ef50: 10 bf ff a5 b 4000ede4 <rtems_task_mode+0x64>
<== NOT EXECUTED
4000ef54: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1
<== NOT EXECUTED
if ( mask & RTEMS_INTERRUPT_MASK ) {
4000ef58: 02 bf ff ba be 4000ee40 <rtems_task_mode+0xc0>
<== NOT EXECUTED
4000ef5c: c0 27 20 90 clr [ %i4 + 0x90 ]
<== NOT EXECUTED
4000ef60: 30 bf ff b4 b,a 4000ee30 <rtems_task_mode+0xb0>
<== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
4000ef64: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ef68: 91 e8 20 09 restore %g0, 9, %o0
<== NOT EXECUTED
}
4000ef6c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ef70: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
return &the_chain->Tail.Node;
4000ef74: 86 07 20 e4 add %i4, 0xe4, %g3
<== NOT EXECUTED
the_node->next = tail;
4000ef78: c6 24 20 20 st %g3, [ %l0 + 0x20 ]
<== NOT EXECUTED
_Chain_Append_if_is_off_chain_unprotected(
4000ef7c: 86 04 20 20 add %l0, 0x20, %g3
<== NOT EXECUTED
tail->previous = the_node;
4000ef80: c6 27 20 e8 st %g3, [ %i4 + 0xe8 ]
<== NOT EXECUTED
old_last->next = the_node;
4000ef84: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
the_node->previous = old_last;
4000ef88: c4 24 20 24 st %g2, [ %l0 + 0x24 ]
<== NOT EXECUTED
4000ef8c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000ef90: 01 00 00 00 nop
<== NOT EXECUTED
4000ef94: 30 bf ff d0 b,a 4000eed4 <rtems_task_mode+0x154>
<== NOT EXECUTED
4000ef98 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority_p
)
{
4000ef98: 9d e3 bf 70 save %sp, -144, %sp
Thread_queue_Context queue_context;
const Scheduler_Control *scheduler;
Priority_Control old_priority;
rtems_status_code status;
if ( old_priority_p == NULL ) {
4000ef9c: 80 a6 a0 00 cmp %i2, 0
4000efa0: 02 80 00 18 be 4000f000 <rtems_task_set_priority+0x68>
<== NEVER TAKEN
4000efa4: b8 10 20 09 mov 9, %i4
queue_context->Priority.update_count = 0;
4000efa8: c0 27 bf f0 clr [ %fp + -16 ]
return RTEMS_INVALID_ADDRESS;
}
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_clear_priority_updates( &queue_context );
the_thread = _Thread_Get( id, &queue_context.Lock_context.Lock_context );
4000efac: 90 10 00 18 mov %i0, %o0
4000efb0: 40 00 11 b5 call 40013684 <_Thread_Get>
4000efb4: 92 07 bf dc add %fp, -36, %o1
if ( the_thread == NULL ) {
4000efb8: b8 92 20 00 orcc %o0, 0, %i4
4000efbc: 02 80 00 3e be 4000f0b4 <rtems_task_set_priority+0x11c>
<== NEVER TAKEN
4000efc0: 80 a6 60 00 cmp %i1, 0
4000efc4: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
_Thread_Wait_acquire_critical( the_thread, &queue_context );
scheduler = _Thread_Scheduler_get_home( the_thread );
old_priority = _Thread_Get_priority( the_thread );
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
4000efc8: 12 80 00 10 bne 4000f008 <rtems_task_set_priority+0x70>
4000efcc: e0 18 60 18 ldd [ %g1 + 0x18 ], %l0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000efd0: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000efd4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000efd8: 01 00 00 00 nop
4000efdc: 3b 10 00 b5 sethi %hi(0x4002d400), %i5
new_priority,
&queue_context
);
} else {
_Thread_Wait_release( the_thread, &queue_context );
status = RTEMS_SUCCESSFUL;
4000efe0: b8 10 20 00 clr %i4
4000efe4: ba 17 60 00 mov %i5, %i5
return ( *scheduler->Operations.unmap_priority )( scheduler, priority );
4000efe8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000efec: 92 10 00 10 mov %l0, %o1
4000eff0: 94 10 00 11 mov %l1, %o2
4000eff4: 9f c0 40 00 call %g1
4000eff8: 90 10 00 1d mov %i5, %o0
RTEMS_INLINE_ROUTINE rtems_task_priority _RTEMS_Priority_From_core(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return (rtems_task_priority)
4000effc: d2 26 80 00 st %o1, [ %i2 ]
}
*old_priority_p = _RTEMS_Priority_From_core( scheduler, old_priority );
return status;
}
4000f000: 81 c7 e0 08 ret
4000f004: 91 e8 00 1c restore %g0, %i4, %o0
*valid = ( priority <= scheduler->maximum_priority );
4000f008: 3b 10 00 b5 sethi %hi(0x4002d400), %i5
4000f00c: ba 17 60 00 mov %i5, %i5 ! 4002d400 <_Scheduler_Table>
return ( *scheduler->Operations.map_priority )( scheduler, priority );
4000f010: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000f014: f6 07 60 40 ld [ %i5 + 0x40 ], %i3
4000f018: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
4000f01c: 92 10 20 00 clr %o1
4000f020: 94 10 00 19 mov %i1, %o2
4000f024: 9f c0 40 00 call %g1
4000f028: 90 10 00 1d mov %i5, %o0
if ( !valid ) {
4000f02c: 80 a6 e0 00 cmp %i3, 0
4000f030: 32 80 00 06 bne,a 4000f048 <rtems_task_set_priority+0xb0>
<== NEVER TAKEN
4000f034: d0 3f 20 30 std %o0, [ %i4 + 0x30 ]
<== NOT EXECUTED
4000f038: 80 a6 40 18 cmp %i1, %i0
4000f03c: 18 80 00 19 bgu 4000f0a0 <rtems_task_set_priority+0x108>
<== NEVER TAKEN
4000f040: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Priority_Node_set_priority(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
4000f044: d0 3f 20 30 std %o0, [ %i4 + 0x30 ]
_Thread_Priority_changed(
4000f048: 96 07 bf dc add %fp, -36, %o3
4000f04c: 94 10 20 00 clr %o2
4000f050: 92 07 20 20 add %i4, 0x20, %o1
4000f054: 40 00 10 9f call 400132d0 <_Thread_Priority_changed>
4000f058: 90 10 00 1c mov %i4, %o0
disable_level = cpu_self->thread_dispatch_disable_level;
4000f05c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000f060: 82 00 60 01 inc %g1
<== NOT EXECUTED
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000f064: b6 10 00 06 mov %g6, %i3
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000f068: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f06c: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f070: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f074: 01 00 00 00 nop
_Thread_Priority_update( queue_context );
4000f078: 40 00 10 9d call 400132ec <_Thread_Priority_update>
4000f07c: 90 07 bf dc add %fp, -36, %o0
uint32_t disable_level = cpu_self->thread_dispatch_disable_level;
4000f080: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1
if ( disable_level == 1 ) {
4000f084: 80 a0 60 01 cmp %g1, 1
4000f088: 02 80 00 0e be 4000f0c0 <rtems_task_set_priority+0x128>
<== ALWAYS TAKEN
4000f08c: 82 00 7f ff add %g1, -1, %g1
return RTEMS_SUCCESSFUL;
4000f090: b8 10 20 00 clr %i4
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level - 1;
4000f094: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
<== NOT EXECUTED
return ( *scheduler->Operations.unmap_priority )( scheduler, priority );
4000f098: 10 bf ff d5 b 4000efec <rtems_task_set_priority+0x54>
<== NOT EXECUTED
4000f09c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
<== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f0a0: c2 07 bf dc ld [ %fp + -36 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f0a4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f0a8: 01 00 00 00 nop
<== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
4000f0ac: 10 bf ff cf b 4000efe8 <rtems_task_set_priority+0x50>
<== NOT EXECUTED
4000f0b0: b8 10 20 13 mov 0x13, %i4 ! 13 <_TLS_Alignment+0x12>
<== NOT EXECUTED
return RTEMS_INVALID_ID;
4000f0b4: b8 10 20 04 mov 4, %i4
<== NOT EXECUTED
}
4000f0b8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f0bc: 91 e8 00 1c restore %g0, %i4, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f0c0: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (
4000f0c4: c4 0e e0 1c ldub [ %i3 + 0x1c ], %g2
4000f0c8: 80 a0 a0 00 cmp %g2, 0
4000f0cc: 12 80 00 07 bne 4000f0e8 <rtems_task_set_priority+0x150>
<== NEVER TAKEN
4000f0d0: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = 0;
4000f0d4: c0 26 e0 18 clr [ %i3 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f0d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f0dc: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
4000f0e0: 10 bf ff c2 b 4000efe8 <rtems_task_set_priority+0x50>
4000f0e4: b8 10 20 00 clr %i4 ! 0 <PROM_START>
_Thread_Do_dispatch( cpu_self, level );
4000f0e8: c2 27 bf d4 st %g1, [ %fp + -44 ]
<== NOT EXECUTED
4000f0ec: 40 00 11 07 call 40013508 <_Thread_Do_dispatch>
<== NOT EXECUTED
4000f0f0: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
4000f0f4: 10 bf ff f9 b 4000f0d8 <rtems_task_set_priority+0x140>
<== NOT EXECUTED
4000f0f8: c2 07 bf d4 ld [ %fp + -44 ], %g1
<== NOT EXECUTED
40006888 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
40006888: 9d e3 bf 90 save %sp, -112, %sp
Thread_Entry_information entry = {
4000688c: 03 10 00 28 sethi %hi(0x4000a000), %g1
40006890: 82 10 61 e8 or %g1, 0x1e8, %g1 ! 4000a1e8 <_Thread_Entry_adaptor_numeric>
};
Thread_Control *the_thread;
ISR_lock_Context lock_context;
bool ok;
the_thread = _Thread_Get( id, &lock_context );
40006894: 90 10 00 18 mov %i0, %o0
Thread_Entry_information entry = {
40006898: f2 27 bf f8 st %i1, [ %fp + -8 ]
the_thread = _Thread_Get( id, &lock_context );
4000689c: 92 07 bf f0 add %fp, -16, %o1
Thread_Entry_information entry = {
400068a0: f4 27 bf fc st %i2, [ %fp + -4 ]
if ( _Thread_MP_Is_remote( id ) ) {
return RTEMS_ILLEGAL_ON_REMOTE_OBJECT;
}
#endif
return RTEMS_INVALID_ID;
400068a4: b0 10 20 04 mov 4, %i0
the_thread = _Thread_Get( id, &lock_context );
400068a8: 40 00 0e 56 call 4000a200 <_Thread_Get>
400068ac: c2 27 bf f4 st %g1, [ %fp + -12 ]
if ( the_thread == NULL ) {
400068b0: 80 a2 20 00 cmp %o0, 0
400068b4: 02 80 00 08 be 400068d4 <rtems_task_start+0x4c>
<== NEVER TAKEN
400068b8: 94 07 bf f0 add %fp, -16, %o2
}
ok = _Thread_Start( the_thread, &entry, &lock_context );
400068bc: 40 00 14 d6 call 4000bc14 <_Thread_Start>
400068c0: 92 07 bf f4 add %fp, -12, %o1
return ok ? RTEMS_SUCCESSFUL : RTEMS_INCORRECT_STATE;
400068c4: 80 a0 00 08 cmp %g0, %o0
400068c8: b0 60 20 00 subx %g0, 0, %i0
400068cc: b0 0e 3f f2 and %i0, -14, %i0
400068d0: b0 06 20 0e add %i0, 0xe, %i0
}
400068d4: 81 c7 e0 08 ret
400068d8: 81 e8 00 00 restore
4000f198 <rtems_task_wake_after>:
#include <rtems/score/watchdogimpl.h>
rtems_status_code rtems_task_wake_after(
rtems_interval ticks
)
{
4000f198: 9d e3 bf 98 save %sp, -104, %sp
disable_level = cpu_self->thread_dispatch_disable_level;
4000f19c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000f1a0: 82 00 60 01 inc %g1
4000f1a4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000f1a8: ba 10 00 06 mov %g6, %i5
Per_CPU_Control *cpu_self;
cpu_self = _Thread_Dispatch_disable();
executing = _Per_CPU_Get_executing( cpu_self );
if ( ticks == 0 ) {
4000f1ac: 80 a6 20 00 cmp %i0, 0
4000f1b0: 02 80 00 1d be 4000f224 <rtems_task_wake_after+0x8c>
<== NEVER TAKEN
4000f1b4: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
_Thread_Yield( executing );
} else {
_Thread_Set_state( executing, STATES_WAITING_FOR_TIME );
4000f1b8: 92 10 21 00 mov 0x100, %o1
4000f1bc: 40 00 19 0b call 400155e8 <_Thread_Set_state>
4000f1c0: 90 10 00 1c mov %i4, %o0
the_thread->Wait.flags = flags;
4000f1c4: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
4000f1c8: c2 27 20 50 st %g1, [ %i4 + 0x50 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f1cc: 91 d0 20 09 ta 9
<== NOT EXECUTED
return psr;
4000f1d0: c2 27 bf fc st %g1, [ %fp + -4 ]
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
4000f1d4: 05 10 00 56 sethi %hi(0x40015800), %g2
expire = ticks + cpu->Watchdog.ticks;
4000f1d8: d4 1f 60 30 ldd [ %i5 + 0x30 ], %o2
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
4000f1dc: 90 07 60 38 add %i5, 0x38, %o0
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
4000f1e0: 84 10 a0 54 or %g2, 0x54, %g2
the_thread->Timer.header =
4000f1e4: d0 27 20 60 st %o0, [ %i4 + 0x60 ]
_Watchdog_Insert(header, the_watchdog, expire);
4000f1e8: 86 82 c0 18 addcc %o3, %i0, %g3
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
4000f1ec: c4 27 20 78 st %g2, [ %i4 + 0x78 ]
4000f1f0: 84 42 a0 00 addx %o2, 0, %g2
4000f1f4: 92 07 20 68 add %i4, 0x68, %o1
4000f1f8: 94 10 00 02 mov %g2, %o2
4000f1fc: 40 00 1a d6 call 40015d54 <_Watchdog_Insert>
4000f200: 96 10 00 03 mov %g3, %o3
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f204: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f208: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f20c: 01 00 00 00 nop
_Thread_Wait_flags_set( executing, THREAD_WAIT_STATE_BLOCKED );
_Thread_Add_timeout_ticks( executing, cpu_self, ticks );
}
_Thread_Dispatch_direct( cpu_self );
return RTEMS_SUCCESSFUL;
}
4000f210: b0 10 20 00 clr %i0 ! 0 <PROM_START>
_Thread_Dispatch_direct( cpu_self );
4000f214: 40 00 11 05 call 40013628 <_Thread_Dispatch_direct>
4000f218: 90 10 00 1d mov %i5, %o0
}
4000f21c: 81 c7 e0 08 ret
4000f220: 81 e8 00 00 restore
_Thread_Yield( executing );
4000f224: 40 00 19 93 call 40015870 <_Thread_Yield>
<== NOT EXECUTED
4000f228: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
}
4000f22c: b0 10 20 00 clr %i0
<== NOT EXECUTED
_Thread_Dispatch_direct( cpu_self );
4000f230: 40 00 10 fe call 40013628 <_Thread_Dispatch_direct>
<== NOT EXECUTED
4000f234: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
}
4000f238: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f23c: 81 e8 00 00 restore
<== NOT EXECUTED