=============================================================================== 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 #include #include 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 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 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 #include #include 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 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 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 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 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 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 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 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_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 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 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 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 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 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 400050fc: 80 a0 80 03 cmp %g2, %g3 40005100: 08 80 00 49 bleu 40005224 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 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 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 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 400051ec: 80 a7 00 04 cmp %i4, %g4 400051f0: 38 bf ff b8 bgu,a 400050d0 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 4000520c: 80 a0 80 04 cmp %g2, %g4 40005210: 28 bf ff b0 bleu,a 400050d0 40005214: 82 00 60 01 inc %g1 time_buffer->year = year; 40005218: 10 bf ff b1 b 400050dc 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 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 40005240: 80 a0 80 03 cmp %g2, %g3 40005244: 28 bf ff b2 bleu,a 4000510c 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 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 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 40005274: 80 a0 80 04 cmp %g2, %g4 40005278: 18 80 00 04 bgu 40005288 <== ALWAYS TAKEN 4000527c: 05 10 00 4c sethi %hi(0x40013000), %g2 year_days += 1; 40005280: 10 bf ff 94 b 400050d0 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 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 : #include #include #include 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 <== 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_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 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 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 <== 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 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_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 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 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 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 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 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 <== 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 : { 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 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 <== NEVER TAKEN 4000f0d0: 80 a6 60 00 cmp %i1, 0 4000f0d4: 02 80 00 2e be 4000f18c 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 4000f0f0: b0 10 20 08 mov 8, %i0 4000f0f4: 80 a6 80 1b cmp %i2, %i3 4000f0f8: 0a 80 00 23 bcs 4000f184 4000f0fc: 80 8e e0 03 btst 3, %i3 if ( buffer_size < sizeof( Chain_Node ) ) 4000f100: 12 80 00 27 bne 4000f19c <== 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 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 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_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 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 40004c70: 80 a6 40 18 cmp %i1, %i0 40004c74: 0a 80 00 0d bcs 40004ca8 <== 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 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 : #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 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 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 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 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 <== 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 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 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 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 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 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 4001309c: 90 10 00 1d mov %i5, %o0 (void) rtems_rate_monotonic_get_status( id, &the_status ); 400130a0: 7f ff ff 2e call 40012d58 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 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 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 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 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 <== 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 */ 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 <== 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 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 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 : { 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 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 4000f390: 80 a7 60 00 cmp %i5, 0 4000f394: 02 80 00 21 be 4000f418 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 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 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 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 <== 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_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 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 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 40004778: c2 26 c0 00 st %g1, [ %i3 ] 4000477c: 80 a6 20 01 cmp %i0, 1 40004780: 12 80 00 06 bne 40004798 <== 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 : 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 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 400069e4: 01 00 00 00 nop 400069e8: 80 a0 60 03 cmp %g1, 3 400069ec: 12 80 00 0b bne 40006a18 <== 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 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 <== 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_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 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 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 40006980: b0 10 20 03 mov 3, %i0 40006984: 40 00 30 fd call 40012d78 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 <== 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 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_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 40006a34: 03 03 c0 40 sethi %hi(0xf010000), %g1 40006a38: 82 10 60 01 or %g1, 1, %g1 ! f010001 40006a3c: 80 a2 00 01 cmp %o0, %g1 40006a40: 12 80 00 14 bne 40006a90 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 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 <== 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 <== NEVER TAKEN 40006a7c: 80 a0 c0 09 cmp %g3, %o1 40006a80: 18 bf ff fb bgu 40006a6c 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 : 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 40006aa8: 03 03 c0 40 sethi %hi(0xf010000), %g1 40006aac: 82 10 60 01 or %g1, 1, %g1 ! f010001 40006ab0: 80 a2 00 01 cmp %o0, %g1 40006ab4: 12 80 00 15 bne 40006b08 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 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 <== 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 <== NEVER TAKEN 40006af0: 80 a0 40 09 cmp %g1, %o1 40006af4: 38 bf ff fb bgu,a 40006ae0 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 : { 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 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 4000a5a8: 84 8e a1 f0 andcc %i2, 0x1f0, %g2 if ( maybe_global == RTEMS_COUNTING_SEMAPHORE ) { 4000a5ac: 02 80 00 12 be 4000a5f4 4000a5b0: 80 a6 60 01 cmp %i1, 1 } else if ( count > 1 ) { 4000a5b4: 18 80 00 2e bgu 4000a66c 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 4000a5c4: 80 a0 a0 10 cmp %g2, 0x10 } else if ( maybe_global == RTEMS_BINARY_SEMAPHORE ) { 4000a5c8: 02 80 00 2b be 4000a674 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 4000a5d8: 80 a0 a0 94 cmp %g2, 0x94 } else if ( 4000a5dc: 02 80 00 04 be 4000a5ec 4000a5e0: 80 a0 a1 10 cmp %g2, 0x110 4000a5e4: 12 80 00 22 bne 4000a66c 4000a5e8: 82 10 20 0b mov 0xb, %g1 4000a5ec: 10 80 00 03 b 4000a5f8 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 4000a60c: 80 8e a0 04 btst 4, %i2 if ( _Attributes_Is_priority( attribute_set ) ) { 4000a610: 12 80 00 03 bne 4000a61c 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 4000a628: f4 01 a0 20 ld [ %g6 + 0x20 ], %i2 4000a62c: 80 8c 20 05 btst 5, %l0 4000a630: 02 80 00 13 be 4000a67c 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 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 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 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 <== 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 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 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 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 <== NEVER TAKEN 4000a72c: 01 00 00 00 nop 4000a730: 22 80 00 1e be,a 4000a7a8 <== 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 4000a77c: c2 17 60 0a lduh [ %i5 + 0xa ], %g1 variant = SEMAPHORE_VARIANT_SIMPLE_BINARY; 4000a780: 10 bf ff 9e b 4000a5f8 4000a784: a0 10 20 03 mov 3, %l0 return RTEMS_INVALID_ADDRESS; 4000a788: 10 bf ff b9 b 4000a66c 4000a78c: 82 10 20 09 mov 9, %g1 variant = SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY; 4000a790: 10 bf ff 9a b 4000a5f8 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 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 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 4000a7c8: 90 14 61 44 or %l1, 0x144, %o0 =============================================================================== 40004684 : #endif #include 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 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 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 <== 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_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 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 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 4000a818: 84 02 20 10 add %o0, 0x10, %g2 4000a81c: 80 a6 20 02 cmp %i0, 2 4000a820: 02 80 00 3b be 4000a90c 4000a824: 80 a6 20 00 cmp %i0, 0 4000a828: 02 80 00 2b be 4000a8d4 4000a82c: 80 88 60 08 btst 8, %g1 if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 4000a830: 02 80 00 52 be 4000a978 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 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 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 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 4000a8a8: 80 a7 40 01 cmp %i5, %g1 executing, queue_context ); } if ( owner == executing ) { 4000a8ac: 02 80 00 2b be 4000a958 <== 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 4000a8e0: 80 a7 40 01 cmp %i5, %g1 if ( owner == executing ) { 4000a8e4: 02 80 00 2b be 4000a990 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 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 4000a92c: 80 a7 40 01 cmp %i5, %g1 if ( owner == executing ) { 4000a930: 02 80 00 0a be 4000a958 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 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 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 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 <== NEVER TAKEN 4000aa0c: 01 00 00 00 nop 4000aa10: 22 80 00 15 be,a 4000aa64 <== 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 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 : #include #include 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 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 4000aac0: b8 07 60 10 add %i5, 0x10, %i4 4000aac4: 18 80 00 31 bgu 4000ab88 4000aac8: 80 a0 60 00 cmp %g1, 0 4000aacc: 02 80 00 7c be 4000acbc 4000aad0: 80 a0 60 01 cmp %g1, 1 4000aad4: 12 80 00 63 bne 4000ac60 <== 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 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 <== 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 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 <== 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 4000ab90: 80 88 a0 08 btst 8, %g2 if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 4000ab94: 02 80 00 1a be 4000abfc 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 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 <== 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 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 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 <== 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 <== 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 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 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 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 <== 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 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 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 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 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 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 4000ad54: 98 13 22 b0 or %o4, 0x2b0, %o4 4000ad58: 10 bf ff c6 b 4000ac70 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 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 =============================================================================== 40005164 : 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 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 40005178: 80 a6 40 01 cmp %i1, %g1 4000517c: 12 80 00 3c bne 4000526c 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 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 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 <== 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 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 <== 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 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 <== 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 <== NOT EXECUTED 400052b4: b0 10 20 00 clr %i0 ! 0 <== 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 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 400052e8: d2 27 20 34 st %o1, [ %i4 + 0x34 ] =============================================================================== 4000afb0 : [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 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 <== 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 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 : #include 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 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 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 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 : #include #include 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_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 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 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 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 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 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 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 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 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 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 <== 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 _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 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 40007a14: 84 10 20 00 clr %g2 preempt_enabled = !executing->is_preemptible && is_preempt_enabled; 40007a18: 10 bf ff a4 b 400078a8 40007a1c: c2 0f 20 89 ldub [ %i4 + 0x89 ], %g1 if ( mask & RTEMS_INTERRUPT_MASK ) { 40007a20: 02 bf ff b9 be 40007904 40007a24: c0 27 20 90 clr [ %i4 + 0x90 ] 40007a28: 30 bf ff b3 b,a 400078f4 } 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 =============================================================================== 40004660 : 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 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 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_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 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 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 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 <== 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 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 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_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 40007a54: 80 a6 40 01 cmp %i1, %g1 40007a58: 12 80 00 23 bne 40007ae4 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 <== 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 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 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 40007af8: b6 10 20 13 mov 0x13, %i3 40007afc: 30 bf ff f8 b,a 40007adc _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 <== 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 _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 <== NOT EXECUTED 40007b8c: fa 07 20 34 ld [ %i4 + 0x34 ], %i5 <== NOT EXECUTED 40007b90: 12 80 00 07 bne 40007bac <== 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 <== 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 <== 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 <== NOT EXECUTED 40007bcc: 01 00 00 00 nop <== NOT EXECUTED 40007bd0: 10 bf ff f7 b 40007bac <== 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 <== NOT EXECUTED