RTEMS-6
Annotated Report
rtems
Sun Feb 28 22:20:10 2021
4001034c <_Event_Seize>:
Event_Control *event,
Thread_Wait_flags wait_class,
States_Control block_state,
ISR_lock_Context *lock_context
)
{
4001034c: 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;
40010350: c2 07 40 00 ld [ %i5 ], %g1
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
40010354: 84 88 40 18 andcc %g1, %i0, %g2
40010358: 02 80 00 07 be 40010374 <_Event_Seize+0x28>
4001035c: 80 8e 60 01 btst 1, %i1
40010360: 80 a6 00 02 cmp %i0, %g2
40010364: 02 80 00 30 be 40010424 <_Event_Seize+0xd8>
40010368: 80 8e 60 02 btst 2, %i1
(seized_events == event_in || _Options_Is_any( option_set )) ) {
4001036c: 12 80 00 2e bne 40010424 <_Event_Seize+0xd8>
40010370: 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 ) ) {
40010374: 12 80 00 60 bne 400104f4 <_Event_Seize+0x1a8>
40010378: 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;
4001037c: a0 10 60 01 or %g1, 1, %l0
* 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;
40010380: c0 27 20 4c clr [ %i4 + 0x4c ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40010384: ba 10 00 06 mov %g6, %i5
disable_level = cpu_self->thread_dispatch_disable_level;
40010388: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
executing->Wait.option = option_set;
4001038c: f2 27 20 48 st %i1, [ %i4 + 0x48 ]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40010390: 82 00 60 01 inc %g1
executing->Wait.count = event_in;
40010394: f0 27 20 3c st %i0, [ %i4 + 0x3c ]
executing->Wait.return_argument = event_out;
40010398: f6 27 20 40 st %i3, [ %i4 + 0x40 ]
the_thread->Wait.flags = flags;
4001039c: e0 27 20 50 st %l0, [ %i4 + 0x50 ]
400103a0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400103a4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
400103a8: c2 00 40 00 ld [ %g1 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400103ac: 91 d0 20 0a ta 0xa
400103b0: 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 ) {
400103b4: 80 a6 a0 00 cmp %i2, 0
400103b8: 12 80 00 35 bne 4001048c <_Event_Seize+0x140>
400103bc: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
_Thread_Add_timeout_ticks( executing, cpu_self, ticks );
}
_Thread_Set_state( executing, block_state );
400103c0: 7f ff ed ce call 4000baf8 <_Thread_Set_state>
400103c4: 90 10 00 1c mov %i4, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400103c8: 91 d0 20 09 ta 9
bool success = ( the_thread->Wait.flags == expected_flags );
400103cc: c6 07 20 50 ld [ %i4 + 0x50 ], %g3
if ( success ) {
400103d0: 80 a4 00 03 cmp %l0, %g3
400103d4: 02 80 00 0c be 40010404 <_Event_Seize+0xb8>
400103d8: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400103dc: 91 d0 20 0a ta 0xa
400103e0: 01 00 00 00 nop
success = _Thread_Wait_flags_try_change_acquire(
executing,
intend_to_block,
wait_class | THREAD_WAIT_STATE_BLOCKED
);
if ( !success ) {
400103e4: 80 a4 00 03 cmp %l0, %g3
400103e8: 12 80 00 18 bne 40010448 <_Event_Seize+0xfc> <== ALWAYS TAKEN
400103ec: 01 00 00 00 nop
_Thread_Timer_remove( executing );
_Thread_Unblock( executing );
}
_Thread_Dispatch_direct( cpu_self );
400103f0: 7f ff e8 12 call 4000a438 <_Thread_Dispatch_direct>
400103f4: 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 );
400103f8: f0 0f 20 4f ldub [ %i4 + 0x4f ], %i0
return _Status_Get_after_wait( executing );
}
400103fc: 81 c7 e0 08 ret
40010400: 81 e8 00 00 restore
success = _Thread_Wait_flags_try_change_acquire(
40010404: 84 10 a0 02 or %g2, 2, %g2
the_thread->Wait.flags = desired_flags;
40010408: c4 27 20 50 st %g2, [ %i4 + 0x50 ]
4001040c: 91 d0 20 0a ta 0xa
40010410: 01 00 00 00 nop
if ( !success ) {
40010414: 80 a4 00 03 cmp %l0, %g3
40010418: 02 bf ff f6 be 400103f0 <_Event_Seize+0xa4> <== ALWAYS TAKEN
4001041c: 01 00 00 00 nop
40010420: 30 80 00 0a b,a 40010448 <_Event_Seize+0xfc> <== NOT EXECUTED
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) );
40010424: 82 28 40 02 andn %g1, %g2, %g1
event->pending_events =
40010428: c2 27 40 00 st %g1, [ %i5 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4001042c: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
40010430: c2 00 40 00 ld [ %g1 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010434: 91 d0 20 0a ta 0xa
40010438: 01 00 00 00 nop
*event_out = seized_events;
4001043c: c4 26 c0 00 st %g2, [ %i3 ]
return RTEMS_SUCCESSFUL;
40010440: 81 c7 e0 08 ret
40010444: 91 e8 20 00 restore %g0, 0, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40010448: 91 d0 20 09 ta 9
return psr;
4001044c: c2 27 bf fc st %g1, [ %fp + -4 ]
_Watchdog_Remove(
40010450: d0 07 20 60 ld [ %i4 + 0x60 ], %o0
40010454: 7f ff ef 39 call 4000c138 <_Watchdog_Remove>
40010458: 92 07 20 68 add %i4, 0x68, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4001045c: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40010460: 91 d0 20 0a ta 0xa
40010464: 01 00 00 00 nop
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40010468: 13 0c 00 57 sethi %hi(0x30015c00), %o1
4001046c: 90 10 00 1c mov %i4, %o0
40010470: 40 00 06 63 call 40011dfc <_Thread_Clear_state>
40010474: 92 12 63 ff or %o1, 0x3ff, %o1
_Thread_Dispatch_direct( cpu_self );
40010478: 7f ff e7 f0 call 4000a438 <_Thread_Dispatch_direct>
4001047c: 90 10 00 1d mov %i5, %o0
40010480: f0 0f 20 4f ldub [ %i4 + 0x4f ], %i0
}
40010484: 81 c7 e0 08 ret
40010488: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001048c: 91 d0 20 09 ta 9
return psr;
40010490: c2 27 bf fc st %g1, [ %fp + -4 ]
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
40010494: 05 10 00 2f sethi %hi(0x4000bc00), %g2
expire = ticks + cpu->Watchdog.ticks;
40010498: d4 19 a0 30 ldd [ %g6 + 0x30 ], %o2
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
4001049c: 90 01 a0 38 add %g6, 0x38, %o0
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
400104a0: 84 10 a0 c0 or %g2, 0xc0, %g2
the_thread->Timer.header =
400104a4: d0 27 20 60 st %o0, [ %i4 + 0x60 ]
_Watchdog_Insert(header, the_watchdog, expire);
400104a8: 96 82 c0 1a addcc %o3, %i2, %o3
the_thread->Timer.Watchdog.routine = _Thread_Timeout;
400104ac: c4 27 20 78 st %g2, [ %i4 + 0x78 ]
400104b0: 84 10 00 0a mov %o2, %g2
400104b4: 92 07 20 68 add %i4, 0x68, %o1
400104b8: 7f ff ee ed call 4000c06c <_Watchdog_Insert>
400104bc: 94 40 a0 00 addx %g2, 0, %o2
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400104c0: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400104c4: 91 d0 20 0a ta 0xa
400104c8: 01 00 00 00 nop
_Thread_Set_state( executing, block_state );
400104cc: d2 07 a0 60 ld [ %fp + 0x60 ], %o1
400104d0: 7f ff ed 8a call 4000baf8 <_Thread_Set_state>
400104d4: 90 10 00 1c mov %i4, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400104d8: 91 d0 20 09 ta 9
bool success = ( the_thread->Wait.flags == expected_flags );
400104dc: c6 07 20 50 ld [ %i4 + 0x50 ], %g3
if ( success ) {
400104e0: 80 a4 00 03 cmp %l0, %g3
400104e4: 12 bf ff be bne 400103dc <_Event_Seize+0x90>
400104e8: c4 07 a0 5c ld [ %fp + 0x5c ], %g2
success = _Thread_Wait_flags_try_change_acquire(
400104ec: 10 bf ff c7 b 40010408 <_Event_Seize+0xbc>
400104f0: 84 10 a0 02 or %g2, 2, %g2
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400104f4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
400104f8: c2 00 40 00 ld [ %g1 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400104fc: 91 d0 20 0a ta 0xa
40010500: 01 00 00 00 nop
*event_out = seized_events;
40010504: c4 26 c0 00 st %g2, [ %i3 ]
return RTEMS_UNSATISFIED;
40010508: 81 c7 e0 08 ret
4001050c: 91 e8 20 0d restore %g0, 0xd, %o0
4000426c <_RTEMS_tasks_Construct_user_task>:
#include <rtems/score/assert.h>
#include <rtems/score/threadimpl.h>
#include <rtems/score/interr.h>
void _RTEMS_tasks_Construct_user_task( void )
{
4000426c: 9d e3 bf 98 save %sp, -104, %sp
const RTEMS_tasks_User_task_config *config;
rtems_status_code status;
rtems_id id;
config = &_RTEMS_tasks_User_task_config;
status = rtems_task_construct( &config->config, &id );
40004270: 3b 10 00 3c sethi %hi(0x4000f000), %i5
40004274: 92 07 bf fc add %fp, -4, %o1
40004278: 40 00 0f 7d call 4000806c <rtems_task_construct>
4000427c: 90 17 61 cc or %i5, 0x1cc, %o0
if ( status != RTEMS_SUCCESSFUL ) {
40004280: 80 a2 20 00 cmp %o0, 0
40004284: 12 80 00 0b bne 400042b0 <_RTEMS_tasks_Construct_user_task+0x44>
40004288: ba 17 61 cc or %i5, 0x1cc, %i5
_Internal_error( INTERNAL_ERROR_RTEMS_INIT_TASK_CONSTRUCT_FAILED );
}
status = rtems_task_start( id, config->entry_point, config->argument );
4000428c: d0 07 bf fc ld [ %fp + -4 ], %o0
40004290: d4 07 60 24 ld [ %i5 + 0x24 ], %o2
40004294: 40 00 00 0a call 400042bc <rtems_task_start>
40004298: d2 07 60 20 ld [ %i5 + 0x20 ], %o1
_Assert( status == RTEMS_SUCCESSFUL );
(void) status;
_Assert( _Thread_Global_constructor == 0 );
_Thread_Global_constructor = id;
4000429c: c4 07 bf fc ld [ %fp + -4 ], %g2
400042a0: 03 10 00 55 sethi %hi(0x40015400), %g1
400042a4: c4 20 60 d8 st %g2, [ %g1 + 0xd8 ] ! 400154d8 <_Thread_Global_constructor>
}
400042a8: 81 c7 e0 08 ret
400042ac: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_RTEMS_INIT_TASK_CONSTRUCT_FAILED );
400042b0: 40 00 00 84 call 400044c0 <_Internal_error>
400042b4: 90 10 20 2a mov 0x2a, %o0
400042b8: 01 00 00 00 nop <== NOT EXECUTED
4000b024 <_RTEMS_tasks_Create>:
{
4000b024: 9d e3 bf 70 save %sp, -144, %sp
if ( !rtems_is_name_valid( config->name ) ) {
4000b028: c6 06 00 00 ld [ %i0 ], %g3
{
4000b02c: ba 10 00 18 mov %i0, %i5
if ( !rtems_is_name_valid( config->name ) ) {
4000b030: 80 a0 e0 00 cmp %g3, 0
4000b034: 02 80 00 45 be 4000b148 <_RTEMS_tasks_Create+0x124>
4000b038: b0 10 20 03 mov 3, %i0
if ( id == NULL ) {
4000b03c: 80 a6 60 00 cmp %i1, 0
4000b040: 02 80 00 5a be 4000b1a8 <_RTEMS_tasks_Create+0x184>
4000b044: 01 00 00 00 nop
thread_config.budget_algorithm = _Modes_Is_timeslice( config->initial_modes ) ?
4000b048: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
memset( &thread_config, 0, sizeof( thread_config ) );
4000b04c: c0 27 bf f8 clr [ %fp + -8 ]
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_timeslice (
rtems_mode mode_set
)
{
return (mode_set & RTEMS_TIMESLICE_MASK) == RTEMS_TIMESLICE;
4000b050: 89 30 60 09 srl %g1, 9, %g4
attributes = _Attributes_Set( config->attributes, ATTRIBUTES_REQUIRED );
4000b054: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false;
4000b058: b8 08 a0 01 and %g2, 1, %i4
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
rtems_mode mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
4000b05c: b6 08 60 0f and %g1, 0xf, %i3
4000b060: f8 2f bf f8 stb %i4, [ %fp + -8 ]
return (mode_set & RTEMS_TIMESLICE_MASK) == RTEMS_TIMESLICE;
4000b064: 88 09 20 01 and %g4, 1, %g4
return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;
4000b068: 83 30 60 08 srl %g1, 8, %g1
memset( &thread_config, 0, sizeof( thread_config ) );
4000b06c: c0 27 bf fc clr [ %fp + -4 ]
4000b070: 82 18 60 01 xor %g1, 1, %g1
4000b074: c0 27 bf ec clr [ %fp + -20 ]
4000b078: 82 08 60 01 and %g1, 1, %g1
thread_config.budget_algorithm = _Modes_Is_timeslice( config->initial_modes ) ?
4000b07c: c8 27 bf e8 st %g4, [ %fp + -24 ]
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_system_task(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_SYSTEM_TASK ) ? true : false;
4000b080: 85 30 a0 0f srl %g2, 0xf, %g2
thread_config.isr_level = _Modes_Get_interrupt_level( config->initial_modes );
4000b084: f6 27 bf f4 st %i3, [ %fp + -12 ]
if ( !_Attributes_Is_system_task( attributes ) ) {
4000b088: 80 88 a0 01 btst 1, %g2
thread_config.name.name_u32 = config->name;
4000b08c: c6 27 bf f0 st %g3, [ %fp + -16 ]
memset( &thread_config, 0, sizeof( thread_config ) );
4000b090: c0 27 bf d0 clr [ %fp + -48 ]
4000b094: c0 27 bf d4 clr [ %fp + -44 ]
4000b098: c0 27 bf d8 clr [ %fp + -40 ]
4000b09c: c0 27 bf dc clr [ %fp + -36 ]
thread_config.is_preemptible = _Modes_Is_preempt( config->initial_modes );
4000b0a0: c2 2f bf f9 stb %g1, [ %fp + -7 ]
memset( &thread_config, 0, sizeof( thread_config ) );
4000b0a4: c0 27 bf e0 clr [ %fp + -32 ]
4000b0a8: c0 27 bf e4 clr [ %fp + -28 ]
if ( !_Attributes_Is_system_task( attributes ) ) {
4000b0ac: 12 80 00 05 bne 4000b0c0 <_RTEMS_tasks_Create+0x9c>
4000b0b0: f8 07 60 04 ld [ %i5 + 4 ], %i4
if ( config->initial_priority == PRIORITY_MINIMUM ) {
4000b0b4: 80 a7 20 00 cmp %i4, 0
4000b0b8: 02 80 00 3a be 4000b1a0 <_RTEMS_tasks_Create+0x17c>
4000b0bc: 01 00 00 00 nop
thread_config.scheduler =
4000b0c0: 11 10 00 5e sethi %hi(0x40017800), %o0
4000b0c4: 90 12 20 c0 or %o0, 0xc0, %o0 ! 400178c0 <_Scheduler_Table>
4000b0c8: d0 27 bf d0 st %o0, [ %fp + -48 ]
return ( *scheduler->Operations.map_priority )( scheduler, priority );
4000b0cc: 92 10 20 00 clr %o1
4000b0d0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
const Scheduler_Control *scheduler,
rtems_task_priority priority,
bool *valid
)
{
*valid = ( priority <= scheduler->maximum_priority );
4000b0d4: f6 02 20 40 ld [ %o0 + 0x40 ], %i3
4000b0d8: f0 02 20 44 ld [ %o0 + 0x44 ], %i0
4000b0dc: 9f c0 40 00 call %g1
4000b0e0: 94 10 00 1c mov %i4, %o2
if ( !valid ) {
4000b0e4: 80 a6 e0 00 cmp %i3, 0
4000b0e8: 02 80 00 2b be 4000b194 <_RTEMS_tasks_Create+0x170> <== ALWAYS TAKEN
4000b0ec: d0 3f bf e0 std %o0, [ %fp + -32 ]
_RTEMS_Lock_allocator();
4000b0f0: 7f ff f2 fc call 40007ce0 <_RTEMS_Lock_allocator>
4000b0f4: 37 10 00 6a sethi %hi(0x4001a800), %i3
_Thread_Kill_zombies();
4000b0f8: 7f ff eb 17 call 40005d54 <_Thread_Kill_zombies>
4000b0fc: b6 16 e3 04 or %i3, 0x304, %i3 ! 4001ab04 <_RTEMS_tasks_Information>
return ( *information->allocate )( information );
4000b100: c2 06 e0 08 ld [ %i3 + 8 ], %g1
4000b104: 9f c0 40 00 call %g1
4000b108: 90 10 00 1b mov %i3, %o0
if ( !the_thread ) {
4000b10c: b8 92 20 00 orcc %o0, 0, %i4
4000b110: 02 80 00 28 be 4000b1b0 <_RTEMS_tasks_Create+0x18c>
4000b114: 92 10 00 1d mov %i5, %o1
status = ( *prepare_stack )( &thread_config, config );
4000b118: 9f c6 80 00 call %i2
4000b11c: 90 07 bf d0 add %fp, -48, %o0
if ( status == RTEMS_SUCCESSFUL ) {
4000b120: b0 92 20 00 orcc %o0, 0, %i0
4000b124: 02 80 00 0b be 4000b150 <_RTEMS_tasks_Create+0x12c>
4000b128: 94 07 bf d0 add %fp, -48, %o2
_Objects_Free(
4000b12c: 7f ff f5 95 call 40008780 <_Objects_Get_information_id>
4000b130: d0 07 20 08 ld [ %i4 + 8 ], %o0
( *information->deallocate )( information, the_object );
4000b134: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000b138: 9f c0 40 00 call %g1
4000b13c: 92 10 00 1c mov %i4, %o1
_RTEMS_Unlock_allocator();
4000b140: 7f ff f2 ed call 40007cf4 <_RTEMS_Unlock_allocator>
4000b144: 01 00 00 00 nop
return status;
4000b148: 81 c7 e0 08 ret
4000b14c: 81 e8 00 00 restore
ok = _Thread_Initialize(
4000b150: 92 10 00 1c mov %i4, %o1
4000b154: 7f ff f9 28 call 400095f4 <_Thread_Initialize>
4000b158: 90 10 00 1b mov %i3, %o0
if ( !ok ) {
4000b15c: 80 a2 20 00 cmp %o0, 0
4000b160: 22 bf ff f3 be,a 4000b12c <_RTEMS_tasks_Create+0x108>
4000b164: b0 10 20 0d mov 0xd, %i0
asr->is_enabled = !_Modes_Is_asr_disabled( config->initial_modes );
4000b168: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000b16c: c6 07 21 58 ld [ %i4 + 0x158 ], %g3
*id = the_thread->Object.id;
4000b170: c4 07 20 08 ld [ %i4 + 8 ], %g2
asr->is_enabled = !_Modes_Is_asr_disabled( config->initial_modes );
4000b174: 83 30 60 0a srl %g1, 0xa, %g1
4000b178: 82 18 60 01 xor %g1, 1, %g1
4000b17c: 82 08 60 01 and %g1, 1, %g1
4000b180: c2 28 e0 08 stb %g1, [ %g3 + 8 ]
4000b184: 7f ff f2 dc call 40007cf4 <_RTEMS_Unlock_allocator>
4000b188: c4 26 40 00 st %g2, [ %i1 ]
}
4000b18c: 81 c7 e0 08 ret
4000b190: 81 e8 00 00 restore
if ( !valid ) {
4000b194: 80 a7 00 18 cmp %i4, %i0
4000b198: 08 bf ff d6 bleu 4000b0f0 <_RTEMS_tasks_Create+0xcc>
4000b19c: 01 00 00 00 nop
return RTEMS_INVALID_PRIORITY;
4000b1a0: 81 c7 e0 08 ret
4000b1a4: 91 e8 20 13 restore %g0, 0x13, %o0
return RTEMS_INVALID_ADDRESS;
4000b1a8: 81 c7 e0 08 ret
4000b1ac: 91 e8 20 09 restore %g0, 9, %o0
4000b1b0: 7f ff f2 d1 call 40007cf4 <_RTEMS_Unlock_allocator>
4000b1b4: b0 10 20 05 mov 5, %i0
return RTEMS_TOO_MANY;
4000b1b8: 81 c7 e0 08 ret
4000b1bc: 81 e8 00 00 restore
400047a4 <_RTEMS_tasks_Initialize_user_task>:
#include <rtems/score/assert.h>
#include <rtems/score/threadimpl.h>
#include <rtems/score/interr.h>
void _RTEMS_tasks_Initialize_user_task( void )
{
400047a4: 9d e3 bf 98 save %sp, -104, %sp
rtems_id id;
rtems_status_code return_value;
const rtems_initialization_tasks_table *user_task;
user_task = &_RTEMS_tasks_User_task_table;
return_value = rtems_task_create(
400047a8: 03 10 00 5e sethi %hi(0x40017800), %g1
400047ac: ba 10 60 6c or %g1, 0x6c, %i5 ! 4001786c <_RTEMS_tasks_User_task_table>
400047b0: d0 00 60 6c ld [ %g1 + 0x6c ], %o0
400047b4: d8 07 60 0c ld [ %i5 + 0xc ], %o4
400047b8: d6 07 60 14 ld [ %i5 + 0x14 ], %o3
400047bc: d4 07 60 04 ld [ %i5 + 4 ], %o2
400047c0: d2 07 60 08 ld [ %i5 + 8 ], %o1
400047c4: 40 00 0d 19 call 40007c28 <rtems_task_create>
400047c8: 9a 07 bf fc add %fp, -4, %o5
user_task->stack_size,
user_task->mode_set,
user_task->attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) ) {
400047cc: 80 a2 20 00 cmp %o0, 0
400047d0: 12 80 00 0b bne 400047fc <_RTEMS_tasks_Initialize_user_task+0x58>
400047d4: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_RTEMS_INIT_TASK_CREATE_FAILED );
}
return_value = rtems_task_start(
400047d8: d4 07 60 18 ld [ %i5 + 0x18 ], %o2
400047dc: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
400047e0: 40 00 00 0a call 40004808 <rtems_task_start>
400047e4: d0 07 bf fc ld [ %fp + -4 ], %o0
);
_Assert( rtems_is_status_successful( return_value ) );
(void) return_value;
_Assert( _Thread_Global_constructor == 0 );
_Thread_Global_constructor = id;
400047e8: c4 07 bf fc ld [ %fp + -4 ], %g2
400047ec: 03 10 00 72 sethi %hi(0x4001c800), %g1
400047f0: c4 20 60 18 st %g2, [ %g1 + 0x18 ] ! 4001c818 <_Thread_Global_constructor>
}
400047f4: 81 c7 e0 08 ret
400047f8: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_RTEMS_INIT_TASK_CREATE_FAILED );
400047fc: 40 00 00 70 call 400049bc <_Internal_error>
40004800: 90 10 20 20 mov 0x20, %o0
40004804: 01 00 00 00 nop <== NOT EXECUTED
40012e5c <_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
)
{
40012e5c: 9d e3 bf 98 save %sp, -104, %sp
*time = _Timecounter_Sbinuptime();
40012e60: 40 00 0e a2 call 400168e8 <_Timecounter_Sbinuptime>
40012e64: fa 06 20 54 ld [ %i0 + 0x54 ], %i5
*_result = *_end - *_start;
40012e68: d8 1e 20 60 ldd [ %i0 + 0x60 ], %o4
40012e6c: 86 a2 40 0d subcc %o1, %o5, %g3
40012e70: 84 62 00 0c subx %o0, %o4, %g2
40012e74: c4 3e 40 00 std %g2, [ %i1 ]
);
/*
* Determine cpu usage since period initiated.
*/
_Thread_Get_CPU_time_used( owning_thread, &used );
40012e78: 90 10 00 1d mov %i5, %o0
40012e7c: 40 00 19 78 call 4001945c <_Thread_Get_CPU_time_used>
40012e80: 92 07 bf f8 add %fp, -8, %o1
return *_lhs < *_rhs;
40012e84: c4 1e 20 58 ldd [ %i0 + 0x58 ], %g2
40012e88: f8 1f bf f8 ldd [ %fp + -8 ], %i4
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if ( _Timestamp_Less_than( &used, &the_period->cpu_usage_period_initiated ) )
40012e8c: 80 a0 80 1c cmp %g2, %i4
40012e90: 14 80 00 0e bg 40012ec8 <_Rate_monotonic_Get_status+0x6c> <== NEVER TAKEN
40012e94: b0 10 20 00 clr %i0
40012e98: 02 80 00 09 be 40012ebc <_Rate_monotonic_Get_status+0x60>
40012e9c: 80 a0 c0 1d cmp %g3, %i5
*_result = *_end - *_start;
40012ea0: 9a a7 40 03 subcc %i5, %g3, %o5
&the_period->cpu_usage_period_initiated,
&used,
cpu_since_last_period
);
return true;
40012ea4: b0 10 20 01 mov 1, %i0
40012ea8: 98 67 00 02 subx %i4, %g2, %o4
}
40012eac: b0 0e 20 01 and %i0, 1, %i0
40012eb0: d8 3e 80 00 std %o4, [ %i2 ]
40012eb4: 81 c7 e0 08 ret
40012eb8: 81 e8 00 00 restore
if ( _Timestamp_Less_than( &used, &the_period->cpu_usage_period_initiated ) )
40012ebc: 08 bf ff fa bleu 40012ea4 <_Rate_monotonic_Get_status+0x48>
40012ec0: 9a a7 40 03 subcc %i5, %g3, %o5
return false;
40012ec4: b0 10 20 00 clr %i0
}
40012ec8: b0 0e 20 01 and %i0, 1, %i0
40012ecc: 81 c7 e0 08 ret
40012ed0: 81 e8 00 00 restore
4000e394 <_Signal_Action_handler>:
void _Signal_Action_handler(
Thread_Control *executing,
Thread_Action *action,
ISR_lock_Context *lock_context
)
{
4000e394: 9d e3 bf 98 save %sp, -104, %sp
/*
* Signal Processing
*/
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4000e398: fa 06 21 58 ld [ %i0 + 0x158 ], %i5
ASR_Information *asr
)
{
rtems_signal_set signal_set;
signal_set = asr->signals_posted;
4000e39c: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
asr->signals_posted = 0;
4000e3a0: c0 27 60 14 clr [ %i5 + 0x14 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000e3a4: c2 06 80 00 ld [ %i2 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e3a8: 91 d0 20 0a ta 0xa
4000e3ac: 01 00 00 00 nop
asr = &api->Signal;
signal_set = _ASR_Get_posted_signals( asr );
_Thread_State_release( executing, lock_context );
if ( signal_set == 0 ) {
4000e3b0: 80 a7 20 00 cmp %i4, 0
4000e3b4: 32 80 00 04 bne,a 4000e3c4 <_Signal_Action_handler+0x30> <== ALWAYS TAKEN
4000e3b8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
(*asr->handler)( signal_set );
asr->nest_level -= 1;
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
}
4000e3bc: 81 c7 e0 08 ret <== NOT EXECUTED
4000e3c0: 81 e8 00 00 restore <== NOT EXECUTED
asr->nest_level += 1;
4000e3c4: 82 00 60 01 inc %g1
4000e3c8: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000e3cc: 94 07 bf fc add %fp, -4, %o2
4000e3d0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
4000e3d4: 37 00 00 3f sethi %hi(0xfc00), %i3
4000e3d8: 7f ff e5 1c call 40007848 <rtems_task_mode>
4000e3dc: 92 16 e3 ff or %i3, 0x3ff, %o1 ! ffff <_ISR_Stack_size+0xefff>
(*asr->handler)( signal_set );
4000e3e0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000e3e4: 9f c0 40 00 call %g1
4000e3e8: 90 10 00 1c mov %i4, %o0
asr->nest_level -= 1;
4000e3ec: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000e3f0: 82 00 7f ff add %g1, -1, %g1
4000e3f4: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000e3f8: 94 07 bf fc add %fp, -4, %o2
4000e3fc: d0 07 bf fc ld [ %fp + -4 ], %o0
4000e400: 7f ff e5 12 call 40007848 <rtems_task_mode>
4000e404: 92 16 e3 ff or %i3, 0x3ff, %o1
}
4000e408: 81 c7 e0 08 ret
4000e40c: 81 e8 00 00 restore
400053d4 <_TOD_Validate>:
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) ||
400053d4: 80 a2 20 00 cmp %o0, 0
400053d8: 02 80 00 3b be 400054c4 <_TOD_Validate+0xf0> <== NEVER TAKEN
400053dc: 07 10 00 4a sethi %hi(0x40012800), %g3
400053e0: c8 02 20 18 ld [ %o0 + 0x18 ], %g4
400053e4: 03 00 03 d0 sethi %hi(0xf4000), %g1
400053e8: 82 10 62 40 or %g1, 0x240, %g1 ! f4240 <_ISR_Stack_size+0xf3240>
400053ec: 81 80 20 00 wr %g0, %y
400053f0: da 00 e1 d8 ld [ %g3 + 0x1d8 ], %o5
400053f4: 01 00 00 00 nop
400053f8: 01 00 00 00 nop
400053fc: 9a 70 40 0d udiv %g1, %o5, %o5
40005400: 80 a1 00 0d cmp %g4, %o5
40005404: 1a 80 00 2e bcc 400054bc <_TOD_Validate+0xe8>
40005408: 84 10 20 00 clr %g2
(the_tod->ticks >= ticks_per_second) ||
4000540c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40005410: 80 a0 60 3b cmp %g1, 0x3b
40005414: 18 80 00 2a bgu 400054bc <_TOD_Validate+0xe8>
40005418: 01 00 00 00 nop
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
4000541c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40005420: 80 a0 60 3b cmp %g1, 0x3b
40005424: 18 80 00 26 bgu 400054bc <_TOD_Validate+0xe8>
40005428: 01 00 00 00 nop
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
4000542c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005430: 80 a0 60 17 cmp %g1, 0x17
40005434: 18 80 00 22 bgu 400054bc <_TOD_Validate+0xe8>
40005438: 01 00 00 00 nop
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
4000543c: c2 02 20 04 ld [ %o0 + 4 ], %g1
40005440: 86 00 7f ff add %g1, -1, %g3
40005444: 80 a0 e0 0b cmp %g3, 0xb
40005448: 18 80 00 1d bgu 400054bc <_TOD_Validate+0xe8>
4000544c: 01 00 00 00 nop
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
40005450: c6 02 00 00 ld [ %o0 ], %g3
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
40005454: 80 a0 e7 c3 cmp %g3, 0x7c3
40005458: 08 80 00 19 bleu 400054bc <_TOD_Validate+0xe8>
4000545c: 01 00 00 00 nop
(the_tod->day == 0) )
40005460: c8 02 20 08 ld [ %o0 + 8 ], %g4
(the_tod->year < TOD_BASE_YEAR) ||
40005464: 80 a1 20 00 cmp %g4, 0
40005468: 02 80 00 15 be 400054bc <_TOD_Validate+0xe8> <== NEVER TAKEN
4000546c: 80 88 e0 03 btst 3, %g3
return false;
if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) ||
40005470: 12 80 00 18 bne 400054d0 <_TOD_Validate+0xfc>
40005474: 05 30 a3 d7 sethi %hi(0xc28f5c00), %g2
40005478: 84 10 a0 29 or %g2, 0x29, %g2 ! c28f5c29 <RAM_END+0x824f5c29>
4000547c: 84 58 c0 02 smul %g3, %g2, %g2
40005480: 9b 30 a0 02 srl %g2, 2, %o5
40005484: 85 28 a0 1e sll %g2, 0x1e, %g2
40005488: 9a 13 40 02 or %o5, %g2, %o5
4000548c: 05 00 a3 d7 sethi %hi(0x28f5c00), %g2
40005490: 84 10 a0 28 or %g2, 0x28, %g2 ! 28f5c28 <RAM_SIZE+0x24f5c28>
40005494: 80 a3 40 02 cmp %o5, %g2
40005498: 08 80 00 0e bleu 400054d0 <_TOD_Validate+0xfc>
4000549c: 05 30 a3 d7 sethi %hi(0xc28f5c00), %g2
(the_tod->year % 400 == 0))
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
400054a0: 82 00 60 0d add %g1, 0xd, %g1
400054a4: 05 10 00 4c sethi %hi(0x40013000), %g2
400054a8: 83 28 60 02 sll %g1, 2, %g1
400054ac: 84 10 a2 08 or %g2, 0x208, %g2
400054b0: c2 00 80 01 ld [ %g2 + %g1 ], %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
if ( the_tod->day > days_in_month )
400054b4: 80 a0 40 04 cmp %g1, %g4
400054b8: 84 60 3f ff subx %g0, -1, %g2
return false;
return true;
}
400054bc: 81 c3 e0 08 retl
400054c0: 90 08 a0 01 and %g2, 1, %o0
return false;
400054c4: 84 10 20 00 clr %g2 <== NOT EXECUTED
}
400054c8: 81 c3 e0 08 retl <== NOT EXECUTED
400054cc: 90 08 a0 01 and %g2, 1, %o0 <== NOT EXECUTED
400054d0: 84 10 a0 29 or %g2, 0x29, %g2
400054d4: 86 58 c0 02 smul %g3, %g2, %g3
400054d8: 85 30 e0 04 srl %g3, 4, %g2
400054dc: 87 28 e0 1c sll %g3, 0x1c, %g3
400054e0: 86 10 80 03 or %g2, %g3, %g3
if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) ||
400054e4: 05 00 28 f5 sethi %hi(0xa3d400), %g2
400054e8: 84 10 a3 0a or %g2, 0x30a, %g2 ! a3d70a <RAM_SIZE+0x63d70a>
400054ec: 80 a0 c0 02 cmp %g3, %g2
400054f0: 28 bf ff ed bleu,a 400054a4 <_TOD_Validate+0xd0>
400054f4: 82 00 60 0d add %g1, 0xd, %g1
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
400054f8: 83 28 60 02 sll %g1, 2, %g1
400054fc: 05 10 00 4c sethi %hi(0x40013000), %g2
40005500: 84 10 a2 08 or %g2, 0x208, %g2 ! 40013208 <_TOD_Days_per_month>
40005504: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( the_tod->day > days_in_month )
40005508: 80 a0 40 04 cmp %g1, %g4
4000550c: 10 bf ff ec b 400054bc <_TOD_Validate+0xe8>
40005510: 84 60 3f ff subx %g0, -1, %g2
40004fe4 <rtems_clock_get_tod>:
}
rtems_status_code rtems_clock_get_tod(
rtems_time_of_day *time_buffer
)
{
40004fe4: 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 )
40004fe8: ba 96 20 00 orcc %i0, 0, %i5
40004fec: 02 80 00 aa be 40005294 <rtems_clock_get_tod+0x2b0>
40004ff0: 03 10 00 62 sethi %hi(0x40018800), %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set() )
40004ff4: c2 08 62 c8 ldub [ %g1 + 0x2c8 ], %g1 ! 40018ac8 <_TOD>
40004ff8: 80 a0 60 00 cmp %g1, 0
40004ffc: 02 80 00 70 be 400051bc <rtems_clock_get_tod+0x1d8>
40005000: b0 10 20 0b mov 0xb, %i0
*/
RTEMS_INLINE_ROUTINE void _TOD_Get_timeval(
struct timeval *time
)
{
_Timecounter_Microtime( time );
40005004: 40 00 05 20 call 40006484 <_Timecounter_Microtime>
40005008: 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;
4000500c: f4 1f bf f0 ldd [ %fp + -16 ], %i2
40005010: 94 10 20 00 clr %o2
40005014: 90 10 00 1a mov %i2, %o0
40005018: 92 10 00 1b mov %i3, %o1
4000501c: 17 00 00 54 sethi %hi(0x15000), %o3
40005020: 40 00 2b ee call 4000ffd8 <__divdi3>
40005024: 96 12 e1 80 or %o3, 0x180, %o3 ! 15180 <_ISR_Stack_size+0x14180>
day_secs = now.tv_sec % RTEMS_SECS_PER_DAY;
40005028: 90 10 00 1a mov %i2, %o0
days = now.tv_sec / RTEMS_SECS_PER_DAY;
4000502c: b8 10 00 09 mov %o1, %i4
day_secs = now.tv_sec % RTEMS_SECS_PER_DAY;
40005030: 94 10 20 00 clr %o2
40005034: 92 10 00 1b mov %i3, %o1
40005038: 17 00 00 54 sethi %hi(0x15000), %o3
4000503c: 40 00 2c 72 call 40010204 <__moddi3>
40005040: 96 12 e1 80 or %o3, 0x180, %o3 ! 15180 <_ISR_Stack_size+0x14180>
/* How many non-leap year years ? */
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
40005044: 03 19 c6 7c sethi %hi(0x6719f000), %g1
return (year / 4) - (year / 100) + (year / 400);
40005048: 07 14 7a e1 sethi %hi(0x51eb8400), %g3
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
4000504c: 82 10 63 61 or %g1, 0x361, %g1
return (year / 4) - (year / 100) + (year / 400);
40005050: 86 10 e1 1f or %g3, 0x11f, %g3
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
40005054: 80 57 00 01 umul %i4, %g1, %g0
40005058: 89 40 00 00 rd %y, %g4
4000505c: 84 27 00 04 sub %i4, %g4, %g2
40005060: 85 30 a0 01 srl %g2, 1, %g2
40005064: 88 01 00 02 add %g4, %g2, %g4
40005068: 89 31 20 08 srl %g4, 8, %g4
year -= 1;
4000506c: b4 01 27 b1 add %g4, 0x7b1, %i2
return (year / 4) - (year / 100) + (year / 400);
40005070: 80 56 80 03 umul %i2, %g3, %g0
40005074: 87 40 00 00 rd %y, %g3
40005078: b3 30 e0 05 srl %g3, 5, %i1
4000507c: 87 30 e0 07 srl %g3, 7, %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;
40005080: b6 07 00 19 add %i4, %i1, %i3
return (year / 4) - (year / 100) + (year / 400);
40005084: 85 36 a0 02 srl %i2, 2, %g2
40005088: 84 00 80 03 add %g2, %g3, %g2
4000508c: 84 00 be 23 add %g2, -477, %g2
year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR;
40005090: 86 26 c0 02 sub %i3, %g2, %g3
40005094: 80 50 c0 01 umul %g3, %g1, %g0
40005098: 83 40 00 00 rd %y, %g1
4000509c: b6 20 c0 01 sub %g3, %g1, %i3
400050a0: b7 36 e0 01 srl %i3, 1, %i3
return _Leap_years_before( to ) - _Leap_years_before( from + 1 );
400050a4: 84 20 80 19 sub %g2, %i1, %g2
year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR;
400050a8: 82 00 40 1b add %g1, %i3, %g1
/* Adjust the year and days in the year if in the leap year overflow. */
if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) {
400050ac: b6 59 21 6d smul %g4, 0x16d, %i3
year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR;
400050b0: 83 30 60 08 srl %g1, 8, %g1
if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) {
400050b4: b8 27 00 1b sub %i4, %i3, %i4
year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR;
400050b8: 82 58 61 6d smul %g1, 0x16d, %g1
if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) {
400050bc: 80 a7 00 02 cmp %i4, %g2
400050c0: 0a 80 00 41 bcs 400051c4 <rtems_clock_get_tod+0x1e0>
400050c4: 82 20 c0 01 sub %g3, %g1, %g1
year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE;
400050c8: b4 01 27 b2 add %g4, 0x7b2, %i2
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
400050cc: 86 0e a0 03 and %i2, 3, %g3
400050d0: 80 a0 e0 00 cmp %g3, 0
400050d4: 12 80 00 53 bne 40005220 <rtems_clock_get_tod+0x23c>
400050d8: f4 27 40 00 st %i2, [ %i5 ]
400050dc: 05 30 a3 d7 sethi %hi(0xc28f5c00), %g2
400050e0: 84 10 a0 29 or %g2, 0x29, %g2 ! c28f5c29 <RAM_END+0x824f5c29>
400050e4: 84 5e 80 02 smul %i2, %g2, %g2
400050e8: 87 30 a0 02 srl %g2, 2, %g3
400050ec: 85 28 a0 1e sll %g2, 0x1e, %g2
400050f0: 84 10 c0 02 or %g3, %g2, %g2
400050f4: 07 00 a3 d7 sethi %hi(0x28f5c00), %g3
400050f8: 86 10 e0 28 or %g3, 0x28, %g3 ! 28f5c28 <RAM_SIZE+0x24f5c28>
400050fc: 80 a0 80 03 cmp %g2, %g3
40005100: 08 80 00 49 bleu 40005224 <rtems_clock_get_tod+0x240>
40005104: 05 30 a3 d7 sethi %hi(0xc28f5c00), %g2
days_to_date = _TOD_Days_to_date[1];
40005108: 05 10 00 4c sethi %hi(0x40013000), %g2
4000510c: 84 10 a1 ec or %g2, 0x1ec, %g2 ! 400131ec <_TOD_Days_to_date+0x1a>
days_to_date += 2;
40005110: 84 00 a0 04 add %g2, 4, %g2
uint32_t month = 0;
40005114: 86 10 20 00 clr %g3
if (*day < *days_to_date)
40005118: c8 10 80 00 lduh [ %g2 ], %g4
4000511c: 80 a1 00 01 cmp %g4, %g1
40005120: 18 80 00 4e bgu 40005258 <rtems_clock_get_tod+0x274>
40005124: 86 00 e0 01 inc %g3
while (month < 11) {
40005128: 80 a0 e0 0b cmp %g3, 0xb
4000512c: 12 bf ff fb bne 40005118 <rtems_clock_get_tod+0x134>
40005130: 84 00 a0 02 add %g2, 2, %g2
40005134: 86 10 20 0c mov 0xc, %g3
}
}
time_buffer->year = year;
time_buffer->month = _Year_day_as_month( year, &year_days ) + 1;
time_buffer->day = year_days + 1;
40005138: 82 00 60 01 inc %g1
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR;
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE;
time_buffer->ticks = now.tv_usec /
4000513c: f4 07 bf f8 ld [ %fp + -8 ], %i2
time_buffer->day = year_days + 1;
40005140: 88 20 40 04 sub %g1, %g4, %g4
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
40005144: 05 24 68 ac sethi %hi(0x91a2b000), %g2
time_buffer->ticks = now.tv_usec /
40005148: 03 10 00 4a sethi %hi(0x40012800), %g1
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
4000514c: 84 10 a3 c5 or %g2, 0x3c5, %g2
40005150: 80 52 40 02 umul %o1, %g2, %g0
40005154: 85 40 00 00 rd %y, %g2
40005158: 85 30 a0 0b srl %g2, 0xb, %g2
time_buffer->ticks = now.tv_usec /
4000515c: 81 80 20 00 wr %g0, %y
40005160: f6 00 61 d8 ld [ %g1 + 0x1d8 ], %i3
40005164: 01 00 00 00 nop
40005168: 01 00 00 00 nop
4000516c: b6 76 80 1b udiv %i2, %i3, %i3
time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR;
40005170: b8 58 ae 10 smul %g2, 0xe10, %i4
time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR;
40005174: c4 27 60 0c st %g2, [ %i5 + 0xc ]
time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR;
40005178: 92 22 40 1c sub %o1, %i4, %o1
time_buffer->month = _Year_day_as_month( year, &year_days ) + 1;
4000517c: c6 27 60 04 st %g3, [ %i5 + 4 ]
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
40005180: 03 22 22 22 sethi %hi(0x88888800), %g1
time_buffer->day = year_days + 1;
40005184: c8 27 60 08 st %g4, [ %i5 + 8 ]
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
40005188: 82 10 60 89 or %g1, 0x89, %g1
time_buffer->ticks = now.tv_usec /
4000518c: f6 27 60 18 st %i3, [ %i5 + 0x18 ]
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
40005190: 80 52 40 01 umul %o1, %g1, %g0
40005194: 83 40 00 00 rd %y, %g1
40005198: 83 30 60 05 srl %g1, 5, %g1
time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE;
4000519c: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE;
400051a0: 85 28 60 04 sll %g1, 4, %g2
400051a4: 82 20 80 01 sub %g2, %g1, %g1
400051a8: 83 28 60 02 sll %g1, 2, %g1
400051ac: 92 22 40 01 sub %o1, %g1, %o1
400051b0: d2 27 60 14 st %o1, [ %i5 + 0x14 ]
rtems_configuration_get_microseconds_per_tick( );
return RTEMS_SUCCESSFUL;
400051b4: 81 c7 e0 08 ret
400051b8: 91 e8 20 00 restore %g0, 0, %o0
}
400051bc: 81 c7 e0 08 ret
400051c0: 81 e8 00 00 restore
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
400051c4: 05 30 a3 d7 sethi %hi(0xc28f5c00), %g2
400051c8: 86 8e a0 03 andcc %i2, 3, %g3
400051cc: 84 10 a0 29 or %g2, 0x29, %g2
400051d0: 12 80 00 24 bne 40005260 <rtems_clock_get_tod+0x27c>
400051d4: 84 5e 80 02 smul %i2, %g2, %g2
400051d8: 89 28 a0 1e sll %g2, 0x1e, %g4
400051dc: b9 30 a0 02 srl %g2, 2, %i4
400051e0: b8 17 00 04 or %i4, %g4, %i4
400051e4: 09 00 a3 d7 sethi %hi(0x28f5c00), %g4
400051e8: 88 11 20 28 or %g4, 0x28, %g4 ! 28f5c28 <RAM_SIZE+0x24f5c28>
400051ec: 80 a7 00 04 cmp %i4, %g4
400051f0: 38 bf ff b8 bgu,a 400050d0 <rtems_clock_get_tod+0xec>
400051f4: 82 00 60 01 inc %g1
400051f8: 89 30 a0 04 srl %g2, 4, %g4
400051fc: 85 28 a0 1c sll %g2, 0x1c, %g2
40005200: 84 11 00 02 or %g4, %g2, %g2
40005204: 09 00 28 f5 sethi %hi(0xa3d400), %g4
40005208: 88 11 23 0a or %g4, 0x30a, %g4 ! a3d70a <RAM_SIZE+0x63d70a>
4000520c: 80 a0 80 04 cmp %g2, %g4
40005210: 28 bf ff b0 bleu,a 400050d0 <rtems_clock_get_tod+0xec>
40005214: 82 00 60 01 inc %g1
time_buffer->year = year;
40005218: 10 bf ff b1 b 400050dc <rtems_clock_get_tod+0xf8>
4000521c: f4 27 40 00 st %i2, [ %i5 ]
40005220: 05 30 a3 d7 sethi %hi(0xc28f5c00), %g2
40005224: 84 10 a0 29 or %g2, 0x29, %g2 ! c28f5c29 <RAM_END+0x824f5c29>
40005228: 84 5e 80 02 smul %i2, %g2, %g2
4000522c: 87 30 a0 04 srl %g2, 4, %g3
40005230: 85 28 a0 1c sll %g2, 0x1c, %g2
40005234: 84 10 c0 02 or %g3, %g2, %g2
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
40005238: 07 00 28 f5 sethi %hi(0xa3d400), %g3
4000523c: 86 10 e3 0a or %g3, 0x30a, %g3 ! a3d70a <RAM_SIZE+0x63d70a>
40005240: 80 a0 80 03 cmp %g2, %g3
40005244: 28 bf ff b2 bleu,a 4000510c <rtems_clock_get_tod+0x128>
40005248: 05 10 00 4c sethi %hi(0x40013000), %g2
days_to_date = _TOD_Days_to_date[0];
4000524c: 05 10 00 4c sethi %hi(0x40013000), %g2
40005250: 10 bf ff b0 b 40005110 <rtems_clock_get_tod+0x12c>
40005254: 84 10 a1 d2 or %g2, 0x1d2, %g2 ! 400131d2 <_TOD_Days_to_date>
*day -= *(days_to_date - 1);
40005258: 10 bf ff b8 b 40005138 <rtems_clock_get_tod+0x154>
4000525c: c8 10 bf fe lduh [ %g2 + -2 ], %g4
time_buffer->year = year;
40005260: 89 30 a0 04 srl %g2, 4, %g4
40005264: 85 28 a0 1c sll %g2, 0x1c, %g2
40005268: 84 11 00 02 or %g4, %g2, %g2
return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0);
4000526c: 09 00 28 f5 sethi %hi(0xa3d400), %g4
40005270: 88 11 23 0a or %g4, 0x30a, %g4 ! a3d70a <RAM_SIZE+0x63d70a>
40005274: 80 a0 80 04 cmp %g2, %g4
40005278: 18 80 00 04 bgu 40005288 <rtems_clock_get_tod+0x2a4> <== ALWAYS TAKEN
4000527c: 05 10 00 4c sethi %hi(0x40013000), %g2
year_days += 1;
40005280: 10 bf ff 94 b 400050d0 <rtems_clock_get_tod+0xec>
40005284: 82 00 60 01 inc %g1
time_buffer->year = year;
40005288: f4 27 40 00 st %i2, [ %i5 ]
days_to_date = _TOD_Days_to_date[0];
4000528c: 10 bf ff a1 b 40005110 <rtems_clock_get_tod+0x12c>
40005290: 84 10 a1 d2 or %g2, 0x1d2, %g2
return RTEMS_INVALID_ADDRESS;
40005294: 81 c7 e0 08 ret
40005298: 91 e8 20 09 restore %g0, 9, %o0
40005464 <rtems_clock_tick>:
#include <rtems/rtems/clock.h>
#include <rtems/score/timecounter.h>
#include <rtems/score/threadimpl.h>
rtems_status_code rtems_clock_tick( void )
{
40005464: 9d e3 bf 98 save %sp, -104, %sp
40005468: 91 d0 20 09 ta 9
ISR_lock_Context lock_context;
_Timecounter_Acquire( &lock_context );
4000546c: c2 27 bf fc st %g1, [ %fp + -4 ]
_Timecounter_Tick_simple(
40005470: 03 10 00 49 sethi %hi(0x40012400), %g1
40005474: d0 00 61 5c ld [ %g1 + 0x15c ], %o0 ! 4001255c <_Watchdog_Microseconds_per_tick>
40005478: 94 07 bf fc add %fp, -4, %o2
4000547c: 40 00 05 f8 call 40006c5c <_Timecounter_Tick_simple>
40005480: 92 10 20 00 clr %o1
40005484: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
rtems_configuration_get_microseconds_per_tick(),
0,
&lock_context
);
if ( _Thread_Dispatch_is_enabled() ) {
40005488: 80 a0 60 00 cmp %g1, 0
4000548c: 02 80 00 04 be 4000549c <rtems_clock_tick+0x38> <== ALWAYS TAKEN
40005490: 01 00 00 00 nop
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
40005494: 81 c7 e0 08 ret <== NOT EXECUTED
40005498: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
_Thread_Dispatch();
4000549c: 40 00 09 30 call 4000795c <_Thread_Dispatch>
400054a0: b0 10 20 00 clr %i0
}
400054a4: 81 c7 e0 08 ret
400054a8: 81 e8 00 00 restore
400057e4 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
400057e4: 9d e3 bf a0 save %sp, -96, %sp
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
400057e8: 80 a6 a0 00 cmp %i2, 0
400057ec: 02 80 00 25 be 40005880 <rtems_object_get_class_information+0x9c>
400057f0: b3 2e 60 10 sll %i1, 0x10, %i1
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
400057f4: 90 10 00 18 mov %i0, %o0
400057f8: 40 00 04 67 call 40006994 <_Objects_Get_information>
400057fc: 93 36 60 10 srl %i1, 0x10, %o1
if ( !obj_info )
40005800: 80 a2 20 00 cmp %o0, 0
40005804: 02 80 00 21 be 40005888 <rtems_object_get_class_information+0xa4>
40005808: 05 00 00 3f sethi %hi(0xfc00), %g2
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = _Objects_Get_minimum_id( obj_info->maximum_id );
4000580c: c6 02 00 00 ld [ %o0 ], %g3
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Is_auto_extend(
const Objects_Information *information
)
{
return information->objects_per_block != 0;
40005810: c2 12 20 12 lduh [ %o0 + 0x12 ], %g1
40005814: 80 a0 00 01 cmp %g0, %g1
40005818: 88 40 20 00 addx %g0, 0, %g4
id &= ~OBJECTS_INDEX_MASK;
4000581c: 03 3f ff c0 sethi %hi(0xffff0000), %g1
40005820: 84 10 a3 ff or %g2, 0x3ff, %g2
40005824: 82 08 c0 01 and %g3, %g1, %g1
return id;
40005828: 84 08 c0 02 and %g3, %g2, %g2
id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT;
4000582c: 82 00 60 01 inc %g1
info->maximum_id = obj_info->maximum_id;
40005830: c6 26 a0 04 st %g3, [ %i2 + 4 ]
info->auto_extend = _Objects_Is_auto_extend( obj_info );
info->maximum = _Objects_Get_maximum_index( obj_info );
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
40005834: 80 a0 a0 00 cmp %g2, 0
info->minimum_id = _Objects_Get_minimum_id( obj_info->maximum_id );
40005838: c2 26 80 00 st %g1, [ %i2 ]
return information->objects_per_block != 0;
4000583c: c8 2e a0 0c stb %g4, [ %i2 + 0xc ]
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
40005840: 02 80 00 0d be 40005874 <rtems_object_get_class_information+0x90> <== NEVER TAKEN
40005844: c4 26 a0 08 st %g2, [ %i2 + 8 ]
40005848: c2 02 20 04 ld [ %o0 + 4 ], %g1
4000584c: 89 28 a0 02 sll %g2, 2, %g4
40005850: 84 10 20 00 clr %g2
40005854: 88 01 00 01 add %g4, %g1, %g4
if ( !obj_info->local_table[i] )
40005858: c6 00 60 04 ld [ %g1 + 4 ], %g3
unallocated++;
4000585c: 80 a0 00 03 cmp %g0, %g3
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
40005860: 82 00 60 04 add %g1, 4, %g1
unallocated++;
40005864: 84 60 bf ff subx %g2, -1, %g2
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
40005868: 80 a0 40 04 cmp %g1, %g4
4000586c: 32 bf ff fc bne,a 4000585c <rtems_object_get_class_information+0x78>
40005870: c6 00 60 04 ld [ %g1 + 4 ], %g3
info->unallocated = unallocated;
40005874: c4 26 a0 10 st %g2, [ %i2 + 0x10 ]
return RTEMS_SUCCESSFUL;
40005878: 81 c7 e0 08 ret
4000587c: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_INVALID_ADDRESS;
40005880: 81 c7 e0 08 ret
40005884: 91 e8 20 09 restore %g0, 9, %o0
}
40005888: 81 c7 e0 08 ret
4000588c: 91 e8 20 0a restore %g0, 0xa, %o0
40004368 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
40004368: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *information;
Objects_Control *the_object;
Objects_Id tmpId;
Status_Control status;
if ( !name )
4000436c: 80 a6 60 00 cmp %i1, 0
40004370: 02 80 00 22 be 400043f8 <rtems_object_set_name+0x90>
40004374: 80 a6 20 00 cmp %i0, 0
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? rtems_task_self() : id;
40004378: 02 80 00 16 be 400043d0 <rtems_object_set_name+0x68>
4000437c: 01 00 00 00 nop
information = _Objects_Get_information_id( tmpId );
40004380: 40 00 02 81 call 40004d84 <_Objects_Get_information_id>
40004384: 90 10 00 18 mov %i0, %o0
if ( !information )
40004388: ba 92 20 00 orcc %o0, 0, %i5
4000438c: 02 80 00 19 be 400043f0 <rtems_object_set_name+0x88>
40004390: 01 00 00 00 nop
*
* @see _Objects_Allocator_unlock() and _Objects_Allocate().
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void )
{
_RTEMS_Lock_allocator();
40004394: 40 00 00 6d call 40004548 <_RTEMS_Lock_allocator>
40004398: 01 00 00 00 nop
return RTEMS_INVALID_ID;
_Objects_Allocator_lock();
the_object = _Objects_Get_no_protection( tmpId, information );
4000439c: 92 10 00 1d mov %i5, %o1
400043a0: 40 00 02 d4 call 40004ef0 <_Objects_Get_no_protection>
400043a4: 90 10 00 18 mov %i0, %o0
if ( the_object == NULL ) {
400043a8: 92 92 20 00 orcc %o0, 0, %o1
400043ac: 02 80 00 15 be 40004400 <rtems_object_set_name+0x98>
400043b0: 94 10 00 19 mov %i1, %o2
_Objects_Allocator_unlock();
return RTEMS_INVALID_ID;
}
status = _Objects_Set_name( information, the_object, name );
400043b4: 40 00 02 dd call 40004f28 <_Objects_Set_name>
400043b8: 90 10 00 1d mov %i5, %o0
* previous thread life protection state and thus may not return if the
* executing thread was restarted or deleted in the mean-time.
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void )
{
_RTEMS_Unlock_allocator();
400043bc: 40 00 00 68 call 4000455c <_RTEMS_Unlock_allocator>
400043c0: b0 10 00 08 mov %o0, %i0
_Objects_Allocator_unlock();
return STATUS_GET_CLASSIC( status );
400043c4: b0 0e 20 ff and %i0, 0xff, %i0
400043c8: 81 c7 e0 08 ret
400043cc: 81 e8 00 00 restore
tmpId = (id == OBJECTS_ID_OF_SELF) ? rtems_task_self() : id;
400043d0: 40 00 00 2a call 40004478 <rtems_task_self>
400043d4: 01 00 00 00 nop
400043d8: b0 10 00 08 mov %o0, %i0
information = _Objects_Get_information_id( tmpId );
400043dc: 40 00 02 6a call 40004d84 <_Objects_Get_information_id>
400043e0: 90 10 00 18 mov %i0, %o0
if ( !information )
400043e4: ba 92 20 00 orcc %o0, 0, %i5
400043e8: 12 bf ff eb bne 40004394 <rtems_object_set_name+0x2c> <== ALWAYS TAKEN
400043ec: 01 00 00 00 nop
}
400043f0: 81 c7 e0 08 ret
400043f4: 91 e8 20 04 restore %g0, 4, %o0
return RTEMS_INVALID_ADDRESS;
400043f8: 81 c7 e0 08 ret
400043fc: 91 e8 20 09 restore %g0, 9, %o0
40004400: 40 00 00 57 call 4000455c <_RTEMS_Unlock_allocator>
40004404: b0 10 20 04 mov 4, %i0
return RTEMS_INVALID_ID;
40004408: 81 c7 e0 08 ret
4000440c: 81 e8 00 00 restore
4000f0b4 <rtems_partition_create>:
{
4000f0b4: 9d e3 bf a0 save %sp, -96, %sp
4000f0b8: a0 10 00 18 mov %i0, %l0
if ( !rtems_is_name_valid( name ) ) {
4000f0bc: 80 a4 20 00 cmp %l0, 0
4000f0c0: 02 80 00 31 be 4000f184 <rtems_partition_create+0xd0>
4000f0c4: b0 10 20 03 mov 3, %i0
if ( starting_address == NULL ) {
4000f0c8: 80 a7 60 00 cmp %i5, 0
4000f0cc: 02 80 00 30 be 4000f18c <rtems_partition_create+0xd8> <== NEVER TAKEN
4000f0d0: 80 a6 60 00 cmp %i1, 0
4000f0d4: 02 80 00 2e be 4000f18c <rtems_partition_create+0xd8>
4000f0d8: 80 a0 00 1a cmp %g0, %i2
if ( length == 0 )
4000f0dc: 84 60 3f ff subx %g0, -1, %g2
if ( buffer_size == 0 )
4000f0e0: 80 a6 e0 08 cmp %i3, 8
4000f0e4: 82 40 20 00 addx %g0, 0, %g1
if ( length < buffer_size )
4000f0e8: 80 90 80 01 orcc %g2, %g1, %g0
4000f0ec: 12 80 00 26 bne 4000f184 <rtems_partition_create+0xd0>
4000f0f0: b0 10 20 08 mov 8, %i0
4000f0f4: 80 a6 80 1b cmp %i2, %i3
4000f0f8: 0a 80 00 23 bcs 4000f184 <rtems_partition_create+0xd0>
4000f0fc: 80 8e e0 03 btst 3, %i3
if ( buffer_size < sizeof( Chain_Node ) )
4000f100: 12 80 00 27 bne 4000f19c <rtems_partition_create+0xe8> <== NEVER TAKEN
4000f104: 01 00 00 00 nop
if ( (uintptr_t) starting_address % CPU_SIZEOF_POINTER != 0 ) {
4000f108: b0 8e 60 03 andcc %i1, 3, %i0
4000f10c: 12 80 00 20 bne 4000f18c <rtems_partition_create+0xd8>
4000f110: 25 10 00 fc sethi %hi(0x4003f000), %l2
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
4000f114: 40 00 0a 16 call 4001196c <_Objects_Allocate>
4000f118: 90 14 a2 34 or %l2, 0x234, %o0 ! 4003f234 <_Partition_Information>
if ( !the_partition ) {
4000f11c: a2 92 20 00 orcc %o0, 0, %l1
4000f120: 02 80 00 1d be 4000f194 <rtems_partition_create+0xe0>
4000f124: 96 10 00 1b mov %i3, %o3
the_partition->starting_address = starting_address;
4000f128: f2 24 60 10 st %i1, [ %l1 + 0x10 ]
the_partition->length = length;
4000f12c: f4 24 60 14 st %i2, [ %l1 + 0x14 ]
_Chain_Initialize(
4000f130: 81 80 20 00 wr %g0, %y
4000f134: 01 00 00 00 nop
4000f138: 01 00 00 00 nop
4000f13c: 01 00 00 00 nop
4000f140: 94 76 80 1b udiv %i2, %i3, %o2
the_partition->buffer_size = buffer_size;
4000f144: f6 24 60 18 st %i3, [ %l1 + 0x18 ]
_Chain_Initialize(
4000f148: 92 10 00 19 mov %i1, %o1
the_partition->attribute_set = attribute_set;
4000f14c: f8 24 60 1c st %i4, [ %l1 + 0x1c ]
_Chain_Initialize(
4000f150: 90 04 60 24 add %l1, 0x24, %o0
the_partition->number_of_used_blocks = 0;
4000f154: c0 24 60 20 clr [ %l1 + 0x20 ]
_Chain_Initialize(
4000f158: 40 00 02 f2 call 4000fd20 <_Chain_Initialize>
4000f15c: a4 14 a2 34 or %l2, 0x234, %l2
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000f160: c2 14 60 0a lduh [ %l1 + 0xa ], %g1
the_object->name = name;
4000f164: e0 24 60 0c st %l0, [ %l1 + 0xc ]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000f168: 83 28 60 02 sll %g1, 2, %g1
4000f16c: c6 04 a0 04 ld [ %l2 + 4 ], %g3
4000f170: c4 04 60 08 ld [ %l1 + 8 ], %g2
4000f174: 82 00 7f fc add %g1, -4, %g1
4000f178: e2 20 c0 01 st %l1, [ %g3 + %g1 ]
_RTEMS_Unlock_allocator();
4000f17c: 40 00 02 cc call 4000fcac <_RTEMS_Unlock_allocator>
4000f180: c4 27 40 00 st %g2, [ %i5 ]
return RTEMS_SUCCESSFUL;
4000f184: 81 c7 e0 08 ret
4000f188: 81 e8 00 00 restore
}
4000f18c: 81 c7 e0 08 ret
4000f190: 91 e8 20 09 restore %g0, 9, %o0
4000f194: 40 00 02 c6 call 4000fcac <_RTEMS_Unlock_allocator>
4000f198: b0 10 20 05 mov 5, %i0
return RTEMS_TOO_MANY;
4000f19c: 81 c7 e0 08 ret
4000f1a0: 81 e8 00 00 restore
40004c38 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
40004c38: 9d e3 bf 98 save %sp, -104, %sp
40004c3c: 15 10 00 4d sethi %hi(0x40013400), %o2
40004c40: 92 07 bf fc add %fp, -4, %o1
40004c44: 94 12 a0 04 or %o2, 4, %o2
40004c48: 40 00 02 fa call 40005830 <_Objects_Get>
40004c4c: 90 10 00 18 mov %i0, %o0
Partition_Control *the_partition;
ISR_lock_Context lock_context;
the_partition = _Partition_Get( id, &lock_context );
if ( the_partition == NULL ) {
40004c50: 80 a2 20 00 cmp %o0, 0
40004c54: 02 80 00 27 be 40004cf0 <rtems_partition_return_buffer+0xb8>
40004c58: 01 00 00 00 nop
starting = the_partition->starting_address;
40004c5c: f0 02 20 10 ld [ %o0 + 0x10 ], %i0
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
40004c60: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40004c64: 82 06 00 01 add %i0, %g1, %g1
&& _Partition_Is_address_on_buffer_boundary( the_partition, the_buffer );
40004c68: 80 a6 40 01 cmp %i1, %g1
40004c6c: 18 80 00 0f bgu 40004ca8 <rtems_partition_return_buffer+0x70>
40004c70: 80 a6 40 18 cmp %i1, %i0
40004c74: 0a 80 00 0d bcs 40004ca8 <rtems_partition_return_buffer+0x70> <== NEVER TAKEN
40004c78: 01 00 00 00 nop
return ( offset % the_partition->buffer_size ) == 0;
40004c7c: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
RTEMS_INLINE_ROUTINE intptr_t _Addresses_Subtract(
const void *left,
const void *right
)
{
return (intptr_t) ( (const char *) left - (const char *) right );
40004c80: b0 26 40 18 sub %i1, %i0, %i0
40004c84: 81 80 20 00 wr %g0, %y
40004c88: 01 00 00 00 nop
40004c8c: 01 00 00 00 nop
40004c90: 01 00 00 00 nop
40004c94: 82 76 00 02 udiv %i0, %g2, %g1
40004c98: 82 58 40 02 smul %g1, %g2, %g1
&& _Partition_Is_address_on_buffer_boundary( the_partition, the_buffer );
40004c9c: b0 a6 00 01 subcc %i0, %g1, %i0
40004ca0: 22 80 00 07 be,a 40004cbc <rtems_partition_return_buffer+0x84>
40004ca4: c4 02 20 2c ld [ %o0 + 0x2c ], %g2
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40004ca8: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004cac: 91 d0 20 0a ta 0xa
40004cb0: 01 00 00 00 nop
_Partition_Acquire_critical( the_partition, &lock_context );
if ( !_Partition_Is_address_a_buffer_begin( the_partition, buffer ) ) {
_Partition_Release( the_partition, &lock_context );
return RTEMS_INVALID_ADDRESS;
40004cb4: 81 c7 e0 08 ret
40004cb8: 91 e8 20 09 restore %g0, 9, %o0
return &the_chain->Tail.Node;
40004cbc: 82 02 20 28 add %o0, 0x28, %g1
the_node->next = tail;
40004cc0: c2 26 40 00 st %g1, [ %i1 ]
tail->previous = the_node;
40004cc4: f2 22 20 2c st %i1, [ %o0 + 0x2c ]
old_last->next = the_node;
40004cc8: f2 20 80 00 st %i1, [ %g2 ]
}
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
40004ccc: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
the_node->previous = old_last;
40004cd0: c4 26 60 04 st %g2, [ %i1 + 4 ]
40004cd4: 82 00 7f ff add %g1, -1, %g1
40004cd8: c2 22 20 20 st %g1, [ %o0 + 0x20 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40004cdc: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004ce0: 91 d0 20 0a ta 0xa
40004ce4: 01 00 00 00 nop
_Partition_Release( the_partition, &lock_context );
return RTEMS_SUCCESSFUL;
}
40004ce8: 81 c7 e0 08 ret
40004cec: 81 e8 00 00 restore
return RTEMS_INVALID_ID;
40004cf0: 81 c7 e0 08 ret
40004cf4: 91 e8 20 04 restore %g0, 4, %o0
40012ed4 <rtems_rate_monotonic_report_statistics_with_plugin>:
#define NANOSECONDS_FMT "%06ld"
void rtems_rate_monotonic_report_statistics_with_plugin(
const rtems_printer *printer
)
{
40012ed4: 9d e3 be d8 save %sp, -296, %sp
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" );
40012ed8: 13 10 02 17 sethi %hi(0x40085c00), %o1
40012edc: 90 10 00 18 mov %i0, %o0
40012ee0: 7f ff c4 aa call 40004188 <rtems_printf>
40012ee4: 92 12 61 a0 or %o1, 0x1a0, %o1
rtems_printf( printer, "--- CPU times are in seconds ---\n" );
40012ee8: 90 10 00 18 mov %i0, %o0
40012eec: 13 10 02 17 sethi %hi(0x40085c00), %o1
40012ef0: 7f ff c4 a6 call 40004188 <rtems_printf>
40012ef4: 92 12 61 c0 or %o1, 0x1c0, %o1 ! 40085dc0 <_TOD_Days_per_month+0x8c>
rtems_printf( printer, "--- Wall times are in seconds ---\n" );
40012ef8: 90 10 00 18 mov %i0, %o0
40012efc: 13 10 02 17 sethi %hi(0x40085c00), %o1
40012f00: 7f ff c4 a2 call 40004188 <rtems_printf>
40012f04: 92 12 61 e8 or %o1, 0x1e8, %o1 ! 40085de8 <_TOD_Days_per_month+0xb4>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
rtems_printf( printer,
40012f08: 90 10 00 18 mov %i0, %o0
40012f0c: 13 10 02 17 sethi %hi(0x40085c00), %o1
40012f10: 7f ff c4 9e call 40004188 <rtems_printf>
40012f14: 92 12 62 10 or %o1, 0x210, %o1 ! 40085e10 <_TOD_Days_per_month+0xdc>
/*
* 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.
*/
maximum_id = _Rate_monotonic_Information.maximum_id;
40012f18: 03 10 02 4c sethi %hi(0x40093000), %g1
40012f1c: f6 00 63 74 ld [ %g1 + 0x374 ], %i3 ! 40093374 <_Rate_monotonic_Information>
id &= ~OBJECTS_INDEX_MASK;
40012f20: 3b 3f ff c0 sethi %hi(0xffff0000), %i5
40012f24: ba 0e c0 1d and %i3, %i5, %i5
id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT;
40012f28: ba 07 60 01 inc %i5
for (
40012f2c: 80 a6 c0 1d cmp %i3, %i5
40012f30: 0a 80 00 74 bcs 40013100 <rtems_rate_monotonic_report_statistics_with_plugin+0x22c><== NEVER TAKEN
40012f34: 35 10 02 17 sethi %hi(0x40085c00), %i2
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,
40012f38: 39 04 18 93 sethi %hi(0x10624c00), %i4
40012f3c: 21 10 02 17 sethi %hi(0x40085c00), %l0
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,
40012f40: 33 10 02 17 sethi %hi(0x40085c00), %i1
rtems_printf( printer, "\n" );
40012f44: 23 10 02 3c sethi %hi(0x4008f000), %l1
rtems_printf( printer,
40012f48: b4 16 a2 a8 or %i2, 0x2a8, %i2
rtems_printf( printer,
40012f4c: b8 17 21 d3 or %i4, 0x1d3, %i4
40012f50: a0 14 22 c0 or %l0, 0x2c0, %l0
rtems_printf( printer,
40012f54: b2 16 62 e8 or %i1, 0x2e8, %i1
rtems_printf( printer, "\n" );
40012f58: 10 80 00 4a b 40013080 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ac>
40012f5c: a2 14 63 88 or %l1, 0x388, %l1
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
40012f60: 40 00 21 4c call 4001b490 <_Timespec_Divide_by_integer>
40012f64: 01 00 00 00 nop
rtems_printf( printer,
40012f68: c2 07 bf 60 ld [ %fp + -160 ], %g1
40012f6c: 89 38 60 1f sra %g1, 0x1f, %g4
40012f70: c6 07 bf b8 ld [ %fp + -72 ], %g3
40012f74: 80 58 40 1c smul %g1, %i4, %g0
40012f78: 85 40 00 00 rd %y, %g2
40012f7c: 85 38 a0 06 sra %g2, 6, %g2
40012f80: 84 20 80 04 sub %g2, %g4, %g2
40012f84: 80 58 c0 1c smul %g3, %i4, %g0
40012f88: 83 40 00 00 rd %y, %g1
40012f8c: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
40012f90: 87 38 e0 1f sra %g3, 0x1f, %g3
40012f94: c4 07 bf 58 ld [ %fp + -168 ], %g2
40012f98: 83 38 60 06 sra %g1, 6, %g1
40012f9c: 82 20 40 03 sub %g1, %g3, %g1
40012fa0: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
40012fa4: 92 10 00 10 mov %l0, %o1
40012fa8: c4 07 bf 5c ld [ %fp + -164 ], %g2
40012fac: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40012fb0: 90 10 00 18 mov %i0, %o0
40012fb4: c2 07 bf b4 ld [ %fp + -76 ], %g1
40012fb8: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40012fbc: d8 07 bf a8 ld [ %fp + -88 ], %o4
40012fc0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40012fc4: 80 5b 00 1c smul %o4, %i4, %g0
40012fc8: 83 40 00 00 rd %y, %g1
40012fcc: d4 1f bf a0 ldd [ %fp + -96 ], %o2
40012fd0: 83 38 60 06 sra %g1, 6, %g1
40012fd4: da 07 bf b0 ld [ %fp + -80 ], %o5
40012fd8: 99 3b 20 1f sra %o4, 0x1f, %o4
40012fdc: 7f ff c4 6b call 40004188 <rtems_printf>
40012fe0: 98 20 40 0c sub %g1, %o4, %o4
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
40012fe4: d2 07 bf 98 ld [ %fp + -104 ], %o1
40012fe8: 94 07 bf 58 add %fp, -168, %o2
40012fec: 40 00 21 29 call 4001b490 <_Timespec_Divide_by_integer>
40012ff0: 90 07 bf f0 add %fp, -16, %o0
rtems_printf( printer,
40012ff4: c2 07 bf 60 ld [ %fp + -160 ], %g1
40012ff8: c6 07 bf e8 ld [ %fp + -24 ], %g3
40012ffc: 80 58 40 1c smul %g1, %i4, %g0
40013000: 85 40 00 00 rd %y, %g2
40013004: 89 38 60 1f sra %g1, 0x1f, %g4
40013008: 85 38 a0 06 sra %g2, 6, %g2
4001300c: 84 20 80 04 sub %g2, %g4, %g2
40013010: 80 58 c0 1c smul %g3, %i4, %g0
40013014: 83 40 00 00 rd %y, %g1
40013018: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
4001301c: 83 38 60 06 sra %g1, 6, %g1
40013020: c4 07 bf 58 ld [ %fp + -168 ], %g2
40013024: 87 38 e0 1f sra %g3, 0x1f, %g3
40013028: 82 20 40 03 sub %g1, %g3, %g1
4001302c: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
40013030: 92 10 00 19 mov %i1, %o1
40013034: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40013038: 90 10 00 18 mov %i0, %o0
4001303c: c2 07 bf e4 ld [ %fp + -28 ], %g1
40013040: c4 07 bf 5c ld [ %fp + -164 ], %g2
40013044: d8 07 bf d8 ld [ %fp + -40 ], %o4
40013048: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4001304c: 80 5b 00 1c smul %o4, %i4, %g0
40013050: 83 40 00 00 rd %y, %g1
40013054: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
40013058: 83 38 60 06 sra %g1, 6, %g1
4001305c: da 07 bf e0 ld [ %fp + -32 ], %o5
40013060: d4 1f bf d0 ldd [ %fp + -48 ], %o2
40013064: 99 3b 20 1f sra %o4, 0x1f, %o4
40013068: 7f ff c4 48 call 40004188 <rtems_printf>
4001306c: 98 20 40 0c sub %g1, %o4, %o4
++id
40013070: ba 07 60 01 inc %i5
for (
40013074: 80 a6 c0 1d cmp %i3, %i5
40013078: 0a 80 00 22 bcs 40013100 <rtems_rate_monotonic_report_statistics_with_plugin+0x22c>
4001307c: 01 00 00 00 nop
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
40013080: 92 07 bf 98 add %fp, -104, %o1
40013084: 7f ff fe eb call 40012c30 <rtems_rate_monotonic_get_statistics>
40013088: 90 10 00 1d mov %i5, %o0
(void) rtems_rate_monotonic_get_status( id, &the_status );
4001308c: 92 07 bf 68 add %fp, -152, %o1
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
40013090: 82 10 00 08 mov %o0, %g1
if ( status != RTEMS_SUCCESSFUL )
40013094: 80 a0 60 00 cmp %g1, 0
40013098: 12 bf ff f6 bne 40013070 <rtems_rate_monotonic_report_statistics_with_plugin+0x19c>
4001309c: 90 10 00 1d mov %i5, %o0
(void) rtems_rate_monotonic_get_status( id, &the_status );
400130a0: 7f ff ff 2e call 40012d58 <rtems_rate_monotonic_get_status>
400130a4: 01 00 00 00 nop
rtems_object_get_name( the_status.owner, sizeof(name), name );
400130a8: d0 07 bf 68 ld [ %fp + -152 ], %o0
400130ac: 94 07 bf 50 add %fp, -176, %o2
400130b0: 40 00 00 41 call 400131b4 <rtems_object_get_name>
400130b4: 92 10 20 05 mov 5, %o1
rtems_printf( printer,
400130b8: d8 1f bf 98 ldd [ %fp + -104 ], %o4
400130bc: 94 10 00 1d mov %i5, %o2
400130c0: 92 10 00 1a mov %i2, %o1
400130c4: 96 07 bf 50 add %fp, -176, %o3
400130c8: 7f ff c4 30 call 40004188 <rtems_printf>
400130cc: 90 10 00 18 mov %i0, %o0
if (the_stats.count == 0) {
400130d0: d2 07 bf 98 ld [ %fp + -104 ], %o1
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
400130d4: 94 07 bf 58 add %fp, -168, %o2
if (the_stats.count == 0) {
400130d8: 80 a2 60 00 cmp %o1, 0
400130dc: 12 bf ff a1 bne 40012f60 <rtems_rate_monotonic_report_statistics_with_plugin+0x8c>
400130e0: 90 07 bf c0 add %fp, -64, %o0
rtems_printf( printer, "\n" );
400130e4: 92 10 00 11 mov %l1, %o1
400130e8: 7f ff c4 28 call 40004188 <rtems_printf>
400130ec: 90 10 00 18 mov %i0, %o0
++id
400130f0: ba 07 60 01 inc %i5
for (
400130f4: 80 a6 c0 1d cmp %i3, %i5
400130f8: 1a bf ff e3 bcc 40013084 <rtems_rate_monotonic_report_statistics_with_plugin+0x1b0><== ALWAYS TAKEN
400130fc: 92 07 bf 98 add %fp, -104, %o1
_Timespec_Get_seconds( &wall_average ),
_Timespec_Get_nanoseconds( &wall_average ) / NANOSECONDS_DIVIDER
);
}
}
}
40013100: 81 c7 e0 08 ret
40013104: 81 e8 00 00 restore
40013108 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
40013108: 9d e3 bf a0 save %sp, -96, %sp
_RTEMS_Lock_allocator();
4001310c: 40 00 03 41 call 40013e10 <_RTEMS_Lock_allocator>
40013110: 3b 3f ff c0 sethi %hi(0xffff0000), %i5
/*
* 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.
*/
maximum_id = _Rate_monotonic_Information.maximum_id;
40013114: 03 10 02 4c sethi %hi(0x40093000), %g1
40013118: f8 00 63 74 ld [ %g1 + 0x374 ], %i4 ! 40093374 <_Rate_monotonic_Information>
id &= ~OBJECTS_INDEX_MASK;
4001311c: ba 0f 00 1d and %i4, %i5, %i5
id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT;
40013120: ba 07 60 01 inc %i5
for (
40013124: 80 a7 00 1d cmp %i4, %i5
40013128: 0a 80 00 08 bcs 40013148 <rtems_rate_monotonic_reset_all_statistics+0x40><== NEVER TAKEN
4001312c: 01 00 00 00 nop
id = _Objects_Get_minimum_id( maximum_id ) ;
id <= maximum_id ;
++id
) {
(void) rtems_rate_monotonic_reset_statistics( id );
40013130: 40 00 00 08 call 40013150 <rtems_rate_monotonic_reset_statistics>
40013134: 90 10 00 1d mov %i5, %o0
++id
40013138: ba 07 60 01 inc %i5
for (
4001313c: 80 a7 00 1d cmp %i4, %i5
40013140: 1a bf ff fc bcc 40013130 <rtems_rate_monotonic_reset_all_statistics+0x28>
40013144: 01 00 00 00 nop
_RTEMS_Unlock_allocator();
40013148: 40 00 03 37 call 40013e24 <_RTEMS_Unlock_allocator>
4001314c: 81 e8 00 00 restore
4000f374 <rtems_region_create>:
{
4000f374: 9d e3 bf a0 save %sp, -96, %sp
4000f378: a4 10 00 18 mov %i0, %l2
if ( !rtems_is_name_valid( name ) ) {
4000f37c: 80 a4 a0 00 cmp %l2, 0
4000f380: 02 80 00 24 be 4000f410 <rtems_region_create+0x9c>
4000f384: b0 10 20 03 mov 3, %i0
if ( starting_address == NULL ) {
4000f388: 80 a6 60 00 cmp %i1, 0
4000f38c: 02 80 00 23 be 4000f418 <rtems_region_create+0xa4>
4000f390: 80 a7 60 00 cmp %i5, 0
4000f394: 02 80 00 21 be 4000f418 <rtems_region_create+0xa4>
4000f398: 23 10 00 fc sethi %hi(0x4003f000), %l1
return_status = RTEMS_TOO_MANY;
4000f39c: b0 10 20 05 mov 5, %i0
* This function allocates a region control block from
* the inactive chain of free region control blocks.
*/
RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void )
{
return (Region_Control *) _Objects_Allocate( &_Region_Information );
4000f3a0: 40 00 09 73 call 4001196c <_Objects_Allocate>
4000f3a4: 90 14 61 d4 or %l1, 0x1d4, %o0
if ( !the_region )
4000f3a8: a0 92 20 00 orcc %o0, 0, %l0
4000f3ac: 02 80 00 17 be 4000f408 <rtems_region_create+0x94>
4000f3b0: 01 00 00 00 nop
_Thread_queue_Object_initialize( &the_region->Wait_queue );
4000f3b4: 40 00 0f dd call 40013328 <_Thread_queue_Object_initialize>
4000f3b8: 90 04 20 10 add %l0, 0x10, %o0
if ( _Attributes_Is_priority( attribute_set ) ) {
4000f3bc: 80 8f 20 04 btst 4, %i4
4000f3c0: 12 80 00 18 bne 4000f420 <rtems_region_create+0xac>
4000f3c4: 03 10 00 eb sethi %hi(0x4003ac00), %g1
the_region->wait_operations = &_Thread_queue_Operations_FIFO;
4000f3c8: 03 10 00 eb sethi %hi(0x4003ac00), %g1
4000f3cc: 82 10 63 6c or %g1, 0x36c, %g1 ! 4003af6c <_Thread_queue_Operations_FIFO>
4000f3d0: c2 24 20 1c st %g1, [ %l0 + 0x1c ]
the_region->maximum_segment_size = _Heap_Initialize(
4000f3d4: 96 10 00 1b mov %i3, %o3
4000f3d8: 94 10 00 1a mov %i2, %o2
4000f3dc: 92 10 00 19 mov %i1, %o1
4000f3e0: 40 00 03 aa call 40010288 <_Heap_Initialize>
4000f3e4: 90 04 20 28 add %l0, 0x28, %o0
if ( !the_region->maximum_segment_size ) {
4000f3e8: 80 a2 20 00 cmp %o0, 0
4000f3ec: 12 80 00 17 bne 4000f448 <rtems_region_create+0xd4>
4000f3f0: d0 24 20 20 st %o0, [ %l0 + 0x20 ]
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
4000f3f4: 90 14 61 d4 or %l1, 0x1d4, %o0
4000f3f8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000f3fc: 92 10 00 10 mov %l0, %o1
4000f400: 9f c0 40 00 call %g1
4000f404: b0 10 20 08 mov 8, %i0
_RTEMS_Unlock_allocator();
4000f408: 40 00 02 29 call 4000fcac <_RTEMS_Unlock_allocator>
4000f40c: 01 00 00 00 nop
return return_status;
4000f410: 81 c7 e0 08 ret
4000f414: 81 e8 00 00 restore
}
4000f418: 81 c7 e0 08 ret
4000f41c: 91 e8 20 09 restore %g0, 9, %o0
the_region->wait_operations = &_Thread_queue_Operations_priority;
4000f420: 82 10 63 58 or %g1, 0x358, %g1
4000f424: c2 24 20 1c st %g1, [ %l0 + 0x1c ]
the_region->maximum_segment_size = _Heap_Initialize(
4000f428: 96 10 00 1b mov %i3, %o3
4000f42c: 94 10 00 1a mov %i2, %o2
4000f430: 92 10 00 19 mov %i1, %o1
4000f434: 40 00 03 95 call 40010288 <_Heap_Initialize>
4000f438: 90 04 20 28 add %l0, 0x28, %o0
if ( !the_region->maximum_segment_size ) {
4000f43c: 80 a2 20 00 cmp %o0, 0
4000f440: 02 bf ff ed be 4000f3f4 <rtems_region_create+0x80> <== NEVER TAKEN
4000f444: d0 24 20 20 st %o0, [ %l0 + 0x20 ]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000f448: c2 14 20 0a lduh [ %l0 + 0xa ], %g1
the_region->attribute_set = attribute_set;
4000f44c: f8 24 20 24 st %i4, [ %l0 + 0x24 ]
4000f450: a2 14 61 d4 or %l1, 0x1d4, %l1
the_object->name = name;
4000f454: e4 24 20 0c st %l2, [ %l0 + 0xc ]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000f458: 83 28 60 02 sll %g1, 2, %g1
4000f45c: c6 04 60 04 ld [ %l1 + 4 ], %g3
4000f460: c4 04 20 08 ld [ %l0 + 8 ], %g2
4000f464: 82 00 7f fc add %g1, -4, %g1
4000f468: e0 20 c0 01 st %l0, [ %g3 + %g1 ]
return_status = RTEMS_SUCCESSFUL;
4000f46c: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
4000f470: 40 00 02 0f call 4000fcac <_RTEMS_Unlock_allocator>
4000f474: c4 27 40 00 st %g2, [ %i5 ]
return return_status;
4000f478: 81 c7 e0 08 ret
4000f47c: 81 e8 00 00 restore
40004724 <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
40004724: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t osize;
rtems_status_code status;
Heap_Resize_status resize_status;
Region_Control *the_region;
if ( old_size == NULL ) {
40004728: 80 a6 e0 00 cmp %i3, 0
4000472c: 02 80 00 23 be 400047b8 <rtems_region_resize_segment+0x94>
40004730: 01 00 00 00 nop
_RTEMS_Lock_allocator();
40004734: 40 00 00 f0 call 40004af4 <_RTEMS_Lock_allocator>
40004738: 01 00 00 00 nop
_Objects_Get_no_protection( id, &_Region_Information );
4000473c: 90 10 00 18 mov %i0, %o0
40004740: 13 10 00 4d sethi %hi(0x40013400), %o1
40004744: 40 00 05 db call 40005eb0 <_Objects_Get_no_protection>
40004748: 92 12 62 04 or %o1, 0x204, %o1 ! 40013604 <_Region_Information>
if ( the_region != NULL ) {
4000474c: ba 92 20 00 orcc %o0, 0, %i5
40004750: 02 80 00 1c be 400047c0 <rtems_region_resize_segment+0x9c>
40004754: 98 07 bf f8 add %fp, -8, %o4
if ( the_region == NULL ) {
return RTEMS_INVALID_ID;
}
resize_status = _Heap_Resize_block(
40004758: 96 07 bf fc add %fp, -4, %o3
4000475c: 94 10 00 1a mov %i2, %o2
40004760: 92 10 00 19 mov %i1, %o1
40004764: 40 00 03 79 call 40005548 <_Heap_Resize_block>
40004768: 90 07 60 28 add %i5, 0x28, %o0
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
4000476c: c2 07 bf fc ld [ %fp + -4 ], %g1
switch ( resize_status ) {
40004770: b0 92 20 00 orcc %o0, 0, %i0
40004774: 02 80 00 0d be 400047a8 <rtems_region_resize_segment+0x84>
40004778: c2 26 c0 00 st %g1, [ %i3 ]
4000477c: 80 a6 20 01 cmp %i0, 1
40004780: 12 80 00 06 bne 40004798 <rtems_region_resize_segment+0x74> <== ALWAYS TAKEN
40004784: 01 00 00 00 nop
_RTEMS_Unlock_allocator();
40004788: 40 00 00 e0 call 40004b08 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
4000478c: b0 10 20 0d mov 0xd, %i0 ! d <_TLS_Alignment+0xc> <== NOT EXECUTED
status = RTEMS_INVALID_ADDRESS;
break;
}
_Region_Unlock( the_region );
return status;
40004790: 81 c7 e0 08 ret <== NOT EXECUTED
40004794: 81 e8 00 00 restore <== NOT EXECUTED
40004798: 40 00 00 dc call 40004b08 <_RTEMS_Unlock_allocator>
4000479c: b0 10 20 09 mov 9, %i0
400047a0: 81 c7 e0 08 ret
400047a4: 81 e8 00 00 restore
_Region_Process_queue( the_region );
400047a8: 40 00 15 0f call 40009be4 <_Region_Process_queue>
400047ac: 90 10 00 1d mov %i5, %o0
return RTEMS_SUCCESSFUL;
400047b0: 81 c7 e0 08 ret
400047b4: 81 e8 00 00 restore
}
400047b8: 81 c7 e0 08 ret
400047bc: 91 e8 20 09 restore %g0, 9, %o0
_RTEMS_Unlock_allocator();
400047c0: 40 00 00 d2 call 40004b08 <_RTEMS_Unlock_allocator>
400047c4: b0 10 20 04 mov 4, %i0
if ( the_region == NULL ) {
400047c8: 81 c7 e0 08 ret
400047cc: 81 e8 00 00 restore
400069bc <rtems_scheduler_ident>:
size_t n = _Scheduler_Count;
size_t i;
sc = RTEMS_INVALID_NAME;
for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) {
400069bc: 84 10 20 00 clr %g2
if ( id != NULL ) {
400069c0: 80 a2 60 00 cmp %o1, 0
400069c4: 02 80 00 17 be 40006a20 <rtems_scheduler_ident+0x64>
400069c8: 82 10 20 03 mov 3, %g1
const Scheduler_Control *scheduler = &_Scheduler_Table[ i ];
if ( scheduler->name == name ) {
400069cc: 09 10 00 4f sethi %hi(0x40013c00), %g4
*id = _Scheduler_Build_id( i );
400069d0: 07 03 c0 40 sethi %hi(0xf010000), %g3
if ( scheduler->name == name ) {
400069d4: 88 11 21 60 or %g4, 0x160, %g4
*id = _Scheduler_Build_id( i );
400069d8: 9a 10 e0 01 or %g3, 1, %o5
for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) {
400069dc: 80 a0 a0 00 cmp %g2, 0
400069e0: 12 80 00 0e bne 40006a18 <rtems_scheduler_ident+0x5c>
400069e4: 01 00 00 00 nop
400069e8: 80 a0 60 03 cmp %g1, 3
400069ec: 12 80 00 0b bne 40006a18 <rtems_scheduler_ident+0x5c> <== NEVER TAKEN
400069f0: 01 00 00 00 nop
if ( scheduler->name == name ) {
400069f4: c6 01 20 48 ld [ %g4 + 0x48 ], %g3
400069f8: 82 10 20 03 mov 3, %g1
400069fc: 80 a0 c0 08 cmp %g3, %o0
40006a00: 12 bf ff f7 bne 400069dc <rtems_scheduler_ident+0x20>
40006a04: 84 10 20 01 mov 1, %g2
*id = _Scheduler_Build_id( i );
40006a08: da 22 40 00 st %o5, [ %o1 ]
for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) {
40006a0c: 80 a0 a0 00 cmp %g2, 0
40006a10: 02 bf ff f6 be 400069e8 <rtems_scheduler_ident+0x2c> <== NEVER TAKEN
40006a14: 82 10 20 00 clr %g1
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
40006a18: 81 c3 e0 08 retl
40006a1c: 90 10 00 01 mov %g1, %o0
sc = RTEMS_INVALID_ADDRESS;
40006a20: 82 10 20 09 mov 9, %g1
}
40006a24: 81 c3 e0 08 retl
40006a28: 90 10 00 01 mov %g1, %o0
40006944 <rtems_scheduler_ident_by_processor_set>:
rtems_status_code rtems_scheduler_ident_by_processor_set(
size_t cpusetsize,
const cpu_set_t *cpuset,
rtems_id *id
)
{
40006944: 9d e3 bf 98 save %sp, -104, %sp
Processor_mask set;
Processor_mask_Copy_status status;
uint32_t cpu_index;
const Scheduler_Control *scheduler;
if ( id == NULL ) {
40006948: 80 a6 a0 00 cmp %i2, 0
4000694c: 02 80 00 1a be 400069b4 <rtems_scheduler_ident_by_processor_set+0x70>
40006950: 96 10 00 18 mov %i0, %o3
Processor_mask *dst,
size_t src_size,
const cpu_set_t *src
)
{
return _Processor_mask_Copy(
40006954: 94 10 00 19 mov %i1, %o2
40006958: 92 10 20 04 mov 4, %o1
4000695c: 40 00 08 13 call 400089a8 <_Processor_mask_Copy>
40006960: 90 07 bf fc add %fp, -4, %o0
return RTEMS_INVALID_ADDRESS;
}
status = _Processor_mask_From_cpu_set_t( &set, cpusetsize, cpuset );
if ( status == PROCESSOR_MASK_COPY_INVALID_SIZE ) {
40006964: 80 a2 20 03 cmp %o0, 3
40006968: 02 80 00 10 be 400069a8 <rtems_scheduler_ident_by_processor_set+0x64>
4000696c: c2 07 bf fc ld [ %fp + -4 ], %g1
BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c );
40006970: 05 10 00 50 sethi %hi(0x40014000), %g2
40006974: d0 00 a1 a8 ld [ %g2 + 0x1a8 ], %o0 ! 400141a8 <_Processor_mask_The_one_and_only>
return (uint32_t) BIT_FLS( CPU_MAXIMUM_PROCESSORS, a );
40006978: 90 8a 00 01 andcc %o0, %g1, %o0
4000697c: 02 80 00 0c be 400069ac <rtems_scheduler_ident_by_processor_set+0x68>
40006980: b0 10 20 03 mov 3, %i0
40006984: 40 00 30 fd call 40012d78 <flsl>
40006988: 01 00 00 00 nop
return RTEMS_INVALID_SIZE;
}
_Processor_mask_And( &set, &set, _SMP_Get_online_processors() );
cpu_index = _Processor_mask_Find_last_set( &set );
if ( cpu_index == 0 ) {
4000698c: 80 a2 20 00 cmp %o0, 0
40006990: 02 80 00 07 be 400069ac <rtems_scheduler_ident_by_processor_set+0x68> <== NEVER TAKEN
40006994: 03 03 c0 40 sethi %hi(0xf010000), %g1
}
#else
_Assert( scheduler != NULL );
#endif
*id = _Scheduler_Build_id( _Scheduler_Get_index( scheduler ) );
40006998: 82 10 60 01 or %g1, 1, %g1 ! f010001 <RAM_SIZE+0xec10001>
4000699c: c2 26 80 00 st %g1, [ %i2 ]
return RTEMS_SUCCESSFUL;
400069a0: 81 c7 e0 08 ret
400069a4: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_INVALID_SIZE;
400069a8: b0 10 20 08 mov 8, %i0
}
400069ac: 81 c7 e0 08 ret
400069b0: 81 e8 00 00 restore
return RTEMS_INVALID_ADDRESS;
400069b4: 81 c7 e0 08 ret
400069b8: 91 e8 20 09 restore %g0, 9, %o0
40006a2c <rtems_scheduler_map_priority_from_posix>:
rtems_task_priority *priority
)
{
const Scheduler_Control *scheduler;
if ( priority == NULL ) {
40006a2c: 80 a2 a0 00 cmp %o2, 0
40006a30: 02 80 00 1a be 40006a98 <rtems_scheduler_map_priority_from_posix+0x6c>
40006a34: 03 03 c0 40 sethi %hi(0xf010000), %g1
40006a38: 82 10 60 01 or %g1, 1, %g1 ! f010001 <RAM_SIZE+0xec10001>
40006a3c: 80 a2 00 01 cmp %o0, %g1
40006a40: 12 80 00 14 bne 40006a90 <rtems_scheduler_map_priority_from_posix+0x64>
40006a44: 80 a2 60 00 cmp %o1, 0
scheduler = _Scheduler_Get_by_id( scheduler_id );
if ( scheduler == NULL ) {
return RTEMS_INVALID_ID;
}
if ( posix_priority < 1 ) {
40006a48: 04 80 00 10 ble 40006a88 <rtems_scheduler_map_priority_from_posix+0x5c>
40006a4c: 03 10 00 4f sethi %hi(0x40013c00), %g1
return RTEMS_INVALID_PRIORITY;
}
if ( posix_priority >= scheduler->maximum_priority ) {
40006a50: 82 10 61 60 or %g1, 0x160, %g1 ! 40013d60 <_Scheduler_Table>
40006a54: c8 00 60 40 ld [ %g1 + 0x40 ], %g4
40006a58: 85 3a 60 1f sra %o1, 0x1f, %g2
40006a5c: 80 a1 00 02 cmp %g4, %g2
40006a60: 08 80 00 06 bleu 40006a78 <rtems_scheduler_map_priority_from_posix+0x4c> <== ALWAYS TAKEN
40006a64: c6 00 60 44 ld [ %g1 + 0x44 ], %g3
return RTEMS_INVALID_PRIORITY;
}
*priority = scheduler->maximum_priority - (Priority_Control) posix_priority;
40006a68: 92 20 c0 09 sub %g3, %o1, %o1 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
40006a6c: 90 10 20 00 clr %o0
40006a70: 81 c3 e0 08 retl
40006a74: d2 22 80 00 st %o1, [ %o2 ]
if ( posix_priority >= scheduler->maximum_priority ) {
40006a78: 12 80 00 04 bne 40006a88 <rtems_scheduler_map_priority_from_posix+0x5c> <== NEVER TAKEN
40006a7c: 80 a0 c0 09 cmp %g3, %o1
40006a80: 18 bf ff fb bgu 40006a6c <rtems_scheduler_map_priority_from_posix+0x40>
40006a84: 92 20 c0 09 sub %g3, %o1, %o1
}
40006a88: 81 c3 e0 08 retl
40006a8c: 90 10 20 13 mov 0x13, %o0
return RTEMS_INVALID_ID;
40006a90: 81 c3 e0 08 retl
40006a94: 90 10 20 04 mov 4, %o0
return RTEMS_INVALID_ADDRESS;
40006a98: 81 c3 e0 08 retl
40006a9c: 90 10 20 09 mov 9, %o0
40006aa0 <rtems_scheduler_map_priority_to_posix>:
int *posix_priority
)
{
const Scheduler_Control *scheduler;
if ( posix_priority == NULL ) {
40006aa0: 80 a2 a0 00 cmp %o2, 0
40006aa4: 02 80 00 1b be 40006b10 <rtems_scheduler_map_priority_to_posix+0x70>
40006aa8: 03 03 c0 40 sethi %hi(0xf010000), %g1
40006aac: 82 10 60 01 or %g1, 1, %g1 ! f010001 <RAM_SIZE+0xec10001>
40006ab0: 80 a2 00 01 cmp %o0, %g1
40006ab4: 12 80 00 15 bne 40006b08 <rtems_scheduler_map_priority_to_posix+0x68>
40006ab8: 80 a2 60 00 cmp %o1, 0
scheduler = _Scheduler_Get_by_id( scheduler_id );
if ( scheduler == NULL ) {
return RTEMS_INVALID_ID;
}
if ( priority < 1 ) {
40006abc: 02 80 00 11 be 40006b00 <rtems_scheduler_map_priority_to_posix+0x60>
40006ac0: 90 10 20 13 mov 0x13, %o0
return RTEMS_INVALID_PRIORITY;
}
if ( priority >= scheduler->maximum_priority ) {
40006ac4: 03 10 00 4f sethi %hi(0x40013c00), %g1
40006ac8: 82 10 61 60 or %g1, 0x160, %g1 ! 40013d60 <_Scheduler_Table>
40006acc: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
40006ad0: 80 a0 a0 00 cmp %g2, 0
40006ad4: 08 80 00 06 bleu 40006aec <rtems_scheduler_map_priority_to_posix+0x4c> <== ALWAYS TAKEN
40006ad8: c2 00 60 44 ld [ %g1 + 0x44 ], %g1
return RTEMS_INVALID_PRIORITY;
}
*posix_priority = (int) ( scheduler->maximum_priority - priority );
40006adc: 92 20 40 09 sub %g1, %o1, %o1 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
40006ae0: 90 10 20 00 clr %o0
40006ae4: 81 c3 e0 08 retl
40006ae8: d2 22 80 00 st %o1, [ %o2 ]
if ( priority >= scheduler->maximum_priority ) {
40006aec: 12 80 00 04 bne 40006afc <rtems_scheduler_map_priority_to_posix+0x5c> <== NEVER TAKEN
40006af0: 80 a0 40 09 cmp %g1, %o1
40006af4: 38 bf ff fb bgu,a 40006ae0 <rtems_scheduler_map_priority_to_posix+0x40>
40006af8: 92 20 40 09 sub %g1, %o1, %o1
return RTEMS_INVALID_PRIORITY;
40006afc: 90 10 20 13 mov 0x13, %o0
}
40006b00: 81 c3 e0 08 retl
40006b04: 01 00 00 00 nop
return RTEMS_INVALID_ID;
40006b08: 81 c3 e0 08 retl
40006b0c: 90 10 20 04 mov 4, %o0 ! 4 <_TLS_Alignment+0x3>
return RTEMS_INVALID_ADDRESS;
40006b10: 81 c3 e0 08 retl
40006b14: 90 10 20 09 mov 9, %o0
4000a590 <rtems_semaphore_create>:
{
4000a590: 9d e3 bf 78 save %sp, -136, %sp
if ( !rtems_is_name_valid( name ) )
4000a594: 80 a6 20 00 cmp %i0, 0
4000a598: 02 80 00 35 be 4000a66c <rtems_semaphore_create+0xdc>
4000a59c: 82 10 20 03 mov 3, %g1
if ( !id )
4000a5a0: 80 a7 20 00 cmp %i4, 0
4000a5a4: 02 80 00 79 be 4000a788 <rtems_semaphore_create+0x1f8>
4000a5a8: 84 8e a1 f0 andcc %i2, 0x1f0, %g2
if ( maybe_global == RTEMS_COUNTING_SEMAPHORE ) {
4000a5ac: 02 80 00 12 be 4000a5f4 <rtems_semaphore_create+0x64>
4000a5b0: 80 a6 60 01 cmp %i1, 1
} else if ( count > 1 ) {
4000a5b4: 18 80 00 2e bgu 4000a66c <rtems_semaphore_create+0xdc>
4000a5b8: 82 10 20 0a mov 0xa, %g1
} else if ( maybe_global == RTEMS_SIMPLE_BINARY_SEMAPHORE ) {
4000a5bc: 80 a0 a0 20 cmp %g2, 0x20
4000a5c0: 02 80 00 70 be 4000a780 <rtems_semaphore_create+0x1f0>
4000a5c4: 80 a0 a0 10 cmp %g2, 0x10
} else if ( maybe_global == RTEMS_BINARY_SEMAPHORE ) {
4000a5c8: 02 80 00 2b be 4000a674 <rtems_semaphore_create+0xe4>
4000a5cc: 84 0e a1 f6 and %i2, 0x1f6, %g2
} else if (
4000a5d0: 80 a0 a0 54 cmp %g2, 0x54
4000a5d4: 02 80 00 6f be 4000a790 <rtems_semaphore_create+0x200>
4000a5d8: 80 a0 a0 94 cmp %g2, 0x94
} else if (
4000a5dc: 02 80 00 04 be 4000a5ec <rtems_semaphore_create+0x5c>
4000a5e0: 80 a0 a1 10 cmp %g2, 0x110
4000a5e4: 12 80 00 22 bne 4000a66c <rtems_semaphore_create+0xdc>
4000a5e8: 82 10 20 0b mov 0xb, %g1
4000a5ec: 10 80 00 03 b 4000a5f8 <rtems_semaphore_create+0x68>
4000a5f0: a0 10 20 01 mov 1, %l0
variant = SEMAPHORE_VARIANT_COUNTING;
4000a5f4: a0 10 20 04 mov 4, %l0
* 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 );
4000a5f8: 23 10 00 7d sethi %hi(0x4001f400), %l1
4000a5fc: 40 00 07 84 call 4000c40c <_Objects_Allocate>
4000a600: 90 14 61 44 or %l1, 0x144, %o0 ! 4001f544 <_Semaphore_Information>
if ( !the_semaphore ) {
4000a604: ba 92 20 00 orcc %o0, 0, %i5
4000a608: 02 80 00 64 be 4000a798 <rtems_semaphore_create+0x208>
4000a60c: 80 8e a0 04 btst 4, %i2
if ( _Attributes_Is_priority( attribute_set ) ) {
4000a610: 12 80 00 03 bne 4000a61c <rtems_semaphore_create+0x8c>
4000a614: 82 10 00 10 mov %l0, %g1
return flags | ( discipline << 3 );
4000a618: 82 14 20 08 or %l0, 8, %g1
the_semaphore->Object.Node.previous = (Chain_Node *) flags;
4000a61c: c2 27 60 04 st %g1, [ %i5 + 4 ]
switch ( variant ) {
4000a620: 80 a4 20 01 cmp %l0, 1
4000a624: 02 80 00 1d be 4000a698 <rtems_semaphore_create+0x108>
4000a628: f4 01 a0 20 ld [ %g6 + 0x20 ], %i2
4000a62c: 80 8c 20 05 btst 5, %l0
4000a630: 02 80 00 13 be 4000a67c <rtems_semaphore_create+0xec>
4000a634: 92 10 00 19 mov %i1, %o1
_CORE_semaphore_Initialize(
4000a638: 40 00 03 bf call 4000b534 <_CORE_semaphore_Initialize>
4000a63c: 90 07 60 10 add %i5, 0x10, %o0
* occur in normal situations.
*/
_Assert( index >= OBJECTS_INDEX_MINIMUM );
_Assert( index <= _Objects_Get_maximum_index( information ) );
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000a640: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
)
{
_Assert( information != NULL );
_Assert( the_object != NULL );
the_object->name = name;
4000a644: f0 27 60 0c st %i0, [ %i5 + 0xc ]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000a648: 90 14 61 44 or %l1, 0x144, %o0
4000a64c: c6 02 20 04 ld [ %o0 + 4 ], %g3
4000a650: c4 07 60 08 ld [ %i5 + 8 ], %g2
4000a654: 83 28 60 02 sll %g1, 2, %g1
4000a658: 82 00 7f fc add %g1, -4, %g1
4000a65c: fa 20 c0 01 st %i5, [ %g3 + %g1 ]
* previous thread life protection state and thus may not return if the
* executing thread was restarted or deleted in the mean-time.
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void )
{
_RTEMS_Unlock_allocator();
4000a660: 40 00 03 37 call 4000b33c <_RTEMS_Unlock_allocator>
4000a664: c4 27 00 00 st %g2, [ %i4 ]
return RTEMS_SUCCESSFUL;
4000a668: 82 10 20 00 clr %g1
}
4000a66c: 81 c7 e0 08 ret
4000a670: 91 e8 00 01 restore %g0, %g1, %o0
variant = SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL;
4000a674: 10 bf ff e1 b 4000a5f8 <rtems_semaphore_create+0x68>
4000a678: a0 10 20 02 mov 2, %l0
*/
RTEMS_INLINE_ROUTINE void _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex
)
{
_Thread_queue_Object_initialize( &the_mutex->Wait_queue );
4000a67c: 40 00 0c 16 call 4000d6d4 <_Thread_queue_Object_initialize>
4000a680: 90 07 60 10 add %i5, 0x10, %o0
if ( count == 0 ) {
4000a684: 80 a6 60 00 cmp %i1, 0
4000a688: 12 bf ff ee bne 4000a640 <rtems_semaphore_create+0xb0>
4000a68c: c0 27 60 1c clr [ %i5 + 0x1c ]
CORE_mutex_Control *the_mutex,
Thread_Control *owner
)
{
the_mutex->Wait_queue.Queue.owner = owner;
}
4000a690: 10 bf ff ec b 4000a640 <rtems_semaphore_create+0xb0>
4000a694: f4 27 60 14 st %i2, [ %i5 + 0x14 ]
const Scheduler_Control *scheduler,
rtems_task_priority priority,
bool *valid
)
{
*valid = ( priority <= scheduler->maximum_priority );
4000a698: 11 10 00 70 sethi %hi(0x4001c000), %o0
4000a69c: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 4001c1c0 <_Scheduler_Table>
RTEMS_INLINE_ROUTINE Priority_Control _Scheduler_Map_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return ( *scheduler->Operations.map_priority )( scheduler, priority );
4000a6a0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000a6a4: e6 02 20 40 ld [ %o0 + 0x40 ], %l3
4000a6a8: e8 02 20 44 ld [ %o0 + 0x44 ], %l4
4000a6ac: 92 10 20 00 clr %o1
4000a6b0: 9f c0 40 00 call %g1
4000a6b4: 94 10 00 1b mov %i3, %o2
if ( valid ) {
4000a6b8: 80 a4 e0 00 cmp %l3, 0
4000a6bc: a4 10 00 08 mov %o0, %l2
4000a6c0: 12 80 00 0c bne 4000a6f0 <rtems_semaphore_create+0x160> <== NEVER TAKEN
4000a6c4: a0 10 00 09 mov %o1, %l0
4000a6c8: 80 a6 c0 14 cmp %i3, %l4
4000a6cc: 08 80 00 09 bleu 4000a6f0 <rtems_semaphore_create+0x160>
4000a6d0: 90 14 61 44 or %l1, 0x144, %o0
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
4000a6d4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000a6d8: 9f c0 40 00 call %g1
4000a6dc: 92 10 00 1d mov %i5, %o1
_RTEMS_Unlock_allocator();
4000a6e0: 40 00 03 17 call 4000b33c <_RTEMS_Unlock_allocator>
4000a6e4: 01 00 00 00 nop
return _Status_Get( status );
4000a6e8: 10 bf ff e1 b 4000a66c <rtems_semaphore_create+0xdc>
4000a6ec: 82 10 20 13 mov 0x13, %g1 ! 13 <_TLS_Alignment+0x12>
_Thread_queue_Object_initialize( &the_mutex->Wait_queue );
4000a6f0: 40 00 0b f9 call 4000d6d4 <_Thread_queue_Object_initialize>
4000a6f4: 90 07 60 10 add %i5, 0x10, %o0
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;
4000a6f8: c0 27 60 1c clr [ %i5 + 0x1c ]
if ( count == 0 ) {
4000a6fc: 80 a6 60 00 cmp %i1, 0
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
4000a700: e4 27 60 30 st %l2, [ %i5 + 0x30 ]
4000a704: 12 bf ff cf bne 4000a640 <rtems_semaphore_create+0xb0>
4000a708: e0 27 60 34 st %l0, [ %i5 + 0x34 ]
*/
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
4000a70c: c0 27 bf f0 clr [ %fp + -16 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a710: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( &queue_context.Lock_context.Lock_context );
4000a714: c2 27 bf dc st %g1, [ %fp + -36 ]
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
4000a718: c2 06 a0 38 ld [ %i2 + 0x38 ], %g1
_Thread_Wait_acquire_default_critical( owner, &lock_context );
scheduler_node = _Thread_Scheduler_get_home_node( owner );
if (
4000a71c: c6 07 60 30 ld [ %i5 + 0x30 ], %g3
4000a720: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4000a724: 80 a0 c0 02 cmp %g3, %g2
4000a728: 18 80 00 24 bgu 4000a7b8 <rtems_semaphore_create+0x228> <== NEVER TAKEN
4000a72c: 01 00 00 00 nop
4000a730: 22 80 00 1e be,a 4000a7a8 <rtems_semaphore_create+0x218> <== ALWAYS TAKEN
4000a734: c4 07 60 34 ld [ %i5 + 0x34 ], %g2
the_mutex->Wait_queue.Queue.owner = owner;
4000a738: f4 27 60 14 st %i2, [ %i5 + 0x14 ] <== NOT EXECUTED
return STATUS_MUTEX_CEILING_VIOLATED;
}
_CORE_mutex_Set_owner( &the_mutex->Recursive.Mutex, owner );
_Thread_Resource_count_increment( owner );
_Thread_Priority_add(
4000a73c: 92 07 60 20 add %i5, 0x20, %o1
4000a740: 94 07 bf dc add %fp, -36, %o2
4000a744: 40 00 0a 96 call 4000d19c <_Thread_Priority_add>
4000a748: 90 10 00 1a mov %i2, %o0
disable_level = cpu_self->thread_dispatch_disable_level;
4000a74c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000a750: 82 00 60 01 inc %g1
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000a754: b6 10 00 06 mov %g6, %i3
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000a758: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a75c: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a760: 91 d0 20 0a ta 0xa
4000a764: 01 00 00 00 nop
);
_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 );
4000a768: 40 00 0a f2 call 4000d330 <_Thread_Priority_update>
4000a76c: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_enable( cpu_self );
4000a770: 40 00 0b 80 call 4000d570 <_Thread_Dispatch_enable>
4000a774: 90 10 00 1b mov %i3, %o0
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000a778: 10 bf ff b3 b 4000a644 <rtems_semaphore_create+0xb4>
4000a77c: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
variant = SEMAPHORE_VARIANT_SIMPLE_BINARY;
4000a780: 10 bf ff 9e b 4000a5f8 <rtems_semaphore_create+0x68>
4000a784: a0 10 20 03 mov 3, %l0
return RTEMS_INVALID_ADDRESS;
4000a788: 10 bf ff b9 b 4000a66c <rtems_semaphore_create+0xdc>
4000a78c: 82 10 20 09 mov 9, %g1
variant = SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY;
4000a790: 10 bf ff 9a b 4000a5f8 <rtems_semaphore_create+0x68>
4000a794: a0 10 20 00 clr %l0
_RTEMS_Unlock_allocator();
4000a798: 40 00 02 e9 call 4000b33c <_RTEMS_Unlock_allocator>
4000a79c: 01 00 00 00 nop
return RTEMS_TOO_MANY;
4000a7a0: 10 bf ff b3 b 4000a66c <rtems_semaphore_create+0xdc>
4000a7a4: 82 10 20 05 mov 5, %g1 ! 5 <_TLS_Alignment+0x4>
if (
4000a7a8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4000a7ac: 80 a0 80 01 cmp %g2, %g1
4000a7b0: 28 bf ff e3 bleu,a 4000a73c <rtems_semaphore_create+0x1ac>
4000a7b4: f4 27 60 14 st %i2, [ %i5 + 0x14 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a7b8: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a7bc: 91 d0 20 0a ta 0xa
4000a7c0: 01 00 00 00 nop
( *information->deallocate )( information, the_object );
4000a7c4: 10 bf ff c4 b 4000a6d4 <rtems_semaphore_create+0x144>
4000a7c8: 90 14 61 44 or %l1, 0x144, %o0
40004684 <rtems_semaphore_flush>:
#endif
#include <rtems/rtems/semimpl.h>
rtems_status_code rtems_semaphore_flush( rtems_id id )
{
40004684: 9d e3 bf 78 save %sp, -136, %sp
Objects_Id id,
Thread_queue_Context *queue_context
)
{
_Thread_queue_Context_initialize( queue_context );
return (Semaphore_Control *) _Objects_Get(
40004688: 15 10 00 4c sethi %hi(0x40013000), %o2
4000468c: 92 07 bf dc add %fp, -36, %o1
40004690: 94 12 a0 84 or %o2, 0x84, %o2
40004694: 40 00 03 ed call 40005648 <_Objects_Get>
40004698: 90 10 00 18 mov %i0, %o0
uintptr_t flags;
Semaphore_Variant variant;
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
4000469c: 80 a2 20 00 cmp %o0, 0
400046a0: 02 80 00 22 be 40004728 <rtems_semaphore_flush+0xa4>
400046a4: 01 00 00 00 nop
return (uintptr_t) the_semaphore->Object.Node.previous;
400046a8: c2 02 20 04 ld [ %o0 + 4 ], %g1
if (
400046ac: 80 88 60 07 btst 7, %g1
400046b0: 02 80 00 15 be 40004704 <rtems_semaphore_flush+0x80>
400046b4: 90 02 20 10 add %o0, 0x10, %o0
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
400046b8: 80 88 60 08 btst 8, %g1
400046bc: 02 80 00 0a be 400046e4 <rtems_semaphore_flush+0x60> <== NEVER TAKEN
400046c0: 96 07 bf dc add %fp, -36, %o3
return &_Thread_queue_Operations_FIFO;
400046c4: 13 10 00 42 sethi %hi(0x40010800), %o1
|| variant == SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING
|| variant == SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL
|| variant == SEMAPHORE_VARIANT_SIMPLE_BINARY
|| variant == SEMAPHORE_VARIANT_COUNTING
);
_Thread_queue_Flush_critical(
400046c8: 15 10 00 1a sethi %hi(0x40006800), %o2
400046cc: 92 12 61 d4 or %o1, 0x1d4, %o1
400046d0: 94 12 a2 24 or %o2, 0x224, %o2
400046d4: 40 00 08 d8 call 40006a34 <_Thread_queue_Flush_critical>
400046d8: b0 10 20 00 clr %i0
&queue_context
);
break;
}
return RTEMS_SUCCESSFUL;
400046dc: 81 c7 e0 08 ret
400046e0: 81 e8 00 00 restore
return &_Thread_queue_Operations_priority;
400046e4: 13 10 00 42 sethi %hi(0x40010800), %o1 <== NOT EXECUTED
_Thread_queue_Flush_critical(
400046e8: 15 10 00 1a sethi %hi(0x40006800), %o2 <== NOT EXECUTED
400046ec: 92 12 61 c0 or %o1, 0x1c0, %o1 <== NOT EXECUTED
400046f0: 94 12 a2 24 or %o2, 0x224, %o2 <== NOT EXECUTED
400046f4: 40 00 08 d0 call 40006a34 <_Thread_queue_Flush_critical> <== NOT EXECUTED
400046f8: b0 10 20 00 clr %i0 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
400046fc: 81 c7 e0 08 ret <== NOT EXECUTED
40004700: 81 e8 00 00 restore <== NOT EXECUTED
_Thread_queue_Flush_critical(
40004704: 96 07 bf dc add %fp, -36, %o3
return &_Thread_queue_Operations_priority_inherit;
40004708: 13 10 00 42 sethi %hi(0x40010800), %o1
4000470c: 15 10 00 1a sethi %hi(0x40006800), %o2
40004710: 92 12 61 ac or %o1, 0x1ac, %o1
40004714: 94 12 a2 24 or %o2, 0x224, %o2
40004718: 40 00 08 c7 call 40006a34 <_Thread_queue_Flush_critical>
4000471c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
40004720: 81 c7 e0 08 ret
40004724: 81 e8 00 00 restore
}
40004728: 81 c7 e0 08 ret
4000472c: 91 e8 20 04 restore %g0, 4, %o0
4000a7cc <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
4000a7cc: 9d e3 bf 78 save %sp, -136, %sp
Objects_Id id,
Thread_queue_Context *queue_context
)
{
_Thread_queue_Context_initialize( queue_context );
return (Semaphore_Control *) _Objects_Get(
4000a7d0: 15 10 00 7d sethi %hi(0x4001f400), %o2
4000a7d4: 92 07 bf dc add %fp, -36, %o1
4000a7d8: 94 12 a1 44 or %o2, 0x144, %o2
4000a7dc: 40 00 07 27 call 4000c478 <_Objects_Get>
4000a7e0: 90 10 00 18 mov %i0, %o0
Semaphore_Variant variant;
Status_Control status;
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
4000a7e4: 80 a2 20 00 cmp %o0, 0
4000a7e8: 02 80 00 66 be 4000a980 <rtems_semaphore_obtain+0x1b4>
4000a7ec: b2 0e 60 01 and %i1, 1, %i1
}
executing = _Thread_Executing;
wait = !_Options_Is_no_wait( option_set );
if ( wait ) {
4000a7f0: 96 9e 60 01 xorcc %i1, 1, %o3
4000a7f4: 12 80 00 21 bne 4000a878 <rtems_semaphore_obtain+0xac>
4000a7f8: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
4000a7fc: 03 10 00 35 sethi %hi(0x4000d400), %g1
4000a800: 82 10 63 48 or %g1, 0x348, %g1 ! 4000d748 <_Thread_queue_Enqueue_do_nothing_extra>
4000a804: c2 27 bf e4 st %g1, [ %fp + -28 ]
return (uintptr_t) the_semaphore->Object.Node.previous;
4000a808: c2 02 20 04 ld [ %o0 + 4 ], %g1
return (Semaphore_Discipline) ( flags & 0x7 );
4000a80c: b0 08 60 07 and %g1, 7, %i0
}
flags = _Semaphore_Get_flags( the_semaphore );
variant = _Semaphore_Get_variant( flags );
switch ( variant ) {
4000a810: 80 a6 20 01 cmp %i0, 1
4000a814: 02 80 00 22 be 4000a89c <rtems_semaphore_obtain+0xd0>
4000a818: 84 02 20 10 add %o0, 0x10, %g2
4000a81c: 80 a6 20 02 cmp %i0, 2
4000a820: 02 80 00 3b be 4000a90c <rtems_semaphore_obtain+0x140>
4000a824: 80 a6 20 00 cmp %i0, 0
4000a828: 02 80 00 2b be 4000a8d4 <rtems_semaphore_obtain+0x108>
4000a82c: 80 88 60 08 btst 8, %g1
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000a830: 02 80 00 52 be 4000a978 <rtems_semaphore_obtain+0x1ac>
4000a834: 13 10 00 72 sethi %hi(0x4001c800), %o1
return &_Thread_queue_Operations_FIFO;
4000a838: 13 10 00 72 sethi %hi(0x4001c800), %o1
4000a83c: 92 12 62 c4 or %o1, 0x2c4, %o1 ! 4001cac4 <_Thread_queue_Operations_FIFO>
)
{
_Assert( _ISR_Get_level() != 0 );
_CORE_semaphore_Acquire_critical( the_semaphore, queue_context );
if ( the_semaphore->count != 0 ) {
4000a840: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000a844: 80 a0 60 00 cmp %g1, 0
4000a848: 12 80 00 50 bne 4000a988 <rtems_semaphore_obtain+0x1bc>
4000a84c: 80 a2 e0 00 cmp %o3, 0
the_semaphore->count -= 1;
_CORE_semaphore_Release( the_semaphore, queue_context );
return STATUS_SUCCESSFUL;
}
if ( !wait ) {
4000a850: 02 80 00 58 be 4000a9b0 <rtems_semaphore_obtain+0x1e4>
4000a854: 82 10 20 02 mov 2, %g1
_Thread_queue_Context_set_thread_state(
queue_context,
STATES_WAITING_FOR_SEMAPHORE
);
_Thread_queue_Enqueue(
4000a858: 96 07 bf dc add %fp, -36, %o3
queue_context->thread_state = thread_state;
4000a85c: c2 27 bf e0 st %g1, [ %fp + -32 ]
4000a860: 94 10 00 1d mov %i5, %o2
4000a864: 40 00 0b c3 call 4000d770 <_Thread_queue_Enqueue>
4000a868: 90 10 00 02 mov %g2, %o0
4000a86c: f0 0f 60 4f ldub [ %i5 + 0x4f ], %i0
&queue_context
);
break;
}
return _Status_Get( status );
4000a870: 81 c7 e0 08 ret
4000a874: 81 e8 00 00 restore
queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks;
4000a878: 03 10 00 39 sethi %hi(0x4000e400), %g1
queue_context->Timeout.ticks = ticks;
4000a87c: f4 27 bf e8 st %i2, [ %fp + -24 ]
queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks;
4000a880: 82 10 62 78 or %g1, 0x278, %g1
4000a884: c2 27 bf e4 st %g1, [ %fp + -28 ]
return (uintptr_t) the_semaphore->Object.Node.previous;
4000a888: c2 02 20 04 ld [ %o0 + 4 ], %g1
return (Semaphore_Discipline) ( flags & 0x7 );
4000a88c: b0 08 60 07 and %g1, 7, %i0
switch ( variant ) {
4000a890: 80 a6 20 01 cmp %i0, 1
4000a894: 12 bf ff e2 bne 4000a81c <rtems_semaphore_obtain+0x50>
4000a898: 84 02 20 10 add %o0, 0x10, %g2
return the_mutex->Wait_queue.Queue.owner;
4000a89c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
_CORE_mutex_Acquire_critical( &the_mutex->Recursive.Mutex, queue_context );
owner = _CORE_mutex_Get_owner( &the_mutex->Recursive.Mutex );
if ( owner == NULL ) {
4000a8a0: 80 a0 60 00 cmp %g1, 0
4000a8a4: 02 80 00 54 be 4000a9f4 <rtems_semaphore_obtain+0x228>
4000a8a8: 80 a7 40 01 cmp %i5, %g1
executing,
queue_context
);
}
if ( owner == executing ) {
4000a8ac: 02 80 00 2b be 4000a958 <rtems_semaphore_obtain+0x18c> <== NEVER TAKEN
4000a8b0: 98 07 bf dc add %fp, -36, %o4
status = ( *nested )( &the_mutex->Recursive );
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
return status;
}
return _CORE_mutex_Seize_slow(
4000a8b4: 94 10 00 1d mov %i5, %o2
4000a8b8: 90 10 00 02 mov %g2, %o0
4000a8bc: 13 10 00 72 sethi %hi(0x4001c800), %o1
4000a8c0: 40 00 03 06 call 4000b4d8 <_CORE_mutex_Seize_slow>
4000a8c4: 92 12 62 b0 or %o1, 0x2b0, %o1 ! 4001cab0 <_Thread_queue_Operations_priority>
4000a8c8: b0 0a 20 ff and %o0, 0xff, %i0
4000a8cc: 81 c7 e0 08 ret
4000a8d0: 81 e8 00 00 restore
return the_mutex->Wait_queue.Queue.owner;
4000a8d4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( owner == NULL ) {
4000a8d8: 80 a0 60 00 cmp %g1, 0
4000a8dc: 02 80 00 3a be 4000a9c4 <rtems_semaphore_obtain+0x1f8>
4000a8e0: 80 a7 40 01 cmp %i5, %g1
if ( owner == executing ) {
4000a8e4: 02 80 00 2b be 4000a990 <rtems_semaphore_obtain+0x1c4>
4000a8e8: 98 07 bf dc add %fp, -36, %o4
return _CORE_mutex_Seize_slow(
4000a8ec: 94 10 00 1d mov %i5, %o2
4000a8f0: 90 10 00 02 mov %g2, %o0
4000a8f4: 13 10 00 72 sethi %hi(0x4001c800), %o1
4000a8f8: 40 00 02 f8 call 4000b4d8 <_CORE_mutex_Seize_slow>
4000a8fc: 92 12 62 9c or %o1, 0x29c, %o1 ! 4001ca9c <_Thread_queue_Operations_priority_inherit>
4000a900: b0 0a 20 ff and %o0, 0xff, %i0
4000a904: 81 c7 e0 08 ret
4000a908: 81 e8 00 00 restore
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000a90c: 80 88 60 08 btst 8, %g1
4000a910: 02 80 00 10 be 4000a950 <rtems_semaphore_obtain+0x184>
4000a914: 13 10 00 72 sethi %hi(0x4001c800), %o1
return &_Thread_queue_Operations_FIFO;
4000a918: 13 10 00 72 sethi %hi(0x4001c800), %o1
4000a91c: 92 12 62 c4 or %o1, 0x2c4, %o1 ! 4001cac4 <_Thread_queue_Operations_FIFO>
return the_mutex->Wait_queue.Queue.owner;
4000a920: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( owner == NULL ) {
4000a924: 80 a0 60 00 cmp %g1, 0
4000a928: 02 80 00 2d be 4000a9dc <rtems_semaphore_obtain+0x210>
4000a92c: 80 a7 40 01 cmp %i5, %g1
if ( owner == executing ) {
4000a930: 02 80 00 0a be 4000a958 <rtems_semaphore_obtain+0x18c>
4000a934: 98 07 bf dc add %fp, -36, %o4
return _CORE_mutex_Seize_slow(
4000a938: 94 10 00 1d mov %i5, %o2
4000a93c: 40 00 02 e7 call 4000b4d8 <_CORE_mutex_Seize_slow>
4000a940: 90 10 00 02 mov %g2, %o0
4000a944: b0 0a 20 ff and %o0, 0xff, %i0
4000a948: 81 c7 e0 08 ret
4000a94c: 81 e8 00 00 restore
return &_Thread_queue_Operations_priority;
4000a950: 10 bf ff f4 b 4000a920 <rtems_semaphore_obtain+0x154>
4000a954: 92 12 62 b0 or %o1, 0x2b0, %o1
++the_mutex->nest_level;
4000a958: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000a95c: 82 00 60 01 inc %g1
the_semaphore->count -= 1;
4000a960: c2 22 20 1c st %g1, [ %o0 + 0x1c ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a964: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a968: 91 d0 20 0a ta 0xa
4000a96c: 01 00 00 00 nop
return STATUS_SUCCESSFUL;
4000a970: 81 c7 e0 08 ret
4000a974: 91 e8 20 00 restore %g0, 0, %o0
4000a978: 10 bf ff b2 b 4000a840 <rtems_semaphore_obtain+0x74>
4000a97c: 92 12 62 b0 or %o1, 0x2b0, %o1
}
4000a980: 81 c7 e0 08 ret
4000a984: 91 e8 20 04 restore %g0, 4, %o0
the_semaphore->count -= 1;
4000a988: 10 bf ff f6 b 4000a960 <rtems_semaphore_obtain+0x194>
4000a98c: 82 00 7f ff add %g1, -1, %g1
4000a990: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
4000a994: 82 00 60 01 inc %g1
4000a998: c2 22 20 1c st %g1, [ %o0 + 0x1c ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a99c: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a9a0: 91 d0 20 0a ta 0xa
4000a9a4: 01 00 00 00 nop
return status;
4000a9a8: 81 c7 e0 08 ret
4000a9ac: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a9b0: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a9b4: 91 d0 20 0a ta 0xa
4000a9b8: 01 00 00 00 nop
return STATUS_UNSATISFIED;
4000a9bc: 81 c7 e0 08 ret
4000a9c0: 91 e8 20 0d restore %g0, 0xd, %o0
the_mutex->Wait_queue.Queue.owner = owner;
4000a9c4: fa 22 20 14 st %i5, [ %o0 + 0x14 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a9c8: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a9cc: 91 d0 20 0a ta 0xa
4000a9d0: 01 00 00 00 nop
return STATUS_SUCCESSFUL;
4000a9d4: 81 c7 e0 08 ret
4000a9d8: 81 e8 00 00 restore
the_mutex->Wait_queue.Queue.owner = owner;
4000a9dc: fa 22 20 14 st %i5, [ %o0 + 0x14 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a9e0: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a9e4: 91 d0 20 0a ta 0xa
4000a9e8: 01 00 00 00 nop
4000a9ec: 81 c7 e0 08 ret
4000a9f0: 91 e8 20 00 restore %g0, 0, %o0
4000a9f4: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
queue_context->Priority.update_count = 0;
4000a9f8: c0 27 bf f0 clr [ %fp + -16 ]
if (
4000a9fc: c6 02 20 30 ld [ %o0 + 0x30 ], %g3
4000aa00: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
4000aa04: 80 a0 c0 02 cmp %g3, %g2
4000aa08: 18 80 00 1b bgu 4000aa74 <rtems_semaphore_obtain+0x2a8> <== NEVER TAKEN
4000aa0c: 01 00 00 00 nop
4000aa10: 22 80 00 15 be,a 4000aa64 <rtems_semaphore_obtain+0x298> <== ALWAYS TAKEN
4000aa14: c4 02 20 34 ld [ %o0 + 0x34 ], %g2
the_mutex->Wait_queue.Queue.owner = owner;
4000aa18: fa 22 20 14 st %i5, [ %o0 + 0x14 ] <== NOT EXECUTED
_Thread_Priority_add(
4000aa1c: 92 02 20 20 add %o0, 0x20, %o1
4000aa20: 94 07 bf dc add %fp, -36, %o2
4000aa24: 40 00 09 de call 4000d19c <_Thread_Priority_add>
4000aa28: 90 10 00 1d mov %i5, %o0
disable_level = cpu_self->thread_dispatch_disable_level;
4000aa2c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000aa30: 82 00 60 01 inc %g1
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000aa34: ba 10 00 06 mov %g6, %i5
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000aa38: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aa3c: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aa40: 91 d0 20 0a ta 0xa
4000aa44: 01 00 00 00 nop
_Thread_Priority_update( queue_context );
4000aa48: 40 00 0a 3a call 4000d330 <_Thread_Priority_update>
4000aa4c: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_enable( cpu_self );
4000aa50: 90 10 00 1d mov %i5, %o0
4000aa54: 40 00 0a c7 call 4000d570 <_Thread_Dispatch_enable>
4000aa58: b0 10 20 00 clr %i0
return STATUS_SUCCESSFUL;
4000aa5c: 81 c7 e0 08 ret
4000aa60: 81 e8 00 00 restore
if (
4000aa64: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4000aa68: 80 a0 80 01 cmp %g2, %g1
4000aa6c: 28 bf ff ec bleu,a 4000aa1c <rtems_semaphore_obtain+0x250>
4000aa70: fa 22 20 14 st %i5, [ %o0 + 0x14 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aa74: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000aa78: 91 d0 20 0a ta 0xa
4000aa7c: 01 00 00 00 nop
return STATUS_MUTEX_CEILING_VIOLATED;
4000aa80: 81 c7 e0 08 ret
4000aa84: 91 e8 20 13 restore %g0, 0x13, %o0
4000aa88 <rtems_semaphore_release>:
#include <rtems/rtems/semimpl.h>
#include <rtems/rtems/statusimpl.h>
rtems_status_code rtems_semaphore_release( rtems_id id )
{
4000aa88: 9d e3 bf 78 save %sp, -136, %sp
return (Semaphore_Control *) _Objects_Get(
4000aa8c: 15 10 00 7d sethi %hi(0x4001f400), %o2
4000aa90: 92 07 bf dc add %fp, -36, %o1
4000aa94: 94 12 a1 44 or %o2, 0x144, %o2
4000aa98: 40 00 06 78 call 4000c478 <_Objects_Get>
4000aa9c: 90 10 00 18 mov %i0, %o0
Semaphore_Variant variant;
Status_Control status;
the_semaphore = _Semaphore_Get( id, &queue_context );
if ( the_semaphore == NULL ) {
4000aaa0: ba 92 20 00 orcc %o0, 0, %i5
4000aaa4: 02 80 00 a0 be 4000ad24 <rtems_semaphore_release+0x29c>
4000aaa8: 01 00 00 00 nop
return (uintptr_t) the_semaphore->Object.Node.previous;
4000aaac: c4 07 60 04 ld [ %i5 + 4 ], %g2
return (Semaphore_Discipline) ( flags & 0x7 );
4000aab0: 82 08 a0 07 and %g2, 7, %g1
#else
return RTEMS_INVALID_ID;
#endif
}
executing = _Thread_Executing;
4000aab4: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
_Semaphore_Core_mutex_mp_support
);
flags = _Semaphore_Get_flags( the_semaphore );
variant = _Semaphore_Get_variant( flags );
switch ( variant ) {
4000aab8: 80 a0 60 02 cmp %g1, 2
4000aabc: 02 80 00 52 be 4000ac04 <rtems_semaphore_release+0x17c>
4000aac0: b8 07 60 10 add %i5, 0x10, %i4
4000aac4: 18 80 00 31 bgu 4000ab88 <rtems_semaphore_release+0x100>
4000aac8: 80 a0 60 00 cmp %g1, 0
4000aacc: 02 80 00 7c be 4000acbc <rtems_semaphore_release+0x234>
4000aad0: 80 a0 60 01 cmp %g1, 1
4000aad4: 12 80 00 63 bne 4000ac60 <rtems_semaphore_release+0x1d8> <== NEVER TAKEN
4000aad8: 80 88 a0 08 btst 8, %g2
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 ) ) {
4000aadc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000aae0: 80 a2 00 01 cmp %o0, %g1
4000aae4: 12 80 00 41 bne 4000abe8 <rtems_semaphore_release+0x160>
4000aae8: 01 00 00 00 nop
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
return STATUS_NOT_OWNER;
}
nest_level = the_mutex->Recursive.nest_level;
4000aaec: f0 07 60 1c ld [ %i5 + 0x1c ], %i0
if ( nest_level > 0 ) {
4000aaf0: 80 a6 20 00 cmp %i0, 0
4000aaf4: 32 80 00 86 bne,a 4000ad0c <rtems_semaphore_release+0x284> <== NEVER TAKEN
4000aaf8: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED
4000aafc: c0 27 bf f0 clr [ %fp + -16 ]
_Thread_Resource_count_decrement( executing );
_Thread_queue_Context_clear_priority_updates( queue_context );
_Thread_Wait_acquire_default_critical( executing, &lock_context );
_Thread_Priority_remove(
4000ab00: a0 07 60 20 add %i5, 0x20, %l0
4000ab04: 94 07 bf dc add %fp, -36, %o2
4000ab08: 40 00 09 c6 call 4000d220 <_Thread_Priority_remove>
4000ab0c: 92 10 00 10 mov %l0, %o1
RTEMS_INLINE_ROUTINE Thread_Control *_Thread_queue_First_locked(
Thread_queue_Control *the_thread_queue,
const Thread_queue_Operations *operations
)
{
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
4000ab10: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if ( heads != NULL ) {
4000ab14: 80 a2 20 00 cmp %o0, 0
4000ab18: 02 80 00 96 be 4000ad70 <rtems_semaphore_release+0x2e8>
4000ab1c: 33 10 00 72 sethi %hi(0x4001c800), %i1
return ( *operations->first )( heads );
4000ab20: b2 16 62 b0 or %i1, 0x2b0, %i1 ! 4001cab0 <_Thread_queue_Operations_priority>
4000ab24: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000ab28: 9f c0 40 00 call %g1
4000ab2c: 01 00 00 00 nop
disable_level = cpu_self->thread_dispatch_disable_level;
4000ab30: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
the_mutex->Wait_queue.Queue.owner = owner;
4000ab34: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000ab38: 82 00 60 01 inc %g1
4000ab3c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000ab40: b4 10 00 06 mov %g6, %i2
cpu_self = _Thread_Dispatch_disable_critical(
&queue_context->Lock_context.Lock_context
);
if ( new_owner != NULL ) {
4000ab44: 80 a2 20 00 cmp %o0, 0
4000ab48: 02 80 00 8f be 4000ad84 <rtems_semaphore_release+0x2fc> <== NEVER TAKEN
4000ab4c: b6 10 00 08 mov %o0, %i3
#if defined(RTEMS_MULTIPROCESSING)
if ( _Objects_Is_local_id( new_owner->Object.id ) )
#endif
{
_Thread_Resource_count_increment( new_owner );
_Thread_Priority_add(
4000ab50: 94 07 bf dc add %fp, -36, %o2
4000ab54: 40 00 09 92 call 4000d19c <_Thread_Priority_add>
4000ab58: 92 10 00 10 mov %l0, %o1
&the_mutex->Priority_ceiling,
queue_context
);
}
_Thread_queue_Extract_critical(
4000ab5c: 96 07 bf dc add %fp, -36, %o3
4000ab60: 94 10 00 1b mov %i3, %o2
4000ab64: 92 10 00 19 mov %i1, %o1
4000ab68: 40 00 0b 6c call 4000d918 <_Thread_queue_Extract_critical>
4000ab6c: 90 10 00 1c mov %i4, %o0
);
} else {
_CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context );
}
_Thread_Priority_update( queue_context );
4000ab70: 40 00 09 f0 call 4000d330 <_Thread_Priority_update>
4000ab74: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_enable( cpu_self );
4000ab78: 40 00 0a 7e call 4000d570 <_Thread_Dispatch_enable>
4000ab7c: 90 10 00 1a mov %i2, %o0
return STATUS_SUCCESSFUL;
4000ab80: 81 c7 e0 08 ret
4000ab84: 81 e8 00 00 restore
4000ab88: 80 a0 60 03 cmp %g1, 3
4000ab8c: 12 80 00 35 bne 4000ac60 <rtems_semaphore_release+0x1d8>
4000ab90: 80 88 a0 08 btst 8, %g2
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000ab94: 02 80 00 1a be 4000abfc <rtems_semaphore_release+0x174>
4000ab98: 37 10 00 72 sethi %hi(0x4001c800), %i3
return &_Thread_queue_Operations_FIFO;
4000ab9c: 37 10 00 72 sethi %hi(0x4001c800), %i3
4000aba0: b6 16 e2 c4 or %i3, 0x2c4, %i3 ! 4001cac4 <_Thread_queue_Operations_FIFO>
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
4000aba4: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if ( heads != NULL ) {
4000aba8: 80 a2 20 00 cmp %o0, 0
4000abac: 22 80 00 60 be,a 4000ad2c <rtems_semaphore_release+0x2a4>
4000abb0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
return ( *operations->first )( heads );
4000abb4: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
4000abb8: 9f c0 40 00 call %g1
4000abbc: 01 00 00 00 nop
if ( the_thread != NULL ) {
4000abc0: 94 92 20 00 orcc %o0, 0, %o2
4000abc4: 22 80 00 5a be,a 4000ad2c <rtems_semaphore_release+0x2a4> <== NEVER TAKEN
4000abc8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
_Thread_queue_Extract_critical(
4000abcc: b0 10 20 00 clr %i0
4000abd0: 96 07 bf dc add %fp, -36, %o3
4000abd4: 92 10 00 1b mov %i3, %o1
4000abd8: 40 00 0b 50 call 4000d918 <_Thread_queue_Extract_critical>
4000abdc: 90 10 00 1c mov %i4, %o0
4000abe0: 81 c7 e0 08 ret
4000abe4: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000abe8: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000abec: 91 d0 20 0a ta 0xa
4000abf0: 01 00 00 00 nop
return STATUS_NOT_OWNER;
4000abf4: 81 c7 e0 08 ret
4000abf8: 91 e8 20 17 restore %g0, 0x17, %o0
return &_Thread_queue_Operations_priority;
4000abfc: 10 bf ff ea b 4000aba4 <rtems_semaphore_release+0x11c>
4000ac00: b6 16 e2 b0 or %i3, 0x2b0, %i3
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000ac04: 80 88 a0 08 btst 8, %g2
4000ac08: 02 80 00 52 be 4000ad50 <rtems_semaphore_release+0x2c8>
4000ac0c: 19 10 00 72 sethi %hi(0x4001c800), %o4
return &_Thread_queue_Operations_FIFO;
4000ac10: 19 10 00 72 sethi %hi(0x4001c800), %o4
4000ac14: 98 13 22 c4 or %o4, 0x2c4, %o4 ! 4001cac4 <_Thread_queue_Operations_FIFO>
if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) {
4000ac18: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000ac1c: 80 a2 00 01 cmp %o0, %g1
4000ac20: 12 bf ff f2 bne 4000abe8 <rtems_semaphore_release+0x160> <== NEVER TAKEN
4000ac24: 01 00 00 00 nop
nest_level = the_mutex->nest_level;
4000ac28: f0 07 60 1c ld [ %i5 + 0x1c ], %i0
if ( nest_level > 0 ) {
4000ac2c: 80 a6 20 00 cmp %i0, 0
4000ac30: 32 80 00 37 bne,a 4000ad0c <rtems_semaphore_release+0x284> <== NEVER TAKEN
4000ac34: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED
the_mutex->Wait_queue.Queue.owner = owner;
4000ac38: c0 27 60 14 clr [ %i5 + 0x14 ]
heads = the_mutex->Mutex.Wait_queue.Queue.heads;
4000ac3c: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
if ( heads == NULL ) {
4000ac40: 80 a2 60 00 cmp %o1, 0
4000ac44: 02 80 00 19 be 4000aca8 <rtems_semaphore_release+0x220>
4000ac48: 96 07 bf dc add %fp, -36, %o3
_Thread_queue_Surrender(
4000ac4c: 94 10 00 08 mov %o0, %o2
4000ac50: 40 00 0b 73 call 4000da1c <_Thread_queue_Surrender>
4000ac54: 90 10 00 1c mov %i4, %o0
return STATUS_SUCCESSFUL;
4000ac58: 81 c7 e0 08 ret
4000ac5c: 81 e8 00 00 restore
if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) {
4000ac60: 02 80 00 3e be 4000ad58 <rtems_semaphore_release+0x2d0>
4000ac64: 37 10 00 72 sethi %hi(0x4001c800), %i3
return &_Thread_queue_Operations_FIFO;
4000ac68: 37 10 00 72 sethi %hi(0x4001c800), %i3
4000ac6c: b6 16 e2 c4 or %i3, 0x2c4, %i3 ! 4001cac4 <_Thread_queue_Operations_FIFO>
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
4000ac70: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if ( heads != NULL ) {
4000ac74: 80 a2 20 00 cmp %o0, 0
4000ac78: 22 80 00 09 be,a 4000ac9c <rtems_semaphore_release+0x214>
4000ac7c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
return ( *operations->first )( heads );
4000ac80: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
4000ac84: 9f c0 40 00 call %g1
4000ac88: 01 00 00 00 nop
if ( the_thread != NULL ) {
4000ac8c: 94 92 20 00 orcc %o0, 0, %o2
4000ac90: 32 bf ff d0 bne,a 4000abd0 <rtems_semaphore_release+0x148> <== ALWAYS TAKEN
4000ac94: b0 10 20 00 clr %i0
if ( the_semaphore->count < maximum_count )
4000ac98: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
4000ac9c: 80 a0 7f ff cmp %g1, -1
4000aca0: 12 80 00 30 bne 4000ad60 <rtems_semaphore_release+0x2d8>
4000aca4: b0 10 20 0d mov 0xd, %i0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000aca8: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000acac: 91 d0 20 0a ta 0xa
4000acb0: 01 00 00 00 nop
&queue_context
);
break;
}
return _Status_Get( status );
4000acb4: 81 c7 e0 08 ret
4000acb8: 81 e8 00 00 restore
if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) {
4000acbc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000acc0: 80 a2 00 01 cmp %o0, %g1
4000acc4: 12 bf ff c9 bne 4000abe8 <rtems_semaphore_release+0x160>
4000acc8: 01 00 00 00 nop
nest_level = the_mutex->nest_level;
4000accc: f0 07 60 1c ld [ %i5 + 0x1c ], %i0
if ( nest_level > 0 ) {
4000acd0: 80 a6 20 00 cmp %i0, 0
4000acd4: 32 80 00 0e bne,a 4000ad0c <rtems_semaphore_release+0x284>
4000acd8: b0 06 3f ff add %i0, -1, %i0
the_mutex->Wait_queue.Queue.owner = owner;
4000acdc: c0 27 60 14 clr [ %i5 + 0x14 ]
heads = the_mutex->Mutex.Wait_queue.Queue.heads;
4000ace0: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
if ( heads == NULL ) {
4000ace4: 80 a2 60 00 cmp %o1, 0
4000ace8: 02 bf ff f0 be 4000aca8 <rtems_semaphore_release+0x220>
4000acec: 96 07 bf dc add %fp, -36, %o3
_Thread_queue_Surrender(
4000acf0: 94 10 00 08 mov %o0, %o2
4000acf4: 19 10 00 72 sethi %hi(0x4001c800), %o4
4000acf8: 90 10 00 1c mov %i4, %o0
4000acfc: 40 00 0b 48 call 4000da1c <_Thread_queue_Surrender>
4000ad00: 98 13 22 9c or %o4, 0x29c, %o4
return STATUS_SUCCESSFUL;
4000ad04: 81 c7 e0 08 ret
4000ad08: 81 e8 00 00 restore
the_mutex->nest_level = nest_level - 1;
4000ad0c: f0 27 60 1c st %i0, [ %i5 + 0x1c ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ad10: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ad14: 91 d0 20 0a ta 0xa
4000ad18: 01 00 00 00 nop
return STATUS_SUCCESSFUL;
4000ad1c: 81 c7 e0 08 ret
4000ad20: 91 e8 20 00 restore %g0, 0, %o0
}
4000ad24: 81 c7 e0 08 ret
4000ad28: 91 e8 20 04 restore %g0, 4, %o0
4000ad2c: 80 a0 60 00 cmp %g1, 0
4000ad30: 12 80 00 03 bne 4000ad3c <rtems_semaphore_release+0x2b4>
4000ad34: 82 10 20 01 mov 1, %g1
the_semaphore->count += 1;
4000ad38: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ad3c: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ad40: 91 d0 20 0a ta 0xa
4000ad44: 01 00 00 00 nop
4000ad48: 81 c7 e0 08 ret
4000ad4c: 91 e8 20 00 restore %g0, 0, %o0
return &_Thread_queue_Operations_priority;
4000ad50: 10 bf ff b2 b 4000ac18 <rtems_semaphore_release+0x190>
4000ad54: 98 13 22 b0 or %o4, 0x2b0, %o4
4000ad58: 10 bf ff c6 b 4000ac70 <rtems_semaphore_release+0x1e8>
4000ad5c: b6 16 e2 b0 or %i3, 0x2b0, %i3
4000ad60: 82 00 60 01 inc %g1
4000ad64: b0 10 20 00 clr %i0
4000ad68: 10 bf ff d0 b 4000aca8 <rtems_semaphore_release+0x220>
4000ad6c: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
disable_level = cpu_self->thread_dispatch_disable_level;
4000ad70: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
the_mutex->Wait_queue.Queue.owner = owner;
4000ad74: c0 27 60 14 clr [ %i5 + 0x14 ]
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000ad78: 82 00 60 01 inc %g1
4000ad7c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
4000ad80: b4 10 00 06 mov %g6, %i2
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000ad84: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000ad88: 91 d0 20 0a ta 0xa
4000ad8c: 01 00 00 00 nop
}
4000ad90: 30 bf ff 78 b,a 4000ab70 <rtems_semaphore_release+0xe8>
40005164 <rtems_semaphore_set_priority>:
rtems_id semaphore_id,
rtems_id scheduler_id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
40005164: 9d e3 bf 78 save %sp, -136, %sp
const Scheduler_Control *scheduler;
Semaphore_Control *the_semaphore;
Thread_queue_Context queue_context;
if ( old_priority == NULL ) {
40005168: 80 a6 e0 00 cmp %i3, 0
4000516c: 02 80 00 53 be 400052b8 <rtems_semaphore_set_priority+0x154>
40005170: 03 03 c0 40 sethi %hi(0xf010000), %g1
{
uint32_t index;
index = _Scheduler_Get_index_by_id( id );
if ( index >= _Scheduler_Count ) {
40005174: 82 10 60 01 or %g1, 1, %g1 ! f010001 <RAM_SIZE+0xec10001>
40005178: 80 a6 40 01 cmp %i1, %g1
4000517c: 12 80 00 3c bne 4000526c <rtems_semaphore_set_priority+0x108>
40005180: 92 07 bf dc add %fp, -36, %o1
return (Semaphore_Control *) _Objects_Get(
40005184: 15 10 00 4f sethi %hi(0x40013c00), %o2
40005188: 90 10 00 18 mov %i0, %o0
4000518c: 40 00 04 0d call 400061c0 <_Objects_Get>
40005190: 94 12 a1 04 or %o2, 0x104, %o2
return RTEMS_INVALID_ID;
}
the_semaphore = _Semaphore_Get( semaphore_id, &queue_context );
if ( the_semaphore == NULL ) {
40005194: b8 92 20 00 orcc %o0, 0, %i4
40005198: 02 80 00 35 be 4000526c <rtems_semaphore_set_priority+0x108>
4000519c: 3b 10 00 44 sethi %hi(0x40011000), %i5
400051a0: ba 17 61 e8 or %i5, 0x1e8, %i5 ! 400111e8 <_Scheduler_Table>
return ( *scheduler->Operations.map_priority )( scheduler, priority );
400051a4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400051a8: f2 07 60 40 ld [ %i5 + 0x40 ], %i1
400051ac: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
400051b0: 92 10 20 00 clr %o1
400051b4: 94 10 00 1a mov %i2, %o2
400051b8: 9f c0 40 00 call %g1
400051bc: 90 10 00 1d mov %i5, %o0
if ( new_priority != RTEMS_CURRENT_PRIORITY && !valid ) {
400051c0: 80 a6 a0 00 cmp %i2, 0
400051c4: 22 80 00 22 be,a 4000524c <rtems_semaphore_set_priority+0xe8>
400051c8: c0 27 bf f0 clr [ %fp + -16 ]
400051cc: 82 10 20 00 clr %g1
400051d0: 80 a0 40 19 cmp %g1, %i1
400051d4: 02 80 00 3b be 400052c0 <rtems_semaphore_set_priority+0x15c> <== ALWAYS TAKEN
400051d8: 80 a6 80 18 cmp %i2, %i0
queue_context->Priority.update_count = 0;
400051dc: c0 27 bf f0 clr [ %fp + -16 ] <== NOT EXECUTED
return (Semaphore_Discipline) ( flags & 0x7 );
400051e0: c2 07 20 04 ld [ %i4 + 4 ], %g1
400051e4: 82 08 60 07 and %g1, 7, %g1
switch ( variant ) {
400051e8: 80 a0 60 01 cmp %g1, 1
400051ec: 22 80 00 22 be,a 40005274 <rtems_semaphore_set_priority+0x110>
400051f0: c4 07 20 14 ld [ %i4 + 0x14 ], %g2
old_priority = 0;
400051f4: a0 10 20 00 clr %l0
400051f8: a2 10 20 00 clr %l1
sc = RTEMS_NOT_DEFINED;
400051fc: b0 10 20 0b mov 0xb, %i0
disable_level = cpu_self->thread_dispatch_disable_level;
40005200: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40005204: 82 00 60 01 inc %g1
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40005208: b8 10 00 06 mov %g6, %i4
cpu_self->thread_dispatch_disable_level = disable_level + 1;
4000520c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40005210: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005214: 91 d0 20 0a ta 0xa
40005218: 01 00 00 00 nop
_Thread_Priority_update( queue_context );
4000521c: 40 00 07 90 call 4000705c <_Thread_Priority_update>
40005220: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_enable( cpu_self );
40005224: 40 00 07 f8 call 40007204 <_Thread_Dispatch_enable>
40005228: 90 10 00 1c mov %i4, %o0
return ( *scheduler->Operations.unmap_priority )( scheduler, priority );
4000522c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
40005230: 92 10 00 10 mov %l0, %o1
40005234: 94 10 00 11 mov %l1, %o2
40005238: 9f c0 40 00 call %g1
4000523c: 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)
40005240: d2 26 c0 00 st %o1, [ %i3 ]
return sc;
40005244: 81 c7 e0 08 ret
40005248: 81 e8 00 00 restore
4000524c: c2 07 20 04 ld [ %i4 + 4 ], %g1
40005250: 82 08 60 07 and %g1, 7, %g1
switch ( variant ) {
40005254: 80 a0 60 01 cmp %g1, 1
40005258: 32 bf ff e8 bne,a 400051f8 <rtems_semaphore_set_priority+0x94> <== NEVER TAKEN
4000525c: a0 10 20 00 clr %l0 <== NOT EXECUTED
return the_mutex->Priority_ceiling.priority;
40005260: e0 1f 20 30 ldd [ %i4 + 0x30 ], %l0
if ( sc == RTEMS_SUCCESSFUL && new_priority != RTEMS_CURRENT_PRIORITY ) {
40005264: 10 bf ff e7 b 40005200 <rtems_semaphore_set_priority+0x9c>
40005268: b0 10 20 00 clr %i0
return RTEMS_INVALID_ID;
4000526c: 81 c7 e0 08 ret
40005270: 91 e8 20 04 restore %g0, 4, %o0
if ( owner != NULL ) {
40005274: 80 a0 a0 00 cmp %g2, 0
40005278: 02 80 00 19 be 400052dc <rtems_semaphore_set_priority+0x178> <== ALWAYS TAKEN
4000527c: e0 1f 20 30 ldd [ %i4 + 0x30 ], %l0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005280: 91 d0 20 09 ta 9 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire(
Thread_Control *the_thread,
Thread_queue_Context *queue_context
)
{
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40005284: c2 27 bf dc st %g1, [ %fp + -36 ] <== NOT EXECUTED
node->priority = priority;
40005288: d0 27 20 30 st %o0, [ %i4 + 0x30 ] <== NOT EXECUTED
_Thread_Priority_changed(
4000528c: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED
40005290: d2 27 20 34 st %o1, [ %i4 + 0x34 ] <== NOT EXECUTED
40005294: 94 10 20 00 clr %o2 <== NOT EXECUTED
40005298: 92 07 20 20 add %i4, 0x20, %o1 <== NOT EXECUTED
4000529c: 40 00 07 4e call 40006fd4 <_Thread_Priority_changed> <== NOT EXECUTED
400052a0: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400052a4: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400052a8: 91 d0 20 0a ta 0xa <== NOT EXECUTED
400052ac: 01 00 00 00 nop <== NOT EXECUTED
Thread_queue_Context *queue_context
)
{
_Thread_Wait_release_critical( the_thread, queue_context );
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
}
400052b0: 10 bf ff d4 b 40005200 <rtems_semaphore_set_priority+0x9c> <== NOT EXECUTED
400052b4: b0 10 20 00 clr %i0 ! 0 <PROM_START> <== NOT EXECUTED
scheduler,
new_priority,
old_priority,
&queue_context
);
}
400052b8: 81 c7 e0 08 ret
400052bc: 91 e8 20 09 restore %g0, 9, %o0
if ( new_priority != RTEMS_CURRENT_PRIORITY && !valid ) {
400052c0: 28 bf ff c8 bleu,a 400051e0 <rtems_semaphore_set_priority+0x7c>
400052c4: c0 27 bf f0 clr [ %fp + -16 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400052c8: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400052cc: 91 d0 20 0a ta 0xa
400052d0: 01 00 00 00 nop
return RTEMS_INVALID_PRIORITY;
400052d4: 81 c7 e0 08 ret
400052d8: 91 e8 20 13 restore %g0, 0x13, %o0
the_mutex->Priority_ceiling.priority = priority_ceiling;
400052dc: d0 27 20 30 st %o0, [ %i4 + 0x30 ]
sc = _Semaphore_Is_scheduler_valid(
400052e0: b0 10 20 00 clr %i0
400052e4: 10 bf ff c7 b 40005200 <rtems_semaphore_set_priority+0x9c>
400052e8: d2 27 20 34 st %o1, [ %i4 + 0x34 ]
4000afb0 <rtems_status_code_to_errno>:
[RTEMS_INTERRUPTED] = EINTR,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_status_code_to_errno(rtems_status_code sc)
{
4000afb0: 9d e3 bf a0 save %sp, -96, %sp
4000afb4: 82 10 00 18 mov %i0, %g1
if (sc == RTEMS_SUCCESSFUL) {
4000afb8: 80 a0 60 00 cmp %g1, 0
4000afbc: 02 80 00 0c be 4000afec <rtems_status_code_to_errno+0x3c>
4000afc0: b0 10 20 00 clr %i0
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
4000afc4: 80 a0 60 1d cmp %g1, 0x1d
4000afc8: 18 80 00 06 bgu 4000afe0 <rtems_status_code_to_errno+0x30> <== NEVER TAKEN
4000afcc: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
4000afd0: 83 28 60 02 sll %g1, 2, %g1
4000afd4: 05 10 00 5f sethi %hi(0x40017c00), %g2
4000afd8: 84 10 a2 a8 or %g2, 0x2a8, %g2 ! 40017ea8 <status_code_to_errno>
4000afdc: fa 00 80 01 ld [ %g2 + %g1 ], %i5
}
errno = eno;
4000afe0: 40 00 13 07 call 4000fbfc <__errno>
4000afe4: b0 10 3f ff mov -1, %i0
4000afe8: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
4000afec: 81 c7 e0 08 ret
4000aff0: 81 e8 00 00 restore
4001075c <rtems_task_delete>:
#include <rtems/score/threadimpl.h>
rtems_status_code rtems_task_delete(
rtems_id id
)
{
4001075c: 9d e3 bf 78 save %sp, -136, %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 );
40010760: 90 10 00 18 mov %i0, %o0
40010764: 7f ff e7 5a call 4000a4cc <_Thread_Get>
40010768: 92 07 bf d8 add %fp, -40, %o1
if ( the_thread == NULL ) {
4001076c: 82 92 20 00 orcc %o0, 0, %g1
40010770: 02 80 00 19 be 400107d4 <rtems_task_delete+0x78>
40010774: 01 00 00 00 nop
#endif
return RTEMS_INVALID_ID;
}
executing = _Thread_Executing;
40010778: d2 01 a0 20 ld [ %g6 + 0x20 ], %o1
if ( the_thread == executing ) {
4001077c: 80 a0 40 09 cmp %g1, %o1
40010780: 02 80 00 07 be 4001079c <rtems_task_delete+0x40>
40010784: 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 );
40010788: 94 07 bf d8 add %fp, -40, %o2
4001078c: 7f ff ec 6a call 4000b934 <_Thread_Close>
40010790: b0 10 20 00 clr %i0
40010794: 81 c7 e0 08 ret
40010798: 81 e8 00 00 restore
disable_level = cpu_self->thread_dispatch_disable_level;
4001079c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400107a0: 82 00 60 01 inc %g1
400107a4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400107a8: c2 07 bf d8 ld [ %fp + -40 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400107ac: 91 d0 20 0a ta 0xa
400107b0: 01 00 00 00 nop
_Thread_Exit(
400107b4: 94 10 20 00 clr %o2 ! 0 <PROM_START>
400107b8: 7f ff ec 6e call 4000b970 <_Thread_Exit>
400107bc: 92 10 20 14 mov 0x14, %o1
_Thread_Dispatch_enable( cpu_self );
400107c0: 90 10 00 1d mov %i5, %o0
400107c4: 7f ff e7 28 call 4000a464 <_Thread_Dispatch_enable>
400107c8: b0 10 20 00 clr %i0
400107cc: 81 c7 e0 08 ret <== NOT EXECUTED
400107d0: 81 e8 00 00 restore <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
400107d4: 81 c7 e0 08 ret
400107d8: 91 e8 20 04 restore %g0, 4, %o0
400107dc <rtems_task_exit>:
#include <rtems/rtems/tasks.h>
#include <rtems/score/threadimpl.h>
void rtems_task_exit( void )
{
400107dc: 9d e3 bf a0 save %sp, -96, %sp
disable_level = cpu_self->thread_dispatch_disable_level;
400107e0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400107e4: 82 00 60 01 inc %g1
400107e8: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
400107ec: ba 10 00 06 mov %g6, %i5
Per_CPU_Control *cpu_self;
cpu_self = _Thread_Dispatch_disable();
executing = _Per_CPU_Get_executing( cpu_self );
_Thread_Exit(
400107f0: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
400107f4: 94 10 20 00 clr %o2
400107f8: 7f ff ec 5e call 4000b970 <_Thread_Exit>
400107fc: 92 10 20 14 mov 0x14, %o1
executing,
THREAD_LIFE_TERMINATING | THREAD_LIFE_DETACHED,
NULL
);
_Thread_Dispatch_direct( cpu_self );
40010800: 7f ff e7 0e call 4000a438 <_Thread_Dispatch_direct>
40010804: 90 10 00 1d mov %i5, %o0
RTEMS_UNREACHABLE();
40010808: 01 00 00 00 nop <== NOT EXECUTED
40007848 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
40007848: 9d e3 bf 98 save %sp, -104, %sp
bool needs_asr_dispatching;
rtems_mode old_mode;
executing = _Thread_Get_executing();
if ( !previous_mode_set )
4000784c: 80 a6 a0 00 cmp %i2, 0
40007850: 02 80 00 77 be 40007a2c <rtems_task_mode+0x1e4>
40007854: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
*/
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40007858: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1
4000785c: 80 a0 00 01 cmp %g0, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
40007860: c2 07 20 90 ld [ %i4 + 0x90 ], %g1
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
40007864: ba 60 3f ff subx %g0, -1, %i5
api = executing->API_Extensions[ THREAD_API_RTEMS ];
40007868: e0 07 21 58 ld [ %i4 + 0x158 ], %l0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4000786c: 80 a0 60 00 cmp %g1, 0
40007870: 12 80 00 5e bne 400079e8 <rtems_task_mode+0x1a0>
40007874: b7 2f 60 08 sll %i5, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
40007878: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
4000787c: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
40007880: 40 00 14 c8 call 4000cba0 <_CPU_ISR_Get_level>
40007884: ba 60 3f ff subx %g0, -1, %i5
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
40007888: bb 2f 60 0a sll %i5, 0xa, %i5
old_mode |= _ISR_Get_level();
4000788c: ba 17 40 08 or %i5, %o0, %i5
40007890: ba 17 40 1b or %i5, %i3, %i5
*previous_mode_set = old_mode;
40007894: fa 26 80 00 st %i5, [ %i2 ]
/*
* These are generic thread scheduling characteristics.
*/
preempt_enabled = false;
if ( mask & RTEMS_PREEMPT_MASK ) {
40007898: 80 8e 61 00 btst 0x100, %i1
4000789c: 02 80 00 09 be 400078c0 <rtems_task_mode+0x78>
400078a0: 84 10 20 00 clr %g2
bool is_preempt_enabled = _Modes_Is_preempt( mode_set );
preempt_enabled = !executing->is_preemptible && is_preempt_enabled;
400078a4: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt (
rtems_mode mode_set
)
{
return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;
400078a8: 85 36 20 08 srl %i0, 8, %g2
400078ac: 82 18 60 01 xor %g1, 1, %g1
400078b0: 84 18 a0 01 xor %g2, 1, %g2
400078b4: 84 08 a0 01 and %g2, 1, %g2
executing->is_preemptible = is_preempt_enabled;
400078b8: c4 2f 20 89 stb %g2, [ %i4 + 0x89 ]
preempt_enabled = !executing->is_preemptible && is_preempt_enabled;
400078bc: 84 08 80 01 and %g2, %g1, %g2
}
if ( mask & RTEMS_TIMESLICE_MASK ) {
400078c0: 80 8e 62 00 btst 0x200, %i1
400078c4: 02 80 00 0a be 400078ec <rtems_task_mode+0xa4>
400078c8: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
400078cc: 80 8e 22 00 btst 0x200, %i0
400078d0: 02 80 00 54 be 40007a20 <rtems_task_mode+0x1d8>
400078d4: 80 8e 60 0f btst 0xf, %i1
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget =
400078d8: 03 10 00 6f sethi %hi(0x4001bc00), %g1
400078dc: c2 00 60 fc ld [ %g1 + 0xfc ], %g1 ! 4001bcfc <_Watchdog_Ticks_per_timeslice>
400078e0: c2 27 20 8c st %g1, [ %i4 + 0x8c ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
400078e4: 82 10 20 01 mov 1, %g1
400078e8: c2 27 20 90 st %g1, [ %i4 + 0x90 ]
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK ) {
400078ec: 02 80 00 07 be 40007908 <rtems_task_mode+0xc0>
400078f0: 80 8e 64 00 btst 0x400, %i1
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
rtems_mode mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
400078f4: 83 2e 20 08 sll %i0, 8, %g1
400078f8: 82 08 6f 00 and %g1, 0xf00, %g1
400078fc: 91 d0 20 0a ta 0xa
40007900: 01 00 00 00 nop
/*
* This is specific to the RTEMS API
*/
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
40007904: 80 8e 64 00 btst 0x400, %i1
40007908: 02 80 00 34 be 400079d8 <rtems_task_mode+0x190>
4000790c: 80 88 a0 ff btst 0xff, %g2
bool is_asr_enabled = !_Modes_Is_asr_disabled( mode_set );
40007910: b1 36 20 0a srl %i0, 0xa, %i0
40007914: b0 1e 20 01 xor %i0, 1, %i0
40007918: b0 0e 20 01 and %i0, 1, %i0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000791c: 91 d0 20 09 ta 9
return psr;
40007920: 88 10 00 01 mov %g1, %g4
_Thread_State_acquire( executing, &lock_context );
if ( is_asr_enabled != asr->is_enabled ) {
40007924: c6 0c 20 08 ldub [ %l0 + 8 ], %g3
40007928: 80 a6 00 03 cmp %i0, %g3
4000792c: 02 80 00 27 be 400079c8 <rtems_task_mode+0x180>
40007930: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE rtems_signal_set _ASR_Swap_signals( ASR_Information *asr )
{
rtems_signal_set new_signals_posted;
new_signals_posted = asr->signals_pending;
40007934: c6 04 20 18 ld [ %l0 + 0x18 ], %g3
asr->signals_pending = asr->signals_posted;
40007938: fa 04 20 14 ld [ %l0 + 0x14 ], %i5
asr->is_enabled = is_asr_enabled;
4000793c: f0 2c 20 08 stb %i0, [ %l0 + 8 ]
if ( _ASR_Swap_signals( asr ) != 0 ) {
40007940: 80 a0 e0 00 cmp %g3, 0
40007944: fa 24 20 18 st %i5, [ %l0 + 0x18 ]
40007948: 02 80 00 20 be 400079c8 <rtems_task_mode+0x180>
4000794c: c6 24 20 14 st %g3, [ %l0 + 0x14 ]
action->handler = handler;
40007950: 05 10 00 38 sethi %hi(0x4000e000), %g2
40007954: 84 10 a3 94 or %g2, 0x394, %g2 ! 4000e394 <_Signal_Action_handler>
40007958: c4 24 20 28 st %g2, [ %l0 + 0x28 ]
} 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;
4000795c: 86 10 20 01 mov 1, %g3
40007960: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
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 ) ) {
40007964: c4 04 20 20 ld [ %l0 + 0x20 ], %g2
40007968: 80 a0 a0 00 cmp %g2, 0
4000796c: 22 80 00 32 be,a 40007a34 <rtems_task_mode+0x1ec> <== ALWAYS TAKEN
40007970: c4 07 20 e8 ld [ %i4 + 0xe8 ], %g2
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007974: 91 d0 20 0a ta 0xa <== NOT EXECUTED
40007978: 01 00 00 00 nop <== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
4000797c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40007980: 82 00 60 01 inc %g1
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40007984: ba 10 00 06 mov %g6, %i5
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40007988: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000798c: 91 d0 20 09 ta 9
return psr;
40007990: c2 27 bf fc st %g1, [ %fp + -4 ]
( *scheduler->Operations.schedule )( scheduler, the_thread );
40007994: 11 10 00 6c sethi %hi(0x4001b000), %o0
40007998: 90 12 20 08 or %o0, 8, %o0 ! 4001b008 <_Scheduler_Table>
4000799c: c4 02 20 08 ld [ %o0 + 8 ], %g2
400079a0: 9f c0 80 00 call %g2
400079a4: 92 10 00 1c mov %i4, %o1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400079a8: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400079ac: 91 d0 20 0a ta 0xa
400079b0: 01 00 00 00 nop
_Scheduler_Schedule( executing );
_Thread_State_release( executing, &lock_context );
_Thread_Dispatch_direct( cpu_self );
}
return RTEMS_SUCCESSFUL;
400079b4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
_Thread_Dispatch_direct( cpu_self );
400079b8: 40 00 0b a8 call 4000a858 <_Thread_Dispatch_direct>
400079bc: 90 10 00 1d mov %i5, %o0
400079c0: 81 c7 e0 08 ret
400079c4: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400079c8: 82 10 00 04 mov %g4, %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400079cc: 91 d0 20 0a ta 0xa
400079d0: 01 00 00 00 nop
if ( preempt_enabled || needs_asr_dispatching ) {
400079d4: 80 88 a0 ff btst 0xff, %g2
400079d8: 12 bf ff e9 bne 4000797c <rtems_task_mode+0x134>
400079dc: b0 10 20 00 clr %i0
}
400079e0: 81 c7 e0 08 ret
400079e4: 81 e8 00 00 restore
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
400079e8: c2 0c 20 08 ldub [ %l0 + 8 ], %g1
400079ec: 80 a0 00 01 cmp %g0, %g1
old_mode |= RTEMS_TIMESLICE;
400079f0: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= _ISR_Get_level();
400079f4: 40 00 14 6b call 4000cba0 <_CPU_ISR_Get_level>
400079f8: ba 60 3f ff subx %g0, -1, %i5
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
400079fc: bb 2f 60 0a sll %i5, 0xa, %i5
old_mode |= _ISR_Get_level();
40007a00: ba 17 40 08 or %i5, %o0, %i5
40007a04: ba 17 40 1b or %i5, %i3, %i5
*previous_mode_set = old_mode;
40007a08: fa 26 80 00 st %i5, [ %i2 ]
if ( mask & RTEMS_PREEMPT_MASK ) {
40007a0c: 80 8e 61 00 btst 0x100, %i1
40007a10: 02 bf ff ac be 400078c0 <rtems_task_mode+0x78>
40007a14: 84 10 20 00 clr %g2
preempt_enabled = !executing->is_preemptible && is_preempt_enabled;
40007a18: 10 bf ff a4 b 400078a8 <rtems_task_mode+0x60>
40007a1c: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1
if ( mask & RTEMS_INTERRUPT_MASK ) {
40007a20: 02 bf ff b9 be 40007904 <rtems_task_mode+0xbc>
40007a24: c0 27 20 90 clr [ %i4 + 0x90 ]
40007a28: 30 bf ff b3 b,a 400078f4 <rtems_task_mode+0xac>
}
40007a2c: 81 c7 e0 08 ret
40007a30: 91 e8 20 09 restore %g0, 9, %o0
return &the_chain->Tail.Node;
40007a34: 86 07 20 e4 add %i4, 0xe4, %g3
the_node->next = tail;
40007a38: c6 24 20 20 st %g3, [ %l0 + 0x20 ]
_Chain_Append_if_is_off_chain_unprotected(
40007a3c: 86 04 20 20 add %l0, 0x20, %g3
tail->previous = the_node;
40007a40: c6 27 20 e8 st %g3, [ %i4 + 0xe8 ]
old_last->next = the_node;
40007a44: c6 20 80 00 st %g3, [ %g2 ]
the_node->previous = old_last;
40007a48: c4 24 20 24 st %g2, [ %l0 + 0x24 ]
40007a4c: 91 d0 20 0a ta 0xa
40007a50: 01 00 00 00 nop
if ( preempt_enabled || needs_asr_dispatching ) {
40007a54: 30 bf ff ca b,a 4000797c <rtems_task_mode+0x134>
40004660 <rtems_task_restart>:
rtems_status_code rtems_task_restart(
rtems_id id,
rtems_task_argument argument
)
{
40004660: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
ISR_lock_Context lock_context;
Thread_Entry_information entry;
bool ok;
the_thread = _Thread_Get( id, &lock_context );
40004664: 90 10 00 18 mov %i0, %o0
40004668: 40 00 05 0b call 40005a94 <_Thread_Get>
4000466c: 92 07 bf f0 add %fp, -16, %o1
if ( the_thread == NULL ) {
40004670: 82 92 20 00 orcc %o0, 0, %g1
40004674: 02 80 00 12 be 400046bc <rtems_task_restart+0x5c>
40004678: 94 07 bf f0 add %fp, -16, %o2
#endif
return RTEMS_INVALID_ID;
}
entry = the_thread->Start.Entry;
4000467c: c4 00 60 a4 ld [ %g1 + 0xa4 ], %g2
40004680: c6 00 60 a0 ld [ %g1 + 0xa0 ], %g3
40004684: c4 27 bf f8 st %g2, [ %fp + -8 ]
40004688: c6 27 bf f4 st %g3, [ %fp + -12 ]
entry.Kinds.Numeric.argument = argument;
4000468c: f2 27 bf fc st %i1, [ %fp + -4 ]
if ( the_thread == _Thread_Executing ) {
40004690: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
40004694: 80 a0 80 01 cmp %g2, %g1
40004698: 02 80 00 0b be 400046c4 <rtems_task_restart+0x64>
4000469c: 92 07 bf f4 add %fp, -12, %o1
_Thread_Restart_self( the_thread, &entry, &lock_context );
RTEMS_UNREACHABLE();
}
ok = _Thread_Restart_other( the_thread, &entry, &lock_context );
400046a0: 40 00 06 e1 call 40006224 <_Thread_Restart_other>
400046a4: 01 00 00 00 nop
return ok ? RTEMS_SUCCESSFUL : RTEMS_INCORRECT_STATE;
400046a8: 80 a0 00 08 cmp %g0, %o0
400046ac: b0 60 20 00 subx %g0, 0, %i0
400046b0: b0 0e 3f f2 and %i0, -14, %i0
400046b4: 81 c7 e0 08 ret
400046b8: 91 ee 20 0e restore %i0, 0xe, %o0
}
400046bc: 81 c7 e0 08 ret
400046c0: 91 e8 20 04 restore %g0, 4, %o0
_Thread_Restart_self( the_thread, &entry, &lock_context );
400046c4: 40 00 07 2c call 40006374 <_Thread_Restart_self>
400046c8: 01 00 00 00 nop
400046cc: 01 00 00 00 nop <== NOT EXECUTED
40008d10 <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
)
{
40008d10: 9d e3 bf 78 save %sp, -136, %sp
Thread_queue_Context queue_context;
const Scheduler_Control *scheduler;
Priority_Control old_priority;
rtems_status_code status;
if ( old_priority_p == NULL ) {
40008d14: 80 a6 a0 00 cmp %i2, 0
40008d18: 02 80 00 47 be 40008e34 <rtems_task_set_priority+0x124>
40008d1c: 90 10 00 18 mov %i0, %o0
*/
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
40008d20: 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 );
40008d24: 40 00 08 ab call 4000afd0 <_Thread_Get>
40008d28: 92 07 bf dc add %fp, -36, %o1
if ( the_thread == NULL ) {
40008d2c: ba 92 20 00 orcc %o0, 0, %i5
40008d30: 02 80 00 43 be 40008e3c <rtems_task_set_priority+0x12c>
40008d34: 80 a6 60 00 cmp %i1, 0
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
40008d38: c2 07 60 38 ld [ %i5 + 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 ) {
40008d3c: 12 80 00 10 bne 40008d7c <rtems_task_set_priority+0x6c>
40008d40: e0 18 60 18 ldd [ %g1 + 0x18 ], %l0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008d44: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008d48: 91 d0 20 0a ta 0xa
40008d4c: 01 00 00 00 nop
new_priority,
&queue_context
);
} else {
_Thread_Wait_release( the_thread, &queue_context );
status = RTEMS_SUCCESSFUL;
40008d50: 39 10 00 4f sethi %hi(0x40013c00), %i4
40008d54: b0 10 20 00 clr %i0
40008d58: b8 17 22 28 or %i4, 0x228, %i4
RTEMS_INLINE_ROUTINE Priority_Control _Scheduler_Unmap_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return ( *scheduler->Operations.unmap_priority )( scheduler, priority );
40008d5c: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
40008d60: 92 10 00 10 mov %l0, %o1
40008d64: 94 10 00 11 mov %l1, %o2
40008d68: 9f c0 40 00 call %g1
40008d6c: 90 10 00 1c mov %i4, %o0
RTEMS_INLINE_ROUTINE rtems_task_priority _RTEMS_Priority_From_core(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
return (rtems_task_priority)
40008d70: d2 26 80 00 st %o1, [ %i2 ]
}
*old_priority_p = _RTEMS_Priority_From_core( scheduler, old_priority );
return status;
40008d74: 81 c7 e0 08 ret
40008d78: 81 e8 00 00 restore
*valid = ( priority <= scheduler->maximum_priority );
40008d7c: 39 10 00 4f sethi %hi(0x40013c00), %i4
40008d80: b8 17 22 28 or %i4, 0x228, %i4 ! 40013e28 <_Scheduler_Table>
return ( *scheduler->Operations.map_priority )( scheduler, priority );
40008d84: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40008d88: f6 07 20 40 ld [ %i4 + 0x40 ], %i3
40008d8c: f0 07 20 44 ld [ %i4 + 0x44 ], %i0
40008d90: 92 10 20 00 clr %o1
40008d94: 94 10 00 19 mov %i1, %o2
40008d98: 9f c0 40 00 call %g1
40008d9c: 90 10 00 1c mov %i4, %o0
if ( !valid ) {
40008da0: 80 a6 e0 00 cmp %i3, 0
40008da4: 02 80 00 1d be 40008e18 <rtems_task_set_priority+0x108> <== ALWAYS TAKEN
40008da8: 80 a6 40 18 cmp %i1, %i0
node->priority = priority;
40008dac: d0 27 60 30 st %o0, [ %i5 + 0x30 ] <== NOT EXECUTED
_Thread_Priority_changed(
40008db0: 96 07 bf dc add %fp, -36, %o3
40008db4: d2 27 60 34 st %o1, [ %i5 + 0x34 ]
40008db8: 90 10 00 1d mov %i5, %o0
40008dbc: 92 07 60 20 add %i5, 0x20, %o1
40008dc0: 40 00 07 b8 call 4000aca0 <_Thread_Priority_changed>
40008dc4: 94 10 20 00 clr %o2
disable_level = cpu_self->thread_dispatch_disable_level;
40008dc8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40008dcc: 82 00 60 01 inc %g1
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40008dd0: ba 10 00 06 mov %g6, %i5
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40008dd4: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008dd8: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008ddc: 91 d0 20 0a ta 0xa
40008de0: 01 00 00 00 nop
_Thread_Priority_update( queue_context );
40008de4: 40 00 07 d1 call 4000ad28 <_Thread_Priority_update>
40008de8: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_enable( cpu_self );
40008dec: 40 00 08 5f call 4000af68 <_Thread_Dispatch_enable>
40008df0: 90 10 00 1d mov %i5, %o0
return ( *scheduler->Operations.unmap_priority )( scheduler, priority );
40008df4: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
40008df8: 92 10 00 10 mov %l0, %o1
40008dfc: 94 10 00 11 mov %l1, %o2
40008e00: 90 10 00 1c mov %i4, %o0
40008e04: 9f c0 40 00 call %g1
40008e08: b0 10 20 00 clr %i0
return (rtems_task_priority)
40008e0c: d2 26 80 00 st %o1, [ %i2 ]
return status;
40008e10: 81 c7 e0 08 ret
40008e14: 81 e8 00 00 restore
if ( !valid ) {
40008e18: 28 bf ff e6 bleu,a 40008db0 <rtems_task_set_priority+0xa0>
40008e1c: d0 27 60 30 st %o0, [ %i5 + 0x30 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40008e20: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008e24: 91 d0 20 0a ta 0xa
40008e28: 01 00 00 00 nop
return RTEMS_INVALID_PRIORITY;
40008e2c: 10 bf ff cc b 40008d5c <rtems_task_set_priority+0x4c>
40008e30: b0 10 20 13 mov 0x13, %i0 ! 13 <_TLS_Alignment+0x12>
return RTEMS_INVALID_ADDRESS;
40008e34: 81 c7 e0 08 ret
40008e38: 91 e8 20 09 restore %g0, 9, %o0
}
40008e3c: 81 c7 e0 08 ret
40008e40: 91 e8 20 04 restore %g0, 4, %o0
40007a48 <rtems_task_set_scheduler>:
rtems_status_code rtems_task_set_scheduler(
rtems_id task_id,
rtems_id scheduler_id,
rtems_task_priority priority
)
{
40007a48: 9d e3 bf 70 save %sp, -144, %sp
if ( index >= _Scheduler_Count ) {
40007a4c: 03 03 c0 40 sethi %hi(0xf010000), %g1
40007a50: 82 10 60 01 or %g1, 1, %g1 ! f010001 <RAM_SIZE+0xec10001>
40007a54: 80 a6 40 01 cmp %i1, %g1
40007a58: 12 80 00 23 bne 40007ae4 <rtems_task_set_scheduler+0x9c>
40007a5c: 3b 10 00 4f sethi %hi(0x40013c00), %i5
*valid = ( priority <= scheduler->maximum_priority );
40007a60: ba 17 61 60 or %i5, 0x160, %i5 ! 40013d60 <_Scheduler_Table>
return ( *scheduler->Operations.map_priority )( scheduler, priority );
40007a64: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40007a68: f8 07 60 40 ld [ %i5 + 0x40 ], %i4
40007a6c: e2 07 60 44 ld [ %i5 + 0x44 ], %l1
40007a70: 92 10 20 00 clr %o1
40007a74: 94 10 00 1a mov %i2, %o2
40007a78: 9f c0 40 00 call %g1
40007a7c: 90 10 00 1d mov %i5, %o0
if ( scheduler == NULL ) {
return RTEMS_INVALID_ID;
}
core_priority = _RTEMS_Priority_To_core( scheduler, priority, &valid );
if ( !valid ) {
40007a80: 80 a7 20 00 cmp %i4, 0
40007a84: b2 10 00 08 mov %o0, %i1
40007a88: 02 80 00 1a be 40007af0 <rtems_task_set_scheduler+0xa8> <== ALWAYS TAKEN
40007a8c: a0 10 00 09 mov %o1, %l0
return RTEMS_INVALID_PRIORITY;
}
_Thread_queue_Context_initialize( &queue_context );
the_thread = _Thread_Get( task_id, &queue_context.Lock_context.Lock_context );
40007a90: 92 07 bf dc add %fp, -36, %o1
40007a94: 40 00 09 e6 call 4000a22c <_Thread_Get>
40007a98: 90 10 00 18 mov %i0, %o0
if ( the_thread == NULL ) {
40007a9c: b8 92 20 00 orcc %o0, 0, %i4
40007aa0: 22 80 00 12 be,a 40007ae8 <rtems_task_set_scheduler+0xa0>
40007aa4: b6 10 20 04 mov 4, %i3
disable_level = cpu_self->thread_dispatch_disable_level;
40007aa8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40007aac: 82 00 60 01 inc %g1
40007ab0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40007ab4: b4 10 00 06 mov %g6, %i2
ISR_lock_Context lock_context;
const Scheduler_Control *old_scheduler;
#endif
if ( the_thread->Wait.queue != NULL ) {
40007ab8: c2 07 20 54 ld [ %i4 + 0x54 ], %g1
40007abc: 80 a0 60 00 cmp %g1, 0
40007ac0: 02 80 00 10 be 40007b00 <rtems_task_set_scheduler+0xb8>
40007ac4: b6 10 20 0c mov 0xc, %i3
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007ac8: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007acc: 91 d0 20 0a ta 0xa
40007ad0: 01 00 00 00 nop
status = _Scheduler_Set( scheduler, the_thread, core_priority );
_Thread_State_release_critical( the_thread, &state_context );
_Thread_Wait_release( the_thread, &queue_context );
_Thread_Dispatch_enable( cpu_self );
40007ad4: 40 00 09 bc call 4000a1c4 <_Thread_Dispatch_enable>
40007ad8: 90 10 00 1a mov %i2, %o0
return _Status_Get( status );
}
40007adc: 81 c7 e0 08 ret
40007ae0: 91 e8 00 1b restore %g0, %i3, %o0
return RTEMS_INVALID_ID;
40007ae4: b6 10 20 04 mov 4, %i3
}
40007ae8: 81 c7 e0 08 ret
40007aec: 91 e8 00 1b restore %g0, %i3, %o0
if ( !valid ) {
40007af0: 80 a6 80 11 cmp %i2, %l1
40007af4: 08 bf ff e7 bleu 40007a90 <rtems_task_set_scheduler+0x48>
40007af8: b6 10 20 13 mov 0x13, %i3
40007afc: 30 bf ff f8 b,a 40007adc <rtems_task_set_scheduler+0x94>
_Assert( !_Chain_Is_empty( &the_thread->Scheduler.Wait_nodes ) );
return SCHEDULER_NODE_OF_THREAD_WAIT_NODE(
_Chain_First( &the_thread->Scheduler.Wait_nodes )
);
#else
return the_thread->Scheduler.nodes;
40007b00: f0 07 20 38 ld [ %i4 + 0x38 ], %i0
RTEMS_INLINE_ROUTINE void _Priority_Plain_extract(
Priority_Aggregation *aggregation,
Priority_Node *node
)
{
_RBTree_Extract( &aggregation->Contributors, &node->Node.RBTree );
40007b04: 90 06 20 20 add %i0, 0x20, %o0
40007b08: a2 07 20 20 add %i4, 0x20, %l1
40007b0c: d0 27 bf d4 st %o0, [ %fp + -44 ]
40007b10: 40 00 03 d8 call 40008a70 <_RBTree_Extract>
40007b14: 92 10 00 11 mov %l1, %o1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_empty(
const RBTree_Control *the_rbtree
)
{
return RB_EMPTY( the_rbtree );
40007b18: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
_Priority_Plain_extract(
&old_scheduler_node->Wait.Priority,
&the_thread->Real_priority
);
if (
40007b1c: 80 a0 60 00 cmp %g1, 0
40007b20: 12 80 00 17 bne 40007b7c <rtems_task_set_scheduler+0x134> <== NEVER TAKEN
40007b24: d0 07 bf d4 ld [ %fp + -44 ], %o0
_Thread_Scheduler_process_requests( the_thread );
#else
new_scheduler_node = old_scheduler_node;
#endif
the_thread->Start.initial_priority = priority;
40007b28: f2 27 20 c0 st %i1, [ %i4 + 0xc0 ]
unsigned int seq;
seq = _SMP_sequence_lock_Write_begin( &node->Priority.Lock );
#endif
new_priority |= ( prepend_it ? 0 : SCHEDULER_PRIORITY_APPEND_FLAG );
40007b2c: 82 14 20 01 or %l0, 1, %g1
40007b30: e0 27 20 c4 st %l0, [ %i4 + 0xc4 ]
( *scheduler->Operations.update_priority )(
40007b34: 92 10 00 1c mov %i4, %o1
node->priority = priority;
40007b38: f2 27 20 30 st %i1, [ %i4 + 0x30 ]
40007b3c: 90 10 00 1d mov %i5, %o0
40007b40: e0 27 20 34 st %l0, [ %i4 + 0x34 ]
}
#endif
_Scheduler_Node_set_priority( new_scheduler_node, priority, false );
_Scheduler_Update_priority( the_thread );
return STATUS_SUCCESSFUL;
40007b44: b6 10 20 00 clr %i3
node->priority = priority;
40007b48: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
40007b4c: e0 26 20 1c st %l0, [ %i0 + 0x1c ]
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
_Assert( _RBTree_Is_node_off_tree( the_node ) );
RB_ROOT( the_rbtree ) = the_node;
40007b50: e2 26 20 20 st %l1, [ %i0 + 0x20 ]
RB_PARENT( the_node, Node ) = NULL;
40007b54: c0 27 20 28 clr [ %i4 + 0x28 ]
RB_LEFT( the_node, Node ) = NULL;
40007b58: c0 27 20 20 clr [ %i4 + 0x20 ]
RB_RIGHT( the_node, Node ) = NULL;
40007b5c: c0 27 20 24 clr [ %i4 + 0x24 ]
RB_COLOR( the_node, Node ) = RB_BLACK;
40007b60: c0 27 20 2c clr [ %i4 + 0x2c ]
40007b64: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
40007b68: f2 26 20 30 st %i1, [ %i0 + 0x30 ]
( *scheduler->Operations.update_priority )(
40007b6c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40007b70: 9f c0 40 00 call %g1
40007b74: d4 07 20 38 ld [ %i4 + 0x38 ], %o2
return STATUS_SUCCESSFUL;
40007b78: 30 bf ff d4 b,a 40007ac8 <rtems_task_set_scheduler+0x80>
_Priority_Plain_insert(
40007b7c: c8 07 20 30 ld [ %i4 + 0x30 ], %g4
is_new_minimum = true;
while ( *link != NULL ) {
parent = *link;
if ( ( *less )( key, parent ) ) {
40007b80: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED
40007b84: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
40007b88: 18 80 00 12 bgu 40007bd0 <rtems_task_set_scheduler+0x188> <== NOT EXECUTED
40007b8c: fa 07 20 34 ld [ %i4 + 0x34 ], %i5 <== NOT EXECUTED
40007b90: 12 80 00 07 bne 40007bac <rtems_task_set_scheduler+0x164> <== NOT EXECUTED
40007b94: 86 00 60 04 add %g1, 4, %g3 <== NOT EXECUTED
40007b98: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
40007b9c: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
40007ba0: 18 80 00 03 bgu 40007bac <rtems_task_set_scheduler+0x164> <== NOT EXECUTED
40007ba4: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED
return &RB_RIGHT( the_node, Node );
40007ba8: 86 00 60 04 add %g1, 4, %g3 <== NOT EXECUTED
while ( *link != NULL ) {
40007bac: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED
40007bb0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40007bb4: 22 80 00 09 be,a 40007bd8 <rtems_task_set_scheduler+0x190> <== NOT EXECUTED
40007bb8: c2 27 20 28 st %g1, [ %i4 + 0x28 ] <== NOT EXECUTED
40007bbc: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
if ( ( *less )( key, parent ) ) {
40007bc0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED
40007bc4: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
40007bc8: 08 bf ff f2 bleu 40007b90 <rtems_task_set_scheduler+0x148> <== NOT EXECUTED
40007bcc: 01 00 00 00 nop <== NOT EXECUTED
40007bd0: 10 bf ff f7 b 40007bac <rtems_task_set_scheduler+0x164> <== NOT EXECUTED
40007bd4: 86 10 00 01 mov %g1, %g3 <== NOT EXECUTED
RB_SET( child, parent, Node );
40007bd8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40007bdc: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
is_new_minimum = false;
}
}
_RBTree_Add_child( the_node, parent, link );
_RBTree_Insert_color( the_rbtree, the_node );
40007be0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
RB_SET( child, parent, Node );
40007be4: c0 27 20 20 clr [ %i4 + 0x20 ] <== NOT EXECUTED
return STATUS_RESOURCE_IN_USE;
40007be8: b6 10 20 0c mov 0xc, %i3 <== NOT EXECUTED
40007bec: c2 27 20 2c st %g1, [ %i4 + 0x2c ] <== NOT EXECUTED
_RBTree_Insert_color( the_rbtree, the_node );
40007bf0: 40 00 05 08 call 40009010 <_RBTree_Insert_color> <== NOT EXECUTED
40007bf4: e2 20 c0 00 st %l1, [ %g3 ] <== NOT EXECUTED
40007bf8: 30 bf ff b4 b,a 40007ac8 <rtems_task_set_scheduler+0x80> <== NOT EXECUTED