=============================================================================== 02008714 <_API_extensions_Run_postdriver>: /* * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 2008714: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 2008718: 39 00 80 7a sethi %hi(0x201e800), %i4 200871c: fa 07 22 94 ld [ %i4 + 0x294 ], %i5 ! 201ea94 <_API_extensions_List> 2008720: b8 17 22 94 or %i4, 0x294, %i4 Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 2008724: b8 07 20 04 add %i4, 4, %i4 2008728: 80 a7 40 1c cmp %i5, %i4 200872c: 02 80 00 09 be 2008750 <_API_extensions_Run_postdriver+0x3c><== NEVER TAKEN 2008730: 01 00 00 00 nop * Currently all APIs configure this hook so it is always non-NULL. */ #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) if ( the_extension->postdriver_hook ) #endif (*the_extension->postdriver_hook)(); 2008734: c2 07 60 08 ld [ %i5 + 8 ], %g1 2008738: 9f c0 40 00 call %g1 200873c: 01 00 00 00 nop Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 2008740: fa 07 40 00 ld [ %i5 ], %i5 void _API_extensions_Run_postdriver( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 2008744: 80 a7 40 1c cmp %i5, %i4 2008748: 32 bf ff fc bne,a 2008738 <_API_extensions_Run_postdriver+0x24> 200874c: c2 07 60 08 ld [ %i5 + 8 ], %g1 2008750: 81 c7 e0 08 ret 2008754: 81 e8 00 00 restore =============================================================================== 02008758 <_API_extensions_Run_postswitch>: /* * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 2008758: 9d e3 bf a0 save %sp, -96, %sp 200875c: 39 00 80 7a sethi %hi(0x201e800), %i4 2008760: fa 07 22 94 ld [ %i4 + 0x294 ], %i5 ! 201ea94 <_API_extensions_List> 2008764: 37 00 80 7b sethi %hi(0x201ec00), %i3 2008768: b8 17 22 94 or %i4, 0x294, %i4 Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 200876c: b8 07 20 04 add %i4, 4, %i4 2008770: 80 a7 40 1c cmp %i5, %i4 2008774: 02 80 00 09 be 2008798 <_API_extensions_Run_postswitch+0x40><== NEVER TAKEN 2008778: b6 16 e1 e0 or %i3, 0x1e0, %i3 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); 200877c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 2008780: 9f c0 40 00 call %g1 2008784: d0 06 e0 0c ld [ %i3 + 0xc ], %o0 Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 2008788: fa 07 40 00 ld [ %i5 ], %i5 void _API_extensions_Run_postswitch( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 200878c: 80 a7 40 1c cmp %i5, %i4 2008790: 32 bf ff fc bne,a 2008780 <_API_extensions_Run_postswitch+0x28> 2008794: c2 07 60 0c ld [ %i5 + 0xc ], %g1 2008798: 81 c7 e0 08 ret 200879c: 81 e8 00 00 restore =============================================================================== 0200ae08 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 200ae08: 9d e3 bf a0 save %sp, -96, %sp ISR_Level level; Thread_Control *executing = _Thread_Executing; 200ae0c: 03 00 80 87 sethi %hi(0x2021c00), %g1 * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 200ae10: 7f ff e3 3f call 2003b0c 200ae14: fa 00 61 fc ld [ %g1 + 0x1fc ], %i5 ! 2021dfc <_Per_CPU_Information+0xc> 200ae18: 84 10 00 08 mov %o0, %g2 if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 200ae1c: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 200ae20: 80 a0 60 00 cmp %g1, 0 200ae24: 02 80 00 2b be 200aed0 <_CORE_RWLock_Release+0xc8> 200ae28: 80 a0 60 01 cmp %g1, 1 _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 200ae2c: 22 80 00 22 be,a 200aeb4 <_CORE_RWLock_Release+0xac> 200ae30: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 return CORE_RWLOCK_SUCCESSFUL; } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 200ae34: c0 27 60 34 clr [ %i5 + 0x34 ] /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 200ae38: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 200ae3c: 7f ff e3 38 call 2003b1c 200ae40: 90 10 00 02 mov %g2, %o0 next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 200ae44: 40 00 08 0a call 200ce6c <_Thread_queue_Dequeue> 200ae48: 90 10 00 18 mov %i0, %o0 if ( next ) { 200ae4c: 80 a2 20 00 cmp %o0, 0 200ae50: 22 80 00 24 be,a 200aee0 <_CORE_RWLock_Release+0xd8> 200ae54: b0 10 20 00 clr %i0 if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 200ae58: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 200ae5c: 80 a0 60 01 cmp %g1, 1 200ae60: 02 80 00 22 be 200aee8 <_CORE_RWLock_Release+0xe0> 200ae64: 84 10 20 01 mov 1, %g2 } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 200ae68: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 200ae6c: 82 00 60 01 inc %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 200ae70: c4 26 20 44 st %g2, [ %i0 + 0x44 ] } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 200ae74: 10 80 00 09 b 200ae98 <_CORE_RWLock_Release+0x90> 200ae78: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); if ( !next || 200ae7c: 80 a0 60 01 cmp %g1, 1 200ae80: 02 80 00 0b be 200aeac <_CORE_RWLock_Release+0xa4> <== NEVER TAKEN 200ae84: 90 10 00 18 mov %i0, %o0 next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 200ae88: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 200ae8c: 82 00 60 01 inc %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 200ae90: 40 00 09 07 call 200d2ac <_Thread_queue_Extract> 200ae94: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 200ae98: 40 00 09 56 call 200d3f0 <_Thread_queue_First> 200ae9c: 90 10 00 18 mov %i0, %o0 if ( !next || 200aea0: 92 92 20 00 orcc %o0, 0, %o1 200aea4: 32 bf ff f6 bne,a 200ae7c <_CORE_RWLock_Release+0x74> 200aea8: c2 02 60 30 ld [ %o1 + 0x30 ], %g1 } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 200aeac: 81 c7 e0 08 ret 200aeb0: 91 e8 20 00 restore %g0, 0, %o0 _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { the_rwlock->number_of_readers -= 1; 200aeb4: 82 00 7f ff add %g1, -1, %g1 if ( the_rwlock->number_of_readers != 0 ) { 200aeb8: 80 a0 60 00 cmp %g1, 0 200aebc: 02 bf ff de be 200ae34 <_CORE_RWLock_Release+0x2c> 200aec0: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* must be unlocked again */ _ISR_Enable( level ); 200aec4: 7f ff e3 16 call 2003b1c 200aec8: b0 10 20 00 clr %i0 return CORE_RWLOCK_SUCCESSFUL; 200aecc: 30 80 00 05 b,a 200aee0 <_CORE_RWLock_Release+0xd8> * If any thread is waiting, then we wait. */ _ISR_Disable( level ); if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ _ISR_Enable( level ); 200aed0: 7f ff e3 13 call 2003b1c 200aed4: b0 10 20 00 clr %i0 executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 200aed8: 82 10 20 02 mov 2, %g1 200aedc: c2 27 60 34 st %g1, [ %i5 + 0x34 ] } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 200aee0: 81 c7 e0 08 ret 200aee4: 81 e8 00 00 restore next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); if ( next ) { if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 200aee8: 82 10 20 02 mov 2, %g1 200aeec: c2 26 20 44 st %g1, [ %i0 + 0x44 ] } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 200aef0: 81 c7 e0 08 ret 200aef4: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 0200aef8 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 200aef8: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 200aefc: 90 10 00 18 mov %i0, %o0 200af00: 40 00 07 00 call 200cb00 <_Thread_Get> 200af04: 92 07 bf fc add %fp, -4, %o1 switch ( location ) { 200af08: c2 07 bf fc ld [ %fp + -4 ], %g1 200af0c: 80 a0 60 00 cmp %g1, 0 200af10: 12 80 00 09 bne 200af34 <_CORE_RWLock_Timeout+0x3c> <== NEVER TAKEN 200af14: 01 00 00 00 nop #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 200af18: 40 00 09 77 call 200d4f4 <_Thread_queue_Process_timeout> 200af1c: 01 00 00 00 nop * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 200af20: 03 00 80 86 sethi %hi(0x2021800), %g1 200af24: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 20218c0 <_Thread_Dispatch_disable_level> 200af28: 84 00 bf ff add %g2, -1, %g2 200af2c: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ] return _Thread_Dispatch_disable_level; 200af30: c2 00 60 c0 ld [ %g1 + 0xc0 ], %g1 200af34: 81 c7 e0 08 ret 200af38: 81 e8 00 00 restore =============================================================================== 02008ac0 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 2008ac0: 9d e3 bf a0 save %sp, -96, %sp * This routine returns true if thread dispatch indicates * that we are in a critical section. */ RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void) { if ( _Thread_Dispatch_disable_level == 0 ) 2008ac4: 3b 00 80 7a sethi %hi(0x201e800), %i5 2008ac8: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 ! 201e8b0 <_Thread_Dispatch_disable_level> 2008acc: 80 a0 60 00 cmp %g1, 0 2008ad0: 02 80 00 20 be 2008b50 <_CORE_mutex_Seize+0x90> 2008ad4: f8 27 a0 54 st %i4, [ %fp + 0x54 ] _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 2008ad8: 80 a6 a0 00 cmp %i2, 0 2008adc: 02 80 00 2d be 2008b90 <_CORE_mutex_Seize+0xd0> 2008ae0: 90 10 00 18 mov %i0, %o0 2008ae4: 03 00 80 7a sethi %hi(0x201e800), %g1 2008ae8: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 201e9f0 <_System_state_Current> 2008aec: 80 a0 60 01 cmp %g1, 1 2008af0: 38 80 00 2f bgu,a 2008bac <_CORE_mutex_Seize+0xec> 2008af4: 90 10 20 00 clr %o0 2008af8: 40 00 15 06 call 200df10 <_CORE_mutex_Seize_interrupt_trylock> 2008afc: 92 07 a0 54 add %fp, 0x54, %o1 2008b00: 80 a2 20 00 cmp %o0, 0 2008b04: 02 80 00 28 be 2008ba4 <_CORE_mutex_Seize+0xe4> <== ALWAYS TAKEN 2008b08: 01 00 00 00 nop * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2008b0c: c4 07 60 b0 ld [ %i5 + 0xb0 ], %g2 2008b10: 03 00 80 7b sethi %hi(0x201ec00), %g1 2008b14: c2 00 61 ec ld [ %g1 + 0x1ec ], %g1 ! 201edec <_Per_CPU_Information+0xc> RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 2008b18: 86 10 20 01 mov 1, %g3 2008b1c: c6 26 20 30 st %g3, [ %i0 + 0x30 ] 2008b20: f0 20 60 44 st %i0, [ %g1 + 0x44 ] 2008b24: f2 20 60 20 st %i1, [ %g1 + 0x20 ] 2008b28: 82 00 a0 01 add %g2, 1, %g1 2008b2c: c2 27 60 b0 st %g1, [ %i5 + 0xb0 ] return _Thread_Dispatch_disable_level; 2008b30: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 2008b34: 7f ff e7 10 call 2002774 2008b38: d0 07 a0 54 ld [ %fp + 0x54 ], %o0 2008b3c: 90 10 00 18 mov %i0, %o0 2008b40: 7f ff ff b9 call 2008a24 <_CORE_mutex_Seize_interrupt_blocking> 2008b44: 92 10 00 1b mov %i3, %o1 2008b48: 81 c7 e0 08 ret 2008b4c: 81 e8 00 00 restore 2008b50: 90 10 00 18 mov %i0, %o0 2008b54: 40 00 14 ef call 200df10 <_CORE_mutex_Seize_interrupt_trylock> 2008b58: 92 07 a0 54 add %fp, 0x54, %o1 2008b5c: 80 a2 20 00 cmp %o0, 0 2008b60: 02 bf ff fa be 2008b48 <_CORE_mutex_Seize+0x88> 2008b64: 80 a6 a0 00 cmp %i2, 0 2008b68: 12 bf ff e9 bne 2008b0c <_CORE_mutex_Seize+0x4c> 2008b6c: 01 00 00 00 nop 2008b70: 7f ff e7 01 call 2002774 2008b74: d0 07 a0 54 ld [ %fp + 0x54 ], %o0 2008b78: 03 00 80 7b sethi %hi(0x201ec00), %g1 2008b7c: c2 00 61 ec ld [ %g1 + 0x1ec ], %g1 ! 201edec <_Per_CPU_Information+0xc> 2008b80: 84 10 20 01 mov 1, %g2 2008b84: c4 20 60 34 st %g2, [ %g1 + 0x34 ] 2008b88: 81 c7 e0 08 ret 2008b8c: 81 e8 00 00 restore 2008b90: 40 00 14 e0 call 200df10 <_CORE_mutex_Seize_interrupt_trylock> 2008b94: 92 07 a0 54 add %fp, 0x54, %o1 2008b98: 80 a2 20 00 cmp %o0, 0 2008b9c: 12 bf ff f5 bne 2008b70 <_CORE_mutex_Seize+0xb0> <== NEVER TAKEN 2008ba0: 01 00 00 00 nop 2008ba4: 81 c7 e0 08 ret 2008ba8: 81 e8 00 00 restore 2008bac: 92 10 20 00 clr %o1 2008bb0: 40 00 01 c2 call 20092b8 <_Internal_error_Occurred> 2008bb4: 94 10 20 12 mov 0x12, %o2 =============================================================================== 02008d34 <_CORE_semaphore_Surrender>: CORE_semaphore_Status _CORE_semaphore_Surrender( CORE_semaphore_Control *the_semaphore, Objects_Id id, CORE_semaphore_API_mp_support_callout api_semaphore_mp_support ) { 2008d34: 9d e3 bf a0 save %sp, -96, %sp 2008d38: ba 10 00 18 mov %i0, %i5 Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 2008d3c: b0 10 20 00 clr %i0 if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 2008d40: 40 00 07 d0 call 200ac80 <_Thread_queue_Dequeue> 2008d44: 90 10 00 1d mov %i5, %o0 2008d48: 80 a2 20 00 cmp %o0, 0 2008d4c: 02 80 00 04 be 2008d5c <_CORE_semaphore_Surrender+0x28> 2008d50: 01 00 00 00 nop status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 2008d54: 81 c7 e0 08 ret 2008d58: 81 e8 00 00 restore if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 2008d5c: 7f ff e6 82 call 2002764 2008d60: 01 00 00 00 nop if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 2008d64: c2 07 60 48 ld [ %i5 + 0x48 ], %g1 2008d68: c4 07 60 40 ld [ %i5 + 0x40 ], %g2 2008d6c: 80 a0 40 02 cmp %g1, %g2 2008d70: 1a 80 00 05 bcc 2008d84 <_CORE_semaphore_Surrender+0x50> <== NEVER TAKEN 2008d74: b0 10 20 04 mov 4, %i0 the_semaphore->count += 1; 2008d78: 82 00 60 01 inc %g1 { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 2008d7c: b0 10 20 00 clr %i0 #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 2008d80: c2 27 60 48 st %g1, [ %i5 + 0x48 ] else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 2008d84: 7f ff e6 7c call 2002774 2008d88: 01 00 00 00 nop } return status; } 2008d8c: 81 c7 e0 08 ret 2008d90: 81 e8 00 00 restore =============================================================================== 020088f0 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 20088f0: 9d e3 bf a0 save %sp, -96, %sp Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; 20088f4: c0 26 20 04 clr [ %i0 + 4 ] size_t node_size ) { size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 20088f8: ba 06 20 04 add %i0, 4, %i5 Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 20088fc: 80 a6 a0 00 cmp %i2, 0 2008900: 02 80 00 13 be 200894c <_Chain_Initialize+0x5c> <== NEVER TAKEN 2008904: 92 06 bf ff add %i2, -1, %o1 2008908: 86 10 00 09 mov %o1, %g3 200890c: 82 10 00 19 mov %i1, %g1 2008910: 84 10 00 18 mov %i0, %g2 current->next = next; 2008914: c2 20 80 00 st %g1, [ %g2 ] next->previous = current; 2008918: c4 20 60 04 st %g2, [ %g1 + 4 ] Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 200891c: 86 00 ff ff add %g3, -1, %g3 2008920: 84 10 00 01 mov %g1, %g2 2008924: 80 a0 ff ff cmp %g3, -1 2008928: 12 bf ff fb bne 2008914 <_Chain_Initialize+0x24> 200892c: 82 00 40 1b add %g1, %i3, %g1 * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 2008930: 40 00 42 f5 call 2019504 <.umul> 2008934: 90 10 00 1b mov %i3, %o0 2008938: 90 06 40 08 add %i1, %o0, %o0 current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = tail; 200893c: fa 22 00 00 st %i5, [ %o0 ] tail->previous = current; 2008940: d0 26 20 08 st %o0, [ %i0 + 8 ] 2008944: 81 c7 e0 08 ret 2008948: 81 e8 00 00 restore ) { size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *current = head; 200894c: 10 bf ff fc b 200893c <_Chain_Initialize+0x4c> <== NOT EXECUTED 2008950: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED =============================================================================== 020078f0 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 20078f0: 9d e3 bf a0 save %sp, -96, %sp rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; RTEMS_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 20078f4: fa 06 21 58 ld [ %i0 + 0x158 ], %i5 option_set = (rtems_option) the_thread->Wait.option; _ISR_Disable( level ); 20078f8: 7f ff eb 9b call 2002764 20078fc: f6 06 20 30 ld [ %i0 + 0x30 ], %i3 pending_events = api->pending_events; 2007900: c4 07 40 00 ld [ %i5 ], %g2 event_condition = (rtems_event_set) the_thread->Wait.count; 2007904: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 2007908: 86 88 40 02 andcc %g1, %g2, %g3 200790c: 02 80 00 39 be 20079f0 <_Event_Surrender+0x100> 2007910: 09 00 80 7b sethi %hi(0x201ec00), %g4 /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 2007914: 88 11 21 e0 or %g4, 0x1e0, %g4 ! 201ede0 <_Per_CPU_Information> 2007918: f8 01 20 08 ld [ %g4 + 8 ], %i4 200791c: 80 a7 20 00 cmp %i4, 0 2007920: 32 80 00 1c bne,a 2007990 <_Event_Surrender+0xa0> 2007924: c8 01 20 0c ld [ %g4 + 0xc ], %g4 */ RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event ( States_Control the_states ) { return (the_states & STATES_WAITING_FOR_EVENT); 2007928: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 200792c: 80 89 21 00 btst 0x100, %g4 2007930: 02 80 00 30 be 20079f0 <_Event_Surrender+0x100> 2007934: 80 a0 40 03 cmp %g1, %g3 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 2007938: 02 80 00 04 be 2007948 <_Event_Surrender+0x58> 200793c: 80 8e e0 02 btst 2, %i3 2007940: 02 80 00 2c be 20079f0 <_Event_Surrender+0x100> <== NEVER TAKEN 2007944: 01 00 00 00 nop api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2007948: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 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) ); 200794c: 84 28 80 03 andn %g2, %g3, %g2 /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 2007950: c4 27 40 00 st %g2, [ %i5 ] the_thread->Wait.count = 0; 2007954: c0 26 20 24 clr [ %i0 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2007958: c6 20 40 00 st %g3, [ %g1 ] _ISR_Flash( level ); 200795c: 7f ff eb 86 call 2002774 2007960: 01 00 00 00 nop 2007964: 7f ff eb 80 call 2002764 2007968: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 200796c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 2007970: 80 a0 60 02 cmp %g1, 2 2007974: 02 80 00 21 be 20079f8 <_Event_Surrender+0x108> 2007978: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 200797c: 7f ff eb 7e call 2002774 2007980: 33 04 00 ff sethi %hi(0x1003fc00), %i1 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2007984: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 2007988: 40 00 0a e3 call 200a514 <_Thread_Clear_state> 200798c: 81 e8 00 00 restore /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 2007990: 80 a6 00 04 cmp %i0, %g4 2007994: 32 bf ff e6 bne,a 200792c <_Event_Surrender+0x3c> 2007998: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 200799c: 09 00 80 7c sethi %hi(0x201f000), %g4 20079a0: f8 01 21 e0 ld [ %g4 + 0x1e0 ], %i4 ! 201f1e0 <_Event_Sync_state> /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && 20079a4: 80 a7 20 02 cmp %i4, 2 20079a8: 02 80 00 07 be 20079c4 <_Event_Surrender+0xd4> <== NEVER TAKEN 20079ac: 80 a0 40 03 cmp %g1, %g3 ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 20079b0: f8 01 21 e0 ld [ %g4 + 0x1e0 ], %i4 * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 20079b4: 80 a7 20 01 cmp %i4, 1 20079b8: 32 bf ff dd bne,a 200792c <_Event_Surrender+0x3c> 20079bc: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 20079c0: 80 a0 40 03 cmp %g1, %g3 20079c4: 02 80 00 04 be 20079d4 <_Event_Surrender+0xe4> 20079c8: 80 8e e0 02 btst 2, %i3 20079cc: 02 80 00 09 be 20079f0 <_Event_Surrender+0x100> <== NEVER TAKEN 20079d0: 01 00 00 00 nop api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20079d4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 20079d8: 84 28 80 03 andn %g2, %g3, %g2 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 20079dc: c4 27 40 00 st %g2, [ %i5 ] the_thread->Wait.count = 0; 20079e0: c0 26 20 24 clr [ %i0 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20079e4: c6 20 40 00 st %g3, [ %g1 ] _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 20079e8: 82 10 20 03 mov 3, %g1 20079ec: c2 21 21 e0 st %g1, [ %g4 + 0x1e0 ] _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 20079f0: 7f ff eb 61 call 2002774 20079f4: 91 e8 00 08 restore %g0, %o0, %o0 RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 20079f8: c2 26 20 50 st %g1, [ %i0 + 0x50 ] if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 20079fc: 7f ff eb 5e call 2002774 2007a00: 33 04 00 ff sethi %hi(0x1003fc00), %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 2007a04: 40 00 0f 98 call 200b864 <_Watchdog_Remove> 2007a08: 90 06 20 48 add %i0, 0x48, %o0 2007a0c: b2 16 63 f8 or %i1, 0x3f8, %i1 2007a10: 40 00 0a c1 call 200a514 <_Thread_Clear_state> 2007a14: 81 e8 00 00 restore =============================================================================== 02007a18 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 2007a18: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 2007a1c: 90 10 00 18 mov %i0, %o0 2007a20: 40 00 0b bd call 200a914 <_Thread_Get> 2007a24: 92 07 bf fc add %fp, -4, %o1 switch ( location ) { 2007a28: c2 07 bf fc ld [ %fp + -4 ], %g1 2007a2c: 80 a0 60 00 cmp %g1, 0 2007a30: 12 80 00 16 bne 2007a88 <_Event_Timeout+0x70> <== NEVER TAKEN 2007a34: ba 10 00 08 mov %o0, %i5 * * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 2007a38: 7f ff eb 4b call 2002764 2007a3c: 01 00 00 00 nop RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 2007a40: 03 00 80 7b sethi %hi(0x201ec00), %g1 return; } #endif the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { 2007a44: c2 00 61 ec ld [ %g1 + 0x1ec ], %g1 ! 201edec <_Per_CPU_Information+0xc> 2007a48: 80 a7 40 01 cmp %i5, %g1 2007a4c: 02 80 00 11 be 2007a90 <_Event_Timeout+0x78> 2007a50: c0 27 60 24 clr [ %i5 + 0x24 ] if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } the_thread->Wait.return_code = RTEMS_TIMEOUT; 2007a54: 82 10 20 06 mov 6, %g1 2007a58: c2 27 60 34 st %g1, [ %i5 + 0x34 ] _ISR_Enable( level ); 2007a5c: 7f ff eb 46 call 2002774 2007a60: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2007a64: 90 10 00 1d mov %i5, %o0 2007a68: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2007a6c: 40 00 0a aa call 200a514 <_Thread_Clear_state> 2007a70: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 2007a74: 03 00 80 7a sethi %hi(0x201e800), %g1 2007a78: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 201e8b0 <_Thread_Dispatch_disable_level> 2007a7c: 84 00 bf ff add %g2, -1, %g2 2007a80: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] return _Thread_Dispatch_disable_level; 2007a84: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 2007a88: 81 c7 e0 08 ret 2007a8c: 81 e8 00 00 restore } #endif the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 2007a90: 03 00 80 7c sethi %hi(0x201f000), %g1 2007a94: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201f1e0 <_Event_Sync_state> 2007a98: 80 a0 a0 01 cmp %g2, 1 2007a9c: 32 bf ff ef bne,a 2007a58 <_Event_Timeout+0x40> 2007aa0: 82 10 20 06 mov 6, %g1 _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 2007aa4: 84 10 20 02 mov 2, %g2 2007aa8: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] } the_thread->Wait.return_code = RTEMS_TIMEOUT; 2007aac: 10 bf ff eb b 2007a58 <_Event_Timeout+0x40> 2007ab0: 82 10 20 06 mov 6, %g1 =============================================================================== 0200e0bc <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 200e0bc: 9d e3 bf 98 save %sp, -104, %sp Heap_Statistics *const stats = &heap->stats; uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE 200e0c0: a2 06 60 04 add %i1, 4, %l1 Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 200e0c4: a0 10 00 18 mov %i0, %l0 Heap_Block *block = NULL; uintptr_t alloc_begin = 0; uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { 200e0c8: 80 a6 40 11 cmp %i1, %l1 200e0cc: 18 80 00 85 bgu 200e2e0 <_Heap_Allocate_aligned_with_boundary+0x224> 200e0d0: ea 06 20 10 ld [ %i0 + 0x10 ], %l5 /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 200e0d4: 80 a6 e0 00 cmp %i3, 0 200e0d8: 12 80 00 7c bne 200e2c8 <_Heap_Allocate_aligned_with_boundary+0x20c> 200e0dc: 80 a6 40 1b cmp %i1, %i3 return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 200e0e0: fa 04 20 08 ld [ %l0 + 8 ], %i5 do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 200e0e4: 80 a4 00 1d cmp %l0, %i5 200e0e8: 02 80 00 18 be 200e148 <_Heap_Allocate_aligned_with_boundary+0x8c> 200e0ec: b8 10 20 00 clr %i4 uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 200e0f0: ac 10 20 04 mov 4, %l6 uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 200e0f4: ae 05 60 07 add %l5, 7, %l7 + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 200e0f8: ac 25 80 19 sub %l6, %i1, %l6 200e0fc: 10 80 00 0b b 200e128 <_Heap_Allocate_aligned_with_boundary+0x6c> 200e100: ec 27 bf fc st %l6, [ %fp + -4 ] * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag * field. Thus the value is about one unit larger than the real block * size. The greater than operator takes this into account. */ if ( block->size_and_flag > block_size_floor ) { if ( alignment == 0 ) { 200e104: 12 80 00 18 bne 200e164 <_Heap_Allocate_aligned_with_boundary+0xa8> 200e108: b0 07 60 08 add %i5, 8, %i0 } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 200e10c: 80 a6 20 00 cmp %i0, 0 200e110: 12 80 00 4d bne 200e244 <_Heap_Allocate_aligned_with_boundary+0x188><== ALWAYS TAKEN 200e114: b8 07 20 01 inc %i4 break; } block = block->next; 200e118: fa 07 60 08 ld [ %i5 + 8 ], %i5 do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 200e11c: 80 a4 00 1d cmp %l0, %i5 200e120: 22 80 00 0b be,a 200e14c <_Heap_Allocate_aligned_with_boundary+0x90> 200e124: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 /* * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag * field. Thus the value is about one unit larger than the real block * size. The greater than operator takes this into account. */ if ( block->size_and_flag > block_size_floor ) { 200e128: c2 07 60 04 ld [ %i5 + 4 ], %g1 200e12c: 80 a4 40 01 cmp %l1, %g1 200e130: 0a bf ff f5 bcs 200e104 <_Heap_Allocate_aligned_with_boundary+0x48> 200e134: 80 a6 a0 00 cmp %i2, 0 if ( alloc_begin != 0 ) { break; } block = block->next; 200e138: fa 07 60 08 ld [ %i5 + 8 ], %i5 do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 200e13c: 80 a4 00 1d cmp %l0, %i5 200e140: 12 bf ff fa bne 200e128 <_Heap_Allocate_aligned_with_boundary+0x6c> 200e144: b8 07 20 01 inc %i4 boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 200e148: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 200e14c: 80 a0 40 1c cmp %g1, %i4 200e150: 1a 80 00 03 bcc 200e15c <_Heap_Allocate_aligned_with_boundary+0xa0> 200e154: b0 10 20 00 clr %i0 stats->max_search = search_count; 200e158: f8 24 20 44 st %i4, [ %l0 + 0x44 ] } return (void *) alloc_begin; 200e15c: 81 c7 e0 08 ret 200e160: 81 e8 00 00 restore uintptr_t alignment, uintptr_t boundary ) { uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; 200e164: e8 04 20 14 ld [ %l0 + 0x14 ], %l4 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200e168: a4 08 7f fe and %g1, -2, %l2 uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; uintptr_t alloc_begin = alloc_end - alloc_size; 200e16c: c2 07 bf fc ld [ %fp + -4 ], %g1 uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size + HEAP_BLOCK_HEADER_SIZE + page_size - 1; 200e170: 84 25 c0 14 sub %l7, %l4, %g2 uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; 200e174: a4 07 40 12 add %i5, %l2, %l2 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 200e178: 92 10 00 1a mov %i2, %o1 uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; uintptr_t alloc_begin = alloc_end - alloc_size; 200e17c: b0 00 40 12 add %g1, %l2, %i0 uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 200e180: a4 00 80 12 add %g2, %l2, %l2 200e184: 40 00 2d c6 call 201989c <.urem> 200e188: 90 10 00 18 mov %i0, %o0 200e18c: b0 26 00 08 sub %i0, %o0, %i0 uintptr_t alloc_begin = alloc_end - alloc_size; alloc_begin = _Heap_Align_down( alloc_begin, alignment ); /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { 200e190: 80 a4 80 18 cmp %l2, %i0 200e194: 1a 80 00 06 bcc 200e1ac <_Heap_Allocate_aligned_with_boundary+0xf0> 200e198: a6 07 60 08 add %i5, 8, %l3 200e19c: 90 10 00 12 mov %l2, %o0 200e1a0: 40 00 2d bf call 201989c <.urem> 200e1a4: 92 10 00 1a mov %i2, %o1 200e1a8: b0 24 80 08 sub %l2, %o0, %i0 } alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { 200e1ac: 80 a6 e0 00 cmp %i3, 0 200e1b0: 02 80 00 37 be 200e28c <_Heap_Allocate_aligned_with_boundary+0x1d0> 200e1b4: 80 a4 c0 18 cmp %l3, %i0 /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment ); } alloc_end = alloc_begin + alloc_size; 200e1b8: 86 06 00 19 add %i0, %i1, %g3 200e1bc: 92 10 00 1b mov %i3, %o1 200e1c0: 90 10 00 03 mov %g3, %o0 200e1c4: 40 00 2d b6 call 201989c <.urem> 200e1c8: c6 27 bf f8 st %g3, [ %fp + -8 ] 200e1cc: c6 07 bf f8 ld [ %fp + -8 ], %g3 200e1d0: 90 20 c0 08 sub %g3, %o0, %o0 /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 200e1d4: 80 a6 00 08 cmp %i0, %o0 200e1d8: 1a 80 00 2c bcc 200e288 <_Heap_Allocate_aligned_with_boundary+0x1cc> 200e1dc: a4 04 c0 19 add %l3, %i1, %l2 200e1e0: 80 a2 00 03 cmp %o0, %g3 200e1e4: 2a 80 00 12 bcs,a 200e22c <_Heap_Allocate_aligned_with_boundary+0x170> 200e1e8: 80 a4 80 08 cmp %l2, %o0 boundary_line = _Heap_Align_down( alloc_end, boundary ); } } /* Ensure that the we have a valid new block at the beginning */ if ( alloc_begin >= alloc_begin_floor ) { 200e1ec: 10 80 00 28 b 200e28c <_Heap_Allocate_aligned_with_boundary+0x1d0> 200e1f0: 80 a4 c0 18 cmp %l3, %i0 200e1f4: 92 10 00 1a mov %i2, %o1 200e1f8: 40 00 2d a9 call 201989c <.urem> 200e1fc: 90 10 00 18 mov %i0, %o0 200e200: 92 10 00 1b mov %i3, %o1 200e204: b0 26 00 08 sub %i0, %o0, %i0 if ( boundary_line < boundary_floor ) { return 0; } alloc_begin = boundary_line - alloc_size; alloc_begin = _Heap_Align_down( alloc_begin, alignment ); alloc_end = alloc_begin + alloc_size; 200e208: ac 06 00 19 add %i0, %i1, %l6 200e20c: 40 00 2d a4 call 201989c <.urem> 200e210: 90 10 00 16 mov %l6, %o0 200e214: 90 25 80 08 sub %l6, %o0, %o0 /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 200e218: 80 a2 00 16 cmp %o0, %l6 200e21c: 1a 80 00 1b bcc 200e288 <_Heap_Allocate_aligned_with_boundary+0x1cc> 200e220: 80 a6 00 08 cmp %i0, %o0 200e224: 1a 80 00 19 bcc 200e288 <_Heap_Allocate_aligned_with_boundary+0x1cc> 200e228: 80 a4 80 08 cmp %l2, %o0 if ( boundary_line < boundary_floor ) { 200e22c: 08 bf ff f2 bleu 200e1f4 <_Heap_Allocate_aligned_with_boundary+0x138> 200e230: b0 22 00 19 sub %o0, %i1, %i0 return 0; 200e234: b0 10 20 00 clr %i0 } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 200e238: 80 a6 20 00 cmp %i0, 0 200e23c: 02 bf ff b7 be 200e118 <_Heap_Allocate_aligned_with_boundary+0x5c><== ALWAYS TAKEN 200e240: b8 07 20 01 inc %i4 search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; 200e244: c6 04 20 48 ld [ %l0 + 0x48 ], %g3 stats->searches += search_count; 200e248: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; 200e24c: 86 00 e0 01 inc %g3 stats->searches += search_count; 200e250: 84 00 80 1c add %g2, %i4, %g2 search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; 200e254: c6 24 20 48 st %g3, [ %l0 + 0x48 ] stats->searches += search_count; 200e258: c4 24 20 4c st %g2, [ %l0 + 0x4c ] block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 200e25c: 90 10 00 10 mov %l0, %o0 200e260: 92 10 00 1d mov %i5, %o1 200e264: 94 10 00 18 mov %i0, %o2 200e268: 7f ff eb c8 call 2009188 <_Heap_Block_allocate> 200e26c: 96 10 00 19 mov %i1, %o3 boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 200e270: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 200e274: 80 a0 40 1c cmp %g1, %i4 200e278: 2a bf ff b9 bcs,a 200e15c <_Heap_Allocate_aligned_with_boundary+0xa0> 200e27c: f8 24 20 44 st %i4, [ %l0 + 0x44 ] stats->max_search = search_count; } return (void *) alloc_begin; } 200e280: 81 c7 e0 08 ret 200e284: 81 e8 00 00 restore boundary_line = _Heap_Align_down( alloc_end, boundary ); } } /* Ensure that the we have a valid new block at the beginning */ if ( alloc_begin >= alloc_begin_floor ) { 200e288: 80 a4 c0 18 cmp %l3, %i0 200e28c: 18 bf ff ea bgu 200e234 <_Heap_Allocate_aligned_with_boundary+0x178> 200e290: 82 10 3f f8 mov -8, %g1 200e294: 90 10 00 18 mov %i0, %o0 200e298: a4 20 40 1d sub %g1, %i5, %l2 200e29c: 92 10 00 15 mov %l5, %o1 200e2a0: 40 00 2d 7f call 201989c <.urem> 200e2a4: a4 04 80 18 add %l2, %i0, %l2 uintptr_t const alloc_block_begin = (uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size ); uintptr_t const free_size = alloc_block_begin - block_begin; if ( free_size >= min_block_size || free_size == 0 ) { 200e2a8: 90 a4 80 08 subcc %l2, %o0, %o0 200e2ac: 02 bf ff 99 be 200e110 <_Heap_Allocate_aligned_with_boundary+0x54> 200e2b0: 80 a6 20 00 cmp %i0, 0 200e2b4: 80 a2 00 14 cmp %o0, %l4 200e2b8: 1a bf ff 96 bcc 200e110 <_Heap_Allocate_aligned_with_boundary+0x54> 200e2bc: 80 a6 20 00 cmp %i0, 0 uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { if ( boundary_line < boundary_floor ) { return 0; 200e2c0: 10 bf ff de b 200e238 <_Heap_Allocate_aligned_with_boundary+0x17c> 200e2c4: b0 10 20 00 clr %i0 /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { if ( boundary < alloc_size ) { 200e2c8: 18 80 00 06 bgu 200e2e0 <_Heap_Allocate_aligned_with_boundary+0x224> 200e2cc: 80 a6 a0 00 cmp %i2, 0 return NULL; } if ( alignment == 0 ) { 200e2d0: 22 bf ff 84 be,a 200e0e0 <_Heap_Allocate_aligned_with_boundary+0x24> 200e2d4: b4 10 00 15 mov %l5, %i2 return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 200e2d8: 10 bf ff 83 b 200e0e4 <_Heap_Allocate_aligned_with_boundary+0x28> 200e2dc: fa 04 20 08 ld [ %l0 + 8 ], %i5 uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { /* Integer overflow occured */ return NULL; 200e2e0: 81 c7 e0 08 ret 200e2e4: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 0200e300 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 200e300: 9d e3 bf 98 save %sp, -104, %sp Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 200e304: c0 27 bf f8 clr [ %fp + -8 ] Heap_Block *extend_last_block = NULL; 200e308: c0 27 bf fc clr [ %fp + -4 ] uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; 200e30c: a0 06 40 1a add %i1, %i2, %l0 uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 200e310: ee 06 20 20 ld [ %i0 + 0x20 ], %l7 Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; 200e314: e2 06 20 10 ld [ %i0 + 0x10 ], %l1 uintptr_t const min_block_size = heap->min_block_size; 200e318: d6 06 20 14 ld [ %i0 + 0x14 ], %o3 uintptr_t const free_size = stats->free_size; uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 200e31c: 80 a6 40 10 cmp %i1, %l0 200e320: 08 80 00 06 bleu 200e338 <_Heap_Extend+0x38> 200e324: e6 06 20 30 ld [ %i0 + 0x30 ], %l3 return false; 200e328: b0 10 20 00 clr %i0 if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 200e32c: b0 0e 20 01 and %i0, 1, %i0 200e330: 81 c7 e0 08 ret 200e334: 81 e8 00 00 restore if ( extend_area_end < extend_area_begin ) { return false; } extend_area_ok = _Heap_Get_first_and_last_block( 200e338: 90 10 00 19 mov %i1, %o0 200e33c: 92 10 00 1a mov %i2, %o1 200e340: 94 10 00 11 mov %l1, %o2 200e344: 98 07 bf f8 add %fp, -8, %o4 200e348: 7f ff eb 35 call 200901c <_Heap_Get_first_and_last_block> 200e34c: 9a 07 bf fc add %fp, -4, %o5 page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 200e350: 80 8a 20 ff btst 0xff, %o0 200e354: 02 bf ff f5 be 200e328 <_Heap_Extend+0x28> 200e358: ba 10 00 17 mov %l7, %i5 200e35c: aa 10 20 00 clr %l5 200e360: ac 10 20 00 clr %l6 200e364: a4 10 20 00 clr %l2 200e368: 10 80 00 10 b 200e3a8 <_Heap_Extend+0xa8> 200e36c: a8 10 20 00 clr %l4 return false; } if ( extend_area_end == sub_area_begin ) { merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 200e370: 2a 80 00 02 bcs,a 200e378 <_Heap_Extend+0x78> 200e374: ac 10 00 1d mov %i5, %l6 link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 200e378: 80 a7 00 19 cmp %i4, %i1 200e37c: 22 80 00 1e be,a 200e3f4 <_Heap_Extend+0xf4> 200e380: e0 27 40 00 st %l0, [ %i5 ] start_block->prev_size = extend_area_end; merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 200e384: 80 a6 40 1c cmp %i1, %i4 200e388: 38 80 00 02 bgu,a 200e390 <_Heap_Extend+0x90> 200e38c: aa 10 00 08 mov %o0, %l5 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200e390: fa 02 20 04 ld [ %o0 + 4 ], %i5 200e394: ba 0f 7f fe and %i5, -2, %i5 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 200e398: ba 02 00 1d add %o0, %i5, %i5 link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 200e39c: 80 a5 c0 1d cmp %l7, %i5 200e3a0: 22 80 00 1c be,a 200e410 <_Heap_Extend+0x110> 200e3a4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 200e3a8: 80 a7 40 17 cmp %i5, %l7 200e3ac: 22 80 00 03 be,a 200e3b8 <_Heap_Extend+0xb8> 200e3b0: f4 06 20 18 ld [ %i0 + 0x18 ], %i2 200e3b4: b4 10 00 1d mov %i5, %i2 uintptr_t const sub_area_end = start_block->prev_size; 200e3b8: f8 07 40 00 ld [ %i5 ], %i4 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 200e3bc: 92 10 00 11 mov %l1, %o1 200e3c0: 40 00 2d fc call 2019bb0 <.urem> 200e3c4: 90 10 00 1c mov %i4, %o0 200e3c8: 82 07 3f f8 add %i4, -8, %g1 Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 200e3cc: 80 a6 80 10 cmp %i2, %l0 200e3d0: 0a 80 00 69 bcs 200e574 <_Heap_Extend+0x274> 200e3d4: 90 20 40 08 sub %g1, %o0, %o0 sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 200e3d8: 80 a6 80 10 cmp %i2, %l0 200e3dc: 12 bf ff e5 bne 200e370 <_Heap_Extend+0x70> 200e3e0: 80 a4 00 1c cmp %l0, %i4 merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 200e3e4: 80 a7 00 19 cmp %i4, %i1 200e3e8: 12 bf ff e7 bne 200e384 <_Heap_Extend+0x84> <== ALWAYS TAKEN 200e3ec: a8 10 00 1d mov %i5, %l4 start_block->prev_size = extend_area_end; 200e3f0: e0 27 40 00 st %l0, [ %i5 ] <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200e3f4: fa 02 20 04 ld [ %o0 + 4 ], %i5 200e3f8: ba 0f 7f fe and %i5, -2, %i5 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 200e3fc: ba 02 00 1d add %o0, %i5, %i5 } else if ( sub_area_end < extend_area_begin ) { link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 200e400: 80 a5 c0 1d cmp %l7, %i5 200e404: 12 bf ff e9 bne 200e3a8 <_Heap_Extend+0xa8> <== NEVER TAKEN 200e408: a4 10 00 08 mov %o0, %l2 if ( extend_area_begin < heap->area_begin ) { 200e40c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 200e410: 80 a6 40 01 cmp %i1, %g1 200e414: 3a 80 00 53 bcc,a 200e560 <_Heap_Extend+0x260> 200e418: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 heap->area_begin = extend_area_begin; 200e41c: f2 26 20 18 st %i1, [ %i0 + 0x18 ] } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 200e420: c2 07 bf f8 ld [ %fp + -8 ], %g1 200e424: c4 07 bf fc ld [ %fp + -4 ], %g2 extend_last_block->prev_size = extend_first_block_size; extend_last_block->size_and_flag = 0; _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 200e428: c8 06 20 20 ld [ %i0 + 0x20 ], %g4 heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = 200e42c: 86 20 80 01 sub %g2, %g1, %g3 (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 200e430: e0 20 40 00 st %l0, [ %g1 ] extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 200e434: ba 10 e0 01 or %g3, 1, %i5 extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; extend_first_block->size_and_flag = 200e438: fa 20 60 04 st %i5, [ %g1 + 4 ] extend_first_block_size | HEAP_PREV_BLOCK_USED; _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 200e43c: c6 20 80 00 st %g3, [ %g2 ] extend_last_block->size_and_flag = 0; _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 200e440: 80 a1 00 01 cmp %g4, %g1 200e444: 08 80 00 41 bleu 200e548 <_Heap_Extend+0x248> 200e448: c0 20 a0 04 clr [ %g2 + 4 ] heap->first_block = extend_first_block; 200e44c: c2 26 20 20 st %g1, [ %i0 + 0x20 ] } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { 200e450: 80 a5 20 00 cmp %l4, 0 200e454: 02 80 00 4d be 200e588 <_Heap_Extend+0x288> 200e458: b2 06 60 08 add %i1, 8, %i1 Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 200e45c: fa 06 20 10 ld [ %i0 + 0x10 ], %i5 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 200e460: 92 10 00 1d mov %i5, %o1 200e464: 40 00 2d d3 call 2019bb0 <.urem> 200e468: 90 10 00 19 mov %i1, %o0 if ( remainder != 0 ) { 200e46c: 80 a2 20 00 cmp %o0, 0 200e470: 02 80 00 04 be 200e480 <_Heap_Extend+0x180> 200e474: c4 05 00 00 ld [ %l4 ], %g2 return value - remainder + alignment; 200e478: b2 06 40 1d add %i1, %i5, %i1 200e47c: b2 26 40 08 sub %i1, %o0, %i1 uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const new_first_block_begin = 200e480: 82 06 7f f8 add %i1, -8, %g1 uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; 200e484: c4 26 7f f8 st %g2, [ %i1 + -8 ] uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const new_first_block_begin = new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = 200e488: 84 25 00 01 sub %l4, %g1, %g2 first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED; 200e48c: 84 10 a0 01 or %g2, 1, %g2 _Heap_Free_block( heap, new_first_block ); 200e490: 90 10 00 18 mov %i0, %o0 200e494: 92 10 00 01 mov %g1, %o1 200e498: 7f ff ff 90 call 200e2d8 <_Heap_Free_block> 200e49c: c4 26 7f fc st %g2, [ %i1 + -4 ] link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 200e4a0: 80 a4 a0 00 cmp %l2, 0 200e4a4: 02 80 00 40 be 200e5a4 <_Heap_Extend+0x2a4> 200e4a8: a0 04 3f f8 add %l0, -8, %l0 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 200e4ac: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 uintptr_t extend_area_end ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( 200e4b0: a0 24 00 12 sub %l0, %l2, %l0 200e4b4: 40 00 2d bf call 2019bb0 <.urem> 200e4b8: 90 10 00 10 mov %l0, %o0 ); Heap_Block *const new_last_block = _Heap_Block_at( last_block, last_block_new_size ); new_last_block->size_and_flag = (last_block->size_and_flag - last_block_new_size) 200e4bc: c2 04 a0 04 ld [ %l2 + 4 ], %g1 200e4c0: a0 24 00 08 sub %l0, %o0, %l0 200e4c4: 82 20 40 10 sub %g1, %l0, %g1 | HEAP_PREV_BLOCK_USED; 200e4c8: 82 10 60 01 or %g1, 1, %g1 page_size ); Heap_Block *const new_last_block = _Heap_Block_at( last_block, last_block_new_size ); new_last_block->size_and_flag = 200e4cc: 84 04 00 12 add %l0, %l2, %g2 200e4d0: c2 20 a0 04 st %g1, [ %g2 + 4 ] RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 200e4d4: c2 04 a0 04 ld [ %l2 + 4 ], %g1 (last_block->size_and_flag - last_block_new_size) | HEAP_PREV_BLOCK_USED; _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 200e4d8: 90 10 00 18 mov %i0, %o0 200e4dc: 82 08 60 01 and %g1, 1, %g1 200e4e0: 92 10 00 12 mov %l2, %o1 block->size_and_flag = size | flag; 200e4e4: a0 14 00 01 or %l0, %g1, %l0 200e4e8: 7f ff ff 7c call 200e2d8 <_Heap_Free_block> 200e4ec: e0 24 a0 04 st %l0, [ %l2 + 4 ] extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 200e4f0: 80 a4 a0 00 cmp %l2, 0 200e4f4: 02 80 00 39 be 200e5d8 <_Heap_Extend+0x2d8> 200e4f8: 80 a5 20 00 cmp %l4, 0 */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( heap->last_block, (uintptr_t) heap->first_block - (uintptr_t) heap->last_block 200e4fc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 * This feature will be used to terminate the scattered heap area list. See * also _Heap_Extend(). */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( 200e500: fa 06 20 20 ld [ %i0 + 0x20 ], %i5 RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 200e504: c8 00 60 04 ld [ %g1 + 4 ], %g4 _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; /* Statistics */ stats->size += extended_size; 200e508: c4 06 20 2c ld [ %i0 + 0x2c ], %g2 _Heap_Free_block( heap, extend_first_block ); } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 200e50c: c6 06 20 30 ld [ %i0 + 0x30 ], %g3 * This feature will be used to terminate the scattered heap area list. See * also _Heap_Extend(). */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( 200e510: ba 27 40 01 sub %i5, %g1, %i5 RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 200e514: 88 09 20 01 and %g4, 1, %g4 block->size_and_flag = size | flag; 200e518: 88 17 40 04 or %i5, %g4, %g4 200e51c: c8 20 60 04 st %g4, [ %g1 + 4 ] 200e520: a6 20 c0 13 sub %g3, %l3, %l3 /* Statistics */ stats->size += extended_size; 200e524: 82 00 80 13 add %g2, %l3, %g1 if ( extended_size_ptr != NULL ) 200e528: 80 a6 e0 00 cmp %i3, 0 200e52c: 02 80 00 32 be 200e5f4 <_Heap_Extend+0x2f4> <== NEVER TAKEN 200e530: c2 26 20 2c st %g1, [ %i0 + 0x2c ] *extended_size_ptr = extended_size; 200e534: e6 26 c0 00 st %l3, [ %i3 ] return true; 200e538: b0 10 20 01 mov 1, %i0 } 200e53c: b0 0e 20 01 and %i0, 1, %i0 200e540: 81 c7 e0 08 ret 200e544: 81 e8 00 00 restore extend_last_block->size_and_flag = 0; _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { heap->first_block = extend_first_block; } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 200e548: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 200e54c: 80 a0 40 02 cmp %g1, %g2 200e550: 2a bf ff c0 bcs,a 200e450 <_Heap_Extend+0x150> 200e554: c4 26 20 24 st %g2, [ %i0 + 0x24 ] heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { 200e558: 10 bf ff bf b 200e454 <_Heap_Extend+0x154> 200e55c: 80 a5 20 00 cmp %l4, 0 start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); if ( extend_area_begin < heap->area_begin ) { heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { 200e560: 80 a4 00 01 cmp %l0, %g1 200e564: 38 bf ff af bgu,a 200e420 <_Heap_Extend+0x120> 200e568: e0 26 20 1c st %l0, [ %i0 + 0x1c ] heap->area_end = extend_area_end; } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 200e56c: 10 bf ff ae b 200e424 <_Heap_Extend+0x124> 200e570: c2 07 bf f8 ld [ %fp + -8 ], %g1 (uintptr_t) start_block : heap->area_begin; uintptr_t const sub_area_end = start_block->prev_size; Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 200e574: 80 a6 40 1c cmp %i1, %i4 200e578: 1a bf ff 99 bcc 200e3dc <_Heap_Extend+0xdc> 200e57c: 80 a6 80 10 cmp %i2, %l0 uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { return false; 200e580: 10 bf ff 6b b 200e32c <_Heap_Extend+0x2c> 200e584: b0 10 20 00 clr %i0 heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { _Heap_Merge_below( heap, extend_area_begin, merge_below_block ); } else if ( link_below_block != NULL ) { 200e588: 80 a5 a0 00 cmp %l6, 0 200e58c: 02 bf ff c6 be 200e4a4 <_Heap_Extend+0x1a4> 200e590: 80 a4 a0 00 cmp %l2, 0 { uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const link_begin = (uintptr_t) link; last_block->size_and_flag = (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED; 200e594: ac 25 80 02 sub %l6, %g2, %l6 200e598: ac 15 a0 01 or %l6, 1, %l6 ) { uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const link_begin = (uintptr_t) link; last_block->size_and_flag = 200e59c: 10 bf ff c2 b 200e4a4 <_Heap_Extend+0x1a4> 200e5a0: ec 20 a0 04 st %l6, [ %g2 + 4 ] ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 200e5a4: 80 a5 60 00 cmp %l5, 0 200e5a8: 02 bf ff d2 be 200e4f0 <_Heap_Extend+0x1f0> 200e5ac: c4 07 bf f8 ld [ %fp + -8 ], %g2 RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 200e5b0: c6 05 60 04 ld [ %l5 + 4 ], %g3 _Heap_Link_above( 200e5b4: c2 07 bf fc ld [ %fp + -4 ], %g1 200e5b8: 86 08 e0 01 and %g3, 1, %g3 ) { uintptr_t const link_begin = (uintptr_t) link; uintptr_t const first_block_begin = (uintptr_t) first_block; _Heap_Block_set_size( link, first_block_begin - link_begin ); 200e5bc: 84 20 80 15 sub %g2, %l5, %g2 block->size_and_flag = size | flag; 200e5c0: 84 10 80 03 or %g2, %g3, %g2 200e5c4: c4 25 60 04 st %g2, [ %l5 + 4 ] last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 200e5c8: c4 00 60 04 ld [ %g1 + 4 ], %g2 200e5cc: 84 10 a0 01 or %g2, 1, %g2 200e5d0: 10 bf ff c8 b 200e4f0 <_Heap_Extend+0x1f0> 200e5d4: c4 20 60 04 st %g2, [ %g1 + 4 ] extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 200e5d8: 32 bf ff ca bne,a 200e500 <_Heap_Extend+0x200> 200e5dc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 _Heap_Free_block( heap, extend_first_block ); 200e5e0: d2 07 bf f8 ld [ %fp + -8 ], %o1 200e5e4: 7f ff ff 3d call 200e2d8 <_Heap_Free_block> 200e5e8: 90 10 00 18 mov %i0, %o0 */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( heap->last_block, (uintptr_t) heap->first_block - (uintptr_t) heap->last_block 200e5ec: 10 bf ff c5 b 200e500 <_Heap_Extend+0x200> 200e5f0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 stats->size += extended_size; if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 200e5f4: 10 bf ff 4e b 200e32c <_Heap_Extend+0x2c> <== NOT EXECUTED 200e5f8: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED =============================================================================== 0200e2e8 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 200e2e8: 9d e3 bf a0 save %sp, -96, %sp /* * If NULL return true so a free on NULL is considered a valid release. This * is a special case that could be handled by the in heap check how-ever that * would result in false being returned which is wrong. */ if ( alloc_begin_ptr == NULL ) { 200e2ec: 80 a6 60 00 cmp %i1, 0 200e2f0: 02 80 00 3c be 200e3e0 <_Heap_Free+0xf8> 200e2f4: 82 10 20 01 mov 1, %g1 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 200e2f8: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 200e2fc: 40 00 2d 68 call 201989c <.urem> 200e300: 90 10 00 19 mov %i1, %o0 RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap( const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block 200e304: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 200e308: ba 06 7f f8 add %i1, -8, %i5 uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 200e30c: 90 27 40 08 sub %i5, %o0, %o0 const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 200e310: 80 a2 00 02 cmp %o0, %g2 200e314: 0a 80 00 30 bcs 200e3d4 <_Heap_Free+0xec> 200e318: 82 10 20 00 clr %g1 200e31c: c8 06 20 24 ld [ %i0 + 0x24 ], %g4 200e320: 80 a2 00 04 cmp %o0, %g4 200e324: 38 80 00 2d bgu,a 200e3d8 <_Heap_Free+0xf0> 200e328: b0 08 60 ff and %g1, 0xff, %i0 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200e32c: f6 02 20 04 ld [ %o0 + 4 ], %i3 200e330: ba 0e ff fe and %i3, -2, %i5 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 200e334: 86 02 00 1d add %o0, %i5, %g3 const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 200e338: 80 a0 80 03 cmp %g2, %g3 200e33c: 38 80 00 27 bgu,a 200e3d8 <_Heap_Free+0xf0> <== NEVER TAKEN 200e340: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED 200e344: 80 a1 00 03 cmp %g4, %g3 200e348: 2a 80 00 24 bcs,a 200e3d8 <_Heap_Free+0xf0> <== NEVER TAKEN 200e34c: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 200e350: f8 00 e0 04 ld [ %g3 + 4 ], %i4 return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 200e354: 80 8f 20 01 btst 1, %i4 200e358: 02 80 00 1f be 200e3d4 <_Heap_Free+0xec> <== NEVER TAKEN 200e35c: 80 a1 00 03 cmp %g4, %g3 return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 200e360: 02 80 00 23 be 200e3ec <_Heap_Free+0x104> 200e364: b8 0f 3f fe and %i4, -2, %i4 200e368: 82 00 c0 1c add %g3, %i4, %g1 200e36c: c2 00 60 04 ld [ %g1 + 4 ], %g1 200e370: 80 88 60 01 btst 1, %g1 200e374: 12 80 00 1f bne 200e3f0 <_Heap_Free+0x108> 200e378: 80 8e e0 01 btst 1, %i3 if ( !_Heap_Is_prev_used( block ) ) { 200e37c: 02 80 00 20 be 200e3fc <_Heap_Free+0x114> 200e380: b2 10 20 01 mov 1, %i1 RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace( Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *next = old_block->next; 200e384: c4 00 e0 08 ld [ %g3 + 8 ], %g2 Heap_Block *prev = old_block->prev; 200e388: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 new_block->next = next; 200e38c: c4 22 20 08 st %g2, [ %o0 + 8 ] new_block->prev = prev; 200e390: c2 22 20 0c st %g1, [ %o0 + 0xc ] prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ uintptr_t const size = block_size + next_block_size; 200e394: b8 07 00 1d add %i4, %i5, %i4 next->prev = new_block; 200e398: d0 20 a0 0c st %o0, [ %g2 + 0xc ] prev->next = new_block; 200e39c: d0 20 60 08 st %o0, [ %g1 + 8 ] _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 200e3a0: 84 17 20 01 or %i4, 1, %g2 next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 200e3a4: f8 22 00 1c st %i4, [ %o0 + %i4 ] next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ uintptr_t const size = block_size + next_block_size; _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 200e3a8: c4 22 20 04 st %g2, [ %o0 + 4 ] } } /* Statistics */ --stats->used_blocks; ++stats->frees; 200e3ac: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 stats->max_free_blocks = stats->free_blocks; } } /* Statistics */ --stats->used_blocks; 200e3b0: c4 06 20 40 ld [ %i0 + 0x40 ], %g2 ++stats->frees; stats->free_size += block_size; 200e3b4: c6 06 20 30 ld [ %i0 + 0x30 ], %g3 } } /* Statistics */ --stats->used_blocks; ++stats->frees; 200e3b8: 82 00 60 01 inc %g1 stats->max_free_blocks = stats->free_blocks; } } /* Statistics */ --stats->used_blocks; 200e3bc: 84 00 bf ff add %g2, -1, %g2 ++stats->frees; stats->free_size += block_size; 200e3c0: ba 00 c0 1d add %g3, %i5, %i5 } } /* Statistics */ --stats->used_blocks; ++stats->frees; 200e3c4: c2 26 20 50 st %g1, [ %i0 + 0x50 ] stats->max_free_blocks = stats->free_blocks; } } /* Statistics */ --stats->used_blocks; 200e3c8: c4 26 20 40 st %g2, [ %i0 + 0x40 ] ++stats->frees; stats->free_size += block_size; 200e3cc: fa 26 20 30 st %i5, [ %i0 + 0x30 ] return( true ); 200e3d0: 82 10 20 01 mov 1, %g1 200e3d4: b0 08 60 ff and %g1, 0xff, %i0 200e3d8: 81 c7 e0 08 ret 200e3dc: 81 e8 00 00 restore 200e3e0: b0 08 60 ff and %g1, 0xff, %i0 200e3e4: 81 c7 e0 08 ret 200e3e8: 81 e8 00 00 restore next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { 200e3ec: 80 8e e0 01 btst 1, %i3 200e3f0: 32 80 00 1e bne,a 200e468 <_Heap_Free+0x180> 200e3f4: c4 06 20 08 ld [ %i0 + 8 ], %g2 if ( !_Heap_Protection_determine_block_free( heap, block ) ) { return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block 200e3f8: b2 10 20 00 clr %i1 && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { uintptr_t const prev_size = block->prev_size; 200e3fc: f4 02 00 00 ld [ %o0 ], %i2 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 200e400: b6 22 00 1a sub %o0, %i2, %i3 const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 200e404: 80 a0 80 1b cmp %g2, %i3 200e408: 18 bf ff f3 bgu 200e3d4 <_Heap_Free+0xec> <== NEVER TAKEN 200e40c: 82 10 20 00 clr %g1 200e410: 80 a1 00 1b cmp %g4, %i3 200e414: 2a bf ff f1 bcs,a 200e3d8 <_Heap_Free+0xf0> <== NEVER TAKEN 200e418: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 200e41c: c4 06 e0 04 ld [ %i3 + 4 ], %g2 return( false ); } /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { 200e420: 80 88 a0 01 btst 1, %g2 200e424: 02 bf ff ec be 200e3d4 <_Heap_Free+0xec> <== NEVER TAKEN 200e428: 80 8e 60 ff btst 0xff, %i1 _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 200e42c: 22 80 00 21 be,a 200e4b0 <_Heap_Free+0x1c8> 200e430: b4 07 40 1a add %i5, %i2, %i2 return _Heap_Free_list_tail(heap)->prev; } RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; 200e434: c2 00 e0 08 ld [ %g3 + 8 ], %g1 Heap_Block *prev = block->prev; 200e438: c4 00 e0 0c ld [ %g3 + 0xc ], %g2 uintptr_t const size = block_size + prev_size + next_block_size; _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 200e43c: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 prev->next = next; 200e440: c2 20 a0 08 st %g1, [ %g2 + 8 ] next->prev = prev; 200e444: c4 20 60 0c st %g2, [ %g1 + 0xc ] 200e448: 82 00 ff ff add %g3, -1, %g1 200e44c: c2 26 20 38 st %g1, [ %i0 + 0x38 ] _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ uintptr_t const size = block_size + prev_size + next_block_size; 200e450: b8 07 40 1c add %i5, %i4, %i4 200e454: b4 07 00 1a add %i4, %i2, %i2 _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 200e458: 82 16 a0 01 or %i2, 1, %g1 next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; 200e45c: f4 26 c0 1a st %i2, [ %i3 + %i2 ] if ( next_is_free ) { /* coalesce both */ uintptr_t const size = block_size + prev_size + next_block_size; _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 200e460: 10 bf ff d3 b 200e3ac <_Heap_Free+0xc4> 200e464: c2 26 e0 04 st %g1, [ %i3 + 4 ] next_block->prev_size = size; } else { /* no coalesce */ /* Add 'block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block ); block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 200e468: 82 17 60 01 or %i5, 1, %g1 200e46c: c2 22 20 04 st %g1, [ %o0 + 4 ] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 200e470: c8 00 e0 04 ld [ %g3 + 4 ], %g4 ) { Heap_Block *next = block_before->next; new_block->next = next; new_block->prev = block_before; 200e474: f0 22 20 0c st %i0, [ %o0 + 0xc ] next_block->prev_size = block_size; /* Statistics */ ++stats->free_blocks; 200e478: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 Heap_Block *new_block ) { Heap_Block *next = block_before->next; new_block->next = next; 200e47c: c4 22 20 08 st %g2, [ %o0 + 8 ] new_block->prev = block_before; block_before->next = new_block; next->prev = new_block; 200e480: d0 20 a0 0c st %o0, [ %g2 + 0xc ] } else { /* no coalesce */ /* Add 'block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block ); block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 200e484: 84 09 3f fe and %g4, -2, %g2 next_block->prev_size = block_size; 200e488: fa 22 00 1d st %i5, [ %o0 + %i5 ] } else { /* no coalesce */ /* Add 'block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block ); block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 200e48c: c4 20 e0 04 st %g2, [ %g3 + 4 ] next_block->prev_size = block_size; /* Statistics */ ++stats->free_blocks; if ( stats->max_free_blocks < stats->free_blocks ) { 200e490: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; next_block->prev_size = block_size; /* Statistics */ ++stats->free_blocks; 200e494: 82 00 60 01 inc %g1 { Heap_Block *next = block_before->next; new_block->next = next; new_block->prev = block_before; block_before->next = new_block; 200e498: d0 26 20 08 st %o0, [ %i0 + 8 ] if ( stats->max_free_blocks < stats->free_blocks ) { 200e49c: 80 a0 40 02 cmp %g1, %g2 200e4a0: 08 bf ff c3 bleu 200e3ac <_Heap_Free+0xc4> 200e4a4: c2 26 20 38 st %g1, [ %i0 + 0x38 ] stats->max_free_blocks = stats->free_blocks; 200e4a8: 10 bf ff c1 b 200e3ac <_Heap_Free+0xc4> 200e4ac: c2 26 20 3c st %g1, [ %i0 + 0x3c ] next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uintptr_t const size = block_size + prev_size; prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 200e4b0: 82 16 a0 01 or %i2, 1, %g1 200e4b4: c2 26 e0 04 st %g1, [ %i3 + 4 ] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 200e4b8: c2 00 e0 04 ld [ %g3 + 4 ], %g1 next_block->prev_size = size; 200e4bc: f4 22 00 1d st %i2, [ %o0 + %i5 ] _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uintptr_t const size = block_size + prev_size; prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 200e4c0: 82 08 7f fe and %g1, -2, %g1 200e4c4: 10 bf ff ba b 200e3ac <_Heap_Free+0xc4> 200e4c8: c2 20 e0 04 st %g1, [ %g3 + 4 ] =============================================================================== 0202f830 <_Heap_Get_free_information>: return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 202f830: c2 02 20 08 ld [ %o0 + 8 ], %g1 ) { Heap_Block *the_block; Heap_Block *const tail = _Heap_Free_list_tail(the_heap); info->number = 0; 202f834: c0 22 40 00 clr [ %o1 ] info->largest = 0; 202f838: c0 22 60 04 clr [ %o1 + 4 ] info->total = 0; 202f83c: c0 22 60 08 clr [ %o1 + 8 ] for(the_block = _Heap_Free_list_first(the_heap); 202f840: 88 10 20 01 mov 1, %g4 202f844: 9a 10 20 00 clr %o5 202f848: 80 a2 00 01 cmp %o0, %g1 202f84c: 12 80 00 04 bne 202f85c <_Heap_Get_free_information+0x2c> <== ALWAYS TAKEN 202f850: 86 10 20 00 clr %g3 202f854: 30 80 00 10 b,a 202f894 <_Heap_Get_free_information+0x64><== NOT EXECUTED 202f858: 88 10 00 0c mov %o4, %g4 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 202f85c: c4 00 60 04 ld [ %g1 + 4 ], %g2 202f860: 98 01 20 01 add %g4, 1, %o4 202f864: 84 08 bf fe and %g2, -2, %g2 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; info->total += the_size; if ( info->largest < the_size ) 202f868: 80 a0 80 0d cmp %g2, %o5 202f86c: 08 80 00 03 bleu 202f878 <_Heap_Get_free_information+0x48> 202f870: 86 00 c0 02 add %g3, %g2, %g3 info->largest = the_size; 202f874: c4 22 60 04 st %g2, [ %o1 + 4 ] info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); the_block != tail; the_block = the_block->next) 202f878: c2 00 60 08 ld [ %g1 + 8 ], %g1 info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); 202f87c: 80 a2 00 01 cmp %o0, %g1 202f880: 32 bf ff f6 bne,a 202f858 <_Heap_Get_free_information+0x28> 202f884: da 02 60 04 ld [ %o1 + 4 ], %o5 202f888: c8 22 40 00 st %g4, [ %o1 ] 202f88c: 81 c3 e0 08 retl 202f890: c6 22 60 08 st %g3, [ %o1 + 8 ] 202f894: 81 c3 e0 08 retl <== NOT EXECUTED =============================================================================== 0200aed0 <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) { 200aed0: 9d e3 bf a0 save %sp, -96, %sp Heap_Block *allocated_blocks = NULL; Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 200aed4: 80 a6 a0 00 cmp %i2, 0 200aed8: 02 80 00 35 be 200afac <_Heap_Greedy_allocate+0xdc> 200aedc: b8 10 00 18 mov %i0, %i4 200aee0: ba 10 20 00 clr %i5 200aee4: b6 10 20 00 clr %i3 #include "config.h" #endif #include Heap_Block *_Heap_Greedy_allocate( 200aee8: 83 2f 60 02 sll %i5, 2, %g1 * @brief See _Heap_Allocate_aligned_with_boundary() with alignment and * boundary equals zero. */ RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 200aeec: d2 06 40 01 ld [ %i1 + %g1 ], %o1 200aef0: 94 10 20 00 clr %o2 200aef4: 96 10 20 00 clr %o3 200aef8: 40 00 1f d9 call 2012e5c <_Heap_Allocate_aligned_with_boundary> 200aefc: 90 10 00 1c mov %i4, %o0 size_t i; for (i = 0; i < block_count; ++i) { void *next = _Heap_Allocate( heap, block_sizes [i] ); if ( next != NULL ) { 200af00: 82 92 20 00 orcc %o0, 0, %g1 200af04: 22 80 00 09 be,a 200af28 <_Heap_Greedy_allocate+0x58> <== NEVER TAKEN 200af08: ba 07 60 01 inc %i5 <== NOT EXECUTED RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 200af0c: d2 07 20 10 ld [ %i4 + 0x10 ], %o1 200af10: 40 00 4d 62 call 201e498 <.urem> 200af14: b0 00 7f f8 add %g1, -8, %i0 uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 200af18: 90 26 00 08 sub %i0, %o0, %o0 Heap_Block *next_block = _Heap_Block_of_alloc_area( (uintptr_t) next, heap->page_size ); next_block->next = allocated_blocks; 200af1c: f6 22 20 08 st %i3, [ %o0 + 8 ] 200af20: b6 10 00 08 mov %o0, %i3 Heap_Block *allocated_blocks = NULL; Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 200af24: ba 07 60 01 inc %i5 200af28: 80 a7 40 1a cmp %i5, %i2 200af2c: 12 bf ff f0 bne 200aeec <_Heap_Greedy_allocate+0x1c> 200af30: 83 2f 60 02 sll %i5, 2, %g1 return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 200af34: fa 07 20 08 ld [ %i4 + 8 ], %i5 next_block->next = allocated_blocks; allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 200af38: 80 a7 00 1d cmp %i4, %i5 200af3c: 02 80 00 17 be 200af98 <_Heap_Greedy_allocate+0xc8> <== NEVER TAKEN 200af40: b0 10 20 00 clr %i0 200af44: 10 80 00 03 b 200af50 <_Heap_Greedy_allocate+0x80> 200af48: b4 10 20 00 clr %i2 200af4c: ba 10 00 01 mov %g1, %i5 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200af50: d6 07 60 04 ld [ %i5 + 4 ], %o3 _Heap_Block_allocate( 200af54: 92 10 00 1d mov %i5, %o1 200af58: 96 0a ff fe and %o3, -2, %o3 200af5c: 94 07 60 08 add %i5, 8, %o2 200af60: 90 10 00 1c mov %i4, %o0 200af64: 40 00 00 e0 call 200b2e4 <_Heap_Block_allocate> 200af68: 96 02 ff f8 add %o3, -8, %o3 current, _Heap_Alloc_area_of_block( current ), _Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE ); current->next = blocks; 200af6c: f4 27 60 08 st %i2, [ %i5 + 8 ] return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 200af70: c2 07 20 08 ld [ %i4 + 8 ], %g1 next_block->next = allocated_blocks; allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 200af74: 80 a7 00 01 cmp %i4, %g1 200af78: 12 bf ff f5 bne 200af4c <_Heap_Greedy_allocate+0x7c> 200af7c: b4 10 00 1d mov %i5, %i2 200af80: 10 80 00 06 b 200af98 <_Heap_Greedy_allocate+0xc8> 200af84: b0 10 00 1d mov %i5, %i0 } while ( allocated_blocks != NULL ) { current = allocated_blocks; allocated_blocks = allocated_blocks->next; _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 200af88: 92 06 e0 08 add %i3, 8, %o1 200af8c: 90 10 00 1c mov %i4, %o0 200af90: 40 00 20 3e call 2013088 <_Heap_Free> 200af94: b6 10 00 1a mov %i2, %i3 current->next = blocks; blocks = current; } while ( allocated_blocks != NULL ) { 200af98: 80 a6 e0 00 cmp %i3, 0 200af9c: 32 bf ff fb bne,a 200af88 <_Heap_Greedy_allocate+0xb8> 200afa0: f4 06 e0 08 ld [ %i3 + 8 ], %i2 allocated_blocks = allocated_blocks->next; _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); } return blocks; } 200afa4: 81 c7 e0 08 ret 200afa8: 81 e8 00 00 restore const uintptr_t *block_sizes, size_t block_count ) { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); Heap_Block *allocated_blocks = NULL; 200afac: 10 bf ff e2 b 200af34 <_Heap_Greedy_allocate+0x64> 200afb0: b6 10 20 00 clr %i3 =============================================================================== 0200afb4 <_Heap_Greedy_free>: void _Heap_Greedy_free( Heap_Control *heap, Heap_Block *blocks ) { 200afb4: 9d e3 bf a0 save %sp, -96, %sp while ( blocks != NULL ) { 200afb8: 80 a6 60 00 cmp %i1, 0 200afbc: 02 80 00 09 be 200afe0 <_Heap_Greedy_free+0x2c> <== NEVER TAKEN 200afc0: 01 00 00 00 nop Heap_Block *current = blocks; blocks = blocks->next; 200afc4: fa 06 60 08 ld [ %i1 + 8 ], %i5 _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 200afc8: 92 06 60 08 add %i1, 8, %o1 200afcc: 40 00 20 2f call 2013088 <_Heap_Free> 200afd0: 90 10 00 18 mov %i0, %o0 void _Heap_Greedy_free( Heap_Control *heap, Heap_Block *blocks ) { while ( blocks != NULL ) { 200afd4: b2 97 60 00 orcc %i5, 0, %i1 200afd8: 32 bf ff fc bne,a 200afc8 <_Heap_Greedy_free+0x14> 200afdc: fa 06 60 08 ld [ %i1 + 8 ], %i5 200afe0: 81 c7 e0 08 ret 200afe4: 81 e8 00 00 restore =============================================================================== 02045b34 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) { 2045b34: 9d e3 bf a0 save %sp, -96, %sp Heap_Block *current = heap->first_block; 2045b38: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 Heap_Block *end = heap->last_block; 2045b3c: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 bool stop = false; while ( !stop && current != end ) { 2045b40: 80 a0 40 1c cmp %g1, %i4 2045b44: 32 80 00 08 bne,a 2045b64 <_Heap_Iterate+0x30> <== ALWAYS TAKEN 2045b48: d2 00 60 04 ld [ %g1 + 4 ], %o1 2045b4c: 30 80 00 10 b,a 2045b8c <_Heap_Iterate+0x58> <== NOT EXECUTED 2045b50: 90 1a 20 01 xor %o0, 1, %o0 2045b54: 80 8a 20 ff btst 0xff, %o0 2045b58: 02 80 00 0d be 2045b8c <_Heap_Iterate+0x58> <== NEVER TAKEN 2045b5c: 01 00 00 00 nop - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 2045b60: d2 00 60 04 ld [ %g1 + 4 ], %o1 uintptr_t size = _Heap_Block_size( current ); Heap_Block *next = _Heap_Block_at( current, size ); bool used = _Heap_Is_prev_used( next ); stop = (*visitor)( current, size, used, visitor_arg ); 2045b64: 90 10 00 01 mov %g1, %o0 2045b68: 92 0a 7f fe and %o1, -2, %o1 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 2045b6c: ba 00 40 09 add %g1, %o1, %i5 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 2045b70: d4 07 60 04 ld [ %i5 + 4 ], %o2 2045b74: 96 10 00 1a mov %i2, %o3 2045b78: 9f c6 40 00 call %i1 2045b7c: 94 0a a0 01 and %o2, 1, %o2 { Heap_Block *current = heap->first_block; Heap_Block *end = heap->last_block; bool stop = false; while ( !stop && current != end ) { 2045b80: 80 a7 00 1d cmp %i4, %i5 2045b84: 12 bf ff f3 bne 2045b50 <_Heap_Iterate+0x1c> 2045b88: 82 10 00 1d mov %i5, %g1 2045b8c: 81 c7 e0 08 ret 2045b90: 81 e8 00 00 restore =============================================================================== 0200e5f4 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 200e5f4: 9d e3 bf a0 save %sp, -96, %sp RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 200e5f8: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 200e5fc: 40 00 2c a8 call 201989c <.urem> 200e600: 90 10 00 19 mov %i1, %o0 RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap( const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block 200e604: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 200e608: 84 06 7f f8 add %i1, -8, %g2 uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 200e60c: 90 20 80 08 sub %g2, %o0, %o0 const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 200e610: 80 a2 00 01 cmp %o0, %g1 200e614: 0a 80 00 16 bcs 200e66c <_Heap_Size_of_alloc_area+0x78> 200e618: 84 10 20 00 clr %g2 200e61c: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 200e620: 80 a2 00 03 cmp %o0, %g3 200e624: 18 80 00 13 bgu 200e670 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN 200e628: b0 08 a0 ff and %g2, 0xff, %i0 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200e62c: c8 02 20 04 ld [ %o0 + 4 ], %g4 200e630: 88 09 3f fe and %g4, -2, %g4 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 200e634: 90 02 00 04 add %o0, %g4, %o0 const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 200e638: 80 a0 40 08 cmp %g1, %o0 200e63c: 18 80 00 0d bgu 200e670 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN 200e640: 01 00 00 00 nop 200e644: 80 a0 c0 08 cmp %g3, %o0 200e648: 0a 80 00 0a bcs 200e670 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN 200e64c: 01 00 00 00 nop block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 200e650: c2 02 20 04 ld [ %o0 + 4 ], %g1 block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 200e654: 80 88 60 01 btst 1, %g1 200e658: 02 80 00 06 be 200e670 <_Heap_Size_of_alloc_area+0x7c> <== NEVER TAKEN 200e65c: 90 22 00 19 sub %o0, %i1, %o0 return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; return true; 200e660: 84 10 20 01 mov 1, %g2 || !_Heap_Is_prev_used( next_block ) ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 200e664: 90 02 20 04 add %o0, 4, %o0 200e668: d0 26 80 00 st %o0, [ %i2 ] 200e66c: b0 08 a0 ff and %g2, 0xff, %i0 200e670: 81 c7 e0 08 ret 200e674: 81 e8 00 00 restore =============================================================================== 02009f58 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 2009f58: 9d e3 bf 80 save %sp, -128, %sp uintptr_t const page_size = heap->page_size; 2009f5c: f6 06 20 10 ld [ %i0 + 0x10 ], %i3 uintptr_t const min_block_size = heap->min_block_size; 2009f60: e0 06 20 14 ld [ %i0 + 0x14 ], %l0 Heap_Block *const first_block = heap->first_block; 2009f64: f8 06 20 20 ld [ %i0 + 0x20 ], %i4 Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 2009f68: 80 a6 a0 00 cmp %i2, 0 2009f6c: 02 80 00 0c be 2009f9c <_Heap_Walk+0x44> 2009f70: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 if ( !_System_state_Is_up( _System_state_Get() ) ) { 2009f74: 03 00 80 83 sethi %hi(0x2020c00), %g1 2009f78: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2020ef0 <_System_state_Current> uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 2009f7c: 07 00 80 27 sethi %hi(0x2009c00), %g3 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 2009f80: 82 10 20 01 mov 1, %g1 Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; if ( !_System_state_Is_up( _System_state_Get() ) ) { 2009f84: 80 a0 a0 03 cmp %g2, 3 2009f88: 02 80 00 0c be 2009fb8 <_Heap_Walk+0x60> <== ALWAYS TAKEN 2009f8c: ae 10 e2 f4 or %g3, 0x2f4, %l7 2009f90: b0 08 60 ff and %g1, 0xff, %i0 2009f94: 81 c7 e0 08 ret 2009f98: 81 e8 00 00 restore 2009f9c: 03 00 80 83 sethi %hi(0x2020c00), %g1 2009fa0: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2020ef0 <_System_state_Current> uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 2009fa4: 07 00 80 27 sethi %hi(0x2009c00), %g3 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 2009fa8: 82 10 20 01 mov 1, %g1 Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; if ( !_System_state_Is_up( _System_state_Get() ) ) { 2009fac: 80 a0 a0 03 cmp %g2, 3 2009fb0: 12 bf ff f8 bne 2009f90 <_Heap_Walk+0x38> 2009fb4: ae 10 e2 ec or %g3, 0x2ec, %l7 Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; (*printer)( 2009fb8: da 06 20 18 ld [ %i0 + 0x18 ], %o5 2009fbc: c8 06 20 1c ld [ %i0 + 0x1c ], %g4 2009fc0: c4 06 20 08 ld [ %i0 + 8 ], %g2 2009fc4: c2 06 20 0c ld [ %i0 + 0xc ], %g1 2009fc8: 90 10 00 19 mov %i1, %o0 2009fcc: c8 23 a0 5c st %g4, [ %sp + 0x5c ] 2009fd0: f8 23 a0 60 st %i4, [ %sp + 0x60 ] 2009fd4: e2 23 a0 64 st %l1, [ %sp + 0x64 ] 2009fd8: c4 23 a0 68 st %g2, [ %sp + 0x68 ] 2009fdc: c2 23 a0 6c st %g1, [ %sp + 0x6c ] 2009fe0: 92 10 20 00 clr %o1 2009fe4: 96 10 00 1b mov %i3, %o3 2009fe8: 15 00 80 75 sethi %hi(0x201d400), %o2 2009fec: 98 10 00 10 mov %l0, %o4 2009ff0: 9f c5 c0 00 call %l7 2009ff4: 94 12 a3 d8 or %o2, 0x3d8, %o2 heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 2009ff8: 80 a6 e0 00 cmp %i3, 0 2009ffc: 02 80 00 2a be 200a0a4 <_Heap_Walk+0x14c> 200a000: 80 8e e0 07 btst 7, %i3 (*printer)( source, true, "page size is zero\n" ); return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 200a004: 12 80 00 2f bne 200a0c0 <_Heap_Walk+0x168> 200a008: 90 10 00 10 mov %l0, %o0 RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 200a00c: 7f ff de d9 call 2001b70 <.urem> 200a010: 92 10 00 1b mov %i3, %o1 ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 200a014: 80 a2 20 00 cmp %o0, 0 200a018: 12 80 00 32 bne 200a0e0 <_Heap_Walk+0x188> 200a01c: 90 07 20 08 add %i4, 8, %o0 200a020: 7f ff de d4 call 2001b70 <.urem> 200a024: 92 10 00 1b mov %i3, %o1 ); return false; } if ( 200a028: 80 a2 20 00 cmp %o0, 0 200a02c: 32 80 00 35 bne,a 200a100 <_Heap_Walk+0x1a8> 200a030: 90 10 00 19 mov %i1, %o0 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 200a034: ec 07 20 04 ld [ %i4 + 4 ], %l6 ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 200a038: b4 8d a0 01 andcc %l6, 1, %i2 200a03c: 22 80 00 38 be,a 200a11c <_Heap_Walk+0x1c4> 200a040: 90 10 00 19 mov %i1, %o0 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200a044: c2 04 60 04 ld [ %l1 + 4 ], %g1 200a048: 82 08 7f fe and %g1, -2, %g1 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 200a04c: 82 04 40 01 add %l1, %g1, %g1 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 200a050: fa 00 60 04 ld [ %g1 + 4 ], %i5 ); return false; } if ( _Heap_Is_free( last_block ) ) { 200a054: 80 8f 60 01 btst 1, %i5 200a058: 02 80 00 0c be 200a088 <_Heap_Walk+0x130> 200a05c: 80 a7 00 01 cmp %i4, %g1 ); return false; } if ( 200a060: 02 80 00 35 be 200a134 <_Heap_Walk+0x1dc> 200a064: 90 10 00 19 mov %i1, %o0 _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 200a068: 92 10 20 01 mov 1, %o1 200a06c: 15 00 80 76 sethi %hi(0x201d800), %o2 200a070: 9f c5 c0 00 call %l7 200a074: 94 12 a1 50 or %o2, 0x150, %o2 ! 201d950 <__log2table+0x2d8> if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a078: 82 10 20 00 clr %g1 200a07c: b0 08 60 ff and %g1, 0xff, %i0 200a080: 81 c7 e0 08 ret 200a084: 81 e8 00 00 restore return false; } if ( _Heap_Is_free( last_block ) ) { (*printer)( 200a088: 90 10 00 19 mov %i1, %o0 200a08c: 92 10 20 01 mov 1, %o1 200a090: 15 00 80 76 sethi %hi(0x201d800), %o2 200a094: 9f c5 c0 00 call %l7 200a098: 94 12 a1 38 or %o2, 0x138, %o2 ! 201d938 <__log2table+0x2c0> if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a09c: 10 bf ff f8 b 200a07c <_Heap_Walk+0x124> 200a0a0: 82 10 20 00 clr %g1 first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { (*printer)( source, true, "page size is zero\n" ); 200a0a4: 90 10 00 19 mov %i1, %o0 200a0a8: 92 10 20 01 mov 1, %o1 200a0ac: 15 00 80 76 sethi %hi(0x201d800), %o2 200a0b0: 9f c5 c0 00 call %l7 200a0b4: 94 12 a0 70 or %o2, 0x70, %o2 ! 201d870 <__log2table+0x1f8> if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a0b8: 10 bf ff f1 b 200a07c <_Heap_Walk+0x124> 200a0bc: 82 10 20 00 clr %g1 return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { (*printer)( 200a0c0: 90 10 00 19 mov %i1, %o0 200a0c4: 92 10 20 01 mov 1, %o1 200a0c8: 15 00 80 76 sethi %hi(0x201d800), %o2 200a0cc: 96 10 00 1b mov %i3, %o3 200a0d0: 9f c5 c0 00 call %l7 200a0d4: 94 12 a0 88 or %o2, 0x88, %o2 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a0d8: 10 bf ff e9 b 200a07c <_Heap_Walk+0x124> 200a0dc: 82 10 20 00 clr %g1 return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { (*printer)( 200a0e0: 90 10 00 19 mov %i1, %o0 200a0e4: 92 10 20 01 mov 1, %o1 200a0e8: 15 00 80 76 sethi %hi(0x201d800), %o2 200a0ec: 96 10 00 10 mov %l0, %o3 200a0f0: 9f c5 c0 00 call %l7 200a0f4: 94 12 a0 a8 or %o2, 0xa8, %o2 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a0f8: 10 bf ff e1 b 200a07c <_Heap_Walk+0x124> 200a0fc: 82 10 20 00 clr %g1 } if ( !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 200a100: 92 10 20 01 mov 1, %o1 200a104: 15 00 80 76 sethi %hi(0x201d800), %o2 200a108: 96 10 00 1c mov %i4, %o3 200a10c: 9f c5 c0 00 call %l7 200a110: 94 12 a0 d0 or %o2, 0xd0, %o2 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a114: 10 bf ff da b 200a07c <_Heap_Walk+0x124> 200a118: 82 10 20 00 clr %g1 return false; } if ( !_Heap_Is_prev_used( first_block ) ) { (*printer)( 200a11c: 92 10 20 01 mov 1, %o1 200a120: 15 00 80 76 sethi %hi(0x201d800), %o2 200a124: 9f c5 c0 00 call %l7 200a128: 94 12 a1 08 or %o2, 0x108, %o2 ! 201d908 <__log2table+0x290> if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a12c: 10 bf ff d4 b 200a07c <_Heap_Walk+0x124> 200a130: 82 10 20 00 clr %g1 return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 200a134: fa 06 20 08 ld [ %i0 + 8 ], %i5 int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 200a138: e8 06 20 10 ld [ %i0 + 0x10 ], %l4 const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 200a13c: 80 a6 00 1d cmp %i0, %i5 200a140: 02 80 00 0d be 200a174 <_Heap_Walk+0x21c> 200a144: da 06 20 20 ld [ %i0 + 0x20 ], %o5 const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 200a148: 80 a3 40 1d cmp %o5, %i5 200a14c: 28 80 00 bf bleu,a 200a448 <_Heap_Walk+0x4f0> <== ALWAYS TAKEN 200a150: e6 06 20 24 ld [ %i0 + 0x24 ], %l3 if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { (*printer)( 200a154: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200a158: 92 10 20 01 mov 1, %o1 200a15c: 15 00 80 76 sethi %hi(0x201d800), %o2 200a160: 96 10 00 1d mov %i5, %o3 200a164: 9f c5 c0 00 call %l7 200a168: 94 12 a1 80 or %o2, 0x180, %o2 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a16c: 10 bf ff c4 b 200a07c <_Heap_Walk+0x124> 200a170: 82 10 20 00 clr %g1 "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 200a174: 27 00 80 76 sethi %hi(0x201d800), %l3 if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { (*printer)( 200a178: 25 00 80 76 sethi %hi(0x201d800), %l2 ); return false; } if ( _Heap_Is_used( free_block ) ) { 200a17c: aa 10 00 1c mov %i4, %l5 "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 200a180: a6 14 e3 b0 or %l3, 0x3b0, %l3 if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { (*printer)( 200a184: a4 14 a3 98 or %l2, 0x398, %l2 " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 200a188: 29 00 80 76 sethi %hi(0x201d800), %l4 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200a18c: ac 0d bf fe and %l6, -2, %l6 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 200a190: ba 05 80 15 add %l6, %l5, %i5 const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 200a194: 80 a3 40 1d cmp %o5, %i5 200a198: 28 80 00 0b bleu,a 200a1c4 <_Heap_Walk+0x26c> <== ALWAYS TAKEN 200a19c: de 06 20 24 ld [ %i0 + 0x24 ], %o7 Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { (*printer)( 200a1a0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200a1a4: 92 10 20 01 mov 1, %o1 200a1a8: 96 10 00 15 mov %l5, %o3 200a1ac: 15 00 80 76 sethi %hi(0x201d800), %o2 200a1b0: 98 10 00 1d mov %i5, %o4 200a1b4: 9f c5 c0 00 call %l7 200a1b8: 94 12 a2 28 or %o2, 0x228, %o2 "block 0x%08x: next block 0x%08x not in heap\n", block, next_block ); return false; 200a1bc: 10 bf ff 75 b 2009f90 <_Heap_Walk+0x38> 200a1c0: 82 10 20 00 clr %g1 200a1c4: 80 a3 c0 1d cmp %o7, %i5 200a1c8: 0a bf ff f7 bcs 200a1a4 <_Heap_Walk+0x24c> 200a1cc: 90 10 00 19 mov %i1, %o0 uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); bool const prev_used = _Heap_Is_prev_used( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; 200a1d0: 9e 1d 40 11 xor %l5, %l1, %o7 200a1d4: 80 a0 00 0f cmp %g0, %o7 200a1d8: 9a 40 20 00 addx %g0, 0, %o5 RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 200a1dc: 90 10 00 16 mov %l6, %o0 200a1e0: da 27 bf fc st %o5, [ %fp + -4 ] 200a1e4: 7f ff de 63 call 2001b70 <.urem> 200a1e8: 92 10 00 1b mov %i3, %o1 ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 200a1ec: 80 a2 20 00 cmp %o0, 0 200a1f0: 02 80 00 18 be 200a250 <_Heap_Walk+0x2f8> 200a1f4: da 07 bf fc ld [ %fp + -4 ], %o5 200a1f8: 80 8b 60 ff btst 0xff, %o5 200a1fc: 12 80 00 8b bne 200a428 <_Heap_Walk+0x4d0> 200a200: 90 10 00 19 mov %i1, %o0 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 200a204: de 07 60 04 ld [ %i5 + 4 ], %o7 ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 200a208: 80 8b e0 01 btst 1, %o7 200a20c: 02 80 00 2b be 200a2b8 <_Heap_Walk+0x360> 200a210: 80 a6 a0 00 cmp %i2, 0 if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 200a214: 22 80 00 21 be,a 200a298 <_Heap_Walk+0x340> 200a218: da 05 40 00 ld [ %l5 ], %o5 (*printer)( 200a21c: 90 10 00 19 mov %i1, %o0 200a220: 92 10 20 00 clr %o1 200a224: 94 10 00 12 mov %l2, %o2 200a228: 96 10 00 15 mov %l5, %o3 200a22c: 9f c5 c0 00 call %l7 200a230: 98 10 00 16 mov %l6, %o4 block->prev_size ); } block = next_block; } while ( block != first_block ); 200a234: 80 a7 00 1d cmp %i4, %i5 200a238: 02 80 00 51 be 200a37c <_Heap_Walk+0x424> 200a23c: aa 10 00 1d mov %i5, %l5 200a240: ec 07 60 04 ld [ %i5 + 4 ], %l6 200a244: da 06 20 20 ld [ %i0 + 0x20 ], %o5 200a248: 10 bf ff d1 b 200a18c <_Heap_Walk+0x234> 200a24c: b4 0d a0 01 and %l6, 1, %i2 ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 200a250: 80 a5 80 10 cmp %l6, %l0 200a254: 0a 80 00 69 bcs 200a3f8 <_Heap_Walk+0x4a0> 200a258: 80 8b 60 ff btst 0xff, %o5 ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 200a25c: 80 a5 40 1d cmp %l5, %i5 200a260: 2a bf ff ea bcs,a 200a208 <_Heap_Walk+0x2b0> 200a264: de 07 60 04 ld [ %i5 + 4 ], %o7 200a268: 80 8b 60 ff btst 0xff, %o5 200a26c: 22 bf ff e7 be,a 200a208 <_Heap_Walk+0x2b0> 200a270: de 07 60 04 ld [ %i5 + 4 ], %o7 (*printer)( 200a274: 90 10 00 19 mov %i1, %o0 200a278: 92 10 20 01 mov 1, %o1 200a27c: 96 10 00 15 mov %l5, %o3 200a280: 15 00 80 76 sethi %hi(0x201d800), %o2 200a284: 98 10 00 1d mov %i5, %o4 200a288: 9f c5 c0 00 call %l7 200a28c: 94 12 a2 b8 or %o2, 0x2b8, %o2 "block 0x%08x: next block 0x%08x is not a successor\n", block, next_block ); return false; 200a290: 10 bf ff 40 b 2009f90 <_Heap_Walk+0x38> 200a294: 82 10 20 00 clr %g1 "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 200a298: 96 10 00 15 mov %l5, %o3 200a29c: 90 10 00 19 mov %i1, %o0 200a2a0: 92 10 20 00 clr %o1 200a2a4: 94 10 00 13 mov %l3, %o2 200a2a8: 9f c5 c0 00 call %l7 200a2ac: 98 10 00 16 mov %l6, %o4 block->prev_size ); } block = next_block; } while ( block != first_block ); 200a2b0: 10 bf ff e2 b 200a238 <_Heap_Walk+0x2e0> 200a2b4: 80 a7 00 1d cmp %i4, %i5 false, "block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n", block, block_size, block->prev, block->prev == first_free_block ? 200a2b8: da 05 60 0c ld [ %l5 + 0xc ], %o5 Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 200a2bc: de 06 20 08 ld [ %i0 + 8 ], %o7 200a2c0: 80 a3 c0 0d cmp %o7, %o5 200a2c4: 02 80 00 3d be 200a3b8 <_Heap_Walk+0x460> 200a2c8: d8 06 20 0c ld [ %i0 + 0xc ], %o4 block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 200a2cc: 80 a6 00 0d cmp %i0, %o5 200a2d0: 02 80 00 40 be 200a3d0 <_Heap_Walk+0x478> 200a2d4: 96 15 23 60 or %l4, 0x360, %o3 block->next, block->next == last_free_block ? 200a2d8: de 05 60 08 ld [ %l5 + 8 ], %o7 Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 200a2dc: 80 a3 00 0f cmp %o4, %o7 200a2e0: 02 80 00 33 be 200a3ac <_Heap_Walk+0x454> 200a2e4: 80 a6 00 0f cmp %i0, %o7 " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 200a2e8: 02 80 00 37 be 200a3c4 <_Heap_Walk+0x46c> 200a2ec: 98 15 23 60 or %l4, 0x360, %o4 Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 200a2f0: d6 23 a0 5c st %o3, [ %sp + 0x5c ] 200a2f4: d8 23 a0 64 st %o4, [ %sp + 0x64 ] 200a2f8: de 23 a0 60 st %o7, [ %sp + 0x60 ] 200a2fc: 90 10 00 19 mov %i1, %o0 200a300: 92 10 20 00 clr %o1 200a304: 15 00 80 76 sethi %hi(0x201d800), %o2 200a308: 96 10 00 15 mov %l5, %o3 200a30c: 94 12 a2 f0 or %o2, 0x2f0, %o2 200a310: 9f c5 c0 00 call %l7 200a314: 98 10 00 16 mov %l6, %o4 block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 200a318: da 07 40 00 ld [ %i5 ], %o5 200a31c: 80 a5 80 0d cmp %l6, %o5 200a320: 12 80 00 19 bne 200a384 <_Heap_Walk+0x42c> 200a324: 80 a6 a0 00 cmp %i2, 0 ); return false; } if ( !prev_used ) { 200a328: 02 80 00 2d be 200a3dc <_Heap_Walk+0x484> 200a32c: 90 10 00 19 mov %i1, %o0 return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 200a330: c4 06 20 08 ld [ %i0 + 8 ], %g2 ) { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { 200a334: 80 a6 00 02 cmp %i0, %g2 200a338: 02 80 00 0b be 200a364 <_Heap_Walk+0x40c> <== NEVER TAKEN 200a33c: 92 10 20 01 mov 1, %o1 if ( free_block == block ) { 200a340: 80 a5 40 02 cmp %l5, %g2 200a344: 02 bf ff bd be 200a238 <_Heap_Walk+0x2e0> 200a348: 80 a7 00 1d cmp %i4, %i5 return true; } free_block = free_block->next; 200a34c: c4 00 a0 08 ld [ %g2 + 8 ], %g2 ) { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { 200a350: 80 a6 00 02 cmp %i0, %g2 200a354: 12 bf ff fc bne 200a344 <_Heap_Walk+0x3ec> 200a358: 80 a5 40 02 cmp %l5, %g2 return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 200a35c: 90 10 00 19 mov %i1, %o0 200a360: 92 10 20 01 mov 1, %o1 200a364: 15 00 80 76 sethi %hi(0x201d800), %o2 200a368: 96 10 00 15 mov %l5, %o3 200a36c: 9f c5 c0 00 call %l7 200a370: 94 12 a3 d8 or %o2, 0x3d8, %o2 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a374: 10 bf ff 42 b 200a07c <_Heap_Walk+0x124> 200a378: 82 10 20 00 clr %g1 } block = next_block; } while ( block != first_block ); return true; 200a37c: 10 bf ff 05 b 2009f90 <_Heap_Walk+0x38> 200a380: 82 10 20 01 mov 1, %g1 " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { (*printer)( 200a384: fa 23 a0 5c st %i5, [ %sp + 0x5c ] 200a388: 90 10 00 19 mov %i1, %o0 200a38c: 92 10 20 01 mov 1, %o1 200a390: 15 00 80 76 sethi %hi(0x201d800), %o2 200a394: 96 10 00 15 mov %l5, %o3 200a398: 94 12 a3 28 or %o2, 0x328, %o2 200a39c: 9f c5 c0 00 call %l7 200a3a0: 98 10 00 16 mov %l6, %o4 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a3a4: 10 bf ff 36 b 200a07c <_Heap_Walk+0x124> 200a3a8: 82 10 20 00 clr %g1 Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 200a3ac: 03 00 80 75 sethi %hi(0x201d400), %g1 200a3b0: 10 bf ff d0 b 200a2f0 <_Heap_Walk+0x398> 200a3b4: 98 10 63 b8 or %g1, 0x3b8, %o4 ! 201d7b8 <__log2table+0x140> 200a3b8: 03 00 80 75 sethi %hi(0x201d400), %g1 200a3bc: 10 bf ff c7 b 200a2d8 <_Heap_Walk+0x380> 200a3c0: 96 10 63 98 or %g1, 0x398, %o3 ! 201d798 <__log2table+0x120> " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 200a3c4: 03 00 80 75 sethi %hi(0x201d400), %g1 200a3c8: 10 bf ff ca b 200a2f0 <_Heap_Walk+0x398> 200a3cc: 98 10 63 c8 or %g1, 0x3c8, %o4 ! 201d7c8 <__log2table+0x150> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 200a3d0: 17 00 80 75 sethi %hi(0x201d400), %o3 200a3d4: 10 bf ff c1 b 200a2d8 <_Heap_Walk+0x380> 200a3d8: 96 12 e3 a8 or %o3, 0x3a8, %o3 ! 201d7a8 <__log2table+0x130> return false; } if ( !prev_used ) { (*printer)( 200a3dc: 92 10 20 01 mov 1, %o1 200a3e0: 15 00 80 76 sethi %hi(0x201d800), %o2 200a3e4: 96 10 00 15 mov %l5, %o3 200a3e8: 9f c5 c0 00 call %l7 200a3ec: 94 12 a3 68 or %o2, 0x368, %o2 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a3f0: 10 bf ff 23 b 200a07c <_Heap_Walk+0x124> 200a3f4: 82 10 20 00 clr %g1 ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 200a3f8: 02 bf ff 9a be 200a260 <_Heap_Walk+0x308> <== NEVER TAKEN 200a3fc: 80 a5 40 1d cmp %l5, %i5 (*printer)( 200a400: 90 10 00 19 mov %i1, %o0 200a404: 92 10 20 01 mov 1, %o1 200a408: 96 10 00 15 mov %l5, %o3 200a40c: 15 00 80 76 sethi %hi(0x201d800), %o2 200a410: 98 10 00 16 mov %l6, %o4 200a414: 94 12 a2 88 or %o2, 0x288, %o2 200a418: 9f c5 c0 00 call %l7 200a41c: 9a 10 00 10 mov %l0, %o5 block, block_size, min_block_size ); return false; 200a420: 10 bf fe dc b 2009f90 <_Heap_Walk+0x38> 200a424: 82 10 20 00 clr %g1 return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { (*printer)( 200a428: 92 10 20 01 mov 1, %o1 200a42c: 96 10 00 15 mov %l5, %o3 200a430: 15 00 80 76 sethi %hi(0x201d800), %o2 200a434: 98 10 00 16 mov %l6, %o4 200a438: 9f c5 c0 00 call %l7 200a43c: 94 12 a2 58 or %o2, 0x258, %o2 "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 200a440: 10 bf fe d4 b 2009f90 <_Heap_Walk+0x38> 200a444: 82 10 20 00 clr %g1 const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 200a448: 80 a4 c0 1d cmp %l3, %i5 200a44c: 0a bf ff 43 bcs 200a158 <_Heap_Walk+0x200> <== NEVER TAKEN 200a450: 90 10 00 19 mov %i1, %o0 RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 200a454: da 27 bf fc st %o5, [ %fp + -4 ] 200a458: 90 07 60 08 add %i5, 8, %o0 200a45c: 7f ff dd c5 call 2001b70 <.urem> 200a460: 92 10 00 14 mov %l4, %o1 ); return false; } if ( 200a464: 80 a2 20 00 cmp %o0, 0 200a468: 12 80 00 36 bne 200a540 <_Heap_Walk+0x5e8> <== NEVER TAKEN 200a46c: da 07 bf fc ld [ %fp + -4 ], %o5 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200a470: c2 07 60 04 ld [ %i5 + 4 ], %g1 200a474: 82 08 7f fe and %g1, -2, %g1 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 200a478: 82 07 40 01 add %i5, %g1, %g1 200a47c: c2 00 60 04 ld [ %g1 + 4 ], %g1 ); return false; } if ( _Heap_Is_used( free_block ) ) { 200a480: 80 88 60 01 btst 1, %g1 200a484: 12 80 00 27 bne 200a520 <_Heap_Walk+0x5c8> <== NEVER TAKEN 200a488: a4 10 00 1d mov %i5, %l2 200a48c: 10 80 00 19 b 200a4f0 <_Heap_Walk+0x598> 200a490: 82 10 00 18 mov %i0, %g1 const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 200a494: 80 a6 00 1d cmp %i0, %i5 200a498: 02 bf ff 37 be 200a174 <_Heap_Walk+0x21c> 200a49c: 80 a7 40 0d cmp %i5, %o5 const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 200a4a0: 0a bf ff 2e bcs 200a158 <_Heap_Walk+0x200> 200a4a4: 90 10 00 19 mov %i1, %o0 200a4a8: 80 a7 40 13 cmp %i5, %l3 200a4ac: 18 bf ff 2c bgu 200a15c <_Heap_Walk+0x204> <== NEVER TAKEN 200a4b0: 92 10 20 01 mov 1, %o1 RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 200a4b4: da 27 bf fc st %o5, [ %fp + -4 ] 200a4b8: 90 07 60 08 add %i5, 8, %o0 200a4bc: 7f ff dd ad call 2001b70 <.urem> 200a4c0: 92 10 00 14 mov %l4, %o1 ); return false; } if ( 200a4c4: 80 a2 20 00 cmp %o0, 0 200a4c8: 12 80 00 1e bne 200a540 <_Heap_Walk+0x5e8> 200a4cc: da 07 bf fc ld [ %fp + -4 ], %o5 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 200a4d0: de 07 60 04 ld [ %i5 + 4 ], %o7 200a4d4: 82 10 00 12 mov %l2, %g1 200a4d8: 9e 0b ff fe and %o7, -2, %o7 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 200a4dc: 9e 03 c0 1d add %o7, %i5, %o7 200a4e0: de 03 e0 04 ld [ %o7 + 4 ], %o7 ); return false; } if ( _Heap_Is_used( free_block ) ) { 200a4e4: 80 8b e0 01 btst 1, %o7 200a4e8: 12 80 00 0e bne 200a520 <_Heap_Walk+0x5c8> 200a4ec: a4 10 00 1d mov %i5, %l2 ); return false; } if ( free_block->prev != prev_block ) { 200a4f0: d8 07 60 0c ld [ %i5 + 0xc ], %o4 200a4f4: 80 a3 00 01 cmp %o4, %g1 200a4f8: 22 bf ff e7 be,a 200a494 <_Heap_Walk+0x53c> 200a4fc: fa 07 60 08 ld [ %i5 + 8 ], %i5 (*printer)( 200a500: 90 10 00 19 mov %i1, %o0 200a504: 92 10 20 01 mov 1, %o1 200a508: 15 00 80 76 sethi %hi(0x201d800), %o2 200a50c: 96 10 00 1d mov %i5, %o3 200a510: 9f c5 c0 00 call %l7 200a514: 94 12 a1 f0 or %o2, 0x1f0, %o2 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a518: 10 bf fe d9 b 200a07c <_Heap_Walk+0x124> 200a51c: 82 10 20 00 clr %g1 return false; } if ( _Heap_Is_used( free_block ) ) { (*printer)( 200a520: 90 10 00 19 mov %i1, %o0 200a524: 92 10 20 01 mov 1, %o1 200a528: 15 00 80 76 sethi %hi(0x201d800), %o2 200a52c: 96 10 00 1d mov %i5, %o3 200a530: 9f c5 c0 00 call %l7 200a534: 94 12 a1 d0 or %o2, 0x1d0, %o2 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a538: 10 bf fe d1 b 200a07c <_Heap_Walk+0x124> 200a53c: 82 10 20 00 clr %g1 } if ( !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 200a540: 90 10 00 19 mov %i1, %o0 200a544: 92 10 20 01 mov 1, %o1 200a548: 15 00 80 76 sethi %hi(0x201d800), %o2 200a54c: 96 10 00 1d mov %i5, %o3 200a550: 9f c5 c0 00 call %l7 200a554: 94 12 a1 a0 or %o2, 0x1a0, %o2 if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 200a558: 10 bf fe c9 b 200a07c <_Heap_Walk+0x124> 200a55c: 82 10 20 00 clr %g1 =============================================================================== 020085c8 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 20085c8: 9d e3 bf a0 save %sp, -96, %sp rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 20085cc: 39 00 80 7c sethi %hi(0x201f000), %i4 20085d0: c2 07 22 24 ld [ %i4 + 0x224 ], %g1 ! 201f224 <_IO_Number_of_drivers> 20085d4: ba 10 20 00 clr %i5 20085d8: 80 a0 60 00 cmp %g1, 0 20085dc: 02 80 00 0b be 2008608 <_IO_Initialize_all_drivers+0x40> <== NEVER TAKEN 20085e0: b8 17 22 24 or %i4, 0x224, %i4 (void) rtems_io_initialize( major, 0, NULL ); 20085e4: 90 10 00 1d mov %i5, %o0 20085e8: 92 10 20 00 clr %o1 20085ec: 40 00 16 29 call 200de90 20085f0: 94 10 20 00 clr %o2 void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 20085f4: c2 07 00 00 ld [ %i4 ], %g1 20085f8: ba 07 60 01 inc %i5 20085fc: 80 a0 40 1d cmp %g1, %i5 2008600: 18 bf ff fa bgu 20085e8 <_IO_Initialize_all_drivers+0x20> 2008604: 90 10 00 1d mov %i5, %o0 2008608: 81 c7 e0 08 ret 200860c: 81 e8 00 00 restore =============================================================================== 020084f8 <_IO_Manager_initialization>: * workspace. * */ void _IO_Manager_initialization(void) { 20084f8: 9d e3 bf a0 save %sp, -96, %sp uint32_t index; rtems_driver_address_table *driver_table; uint32_t drivers_in_table; uint32_t number_of_drivers; driver_table = Configuration.Device_driver_table; 20084fc: 03 00 80 76 sethi %hi(0x201d800), %g1 2008500: 82 10 62 cc or %g1, 0x2cc, %g1 ! 201dacc drivers_in_table = Configuration.number_of_device_drivers; 2008504: f8 00 60 3c ld [ %g1 + 0x3c ], %i4 number_of_drivers = Configuration.maximum_drivers; 2008508: f6 00 60 38 ld [ %g1 + 0x38 ], %i3 /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 200850c: 80 a7 00 1b cmp %i4, %i3 2008510: 0a 80 00 08 bcs 2008530 <_IO_Manager_initialization+0x38> 2008514: fa 00 60 40 ld [ %g1 + 0x40 ], %i5 * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 2008518: 03 00 80 7c sethi %hi(0x201f000), %g1 200851c: fa 20 62 28 st %i5, [ %g1 + 0x228 ] ! 201f228 <_IO_Driver_address_table> _IO_Number_of_drivers = number_of_drivers; 2008520: 03 00 80 7c sethi %hi(0x201f000), %g1 2008524: f8 20 62 24 st %i4, [ %g1 + 0x224 ] ! 201f224 <_IO_Number_of_drivers> return; 2008528: 81 c7 e0 08 ret 200852c: 81 e8 00 00 restore * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) 2008530: 83 2e e0 03 sll %i3, 3, %g1 2008534: b5 2e e0 05 sll %i3, 5, %i2 2008538: b4 26 80 01 sub %i2, %g1, %i2 * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) _Workspace_Allocate_or_fatal_error( 200853c: 40 00 0d 5a call 200baa4 <_Workspace_Allocate_or_fatal_error> 2008540: 90 10 00 1a mov %i2, %o0 sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 2008544: 03 00 80 7c sethi %hi(0x201f000), %g1 /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 2008548: 33 00 80 7c sethi %hi(0x201f000), %i1 _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 200854c: f6 20 62 24 st %i3, [ %g1 + 0x224 ] /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 2008550: d0 26 62 28 st %o0, [ %i1 + 0x228 ] _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 2008554: 92 10 20 00 clr %o1 2008558: 40 00 23 2b call 2011204 200855c: 94 10 00 1a mov %i2, %o2 _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2008560: 80 a7 20 00 cmp %i4, 0 2008564: 02 bf ff f1 be 2008528 <_IO_Manager_initialization+0x30> <== NEVER TAKEN 2008568: c8 06 62 28 ld [ %i1 + 0x228 ], %g4 * registration. The driver table is now allocated in the * workspace. * */ void _IO_Manager_initialization(void) 200856c: 85 2f 20 03 sll %i4, 3, %g2 2008570: b7 2f 20 05 sll %i4, 5, %i3 2008574: 82 10 20 00 clr %g1 2008578: b6 26 c0 02 sub %i3, %g2, %i3 _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; 200857c: c4 07 40 01 ld [ %i5 + %g1 ], %g2 2008580: 86 07 40 01 add %i5, %g1, %g3 2008584: c4 21 00 01 st %g2, [ %g4 + %g1 ] 2008588: f8 00 e0 04 ld [ %g3 + 4 ], %i4 200858c: 84 01 00 01 add %g4, %g1, %g2 2008590: f8 20 a0 04 st %i4, [ %g2 + 4 ] 2008594: f8 00 e0 08 ld [ %g3 + 8 ], %i4 2008598: 82 00 60 18 add %g1, 0x18, %g1 200859c: f8 20 a0 08 st %i4, [ %g2 + 8 ] 20085a0: f8 00 e0 0c ld [ %g3 + 0xc ], %i4 memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 20085a4: 80 a0 40 1b cmp %g1, %i3 _IO_Driver_address_table[index] = driver_table[index]; 20085a8: f8 20 a0 0c st %i4, [ %g2 + 0xc ] 20085ac: f8 00 e0 10 ld [ %g3 + 0x10 ], %i4 20085b0: f8 20 a0 10 st %i4, [ %g2 + 0x10 ] 20085b4: c6 00 e0 14 ld [ %g3 + 0x14 ], %g3 memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 20085b8: 12 bf ff f1 bne 200857c <_IO_Manager_initialization+0x84> 20085bc: c6 20 a0 14 st %g3, [ %g2 + 0x14 ] 20085c0: 81 c7 e0 08 ret 20085c4: 81 e8 00 00 restore =============================================================================== 0200936c <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 200936c: 9d e3 bf a0 save %sp, -96, %sp * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 2009370: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2009374: 80 a0 60 00 cmp %g1, 0 2009378: 02 80 00 26 be 2009410 <_Objects_Allocate+0xa4> <== NEVER TAKEN 200937c: ba 10 00 18 mov %i0, %i5 /* * OK. The manager should be initialized and configured to have objects. * With any luck, it is safe to attempt to allocate an object. */ the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 2009380: b8 06 20 20 add %i0, 0x20, %i4 2009384: 7f ff fd 4b call 20088b0 <_Chain_Get> 2009388: 90 10 00 1c mov %i4, %o0 if ( information->auto_extend ) { 200938c: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1 2009390: 80 a0 60 00 cmp %g1, 0 2009394: 02 80 00 16 be 20093ec <_Objects_Allocate+0x80> 2009398: b0 10 00 08 mov %o0, %i0 /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 200939c: 80 a2 20 00 cmp %o0, 0 20093a0: 02 80 00 15 be 20093f4 <_Objects_Allocate+0x88> 20093a4: 01 00 00 00 nop } if ( the_object ) { uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 20093a8: c4 07 60 08 ld [ %i5 + 8 ], %g2 20093ac: d0 06 20 08 ld [ %i0 + 8 ], %o0 _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 20093b0: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1 } if ( the_object ) { uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 20093b4: 03 00 00 3f sethi %hi(0xfc00), %g1 20093b8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20093bc: 90 0a 00 01 and %o0, %g1, %o0 20093c0: 82 08 80 01 and %g2, %g1, %g1 _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 20093c4: 40 00 40 8a call 20195ec <.udiv> 20093c8: 90 22 00 01 sub %o0, %g1, %o0 information->inactive_per_block[ block ]--; 20093cc: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 20093d0: 91 2a 20 02 sll %o0, 2, %o0 20093d4: c6 00 40 08 ld [ %g1 + %o0 ], %g3 information->inactive--; 20093d8: c4 17 60 2c lduh [ %i5 + 0x2c ], %g2 block = (uint32_t) _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 20093dc: 86 00 ff ff add %g3, -1, %g3 20093e0: c6 20 40 08 st %g3, [ %g1 + %o0 ] information->inactive--; 20093e4: 82 00 bf ff add %g2, -1, %g1 20093e8: c2 37 60 2c sth %g1, [ %i5 + 0x2c ] ); } #endif return the_object; } 20093ec: 81 c7 e0 08 ret 20093f0: 81 e8 00 00 restore * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { _Objects_Extend_information( information ); 20093f4: 40 00 00 10 call 2009434 <_Objects_Extend_information> 20093f8: 90 10 00 1d mov %i5, %o0 the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 20093fc: 7f ff fd 2d call 20088b0 <_Chain_Get> 2009400: 90 10 00 1c mov %i4, %o0 } if ( the_object ) { 2009404: b0 92 20 00 orcc %o0, 0, %i0 2009408: 32 bf ff e9 bne,a 20093ac <_Objects_Allocate+0x40> 200940c: c4 07 60 08 ld [ %i5 + 8 ], %g2 * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) return NULL; 2009410: 81 c7 e0 08 ret 2009414: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 02009434 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 2009434: 9d e3 bf 90 save %sp, -112, %sp minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 2009438: f4 06 20 34 ld [ %i0 + 0x34 ], %i2 /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 200943c: e2 16 20 0a lduh [ %i0 + 0xa ], %l1 index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 2009440: 80 a6 a0 00 cmp %i2, 0 2009444: 02 80 00 a5 be 20096d8 <_Objects_Extend_information+0x2a4> 2009448: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0 block_count = 0; else { block_count = information->maximum / information->allocation_size; 200944c: f6 16 20 14 lduh [ %i0 + 0x14 ], %i3 2009450: a1 2c 20 10 sll %l0, 0x10, %l0 2009454: 92 10 00 1b mov %i3, %o1 2009458: 40 00 40 65 call 20195ec <.udiv> 200945c: 91 34 20 10 srl %l0, 0x10, %o0 2009460: 91 2a 20 10 sll %o0, 0x10, %o0 2009464: b3 32 20 10 srl %o0, 0x10, %i1 for ( ; block < block_count; block++ ) { 2009468: 80 a6 60 00 cmp %i1, 0 200946c: 02 80 00 a2 be 20096f4 <_Objects_Extend_information+0x2c0><== NEVER TAKEN 2009470: 90 10 00 1b mov %i3, %o0 if ( information->object_blocks[ block ] == NULL ) { 2009474: c2 06 80 00 ld [ %i2 ], %g1 2009478: 80 a0 60 00 cmp %g1, 0 200947c: 02 80 00 a2 be 2009704 <_Objects_Extend_information+0x2d0><== NEVER TAKEN 2009480: b8 10 00 11 mov %l1, %i4 * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 2009484: 10 80 00 06 b 200949c <_Objects_Extend_information+0x68> 2009488: ba 10 20 00 clr %i5 block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { 200948c: c2 06 80 01 ld [ %i2 + %g1 ], %g1 2009490: 80 a0 60 00 cmp %g1, 0 2009494: 22 80 00 08 be,a 20094b4 <_Objects_Extend_information+0x80> 2009498: b6 10 20 00 clr %i3 if ( information->object_blocks == NULL ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 200949c: ba 07 60 01 inc %i5 if ( information->object_blocks[ block ] == NULL ) { do_extend = false; break; } else index_base += information->allocation_size; 20094a0: b8 07 00 1b add %i4, %i3, %i4 if ( information->object_blocks == NULL ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 20094a4: 80 a6 40 1d cmp %i1, %i5 20094a8: 18 bf ff f9 bgu 200948c <_Objects_Extend_information+0x58> 20094ac: 83 2f 60 02 sll %i5, 2, %g1 /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 20094b0: b6 10 20 01 mov 1, %i3 } else index_base += information->allocation_size; } } maximum = (uint32_t) information->maximum + information->allocation_size; 20094b4: a1 34 20 10 srl %l0, 0x10, %l0 /* * We need to limit the number of objects to the maximum number * representable in the index portion of the object Id. In the * case of 16-bit Ids, this is only 256 object instances. */ if ( maximum > OBJECTS_ID_FINAL_INDEX ) { 20094b8: 03 00 00 3f sethi %hi(0xfc00), %g1 } else index_base += information->allocation_size; } } maximum = (uint32_t) information->maximum + information->allocation_size; 20094bc: a0 04 00 08 add %l0, %o0, %l0 /* * We need to limit the number of objects to the maximum number * representable in the index portion of the object Id. In the * case of 16-bit Ids, this is only 256 object instances. */ if ( maximum > OBJECTS_ID_FINAL_INDEX ) { 20094c0: 82 10 63 ff or %g1, 0x3ff, %g1 20094c4: 80 a4 00 01 cmp %l0, %g1 20094c8: 18 80 00 94 bgu 2009718 <_Objects_Extend_information+0x2e4> 20094cc: 01 00 00 00 nop /* * Allocate the name table, and the objects and if it fails either return or * generate a fatal error depending on auto-extending being active. */ block_size = information->allocation_size * information->size; 20094d0: 40 00 40 0d call 2019504 <.umul> 20094d4: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 if ( information->auto_extend ) { 20094d8: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 20094dc: 80 a0 60 00 cmp %g1, 0 20094e0: 02 80 00 6a be 2009688 <_Objects_Extend_information+0x254> 20094e4: 01 00 00 00 nop new_object_block = _Workspace_Allocate( block_size ); 20094e8: 40 00 09 61 call 200ba6c <_Workspace_Allocate> 20094ec: 01 00 00 00 nop if ( !new_object_block ) 20094f0: b4 92 20 00 orcc %o0, 0, %i2 20094f4: 02 80 00 89 be 2009718 <_Objects_Extend_information+0x2e4> 20094f8: 01 00 00 00 nop } /* * Do we need to grow the tables? */ if ( do_extend ) { 20094fc: 80 8e e0 ff btst 0xff, %i3 2009500: 22 80 00 3f be,a 20095fc <_Objects_Extend_information+0x1c8> 2009504: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 */ /* * Up the block count and maximum */ block_count++; 2009508: b6 06 60 01 add %i1, 1, %i3 /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 200950c: 91 2e e0 01 sll %i3, 1, %o0 2009510: 90 02 00 1b add %o0, %i3, %o0 ((maximum + minimum_index) * sizeof(Objects_Control *)); 2009514: 90 04 00 08 add %l0, %o0, %o0 /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 2009518: 90 02 00 11 add %o0, %l1, %o0 ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); 200951c: 40 00 09 54 call 200ba6c <_Workspace_Allocate> 2009520: 91 2a 20 02 sll %o0, 2, %o0 if ( !object_blocks ) { 2009524: a4 92 20 00 orcc %o0, 0, %l2 2009528: 02 80 00 7a be 2009710 <_Objects_Extend_information+0x2dc> 200952c: b7 2e e0 02 sll %i3, 2, %i3 * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 2009530: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 2009534: 80 a4 40 01 cmp %l1, %g1 2009538: a6 04 80 1b add %l2, %i3, %l3 200953c: 0a 80 00 57 bcs 2009698 <_Objects_Extend_information+0x264> 2009540: b6 04 c0 1b add %l3, %i3, %i3 * information - object information table * * Output parameters: NONE */ void _Objects_Extend_information( 2009544: 85 2c 60 02 sll %l1, 2, %g2 } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 2009548: 80 a4 60 00 cmp %l1, 0 200954c: 02 80 00 07 be 2009568 <_Objects_Extend_information+0x134><== NEVER TAKEN 2009550: 82 10 20 00 clr %g1 local_table[ index ] = NULL; 2009554: c0 20 40 1b clr [ %g1 + %i3 ] 2009558: 82 00 60 04 add %g1, 4, %g1 } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 200955c: 80 a0 40 02 cmp %g1, %g2 2009560: 32 bf ff fe bne,a 2009558 <_Objects_Extend_information+0x124><== NEVER TAKEN 2009564: c0 20 40 1b clr [ %g1 + %i3 ] <== NOT EXECUTED 2009568: b3 2e 60 02 sll %i1, 2, %i1 */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); 200956c: c6 16 20 14 lduh [ %i0 + 0x14 ], %g3 } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 2009570: c0 24 80 19 clr [ %l2 + %i1 ] inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); 2009574: 82 07 00 03 add %i4, %g3, %g1 * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 2009578: 80 a7 00 01 cmp %i4, %g1 200957c: 1a 80 00 0b bcc 20095a8 <_Objects_Extend_information+0x174><== NEVER TAKEN 2009580: c0 24 c0 19 clr [ %l3 + %i1 ] * information - object information table * * Output parameters: NONE */ void _Objects_Extend_information( 2009584: 85 2f 20 02 sll %i4, 2, %g2 2009588: 87 28 e0 02 sll %g3, 2, %g3 200958c: 84 06 c0 02 add %i3, %g2, %g2 2009590: 82 10 20 00 clr %g1 inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; 2009594: c0 20 80 01 clr [ %g2 + %g1 ] 2009598: 82 00 60 04 add %g1, 4, %g1 * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 200959c: 80 a0 40 03 cmp %g1, %g3 20095a0: 32 bf ff fe bne,a 2009598 <_Objects_Extend_information+0x164> 20095a4: c0 20 80 01 clr [ %g2 + %g1 ] index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 20095a8: 7f ff e4 6f call 2002764 20095ac: 01 00 00 00 nop uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 20095b0: c6 06 00 00 ld [ %i0 ], %g3 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->local_table = local_table; information->maximum = (Objects_Maximum) maximum; information->maximum_id = _Objects_Build_id( 20095b4: c4 16 20 04 lduh [ %i0 + 4 ], %g2 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 20095b8: f2 06 20 34 ld [ %i0 + 0x34 ], %i1 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->local_table = local_table; information->maximum = (Objects_Maximum) maximum; 20095bc: e0 36 20 10 sth %l0, [ %i0 + 0x10 ] 20095c0: 87 28 e0 18 sll %g3, 0x18, %g3 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 20095c4: 85 28 a0 1b sll %g2, 0x1b, %g2 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 20095c8: e4 26 20 34 st %l2, [ %i0 + 0x34 ] information->inactive_per_block = inactive_per_block; 20095cc: e6 26 20 30 st %l3, [ %i0 + 0x30 ] information->local_table = local_table; 20095d0: f6 26 20 1c st %i3, [ %i0 + 0x1c ] uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 20095d4: 03 00 00 40 sethi %hi(0x10000), %g1 20095d8: 82 10 c0 01 or %g3, %g1, %g1 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 20095dc: 82 10 40 02 or %g1, %g2, %g1 uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 20095e0: a0 10 40 10 or %g1, %l0, %l0 information->maximum = (Objects_Maximum) maximum; information->maximum_id = _Objects_Build_id( 20095e4: e0 26 20 0c st %l0, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 20095e8: 7f ff e4 63 call 2002774 20095ec: 01 00 00 00 nop _Workspace_Free( old_tables ); 20095f0: 40 00 09 27 call 200ba8c <_Workspace_Free> 20095f4: 90 10 00 19 mov %i1, %o0 } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 20095f8: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 20095fc: bb 2f 60 02 sll %i5, 2, %i5 2009600: f4 20 40 1d st %i2, [ %g1 + %i5 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2009604: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 2009608: d4 16 20 14 lduh [ %i0 + 0x14 ], %o2 200960c: d2 00 40 1d ld [ %g1 + %i5 ], %o1 2009610: d6 06 20 18 ld [ %i0 + 0x18 ], %o3 2009614: 90 07 bf f4 add %fp, -12, %o0 2009618: 7f ff fc b6 call 20088f0 <_Chain_Initialize> 200961c: 35 00 00 40 sethi %hi(0x10000), %i2 /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 2009620: 10 80 00 0d b 2009654 <_Objects_Extend_information+0x220> 2009624: b6 06 20 20 add %i0, 0x20, %i3 the_object->id = _Objects_Build_id( 2009628: c6 16 20 04 lduh [ %i0 + 4 ], %g3 200962c: 85 28 a0 18 sll %g2, 0x18, %g2 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 2009630: 87 28 e0 1b sll %g3, 0x1b, %g3 uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 2009634: 84 10 80 1a or %g2, %i2, %g2 (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 2009638: 84 10 80 03 or %g2, %g3, %g2 uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 200963c: 84 10 80 1c or %g2, %i4, %g2 information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 2009640: 90 10 00 1b mov %i3, %o0 2009644: 92 10 00 01 mov %g1, %o1 index++; 2009648: b8 07 20 01 inc %i4 information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 200964c: 7f ff fc 8e call 2008884 <_Chain_Append> 2009650: c4 20 60 08 st %g2, [ %g1 + 8 ] /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 2009654: 7f ff fc 97 call 20088b0 <_Chain_Get> 2009658: 90 07 bf f4 add %fp, -12, %o0 200965c: 82 92 20 00 orcc %o0, 0, %g1 2009660: 32 bf ff f2 bne,a 2009628 <_Objects_Extend_information+0x1f4> 2009664: c4 06 00 00 ld [ %i0 ], %g2 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 2009668: c8 16 20 14 lduh [ %i0 + 0x14 ], %g4 200966c: c6 06 20 30 ld [ %i0 + 0x30 ], %g3 information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 2009670: c4 16 20 2c lduh [ %i0 + 0x2c ], %g2 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 2009674: c8 20 c0 1d st %g4, [ %g3 + %i5 ] information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 2009678: 82 00 80 04 add %g2, %g4, %g1 index++; } information->inactive_per_block[ block ] = information->allocation_size; information->inactive = 200967c: c2 36 20 2c sth %g1, [ %i0 + 0x2c ] 2009680: 81 c7 e0 08 ret 2009684: 81 e8 00 00 restore if ( information->auto_extend ) { new_object_block = _Workspace_Allocate( block_size ); if ( !new_object_block ) return; } else { new_object_block = _Workspace_Allocate_or_fatal_error( block_size ); 2009688: 40 00 09 07 call 200baa4 <_Workspace_Allocate_or_fatal_error> 200968c: 01 00 00 00 nop 2009690: 10 bf ff 9b b 20094fc <_Objects_Extend_information+0xc8> 2009694: b4 10 00 08 mov %o0, %i2 /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 2009698: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 information->object_blocks, block_count * sizeof(void*) ); 200969c: b3 2e 60 02 sll %i1, 2, %i1 /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 20096a0: 40 00 1e 9c call 2011110 20096a4: 94 10 00 19 mov %i1, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 20096a8: d2 06 20 30 ld [ %i0 + 0x30 ], %o1 20096ac: 94 10 00 19 mov %i1, %o2 20096b0: 40 00 1e 98 call 2011110 20096b4: 90 10 00 13 mov %l3, %o0 information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, information->local_table, (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 20096b8: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 20096bc: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 information->local_table, (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 20096c0: 94 02 80 11 add %o2, %l1, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 20096c4: 90 10 00 1b mov %i3, %o0 20096c8: 40 00 1e 92 call 2011110 20096cc: 95 2a a0 02 sll %o2, 2, %o2 */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); 20096d0: 10 bf ff a8 b 2009570 <_Objects_Extend_information+0x13c> 20096d4: c6 16 20 14 lduh [ %i0 + 0x14 ], %g3 20096d8: d0 16 20 14 lduh [ %i0 + 0x14 ], %o0 /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 20096dc: b8 10 00 11 mov %l1, %i4 /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 20096e0: b6 10 20 01 mov 1, %i3 minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 20096e4: ba 10 20 00 clr %i5 /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) block_count = 0; 20096e8: b2 10 20 00 clr %i1 20096ec: 10 bf ff 72 b 20094b4 <_Objects_Extend_information+0x80> 20096f0: a1 2c 20 10 sll %l0, 0x10, %l0 /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 20096f4: b8 10 00 11 mov %l1, %i4 <== NOT EXECUTED /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 20096f8: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 20096fc: 10 bf ff 6e b 20094b4 <_Objects_Extend_information+0x80> <== NOT EXECUTED 2009700: ba 10 20 00 clr %i5 <== NOT EXECUTED else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { do_extend = false; 2009704: b6 10 20 00 clr %i3 <== NOT EXECUTED * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 2009708: 10 bf ff 6b b 20094b4 <_Objects_Extend_information+0x80> <== NOT EXECUTED 200970c: ba 10 20 00 clr %i5 <== NOT EXECUTED (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); if ( !object_blocks ) { _Workspace_Free( new_object_block ); 2009710: 40 00 08 df call 200ba8c <_Workspace_Free> 2009714: 90 10 00 1a mov %i2, %o0 2009718: 81 c7 e0 08 ret 200971c: 81 e8 00 00 restore =============================================================================== 020097d0 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 20097d0: 9d e3 bf a0 save %sp, -96, %sp Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 20097d4: 80 a6 60 00 cmp %i1, 0 20097d8: 02 80 00 19 be 200983c <_Objects_Get_information+0x6c> 20097dc: 01 00 00 00 nop /* * This call implicitly validates the_api so we do not call * _Objects_Is_api_valid above here. */ the_class_api_maximum = _Objects_API_maximum_class( the_api ); 20097e0: 40 00 13 a6 call 200e678 <_Objects_API_maximum_class> 20097e4: 90 10 00 18 mov %i0, %o0 if ( the_class_api_maximum == 0 ) 20097e8: 80 a2 20 00 cmp %o0, 0 20097ec: 02 80 00 14 be 200983c <_Objects_Get_information+0x6c> 20097f0: 80 a2 00 19 cmp %o0, %i1 return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 20097f4: 0a 80 00 12 bcs 200983c <_Objects_Get_information+0x6c> 20097f8: 03 00 80 7a sethi %hi(0x201e800), %g1 return NULL; if ( !_Objects_Information_table[ the_api ] ) 20097fc: b1 2e 20 02 sll %i0, 2, %i0 2009800: 82 10 60 14 or %g1, 0x14, %g1 2009804: c2 00 40 18 ld [ %g1 + %i0 ], %g1 2009808: 80 a0 60 00 cmp %g1, 0 200980c: 02 80 00 0c be 200983c <_Objects_Get_information+0x6c> <== NEVER TAKEN 2009810: b3 2e 60 02 sll %i1, 2, %i1 return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 2009814: f0 00 40 19 ld [ %g1 + %i1 ], %i0 if ( !info ) 2009818: 80 a6 20 00 cmp %i0, 0 200981c: 02 80 00 08 be 200983c <_Objects_Get_information+0x6c> <== NEVER TAKEN 2009820: 01 00 00 00 nop * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) 2009824: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 2009828: 80 a0 60 00 cmp %g1, 0 200982c: 02 80 00 04 be 200983c <_Objects_Get_information+0x6c> 2009830: 01 00 00 00 nop return NULL; #endif return info; } 2009834: 81 c7 e0 08 ret 2009838: 81 e8 00 00 restore { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 200983c: 81 c7 e0 08 ret 2009840: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 02017fcc <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 2017fcc: 9d e3 bf 90 save %sp, -112, %sp char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 2017fd0: 80 a6 60 00 cmp %i1, 0 2017fd4: 02 80 00 11 be 2018018 <_Objects_Get_name_as_string+0x4c> 2017fd8: 80 a6 a0 00 cmp %i2, 0 return NULL; if ( name == NULL ) 2017fdc: 02 80 00 0f be 2018018 <_Objects_Get_name_as_string+0x4c> 2017fe0: ba 96 20 00 orcc %i0, 0, %i5 return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 2017fe4: 02 80 00 3d be 20180d8 <_Objects_Get_name_as_string+0x10c> 2017fe8: 03 00 80 c7 sethi %hi(0x2031c00), %g1 information = _Objects_Get_information_id( tmpId ); 2017fec: 7f ff df c0 call 200feec <_Objects_Get_information_id> 2017ff0: 90 10 00 1d mov %i5, %o0 if ( !information ) 2017ff4: b8 92 20 00 orcc %o0, 0, %i4 2017ff8: 02 80 00 08 be 2018018 <_Objects_Get_name_as_string+0x4c> 2017ffc: 92 10 00 1d mov %i5, %o1 return NULL; the_object = _Objects_Get( information, tmpId, &location ); 2018000: 7f ff df fb call 200ffec <_Objects_Get> 2018004: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 2018008: c2 07 bf f4 ld [ %fp + -12 ], %g1 201800c: 80 a0 60 00 cmp %g1, 0 2018010: 22 80 00 05 be,a 2018024 <_Objects_Get_name_as_string+0x58> 2018014: c2 0f 20 38 ldub [ %i4 + 0x38 ], %g1 #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* not supported */ #endif case OBJECTS_ERROR: return NULL; 2018018: b4 10 20 00 clr %i2 _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 201801c: 81 c7 e0 08 ret 2018020: 91 e8 00 1a restore %g0, %i2, %o0 return NULL; case OBJECTS_LOCAL: #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) { 2018024: 80 a0 60 00 cmp %g1, 0 2018028: 12 80 00 2f bne 20180e4 <_Objects_Get_name_as_string+0x118> 201802c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 } else #endif { uint32_t u32_name = (uint32_t) the_object->name.name_u32; lname[ 0 ] = (u32_name >> 24) & 0xff; 2018030: 89 30 60 18 srl %g1, 0x18, %g4 lname[ 1 ] = (u32_name >> 16) & 0xff; 2018034: 87 30 60 10 srl %g1, 0x10, %g3 lname[ 2 ] = (u32_name >> 8) & 0xff; 2018038: 85 30 60 08 srl %g1, 8, %g2 lname[ 3 ] = (u32_name >> 0) & 0xff; 201803c: c2 2f bf fb stb %g1, [ %fp + -5 ] lname[ 4 ] = '\0'; 2018040: c0 2f bf fc clrb [ %fp + -4 ] } else #endif { uint32_t u32_name = (uint32_t) the_object->name.name_u32; lname[ 0 ] = (u32_name >> 24) & 0xff; 2018044: c8 2f bf f8 stb %g4, [ %fp + -8 ] lname[ 1 ] = (u32_name >> 16) & 0xff; 2018048: c6 2f bf f9 stb %g3, [ %fp + -7 ] lname[ 2 ] = (u32_name >> 8) & 0xff; 201804c: c4 2f bf fa stb %g2, [ %fp + -6 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; 2018050: 82 07 bf f8 add %fp, -8, %g1 } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 2018054: 80 a6 60 01 cmp %i1, 1 2018058: 02 80 00 27 be 20180f4 <_Objects_Get_name_as_string+0x128><== NEVER TAKEN 201805c: 86 10 00 1a mov %i2, %g3 2018060: c6 48 40 00 ldsb [ %g1 ], %g3 2018064: 80 a0 e0 00 cmp %g3, 0 2018068: 02 80 00 22 be 20180f0 <_Objects_Get_name_as_string+0x124> 201806c: c4 08 40 00 ldub [ %g1 ], %g2 * This method objects the name of an object and returns its name * in the form of a C string. It attempts to be careful about * overflowing the user's string and about returning unprintable characters. */ char *_Objects_Get_name_as_string( 2018070: b6 06 7f ff add %i1, -1, %i3 2018074: 39 00 80 c2 sethi %hi(0x2030800), %i4 2018078: b6 00 40 1b add %g1, %i3, %i3 201807c: 86 10 00 1a mov %i2, %g3 2018080: 10 80 00 06 b 2018098 <_Objects_Get_name_as_string+0xcc> 2018084: b8 17 20 b8 or %i4, 0xb8, %i4 s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 2018088: c8 48 40 00 ldsb [ %g1 ], %g4 201808c: 80 a1 20 00 cmp %g4, 0 2018090: 02 80 00 0e be 20180c8 <_Objects_Get_name_as_string+0xfc> 2018094: c4 08 40 00 ldub [ %g1 ], %g2 *d = (isprint((unsigned char)*s)) ? *s : '*'; 2018098: fa 07 00 00 ld [ %i4 ], %i5 201809c: 88 08 a0 ff and %g2, 0xff, %g4 20180a0: 88 07 40 04 add %i5, %g4, %g4 20180a4: c8 49 20 01 ldsb [ %g4 + 1 ], %g4 20180a8: 80 89 20 97 btst 0x97, %g4 20180ac: 12 80 00 03 bne 20180b8 <_Objects_Get_name_as_string+0xec> 20180b0: 82 00 60 01 inc %g1 20180b4: 84 10 20 2a mov 0x2a, %g2 20180b8: c4 28 c0 00 stb %g2, [ %g3 ] s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 20180bc: 80 a0 40 1b cmp %g1, %i3 20180c0: 12 bf ff f2 bne 2018088 <_Objects_Get_name_as_string+0xbc> 20180c4: 86 00 e0 01 inc %g3 *d = (isprint((unsigned char)*s)) ? *s : '*'; } } *d = '\0'; _Thread_Enable_dispatch(); 20180c8: 7f ff e3 fc call 20110b8 <_Thread_Enable_dispatch> 20180cc: c0 28 c0 00 clrb [ %g3 ] return name; } return NULL; /* unreachable path */ } 20180d0: 81 c7 e0 08 ret 20180d4: 91 e8 00 1a restore %g0, %i2, %o0 return NULL; if ( name == NULL ) return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 20180d8: c2 00 63 ac ld [ %g1 + 0x3ac ], %g1 20180dc: 10 bf ff c4 b 2017fec <_Objects_Get_name_as_string+0x20> 20180e0: fa 00 60 08 ld [ %g1 + 8 ], %i5 lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 20180e4: 80 a0 60 00 cmp %g1, 0 20180e8: 12 bf ff dc bne 2018058 <_Objects_Get_name_as_string+0x8c> 20180ec: 80 a6 60 01 cmp %i1, 1 for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { *d = (isprint((unsigned char)*s)) ? *s : '*'; 20180f0: 86 10 00 1a mov %i2, %g3 } } *d = '\0'; _Thread_Enable_dispatch(); 20180f4: 7f ff e3 f1 call 20110b8 <_Thread_Enable_dispatch> 20180f8: c0 28 c0 00 clrb [ %g3 ] 20180fc: 30 bf ff f5 b,a 20180d0 <_Objects_Get_name_as_string+0x104> =============================================================================== 0201ad5c <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 201ad5c: 9d e3 bf a0 save %sp, -96, %sp Objects_Control *object; Objects_Id next_id; if ( !information ) 201ad60: 80 a6 20 00 cmp %i0, 0 201ad64: 02 80 00 29 be 201ae08 <_Objects_Get_next+0xac> 201ad68: 80 a6 a0 00 cmp %i2, 0 return NULL; if ( !location_p ) 201ad6c: 02 80 00 27 be 201ae08 <_Objects_Get_next+0xac> 201ad70: 80 a6 e0 00 cmp %i3, 0 return NULL; if ( !next_id_p ) 201ad74: 02 80 00 25 be 201ae08 <_Objects_Get_next+0xac> 201ad78: 83 2e 60 10 sll %i1, 0x10, %g1 return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 201ad7c: 80 a0 60 00 cmp %g1, 0 201ad80: 22 80 00 13 be,a 201adcc <_Objects_Get_next+0x70> 201ad84: f2 06 20 08 ld [ %i0 + 8 ], %i1 else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 201ad88: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 201ad8c: 83 2e 60 10 sll %i1, 0x10, %g1 *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 201ad90: 92 10 00 19 mov %i1, %o1 else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 201ad94: 83 30 60 10 srl %g1, 0x10, %g1 *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 201ad98: 90 10 00 18 mov %i0, %o0 else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 201ad9c: 80 a0 80 01 cmp %g2, %g1 201ada0: 0a 80 00 13 bcs 201adec <_Objects_Get_next+0x90> 201ada4: 94 10 00 1a mov %i2, %o2 *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 201ada8: 7f ff d4 91 call 200ffec <_Objects_Get> 201adac: b2 06 60 01 inc %i1 next_id++; } while (*location_p != OBJECTS_LOCAL); 201adb0: c2 06 80 00 ld [ %i2 ], %g1 201adb4: 80 a0 60 00 cmp %g1, 0 201adb8: 32 bf ff f5 bne,a 201ad8c <_Objects_Get_next+0x30> 201adbc: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 *next_id_p = next_id; 201adc0: f2 26 c0 00 st %i1, [ %i3 ] return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 201adc4: 81 c7 e0 08 ret 201adc8: 91 e8 00 08 restore %g0, %o0, %o0 else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 201adcc: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 201add0: 83 2e 60 10 sll %i1, 0x10, %g1 *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 201add4: 92 10 00 19 mov %i1, %o1 else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 201add8: 83 30 60 10 srl %g1, 0x10, %g1 *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 201addc: 90 10 00 18 mov %i0, %o0 else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 201ade0: 80 a0 80 01 cmp %g2, %g1 201ade4: 1a bf ff f1 bcc 201ada8 <_Objects_Get_next+0x4c> <== ALWAYS TAKEN 201ade8: 94 10 00 1a mov %i2, %o2 { *location_p = OBJECTS_ERROR; 201adec: 82 10 20 01 mov 1, %g1 201adf0: c2 26 80 00 st %g1, [ %i2 ] *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; 201adf4: 90 10 20 00 clr %o0 *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 201adf8: 82 10 3f ff mov -1, %g1 201adfc: c2 26 c0 00 st %g1, [ %i3 ] return 0; } 201ae00: 81 c7 e0 08 ret 201ae04: 91 e8 00 08 restore %g0, %o0, %o0 { Objects_Control *object; Objects_Id next_id; if ( !information ) return NULL; 201ae08: 10 bf ff ef b 201adc4 <_Objects_Get_next+0x68> 201ae0c: 90 10 20 00 clr %o0 =============================================================================== 0201ad50 <_Objects_Get_no_protection>: /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 201ad50: c4 02 20 08 ld [ %o0 + 8 ], %g2 if ( information->maximum >= index ) { 201ad54: c2 12 20 10 lduh [ %o0 + 0x10 ], %g1 /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 201ad58: 92 22 40 02 sub %o1, %g2, %o1 201ad5c: 92 02 60 01 inc %o1 if ( information->maximum >= index ) { 201ad60: 80 a2 40 01 cmp %o1, %g1 201ad64: 18 80 00 09 bgu 201ad88 <_Objects_Get_no_protection+0x38> 201ad68: 93 2a 60 02 sll %o1, 2, %o1 if ( (the_object = information->local_table[ index ]) != NULL ) { 201ad6c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 201ad70: d0 00 40 09 ld [ %g1 + %o1 ], %o0 201ad74: 80 a2 20 00 cmp %o0, 0 201ad78: 02 80 00 05 be 201ad8c <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN 201ad7c: 82 10 20 01 mov 1, %g1 *location = OBJECTS_LOCAL; return the_object; 201ad80: 81 c3 e0 08 retl 201ad84: c0 22 80 00 clr [ %o2 ] /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 201ad88: 82 10 20 01 mov 1, %g1 return NULL; 201ad8c: 90 10 20 00 clr %o0 } 201ad90: 81 c3 e0 08 retl 201ad94: c2 22 80 00 st %g1, [ %o2 ] =============================================================================== 02010064 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 2010064: 9d e3 bf 98 save %sp, -104, %sp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 2010068: 80 a6 20 00 cmp %i0, 0 201006c: 12 80 00 06 bne 2010084 <_Objects_Id_to_name+0x20> 2010070: 83 36 20 18 srl %i0, 0x18, %g1 2010074: 03 00 80 c7 sethi %hi(0x2031c00), %g1 2010078: c2 00 63 ac ld [ %g1 + 0x3ac ], %g1 ! 2031fac <_Per_CPU_Information+0xc> 201007c: f0 00 60 08 ld [ %g1 + 8 ], %i0 2010080: 83 36 20 18 srl %i0, 0x18, %g1 2010084: 82 08 60 07 and %g1, 7, %g1 */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 2010088: 84 00 7f ff add %g1, -1, %g2 201008c: 80 a0 a0 02 cmp %g2, 2 2010090: 18 80 00 11 bgu 20100d4 <_Objects_Id_to_name+0x70> 2010094: 83 28 60 02 sll %g1, 2, %g1 the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 2010098: 05 00 80 c6 sethi %hi(0x2031800), %g2 201009c: 84 10 a1 94 or %g2, 0x194, %g2 ! 2031994 <_Objects_Information_table> 20100a0: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20100a4: 80 a0 60 00 cmp %g1, 0 20100a8: 02 80 00 0b be 20100d4 <_Objects_Id_to_name+0x70> 20100ac: 85 36 20 1b srl %i0, 0x1b, %g2 return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 20100b0: 85 28 a0 02 sll %g2, 2, %g2 20100b4: d0 00 40 02 ld [ %g1 + %g2 ], %o0 if ( !information ) 20100b8: 80 a2 20 00 cmp %o0, 0 20100bc: 02 80 00 06 be 20100d4 <_Objects_Id_to_name+0x70> <== NEVER TAKEN 20100c0: 01 00 00 00 nop return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 20100c4: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1 20100c8: 80 a0 60 00 cmp %g1, 0 20100cc: 02 80 00 04 be 20100dc <_Objects_Id_to_name+0x78> <== ALWAYS TAKEN 20100d0: 92 10 00 18 mov %i0, %o1 tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 20100d4: 81 c7 e0 08 ret 20100d8: 91 e8 20 03 restore %g0, 3, %o0 #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 20100dc: 7f ff ff c4 call 200ffec <_Objects_Get> 20100e0: 94 07 bf fc add %fp, -4, %o2 if ( !the_object ) 20100e4: 80 a2 20 00 cmp %o0, 0 20100e8: 02 bf ff fb be 20100d4 <_Objects_Id_to_name+0x70> 20100ec: 01 00 00 00 nop return OBJECTS_INVALID_ID; *name = the_object->name; 20100f0: c2 02 20 0c ld [ %o0 + 0xc ], %g1 _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 20100f4: b0 10 20 00 clr %i0 the_object = _Objects_Get( information, tmpId, &ignored_location ); if ( !the_object ) return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); 20100f8: 40 00 03 f0 call 20110b8 <_Thread_Enable_dispatch> 20100fc: c2 26 40 00 st %g1, [ %i1 ] 2010100: 81 c7 e0 08 ret 2010104: 81 e8 00 00 restore =============================================================================== 02009ae4 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 2009ae4: 9d e3 bf a0 save %sp, -96, %sp /* * Search the list to find block or chunk with all objects inactive. */ index_base = _Objects_Get_index( information->minimum_id ); 2009ae8: f8 16 20 0a lduh [ %i0 + 0xa ], %i4 block_count = (information->maximum - index_base) / 2009aec: f6 16 20 14 lduh [ %i0 + 0x14 ], %i3 2009af0: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 2009af4: 92 10 00 1b mov %i3, %o1 2009af8: 40 00 3e bd call 20195ec <.udiv> 2009afc: 90 22 00 1c sub %o0, %i4, %o0 information->allocation_size; for ( block = 0; block < block_count; block++ ) { 2009b00: 80 a2 20 00 cmp %o0, 0 2009b04: 02 80 00 36 be 2009bdc <_Objects_Shrink_information+0xf8> <== NEVER TAKEN 2009b08: 01 00 00 00 nop if ( information->inactive_per_block[ block ] == 2009b0c: c8 06 20 30 ld [ %i0 + 0x30 ], %g4 2009b10: c2 01 00 00 ld [ %g4 ], %g1 2009b14: 80 a6 c0 01 cmp %i3, %g1 2009b18: 02 80 00 0f be 2009b54 <_Objects_Shrink_information+0x70> <== NEVER TAKEN 2009b1c: 82 10 20 00 clr %g1 2009b20: 10 80 00 07 b 2009b3c <_Objects_Shrink_information+0x58> 2009b24: ba 10 20 04 mov 4, %i5 2009b28: c4 01 00 1d ld [ %g4 + %i5 ], %g2 2009b2c: 80 a6 c0 02 cmp %i3, %g2 2009b30: 02 80 00 0a be 2009b58 <_Objects_Shrink_information+0x74> 2009b34: 86 07 60 04 add %i5, 4, %g3 2009b38: ba 10 00 03 mov %g3, %i5 index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 2009b3c: 82 00 60 01 inc %g1 2009b40: 80 a0 40 08 cmp %g1, %o0 2009b44: 12 bf ff f9 bne 2009b28 <_Objects_Shrink_information+0x44> 2009b48: b8 07 00 1b add %i4, %i3, %i4 2009b4c: 81 c7 e0 08 ret 2009b50: 81 e8 00 00 restore if ( information->inactive_per_block[ block ] == 2009b54: ba 10 20 00 clr %i5 <== NOT EXECUTED * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); do { index = _Objects_Get_index( the_object->id ); 2009b58: 35 00 00 3f sethi %hi(0xfc00), %i2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 2009b5c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 2009b60: 10 80 00 05 b 2009b74 <_Objects_Shrink_information+0x90> 2009b64: b4 16 a3 ff or %i2, 0x3ff, %i2 if ((index >= index_base) && (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); } } while ( the_object ); 2009b68: 90 96 e0 00 orcc %i3, 0, %o0 2009b6c: 22 80 00 12 be,a 2009bb4 <_Objects_Shrink_information+0xd0> 2009b70: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); do { index = _Objects_Get_index( the_object->id ); 2009b74: c2 02 20 08 ld [ %o0 + 8 ], %g1 2009b78: 82 08 40 1a and %g1, %i2, %g1 /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; if ((index >= index_base) && 2009b7c: 80 a0 40 1c cmp %g1, %i4 2009b80: 0a bf ff fa bcs 2009b68 <_Objects_Shrink_information+0x84> 2009b84: f6 02 00 00 ld [ %o0 ], %i3 (index < (index_base + information->allocation_size))) { 2009b88: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2 2009b8c: 84 07 00 02 add %i4, %g2, %g2 /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; if ((index >= index_base) && 2009b90: 80 a0 40 02 cmp %g1, %g2 2009b94: 3a bf ff f6 bcc,a 2009b6c <_Objects_Shrink_information+0x88> 2009b98: 90 96 e0 00 orcc %i3, 0, %o0 (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); 2009b9c: 40 00 10 d4 call 200deec <_Chain_Extract> 2009ba0: 01 00 00 00 nop } } while ( the_object ); 2009ba4: 90 96 e0 00 orcc %i3, 0, %o0 2009ba8: 32 bf ff f4 bne,a 2009b78 <_Objects_Shrink_information+0x94><== ALWAYS TAKEN 2009bac: c2 02 20 08 ld [ %o0 + 8 ], %g1 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 2009bb0: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED 2009bb4: 40 00 07 b6 call 200ba8c <_Workspace_Free> 2009bb8: d0 00 40 1d ld [ %g1 + %i5 ], %o0 information->object_blocks[ block ] = NULL; 2009bbc: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2009bc0: c4 16 20 2c lduh [ %i0 + 0x2c ], %g2 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->object_blocks[ block ] = NULL; 2009bc4: c0 20 40 1d clr [ %g1 + %i5 ] information->inactive_per_block[ block ] = 0; 2009bc8: c6 06 20 30 ld [ %i0 + 0x30 ], %g3 information->inactive -= information->allocation_size; 2009bcc: c2 16 20 14 lduh [ %i0 + 0x14 ], %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2009bd0: c0 20 c0 1d clr [ %g3 + %i5 ] information->inactive -= information->allocation_size; 2009bd4: 82 20 80 01 sub %g2, %g1, %g1 2009bd8: c2 36 20 2c sth %g1, [ %i0 + 0x2c ] return; 2009bdc: 81 c7 e0 08 ret 2009be0: 81 e8 00 00 restore =============================================================================== 0200fdec <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 200fdec: 9d e3 bf a0 save %sp, -96, %sp Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id ); 200fdf0: c2 06 20 08 ld [ %i0 + 8 ], %g1 for ( index = 1 ; index <= max ; ++index ) { POSIX_Keys_Control *key = (POSIX_Keys_Control *) _POSIX_Keys_Information.local_table [ index ]; if ( key != NULL && key->destructor != NULL ) { void *value = key->Values [ thread_api ][ thread_index ]; 200fdf4: 35 00 00 3f sethi %hi(0xfc00), %i2 200fdf8: b3 30 60 18 srl %g1, 0x18, %i1 200fdfc: b4 16 a3 ff or %i2, 0x3ff, %i2 200fe00: b2 0e 60 07 and %i1, 7, %i1 200fe04: b4 08 40 1a and %g1, %i2, %i2 200fe08: b2 06 60 04 add %i1, 4, %i1 200fe0c: 3b 00 80 7b sethi %hi(0x201ec00), %i5 200fe10: b5 2e a0 02 sll %i2, 2, %i2 200fe14: ba 17 60 b8 or %i5, 0xb8, %i5 200fe18: b3 2e 60 02 sll %i1, 2, %i1 Objects_Maximum index = 0; Objects_Maximum max = _POSIX_Keys_Information.maximum; done = true; for ( index = 1 ; index <= max ; ++index ) { 200fe1c: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1 200fe20: 80 a0 60 00 cmp %g1, 0 200fe24: 02 80 00 21 be 200fea8 <_POSIX_Keys_Run_destructors+0xbc> 200fe28: b8 10 20 01 mov 1, %i4 200fe2c: 86 10 20 01 mov 1, %g3 200fe30: b6 10 00 01 mov %g1, %i3 POSIX_Keys_Control *key = (POSIX_Keys_Control *) 200fe34: c8 07 60 1c ld [ %i5 + 0x1c ], %g4 _POSIX_Keys_Information.local_table [ index ]; 200fe38: 85 2f 20 10 sll %i4, 0x10, %g2 Objects_Maximum max = _POSIX_Keys_Information.maximum; done = true; for ( index = 1 ; index <= max ; ++index ) { POSIX_Keys_Control *key = (POSIX_Keys_Control *) 200fe3c: 85 30 a0 0e srl %g2, 0xe, %g2 200fe40: c4 01 00 02 ld [ %g4 + %g2 ], %g2 _POSIX_Keys_Information.local_table [ index ]; if ( key != NULL && key->destructor != NULL ) { 200fe44: 80 a0 a0 00 cmp %g2, 0 200fe48: 02 80 00 10 be 200fe88 <_POSIX_Keys_Run_destructors+0x9c> 200fe4c: 82 00 80 19 add %g2, %i1, %g1 200fe50: c8 00 a0 10 ld [ %g2 + 0x10 ], %g4 200fe54: 80 a1 20 00 cmp %g4, 0 200fe58: 22 80 00 0d be,a 200fe8c <_POSIX_Keys_Run_destructors+0xa0> 200fe5c: b8 07 20 01 inc %i4 void *value = key->Values [ thread_api ][ thread_index ]; 200fe60: c8 00 60 04 ld [ %g1 + 4 ], %g4 200fe64: d0 01 00 1a ld [ %g4 + %i2 ], %o0 if ( value != NULL ) { 200fe68: 80 a2 20 00 cmp %o0, 0 200fe6c: 22 80 00 08 be,a 200fe8c <_POSIX_Keys_Run_destructors+0xa0><== ALWAYS TAKEN 200fe70: b8 07 20 01 inc %i4 key->Values [ thread_api ][ thread_index ] = NULL; 200fe74: c0 21 00 1a clr [ %g4 + %i2 ] <== NOT EXECUTED (*key->destructor)( value ); 200fe78: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED 200fe7c: 9f c0 40 00 call %g1 <== NOT EXECUTED 200fe80: 01 00 00 00 nop <== NOT EXECUTED done = false; 200fe84: 86 10 20 00 clr %g3 ! 0 <== NOT EXECUTED Objects_Maximum index = 0; Objects_Maximum max = _POSIX_Keys_Information.maximum; done = true; for ( index = 1 ; index <= max ; ++index ) { 200fe88: b8 07 20 01 inc %i4 200fe8c: 85 2f 20 10 sll %i4, 0x10, %g2 200fe90: 85 30 a0 10 srl %g2, 0x10, %g2 200fe94: 80 a6 c0 02 cmp %i3, %g2 200fe98: 1a bf ff e7 bcc 200fe34 <_POSIX_Keys_Run_destructors+0x48> 200fe9c: 80 88 e0 ff btst 0xff, %g3 * number of iterations. An infinite loop may happen if destructors set * thread specific data. This can be considered dubious. * * Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99. */ while ( !done ) { 200fea0: 22 bf ff e0 be,a 200fe20 <_POSIX_Keys_Run_destructors+0x34><== NEVER TAKEN 200fea4: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1 <== NOT EXECUTED 200fea8: 81 c7 e0 08 ret 200feac: 81 e8 00 00 restore =============================================================================== 0200cf04 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 200cf04: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( mqd_t id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) _Objects_Get( 200cf08: 11 00 80 af sethi %hi(0x202bc00), %o0 200cf0c: 92 10 00 18 mov %i0, %o1 200cf10: 90 12 20 7c or %o0, 0x7c, %o0 200cf14: 40 00 0d 84 call 2010524 <_Objects_Get> 200cf18: 94 07 bf f8 add %fp, -8, %o2 Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200cf1c: c2 07 bf f8 ld [ %fp + -8 ], %g1 200cf20: 80 a0 60 00 cmp %g1, 0 200cf24: 22 80 00 08 be,a 200cf44 <_POSIX_Message_queue_Receive_support+0x40> 200cf28: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 200cf2c: 40 00 2b 50 call 2017c6c <__errno> 200cf30: b0 10 3f ff mov -1, %i0 200cf34: 82 10 20 09 mov 9, %g1 200cf38: c2 22 00 00 st %g1, [ %o0 ] } 200cf3c: 81 c7 e0 08 ret 200cf40: 81 e8 00 00 restore the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 200cf44: 84 08 60 03 and %g1, 3, %g2 200cf48: 80 a0 a0 01 cmp %g2, 1 200cf4c: 02 80 00 39 be 200d030 <_POSIX_Message_queue_Receive_support+0x12c> 200cf50: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 200cf54: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 200cf58: c4 02 20 68 ld [ %o0 + 0x68 ], %g2 200cf5c: 80 a0 80 1a cmp %g2, %i2 200cf60: 18 80 00 23 bgu 200cfec <_POSIX_Message_queue_Receive_support+0xe8> 200cf64: 84 10 3f ff mov -1, %g2 /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 200cf68: c4 27 bf fc st %g2, [ %fp + -4 ] /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 200cf6c: 80 a7 20 00 cmp %i4, 0 200cf70: 12 80 00 1b bne 200cfdc <_POSIX_Message_queue_Receive_support+0xd8> 200cf74: 98 10 20 00 clr %o4 do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 200cf78: 9a 10 00 1d mov %i5, %o5 200cf7c: 90 02 20 1c add %o0, 0x1c, %o0 200cf80: 92 10 00 18 mov %i0, %o1 200cf84: 94 10 00 19 mov %i1, %o2 200cf88: 96 07 bf fc add %fp, -4, %o3 200cf8c: 40 00 08 f5 call 200f360 <_CORE_message_queue_Seize> 200cf90: 98 0b 20 01 and %o4, 1, %o4 &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 200cf94: 40 00 11 66 call 201152c <_Thread_Enable_dispatch> 200cf98: 3b 00 80 af sethi %hi(0x202bc00), %i5 if (msg_prio) { 200cf9c: 80 a6 e0 00 cmp %i3, 0 *msg_prio = _POSIX_Message_queue_Priority_from_core( _Thread_Executing->Wait.count 200cfa0: ba 17 60 f0 or %i5, 0xf0, %i5 do_wait, timeout ); _Thread_Enable_dispatch(); if (msg_prio) { 200cfa4: 02 80 00 07 be 200cfc0 <_POSIX_Message_queue_Receive_support+0xbc><== NEVER TAKEN 200cfa8: c2 07 60 0c ld [ %i5 + 0xc ], %g1 RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core( CORE_message_queue_Submit_types priority ) { /* absolute value without a library dependency */ return (unsigned int) ((priority >= 0) ? priority : -priority); 200cfac: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 200cfb0: 85 38 e0 1f sra %g3, 0x1f, %g2 200cfb4: 86 18 80 03 xor %g2, %g3, %g3 200cfb8: 84 20 c0 02 sub %g3, %g2, %g2 *msg_prio = _POSIX_Message_queue_Priority_from_core( 200cfbc: c4 26 c0 00 st %g2, [ %i3 ] _Thread_Executing->Wait.count ); } if ( !_Thread_Executing->Wait.return_code ) 200cfc0: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 200cfc4: 80 a0 60 00 cmp %g1, 0 200cfc8: 12 80 00 11 bne 200d00c <_POSIX_Message_queue_Receive_support+0x108> 200cfcc: 01 00 00 00 nop return length_out; 200cfd0: f0 07 bf fc ld [ %fp + -4 ], %i0 200cfd4: 81 c7 e0 08 ret 200cfd8: 81 e8 00 00 restore /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true; 200cfdc: 99 30 60 0e srl %g1, 0xe, %o4 200cfe0: 98 1b 20 01 xor %o4, 1, %o4 200cfe4: 10 bf ff e5 b 200cf78 <_POSIX_Message_queue_Receive_support+0x74> 200cfe8: 98 0b 20 01 and %o4, 1, %o4 } the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { _Thread_Enable_dispatch(); 200cfec: 40 00 11 50 call 201152c <_Thread_Enable_dispatch> 200cff0: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( EMSGSIZE ); 200cff4: 40 00 2b 1e call 2017c6c <__errno> 200cff8: 01 00 00 00 nop 200cffc: 82 10 20 7a mov 0x7a, %g1 ! 7a 200d000: c2 22 00 00 st %g1, [ %o0 ] 200d004: 81 c7 e0 08 ret 200d008: 81 e8 00 00 restore } if ( !_Thread_Executing->Wait.return_code ) return length_out; rtems_set_errno_and_return_minus_one( 200d00c: 40 00 2b 18 call 2017c6c <__errno> 200d010: b0 10 3f ff mov -1, %i0 200d014: c2 07 60 0c ld [ %i5 + 0xc ], %g1 200d018: b8 10 00 08 mov %o0, %i4 200d01c: 40 00 00 a2 call 200d2a4 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 200d020: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 200d024: d0 27 00 00 st %o0, [ %i4 ] 200d028: 81 c7 e0 08 ret 200d02c: 81 e8 00 00 restore the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { _Thread_Enable_dispatch(); 200d030: 40 00 11 3f call 201152c <_Thread_Enable_dispatch> 200d034: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( EBADF ); 200d038: 40 00 2b 0d call 2017c6c <__errno> 200d03c: 01 00 00 00 nop 200d040: 82 10 20 09 mov 9, %g1 ! 9 200d044: c2 22 00 00 st %g1, [ %o0 ] 200d048: 81 c7 e0 08 ret 200d04c: 81 e8 00 00 restore =============================================================================== 0200f8c0 <_POSIX_Semaphore_Create_support>: size_t name_len, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 200f8c0: 9d e3 bf a0 save %sp, -96, %sp POSIX_Semaphore_Control *the_semaphore; CORE_semaphore_Attributes *the_sem_attr; char *name; /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) 200f8c4: 80 a6 a0 00 cmp %i2, 0 200f8c8: 12 80 00 30 bne 200f988 <_POSIX_Semaphore_Create_support+0xc8> 200f8cc: 03 00 80 8c sethi %hi(0x2023000), %g1 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 200f8d0: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20233a0 <_Thread_Dispatch_disable_level> 200f8d4: 84 00 a0 01 inc %g2 200f8d8: c4 20 63 a0 st %g2, [ %g1 + 0x3a0 ] return _Thread_Dispatch_disable_level; 200f8dc: c2 00 63 a0 ld [ %g1 + 0x3a0 ], %g1 * _POSIX_Semaphore_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) 200f8e0: 35 00 80 8d sethi %hi(0x2023400), %i2 200f8e4: 7f ff ed ca call 200b00c <_Objects_Allocate> 200f8e8: 90 16 a2 90 or %i2, 0x290, %o0 ! 2023690 <_POSIX_Semaphore_Information> rtems_set_errno_and_return_minus_one( ENOSYS ); _Thread_Disable_dispatch(); the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 200f8ec: ba 92 20 00 orcc %o0, 0, %i5 200f8f0: 02 80 00 2c be 200f9a0 <_POSIX_Semaphore_Create_support+0xe0> 200f8f4: 80 a6 20 00 cmp %i0, 0 /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ if ( name_arg != NULL ) { 200f8f8: 02 80 00 1e be 200f970 <_POSIX_Semaphore_Create_support+0xb0> 200f8fc: 92 10 00 19 mov %i1, %o1 name = _Workspace_String_duplicate( name_arg, name_len ); 200f900: 40 00 04 c6 call 2010c18 <_Workspace_String_duplicate> 200f904: 90 10 00 18 mov %i0, %o0 if ( !name ) { 200f908: b2 92 20 00 orcc %o0, 0, %i1 200f90c: 02 80 00 2d be 200f9c0 <_POSIX_Semaphore_Create_support+0x100><== NEVER TAKEN 200f910: 82 10 20 01 mov 1, %g1 } the_semaphore->process_shared = pshared; if ( name ) { the_semaphore->named = true; 200f914: 84 10 20 01 mov 1, %g2 } } else { name = NULL; } the_semaphore->process_shared = pshared; 200f918: c0 27 60 10 clr [ %i5 + 0x10 ] if ( name ) { the_semaphore->named = true; 200f91c: c4 2f 60 14 stb %g2, [ %i5 + 0x14 ] the_semaphore->open_count = 1; 200f920: c2 27 60 18 st %g1, [ %i5 + 0x18 ] the_semaphore->linked = true; 200f924: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ] the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200f928: 82 10 3f ff mov -1, %g1 _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 200f92c: 90 07 60 1c add %i5, 0x1c, %o0 200f930: 92 07 60 5c add %i5, 0x5c, %o1 200f934: 94 10 00 1b mov %i3, %o2 the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200f938: c2 27 60 5c st %g1, [ %i5 + 0x5c ] _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 200f93c: 7f ff ec 11 call 200a980 <_CORE_semaphore_Initialize> 200f940: c0 27 60 60 clr [ %i5 + 0x60 ] Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 200f944: c2 17 60 0a lduh [ %i5 + 0xa ], %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200f948: b4 16 a2 90 or %i2, 0x290, %i2 200f94c: c4 06 a0 1c ld [ %i2 + 0x1c ], %g2 200f950: 83 28 60 02 sll %g1, 2, %g1 200f954: fa 20 80 01 st %i5, [ %g2 + %g1 ] the_object ); #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) /* ASSERT: information->is_string */ the_object->name.name_p = name; 200f958: f2 27 60 0c st %i1, [ %i5 + 0xc ] &_POSIX_Semaphore_Information, &the_semaphore->Object, name ); *the_sem = the_semaphore; 200f95c: fa 27 00 00 st %i5, [ %i4 ] _Thread_Enable_dispatch(); 200f960: 7f ff f3 13 call 200c5ac <_Thread_Enable_dispatch> 200f964: b0 10 20 00 clr %i0 return 0; 200f968: 81 c7 e0 08 ret 200f96c: 81 e8 00 00 restore } } else { name = NULL; } the_semaphore->process_shared = pshared; 200f970: c0 27 60 10 clr [ %i5 + 0x10 ] if ( name ) { the_semaphore->named = true; the_semaphore->open_count = 1; the_semaphore->linked = true; } else { the_semaphore->named = false; 200f974: c0 2f 60 14 clrb [ %i5 + 0x14 ] the_semaphore->open_count = 0; 200f978: c0 27 60 18 clr [ %i5 + 0x18 ] the_semaphore->linked = false; 200f97c: c0 2f 60 15 clrb [ %i5 + 0x15 ] _POSIX_Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); } } else { name = NULL; 200f980: 10 bf ff ea b 200f928 <_POSIX_Semaphore_Create_support+0x68> 200f984: b2 10 20 00 clr %i1 CORE_semaphore_Attributes *the_sem_attr; char *name; /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) rtems_set_errno_and_return_minus_one( ENOSYS ); 200f988: 40 00 0b 71 call 201274c <__errno> 200f98c: b0 10 3f ff mov -1, %i0 200f990: 82 10 20 58 mov 0x58, %g1 200f994: c2 22 00 00 st %g1, [ %o0 ] 200f998: 81 c7 e0 08 ret 200f99c: 81 e8 00 00 restore _Thread_Disable_dispatch(); the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 200f9a0: 7f ff f3 03 call 200c5ac <_Thread_Enable_dispatch> 200f9a4: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( ENOSPC ); 200f9a8: 40 00 0b 69 call 201274c <__errno> 200f9ac: 01 00 00 00 nop 200f9b0: 82 10 20 1c mov 0x1c, %g1 ! 1c 200f9b4: c2 22 00 00 st %g1, [ %o0 ] 200f9b8: 81 c7 e0 08 ret 200f9bc: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free ( POSIX_Semaphore_Control *the_semaphore ) { _Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object ); 200f9c0: 90 16 a2 90 or %i2, 0x290, %o0 <== NOT EXECUTED 200f9c4: 7f ff ee 7f call 200b3c0 <_Objects_Free> <== NOT EXECUTED 200f9c8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED */ if ( name_arg != NULL ) { name = _Workspace_String_duplicate( name_arg, name_len ); if ( !name ) { _POSIX_Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 200f9cc: 7f ff f2 f8 call 200c5ac <_Thread_Enable_dispatch> <== NOT EXECUTED 200f9d0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 200f9d4: 40 00 0b 5e call 201274c <__errno> <== NOT EXECUTED 200f9d8: 01 00 00 00 nop <== NOT EXECUTED 200f9dc: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED 200f9e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200f9e4: 81 c7 e0 08 ret <== NOT EXECUTED 200f9e8: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 0200d340 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: Thread_Control *the_thread ) { POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200d340: c2 02 21 5c ld [ %o0 + 0x15c ], %g1 if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 200d344: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2 200d348: 80 a0 a0 00 cmp %g2, 0 200d34c: 12 80 00 06 bne 200d364 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24><== NEVER TAKEN 200d350: 01 00 00 00 nop 200d354: c4 00 60 dc ld [ %g1 + 0xdc ], %g2 200d358: 80 a0 a0 01 cmp %g2, 1 200d35c: 22 80 00 05 be,a 200d370 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x30> 200d360: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); } else _Thread_Enable_dispatch(); 200d364: 82 13 c0 00 mov %o7, %g1 200d368: 7f ff f5 ae call 200aa20 <_Thread_Enable_dispatch> 200d36c: 9e 10 40 00 mov %g1, %o7 POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 200d370: 80 a0 60 00 cmp %g1, 0 200d374: 02 bf ff fc be 200d364 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24> 200d378: 01 00 00 00 nop * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 200d37c: 03 00 80 7b sethi %hi(0x201ec00), %g1 200d380: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201ede0 <_Thread_Dispatch_disable_level> thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 200d384: 92 10 3f ff mov -1, %o1 200d388: 84 00 bf ff add %g2, -1, %g2 200d38c: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] return _Thread_Dispatch_disable_level; 200d390: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 200d394: 82 13 c0 00 mov %o7, %g1 200d398: 40 00 01 d9 call 200dafc <_POSIX_Thread_Exit> 200d39c: 9e 10 40 00 mov %g1, %o7 =============================================================================== 0200e834 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 200e834: 9d e3 bf a0 save %sp, -96, %sp if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 200e838: 7f ff ff f2 call 200e800 <_POSIX_Priority_Is_valid> 200e83c: d0 06 40 00 ld [ %i1 ], %o0 200e840: 80 8a 20 ff btst 0xff, %o0 200e844: 32 80 00 04 bne,a 200e854 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN 200e848: c0 26 80 00 clr [ %i2 ] return EINVAL; 200e84c: 81 c7 e0 08 ret 200e850: 91 e8 20 16 restore %g0, 0x16, %o0 *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; *budget_callout = NULL; if ( policy == SCHED_OTHER ) { 200e854: 80 a6 20 00 cmp %i0, 0 200e858: 02 80 00 2c be 200e908 <_POSIX_Thread_Translate_sched_param+0xd4> 200e85c: c0 26 c0 00 clr [ %i3 ] *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 200e860: 80 a6 20 01 cmp %i0, 1 200e864: 02 80 00 2d be 200e918 <_POSIX_Thread_Translate_sched_param+0xe4> 200e868: 80 a6 20 02 cmp %i0, 2 *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 200e86c: 02 80 00 2d be 200e920 <_POSIX_Thread_Translate_sched_param+0xec> 200e870: 80 a6 20 04 cmp %i0, 4 *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; return 0; } if ( policy == SCHED_SPORADIC ) { 200e874: 12 bf ff f6 bne 200e84c <_POSIX_Thread_Translate_sched_param+0x18> 200e878: 01 00 00 00 nop if ( (param->sched_ss_repl_period.tv_sec == 0) && 200e87c: c2 06 60 08 ld [ %i1 + 8 ], %g1 200e880: 80 a0 60 00 cmp %g1, 0 200e884: 32 80 00 07 bne,a 200e8a0 <_POSIX_Thread_Translate_sched_param+0x6c> 200e888: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 200e88c: c2 06 60 0c ld [ %i1 + 0xc ], %g1 200e890: 80 a0 60 00 cmp %g1, 0 200e894: 02 bf ff ee be 200e84c <_POSIX_Thread_Translate_sched_param+0x18> 200e898: 01 00 00 00 nop (param->sched_ss_repl_period.tv_nsec == 0) ) return EINVAL; if ( (param->sched_ss_init_budget.tv_sec == 0) && 200e89c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 200e8a0: 80 a0 60 00 cmp %g1, 0 200e8a4: 12 80 00 06 bne 200e8bc <_POSIX_Thread_Translate_sched_param+0x88> 200e8a8: 01 00 00 00 nop 200e8ac: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 200e8b0: 80 a0 60 00 cmp %g1, 0 200e8b4: 02 bf ff e6 be 200e84c <_POSIX_Thread_Translate_sched_param+0x18> 200e8b8: 01 00 00 00 nop (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 200e8bc: 7f ff f6 ca call 200c3e4 <_Timespec_To_ticks> 200e8c0: 90 06 60 08 add %i1, 8, %o0 200e8c4: ba 10 00 08 mov %o0, %i5 _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 200e8c8: 7f ff f6 c7 call 200c3e4 <_Timespec_To_ticks> 200e8cc: 90 06 60 10 add %i1, 0x10, %o0 if ( (param->sched_ss_init_budget.tv_sec == 0) && (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 200e8d0: 80 a7 40 08 cmp %i5, %o0 200e8d4: 0a bf ff de bcs 200e84c <_POSIX_Thread_Translate_sched_param+0x18> 200e8d8: 01 00 00 00 nop _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) ) 200e8dc: 7f ff ff c9 call 200e800 <_POSIX_Priority_Is_valid> 200e8e0: d0 06 60 04 ld [ %i1 + 4 ], %o0 200e8e4: 80 8a 20 ff btst 0xff, %o0 200e8e8: 02 bf ff d9 be 200e84c <_POSIX_Thread_Translate_sched_param+0x18> 200e8ec: 82 10 20 03 mov 3, %g1 return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 200e8f0: c2 26 80 00 st %g1, [ %i2 ] *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 200e8f4: 03 00 80 20 sethi %hi(0x2008000), %g1 200e8f8: 82 10 63 94 or %g1, 0x394, %g1 ! 2008394 <_POSIX_Threads_Sporadic_budget_callout> 200e8fc: c2 26 c0 00 st %g1, [ %i3 ] return 0; 200e900: 81 c7 e0 08 ret 200e904: 91 e8 20 00 restore %g0, 0, %o0 *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; *budget_callout = NULL; if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 200e908: 82 10 20 01 mov 1, %g1 200e90c: c2 26 80 00 st %g1, [ %i2 ] return 0; 200e910: 81 c7 e0 08 ret 200e914: 81 e8 00 00 restore *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; } 200e918: 81 c7 e0 08 ret 200e91c: 91 e8 20 00 restore %g0, 0, %o0 *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 200e920: f0 26 80 00 st %i0, [ %i2 ] return 0; 200e924: 81 c7 e0 08 ret 200e928: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 0200d66c <_POSIX_Threads_Delete_extension>: */ static void _POSIX_Threads_Delete_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *deleted ) { 200d66c: 9d e3 bf a0 save %sp, -96, %sp Thread_Control *the_thread; POSIX_API_Control *api; void **value_ptr; api = deleted->API_Extensions[ THREAD_API_POSIX ]; 200d670: f0 06 61 5c ld [ %i1 + 0x15c ], %i0 /* * Run the POSIX cancellation handlers */ _POSIX_Threads_cancel_run( deleted ); 200d674: 40 00 09 c2 call 200fd7c <_POSIX_Threads_cancel_run> 200d678: 90 10 00 19 mov %i1, %o0 /* * Run all the key destructors */ _POSIX_Keys_Run_destructors( deleted ); 200d67c: 90 10 00 19 mov %i1, %o0 200d680: 40 00 09 db call 200fdec <_POSIX_Keys_Run_destructors> 200d684: ba 06 20 44 add %i0, 0x44, %i5 /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 200d688: 10 80 00 03 b 200d694 <_POSIX_Threads_Delete_extension+0x28> 200d68c: f8 06 60 28 ld [ %i1 + 0x28 ], %i4 *(void **)the_thread->Wait.return_argument = value_ptr; 200d690: f8 20 40 00 st %i4, [ %g1 ] <== NOT EXECUTED /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 200d694: 7f ff f5 7b call 200ac80 <_Thread_queue_Dequeue> 200d698: 90 10 00 1d mov %i5, %o0 200d69c: 80 a2 20 00 cmp %o0, 0 200d6a0: 32 bf ff fc bne,a 200d690 <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN 200d6a4: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) 200d6a8: c2 06 20 84 ld [ %i0 + 0x84 ], %g1 200d6ac: 80 a0 60 04 cmp %g1, 4 200d6b0: 02 80 00 05 be 200d6c4 <_POSIX_Threads_Delete_extension+0x58> 200d6b4: 01 00 00 00 nop (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; 200d6b8: c0 26 61 5c clr [ %i1 + 0x15c ] _Workspace_Free( api ); 200d6bc: 7f ff f8 f4 call 200ba8c <_Workspace_Free> 200d6c0: 81 e8 00 00 restore while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 200d6c4: 7f ff f8 68 call 200b864 <_Watchdog_Remove> 200d6c8: 90 06 20 a8 add %i0, 0xa8, %o0 deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; 200d6cc: c0 26 61 5c clr [ %i1 + 0x15c ] _Workspace_Free( api ); 200d6d0: 7f ff f8 ef call 200ba8c <_Workspace_Free> 200d6d4: 81 e8 00 00 restore =============================================================================== 020080a8 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 20080a8: 9d e3 bf 58 save %sp, -168, %sp uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = Configuration_POSIX_API.User_initialization_threads_table; 20080ac: 03 00 80 8a sethi %hi(0x2022800), %g1 20080b0: 82 10 60 f0 or %g1, 0xf0, %g1 ! 20228f0 maximum = Configuration_POSIX_API.number_of_initialization_threads; 20080b4: f6 00 60 30 ld [ %g1 + 0x30 ], %i3 if ( !user_threads || maximum == 0 ) 20080b8: 80 a6 e0 00 cmp %i3, 0 20080bc: 02 80 00 18 be 200811c <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN 20080c0: fa 00 60 34 ld [ %g1 + 0x34 ], %i5 20080c4: 80 a7 60 00 cmp %i5, 0 20080c8: 02 80 00 15 be 200811c <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN 20080cc: b8 10 20 00 clr %i4 for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 20080d0: 40 00 1a 17 call 200e92c 20080d4: 90 07 bf c0 add %fp, -64, %o0 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 20080d8: 92 10 20 02 mov 2, %o1 20080dc: 40 00 1a 20 call 200e95c 20080e0: 90 07 bf c0 add %fp, -64, %o0 (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 20080e4: d2 07 60 04 ld [ %i5 + 4 ], %o1 20080e8: 40 00 1a 2d call 200e99c 20080ec: 90 07 bf c0 add %fp, -64, %o0 status = pthread_create( 20080f0: d4 07 40 00 ld [ %i5 ], %o2 20080f4: 90 07 bf bc add %fp, -68, %o0 20080f8: 92 07 bf c0 add %fp, -64, %o1 20080fc: 7f ff fe fe call 2007cf4 2008100: 96 10 20 00 clr %o3 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 2008104: 94 92 20 00 orcc %o0, 0, %o2 2008108: 12 80 00 07 bne 2008124 <_POSIX_Threads_Initialize_user_threads_body+0x7c> 200810c: b8 07 20 01 inc %i4 * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 2008110: 80 a7 00 1b cmp %i4, %i3 2008114: 12 bf ff ef bne 20080d0 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN 2008118: ba 07 60 08 add %i5, 8, %i5 200811c: 81 c7 e0 08 ret 2008120: 81 e8 00 00 restore &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 2008124: 90 10 20 02 mov 2, %o0 2008128: 40 00 08 7b call 200a314 <_Internal_error_Occurred> 200812c: 92 10 20 01 mov 1, %o1 =============================================================================== 0200d7f8 <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 200d7f8: 9d e3 bf a0 save %sp, -96, %sp Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200d7fc: fa 06 61 5c ld [ %i1 + 0x15c ], %i5 /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); 200d800: 40 00 04 71 call 200e9c4 <_Timespec_To_ticks> 200d804: 90 07 60 98 add %i5, 0x98, %o0 RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 200d808: c4 07 60 88 ld [ %i5 + 0x88 ], %g2 200d80c: 03 00 80 76 sethi %hi(0x201d800), %g1 200d810: d2 08 63 18 ldub [ %g1 + 0x318 ], %o1 ! 201db18 */ #if 0 printk( "TSR %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 200d814: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 200d818: 92 22 40 02 sub %o1, %g2, %o1 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); the_thread->cpu_time_budget = ticks; 200d81c: d0 26 60 74 st %o0, [ %i1 + 0x74 ] */ #if 0 printk( "TSR %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 200d820: 80 a0 60 00 cmp %g1, 0 200d824: 12 80 00 06 bne 200d83c <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NEVER TAKEN 200d828: d2 26 60 18 st %o1, [ %i1 + 0x18 ] /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { 200d82c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 200d830: 80 a0 40 09 cmp %g1, %o1 200d834: 18 80 00 09 bgu 200d858 <_POSIX_Threads_Sporadic_budget_TSR+0x60> 200d838: 90 10 00 19 mov %i1, %o0 #endif } } /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ); 200d83c: 90 07 60 90 add %i5, 0x90, %o0 200d840: 40 00 04 61 call 200e9c4 <_Timespec_To_ticks> 200d844: 31 00 80 7a sethi %hi(0x201e800), %i0 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200d848: b2 07 60 a8 add %i5, 0xa8, %i1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200d84c: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200d850: 7f ff f7 a6 call 200b6e8 <_Watchdog_Insert> 200d854: 91 ee 21 58 restore %i0, 0x158, %o0 if ( the_thread->resource_count == 0 ) { /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { _Thread_Change_priority( the_thread, new_priority, true ); 200d858: 7f ff f2 e1 call 200a3dc <_Thread_Change_priority> 200d85c: 94 10 20 01 mov 1, %o2 #endif } } /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ); 200d860: 90 07 60 90 add %i5, 0x90, %o0 200d864: 40 00 04 58 call 200e9c4 <_Timespec_To_ticks> 200d868: 31 00 80 7a sethi %hi(0x201e800), %i0 200d86c: b2 07 60 a8 add %i5, 0xa8, %i1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200d870: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200d874: 7f ff f7 9d call 200b6e8 <_Watchdog_Insert> 200d878: 91 ee 21 58 restore %i0, 0x158, %o0 =============================================================================== 0200d87c <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200d87c: c4 02 21 5c ld [ %o0 + 0x15c ], %g2 200d880: c6 00 a0 8c ld [ %g2 + 0x8c ], %g3 200d884: 05 00 80 76 sethi %hi(0x201d800), %g2 200d888: d2 08 a3 18 ldub [ %g2 + 0x318 ], %o1 ! 201db18 */ #if 0 printk( "callout %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 200d88c: c4 02 20 1c ld [ %o0 + 0x1c ], %g2 200d890: 92 22 40 03 sub %o1, %g3, %o1 /* * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 200d894: 86 10 3f ff mov -1, %g3 new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority); the_thread->real_priority = new_priority; 200d898: d2 22 20 18 st %o1, [ %o0 + 0x18 ] */ #if 0 printk( "callout %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 200d89c: 80 a0 a0 00 cmp %g2, 0 200d8a0: 12 80 00 06 bne 200d8b8 <_POSIX_Threads_Sporadic_budget_callout+0x3c><== NEVER TAKEN 200d8a4: c6 22 20 74 st %g3, [ %o0 + 0x74 ] /* * Make sure we are actually lowering it. If they have lowered it * to logically lower than sched_ss_low_priority, then we do not want to * change it. */ if ( the_thread->current_priority < new_priority ) { 200d8a8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200d8ac: 80 a0 40 09 cmp %g1, %o1 200d8b0: 0a 80 00 04 bcs 200d8c0 <_POSIX_Threads_Sporadic_budget_callout+0x44><== ALWAYS TAKEN 200d8b4: 94 10 20 01 mov 1, %o2 200d8b8: 81 c3 e0 08 retl <== NOT EXECUTED 200d8bc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( the_thread, new_priority, true ); 200d8c0: 82 13 c0 00 mov %o7, %g1 200d8c4: 7f ff f2 c6 call 200a3dc <_Thread_Change_priority> 200d8c8: 9e 10 40 00 mov %g1, %o7 =============================================================================== 0200fd7c <_POSIX_Threads_cancel_run>: #include void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 200fd7c: 9d e3 bf a0 save %sp, -96, %sp POSIX_Cancel_Handler_control *handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200fd80: f8 06 21 5c ld [ %i0 + 0x15c ], %i4 handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 200fd84: 84 10 20 01 mov 1, %g2 while ( !_Chain_Is_empty( handler_stack ) ) { 200fd88: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 200fd8c: b6 07 20 e8 add %i4, 0xe8, %i3 200fd90: 80 a0 40 1b cmp %g1, %i3 200fd94: 02 80 00 14 be 200fde4 <_POSIX_Threads_cancel_run+0x68> 200fd98: c4 27 20 d8 st %g2, [ %i4 + 0xd8 ] _ISR_Disable( level ); 200fd9c: 7f ff ca 72 call 2002764 200fda0: 01 00 00 00 nop handler = (POSIX_Cancel_Handler_control *) 200fda4: fa 07 20 ec ld [ %i4 + 0xec ], %i5 ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200fda8: c4 07 40 00 ld [ %i5 ], %g2 previous = the_node->previous; 200fdac: c2 07 60 04 ld [ %i5 + 4 ], %g1 next->previous = previous; 200fdb0: c2 20 a0 04 st %g1, [ %g2 + 4 ] previous->next = next; 200fdb4: c4 20 40 00 st %g2, [ %g1 ] _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 200fdb8: 7f ff ca 6f call 2002774 200fdbc: 01 00 00 00 nop (*handler->routine)( handler->arg ); 200fdc0: c2 07 60 08 ld [ %i5 + 8 ], %g1 200fdc4: 9f c0 40 00 call %g1 200fdc8: d0 07 60 0c ld [ %i5 + 0xc ], %o0 _Workspace_Free( handler ); 200fdcc: 7f ff ef 30 call 200ba8c <_Workspace_Free> 200fdd0: 90 10 00 1d mov %i5, %o0 handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 200fdd4: c2 07 20 e4 ld [ %i4 + 0xe4 ], %g1 200fdd8: 80 a0 40 1b cmp %g1, %i3 200fddc: 12 bf ff f0 bne 200fd9c <_POSIX_Threads_cancel_run+0x20> <== NEVER TAKEN 200fde0: 01 00 00 00 nop 200fde4: 81 c7 e0 08 ret 200fde8: 81 e8 00 00 restore =============================================================================== 02007b30 <_POSIX_Timer_TSR>: * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR( Objects_Id timer __attribute__((unused)), void *data) { 2007b30: 9d e3 bf 98 save %sp, -104, %sp bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 2007b34: c4 06 60 68 ld [ %i1 + 0x68 ], %g2 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 2007b38: c2 06 60 54 ld [ %i1 + 0x54 ], %g1 bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 2007b3c: 84 00 a0 01 inc %g2 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 2007b40: 80 a0 60 00 cmp %g1, 0 2007b44: 12 80 00 0e bne 2007b7c <_POSIX_Timer_TSR+0x4c> 2007b48: c4 26 60 68 st %g2, [ %i1 + 0x68 ] 2007b4c: c2 06 60 58 ld [ %i1 + 0x58 ], %g1 2007b50: 80 a0 60 00 cmp %g1, 0 2007b54: 32 80 00 0b bne,a 2007b80 <_POSIX_Timer_TSR+0x50> <== ALWAYS TAKEN 2007b58: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 2007b5c: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED 2007b60: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 2007b64: d0 06 60 38 ld [ %i1 + 0x38 ], %o0 2007b68: 40 00 18 84 call 200dd78 2007b6c: d2 06 60 44 ld [ %i1 + 0x44 ], %o1 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 2007b70: c0 26 60 68 clr [ %i1 + 0x68 ] 2007b74: 81 c7 e0 08 ret 2007b78: 81 e8 00 00 restore ptimer->overrun = ptimer->overrun + 1; /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 2007b7c: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 2007b80: d4 06 60 08 ld [ %i1 + 8 ], %o2 2007b84: 90 06 60 10 add %i1, 0x10, %o0 2007b88: 98 10 00 19 mov %i1, %o4 2007b8c: 17 00 80 1e sethi %hi(0x2007800), %o3 2007b90: 40 00 19 9d call 200e204 <_POSIX_Timer_Insert_helper> 2007b94: 96 12 e3 30 or %o3, 0x330, %o3 ! 2007b30 <_POSIX_Timer_TSR> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 2007b98: 80 8a 20 ff btst 0xff, %o0 2007b9c: 02 bf ff f6 be 2007b74 <_POSIX_Timer_TSR+0x44> <== NEVER TAKEN 2007ba0: 01 00 00 00 nop struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 2007ba4: 40 00 06 2a call 200944c <_TOD_Get_as_timestamp> 2007ba8: 90 07 bf f8 add %fp, -8, %o0 _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 2007bac: f8 1f bf f8 ldd [ %fp + -8 ], %i4 static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 2007bb0: 94 10 20 00 clr %o2 2007bb4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2007bb8: 90 10 00 1c mov %i4, %o0 2007bbc: 96 12 e2 00 or %o3, 0x200, %o3 2007bc0: 40 00 4b 13 call 201a80c <__divdi3> 2007bc4: 92 10 00 1d mov %i5, %o1 _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 2007bc8: 94 10 20 00 clr %o2 static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 2007bcc: d2 26 60 6c st %o1, [ %i1 + 0x6c ] _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 2007bd0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2007bd4: 90 10 00 1c mov %i4, %o0 2007bd8: 96 12 e2 00 or %o3, 0x200, %o3 2007bdc: 40 00 4b f7 call 201abb8 <__moddi3> 2007be0: 92 10 00 1d mov %i5, %o1 /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 2007be4: 82 10 20 03 mov 3, %g1 2007be8: d2 26 60 70 st %o1, [ %i1 + 0x70 ] 2007bec: 10 bf ff de b 2007b64 <_POSIX_Timer_TSR+0x34> 2007bf0: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] =============================================================================== 0200feb0 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 200feb0: 9d e3 bf 68 save %sp, -152, %sp siginfo_t siginfo_struct; sigset_t saved_signals_blocked; Thread_Wait_information stored_thread_wait_information; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 200feb4: 98 10 20 01 mov 1, %o4 200feb8: 90 10 00 18 mov %i0, %o0 200febc: 92 10 00 19 mov %i1, %o1 200fec0: 94 07 bf cc add %fp, -52, %o2 200fec4: 40 00 00 2e call 200ff7c <_POSIX_signals_Clear_signals> 200fec8: 96 10 00 1a mov %i2, %o3 200fecc: 80 8a 20 ff btst 0xff, %o0 200fed0: 02 80 00 23 be 200ff5c <_POSIX_signals_Check_signal+0xac> 200fed4: 82 10 20 00 clr %g1 #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 200fed8: 85 2e 60 02 sll %i1, 2, %g2 200fedc: 37 00 80 7b sethi %hi(0x201ec00), %i3 200fee0: b9 2e 60 04 sll %i1, 4, %i4 200fee4: b6 16 e2 40 or %i3, 0x240, %i3 200fee8: b8 27 00 02 sub %i4, %g2, %i4 200feec: 84 06 c0 1c add %i3, %i4, %g2 200fef0: fa 00 a0 08 ld [ %g2 + 8 ], %i5 200fef4: 80 a7 60 01 cmp %i5, 1 200fef8: 02 80 00 19 be 200ff5c <_POSIX_signals_Check_signal+0xac> <== NEVER TAKEN 200fefc: 21 00 80 7b sethi %hi(0x201ec00), %l0 return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 200ff00: f4 06 20 d0 ld [ %i0 + 0xd0 ], %i2 api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200ff04: c2 00 a0 04 ld [ %g2 + 4 ], %g1 /* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait, 200ff08: a0 14 21 e0 or %l0, 0x1e0, %l0 200ff0c: d2 04 20 0c ld [ %l0 + 0xc ], %o1 /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200ff10: 82 10 40 1a or %g1, %i2, %g1 /* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait, 200ff14: 90 07 bf d8 add %fp, -40, %o0 /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200ff18: c2 26 20 d0 st %g1, [ %i0 + 0xd0 ] /* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait, 200ff1c: 92 02 60 20 add %o1, 0x20, %o1 200ff20: 40 00 04 7c call 2011110 200ff24: 94 10 20 28 mov 0x28, %o2 sizeof( Thread_Wait_information )); /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 200ff28: c2 06 c0 1c ld [ %i3 + %i4 ], %g1 200ff2c: 80 a0 60 02 cmp %g1, 2 200ff30: 02 80 00 0e be 200ff68 <_POSIX_signals_Check_signal+0xb8> 200ff34: 90 10 00 19 mov %i1, %o0 &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 200ff38: 9f c7 40 00 call %i5 200ff3c: 01 00 00 00 nop } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 200ff40: d0 04 20 0c ld [ %l0 + 0xc ], %o0 200ff44: 92 07 bf d8 add %fp, -40, %o1 200ff48: 90 02 20 20 add %o0, 0x20, %o0 200ff4c: 40 00 04 71 call 2011110 200ff50: 94 10 20 28 mov 0x28, %o2 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; return true; 200ff54: 82 10 20 01 mov 1, %g1 sizeof( Thread_Wait_information )); /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 200ff58: f4 26 20 d0 st %i2, [ %i0 + 0xd0 ] return true; } 200ff5c: b0 08 60 01 and %g1, 1, %i0 200ff60: 81 c7 e0 08 ret 200ff64: 81 e8 00 00 restore /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 200ff68: 92 07 bf cc add %fp, -52, %o1 200ff6c: 9f c7 40 00 call %i5 200ff70: 94 10 20 00 clr %o2 signo, &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; 200ff74: 10 bf ff f4 b 200ff44 <_POSIX_signals_Check_signal+0x94> 200ff78: d0 04 20 0c ld [ %l0 + 0xc ], %o0 =============================================================================== 0201074c <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 201074c: 9d e3 bf a0 save %sp, -96, %sp 2010750: 84 10 20 01 mov 1, %g2 2010754: 82 06 3f ff add %i0, -1, %g1 clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 2010758: 7f ff c8 03 call 2002764 201075c: bb 28 80 01 sll %g2, %g1, %i5 if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 2010760: 05 00 80 7b sethi %hi(0x201ec00), %g2 2010764: 83 2e 20 02 sll %i0, 2, %g1 2010768: 84 10 a2 40 or %g2, 0x240, %g2 201076c: b1 2e 20 04 sll %i0, 4, %i0 2010770: 82 26 00 01 sub %i0, %g1, %g1 2010774: c4 00 80 01 ld [ %g2 + %g1 ], %g2 2010778: 80 a0 a0 02 cmp %g2, 2 201077c: 02 80 00 08 be 201079c <_POSIX_signals_Clear_process_signals+0x50> 2010780: 31 00 80 7c sethi %hi(0x201f000), %i0 if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 2010784: 03 00 80 7c sethi %hi(0x201f000), %g1 2010788: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 ! 201f034 <_POSIX_signals_Pending> 201078c: ba 28 80 1d andn %g2, %i5, %i5 2010790: fa 20 60 34 st %i5, [ %g1 + 0x34 ] } _ISR_Enable( level ); 2010794: 7f ff c7 f8 call 2002774 2010798: 91 e8 00 08 restore %g0, %o0, %o0 ISR_Level level; _ISR_Disable( level ); if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 201079c: b0 16 20 38 or %i0, 0x38, %i0 20107a0: c4 00 40 18 ld [ %g1 + %i0 ], %g2 20107a4: b0 00 40 18 add %g1, %i0, %i0 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 20107a8: b0 06 20 04 add %i0, 4, %i0 20107ac: 80 a0 80 18 cmp %g2, %i0 20107b0: 02 bf ff f6 be 2010788 <_POSIX_signals_Clear_process_signals+0x3c><== ALWAYS TAKEN 20107b4: 03 00 80 7c sethi %hi(0x201f000), %g1 clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; } _ISR_Enable( level ); 20107b8: 7f ff c7 ef call 2002774 <== NOT EXECUTED 20107bc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED =============================================================================== 02008994 <_POSIX_signals_Get_lowest>: sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 2008994: 82 10 20 1b mov 0x1b, %g1 2008998: 86 10 20 01 mov 1, %g3 #include #include #include #include static int _POSIX_signals_Get_lowest( 200899c: 84 00 7f ff add %g1, -1, %g2 20089a0: 85 28 c0 02 sll %g3, %g2, %g2 ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 20089a4: 80 88 80 08 btst %g2, %o0 20089a8: 12 80 00 11 bne 20089ec <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN 20089ac: 01 00 00 00 nop sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 20089b0: 82 00 60 01 inc %g1 20089b4: 80 a0 60 20 cmp %g1, 0x20 20089b8: 12 bf ff fa bne 20089a0 <_POSIX_signals_Get_lowest+0xc> 20089bc: 84 00 7f ff add %g1, -1, %g2 20089c0: 82 10 20 01 mov 1, %g1 20089c4: 10 80 00 05 b 20089d8 <_POSIX_signals_Get_lowest+0x44> 20089c8: 86 10 20 01 mov 1, %g3 */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 20089cc: 80 a0 60 1b cmp %g1, 0x1b 20089d0: 02 80 00 07 be 20089ec <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN 20089d4: 01 00 00 00 nop #include #include #include #include static int _POSIX_signals_Get_lowest( 20089d8: 84 00 7f ff add %g1, -1, %g2 20089dc: 85 28 c0 02 sll %g3, %g2, %g2 #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 20089e0: 80 88 80 08 btst %g2, %o0 20089e4: 22 bf ff fa be,a 20089cc <_POSIX_signals_Get_lowest+0x38> 20089e8: 82 00 60 01 inc %g1 * a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; } 20089ec: 81 c3 e0 08 retl 20089f0: 90 10 00 01 mov %g1, %o0 =============================================================================== 0200d3bc <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 200d3bc: 9d e3 bf a0 save %sp, -96, %sp /* * We need to ensure that if the signal handler executes a call * which overwrites the unblocking status, we restore it. */ hold_errno = _Thread_Executing->Wait.return_code; 200d3c0: 35 00 80 7b sethi %hi(0x201ec00), %i2 POSIX_API_Control *api; int signo; ISR_Level level; int hold_errno; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200d3c4: f8 06 21 5c ld [ %i0 + 0x15c ], %i4 /* * We need to ensure that if the signal handler executes a call * which overwrites the unblocking status, we restore it. */ hold_errno = _Thread_Executing->Wait.return_code; 200d3c8: b4 16 a1 e0 or %i2, 0x1e0, %i2 200d3cc: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 /* * api may be NULL in case of a thread close in progress */ if ( !api ) 200d3d0: 80 a7 20 00 cmp %i4, 0 200d3d4: 02 80 00 34 be 200d4a4 <_POSIX_signals_Post_switch_extension+0xe8> 200d3d8: f2 00 60 34 ld [ %g1 + 0x34 ], %i1 * * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { _ISR_Disable( level ); 200d3dc: 7f ff d4 e2 call 2002764 200d3e0: 37 00 80 7c sethi %hi(0x201f000), %i3 200d3e4: b6 16 e0 34 or %i3, 0x34, %i3 ! 201f034 <_POSIX_signals_Pending> if ( !(~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending)) ) { 200d3e8: c6 06 c0 00 ld [ %i3 ], %g3 200d3ec: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1 * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { _ISR_Disable( level ); if ( !(~api->signals_blocked & 200d3f0: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2 (api->signals_pending | _POSIX_signals_Pending)) ) { 200d3f4: 82 10 c0 01 or %g3, %g1, %g1 * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { _ISR_Disable( level ); if ( !(~api->signals_blocked & 200d3f8: 80 a8 40 02 andncc %g1, %g2, %g0 200d3fc: 02 80 00 26 be 200d494 <_POSIX_signals_Post_switch_extension+0xd8> 200d400: 01 00 00 00 nop (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); break; } _ISR_Enable( level ); 200d404: 7f ff d4 dc call 2002774 200d408: ba 10 20 1b mov 0x1b, %i5 ! 1b for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { _POSIX_signals_Check_signal( api, signo, false ); 200d40c: 92 10 00 1d mov %i5, %o1 200d410: 94 10 20 00 clr %o2 200d414: 40 00 0a a7 call 200feb0 <_POSIX_signals_Check_signal> 200d418: 90 10 00 1c mov %i4, %o0 _POSIX_signals_Check_signal( api, signo, true ); 200d41c: 92 10 00 1d mov %i5, %o1 200d420: 90 10 00 1c mov %i4, %o0 200d424: 40 00 0a a3 call 200feb0 <_POSIX_signals_Check_signal> 200d428: 94 10 20 01 mov 1, %o2 _ISR_Enable( level ); break; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 200d42c: ba 07 60 01 inc %i5 200d430: 80 a7 60 20 cmp %i5, 0x20 200d434: 12 bf ff f7 bne 200d410 <_POSIX_signals_Post_switch_extension+0x54> 200d438: 92 10 00 1d mov %i5, %o1 200d43c: ba 10 20 01 mov 1, %i5 _POSIX_signals_Check_signal( api, signo, true ); } /* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { _POSIX_signals_Check_signal( api, signo, false ); 200d440: 92 10 00 1d mov %i5, %o1 200d444: 94 10 20 00 clr %o2 200d448: 40 00 0a 9a call 200feb0 <_POSIX_signals_Check_signal> 200d44c: 90 10 00 1c mov %i4, %o0 _POSIX_signals_Check_signal( api, signo, true ); 200d450: 92 10 00 1d mov %i5, %o1 200d454: 90 10 00 1c mov %i4, %o0 200d458: 40 00 0a 96 call 200feb0 <_POSIX_signals_Check_signal> 200d45c: 94 10 20 01 mov 1, %o2 _POSIX_signals_Check_signal( api, signo, false ); _POSIX_signals_Check_signal( api, signo, true ); } /* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 200d460: ba 07 60 01 inc %i5 200d464: 80 a7 60 1b cmp %i5, 0x1b 200d468: 12 bf ff f7 bne 200d444 <_POSIX_signals_Post_switch_extension+0x88> 200d46c: 92 10 00 1d mov %i5, %o1 * * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { _ISR_Disable( level ); 200d470: 7f ff d4 bd call 2002764 200d474: 01 00 00 00 nop if ( !(~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending)) ) { 200d478: c6 06 c0 00 ld [ %i3 ], %g3 200d47c: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1 * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { _ISR_Disable( level ); if ( !(~api->signals_blocked & 200d480: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2 (api->signals_pending | _POSIX_signals_Pending)) ) { 200d484: 82 10 c0 01 or %g3, %g1, %g1 * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { _ISR_Disable( level ); if ( !(~api->signals_blocked & 200d488: 80 a8 40 02 andncc %g1, %g2, %g0 200d48c: 12 bf ff de bne 200d404 <_POSIX_signals_Post_switch_extension+0x48><== NEVER TAKEN 200d490: 01 00 00 00 nop (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 200d494: 7f ff d4 b8 call 2002774 200d498: 01 00 00 00 nop _POSIX_signals_Check_signal( api, signo, false ); _POSIX_signals_Check_signal( api, signo, true ); } } _Thread_Executing->Wait.return_code = hold_errno; 200d49c: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 200d4a0: f2 20 60 34 st %i1, [ %g1 + 0x34 ] 200d4a4: 81 c7 e0 08 ret 200d4a8: 81 e8 00 00 restore =============================================================================== 0201b3ec <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 201b3ec: 9d e3 bf a0 save %sp, -96, %sp /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 201b3f0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 201b3f4: 05 04 00 20 sethi %hi(0x10008000), %g2 201b3f8: 88 10 20 01 mov 1, %g4 201b3fc: 86 06 7f ff add %i1, -1, %g3 201b400: ba 08 40 02 and %g1, %g2, %i5 { POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 201b404: f8 06 21 5c ld [ %i0 + 0x15c ], %i4 /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 201b408: 80 a7 40 02 cmp %i5, %g2 201b40c: 02 80 00 2c be 201b4bc <_POSIX_signals_Unblock_thread+0xd0> 201b410: 87 29 00 03 sll %g4, %g3, %g3 } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 201b414: c4 07 20 d0 ld [ %i4 + 0xd0 ], %g2 201b418: 80 a8 c0 02 andncc %g3, %g2, %g0 201b41c: 02 80 00 24 be 201b4ac <_POSIX_signals_Unblock_thread+0xc0> 201b420: 05 04 00 00 sethi %hi(0x10000000), %g2 * it is not blocked, THEN * we need to dispatch at the end of this ISR. * + Any other combination, do nothing. */ if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) { 201b424: 80 88 40 02 btst %g1, %g2 201b428: 02 80 00 15 be 201b47c <_POSIX_signals_Unblock_thread+0x90> 201b42c: 80 a0 60 00 cmp %g1, 0 the_thread->Wait.return_code = EINTR; 201b430: 84 10 20 04 mov 4, %g2 201b434: c4 26 20 34 st %g2, [ %i0 + 0x34 ] */ RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue ( States_Control the_states ) { return (the_states & STATES_WAITING_ON_THREAD_QUEUE); 201b438: 05 00 00 ef sethi %hi(0x3bc00), %g2 201b43c: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 3bee0 /* * In pthread_cond_wait, a thread will be blocking on a thread * queue, but is also interruptible by a POSIX signal. */ if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 201b440: 80 88 40 02 btst %g1, %g2 201b444: 12 80 00 38 bne 201b524 <_POSIX_signals_Unblock_thread+0x138> 201b448: 80 88 60 08 btst 8, %g1 _Thread_queue_Extract_with_proxy( the_thread ); else if ( _States_Is_delaying(the_thread->current_state) ) { 201b44c: 22 80 00 19 be,a 201b4b0 <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN 201b450: b0 10 20 00 clr %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 201b454: 7f ff c1 04 call 200b864 <_Watchdog_Remove> 201b458: 90 06 20 48 add %i0, 0x48, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 201b45c: 90 10 00 18 mov %i0, %o0 201b460: 13 04 00 ff sethi %hi(0x1003fc00), %o1 } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; 201b464: b0 10 20 00 clr %i0 201b468: 7f ff bc 2b call 200a514 <_Thread_Clear_state> 201b46c: 92 12 63 f8 or %o1, 0x3f8, %o1 201b470: b0 0e 20 01 and %i0, 1, %i0 201b474: 81 c7 e0 08 ret 201b478: 81 e8 00 00 restore else if ( _States_Is_delaying(the_thread->current_state) ) { (void) _Watchdog_Remove( &the_thread->Timer ); _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 201b47c: 32 80 00 0d bne,a 201b4b0 <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN 201b480: b0 10 20 00 clr %i0 <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 201b484: 03 00 80 7b sethi %hi(0x201ec00), %g1 201b488: 82 10 61 e0 or %g1, 0x1e0, %g1 ! 201ede0 <_Per_CPU_Information> 201b48c: c4 00 60 08 ld [ %g1 + 8 ], %g2 201b490: 80 a0 a0 00 cmp %g2, 0 201b494: 22 80 00 07 be,a 201b4b0 <_POSIX_signals_Unblock_thread+0xc4> 201b498: b0 10 20 00 clr %i0 201b49c: c4 00 60 0c ld [ %g1 + 0xc ], %g2 201b4a0: 80 a6 00 02 cmp %i0, %g2 201b4a4: 22 80 00 02 be,a 201b4ac <_POSIX_signals_Unblock_thread+0xc0><== ALWAYS TAKEN 201b4a8: c8 28 60 18 stb %g4, [ %g1 + 0x18 ] _Thread_Dispatch_necessary = true; } } return false; 201b4ac: b0 10 20 00 clr %i0 } 201b4b0: b0 0e 20 01 and %i0, 1, %i0 201b4b4: 81 c7 e0 08 ret 201b4b8: 81 e8 00 00 restore * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 201b4bc: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 201b4c0: 80 88 c0 01 btst %g3, %g1 201b4c4: 22 80 00 13 be,a 201b510 <_POSIX_signals_Unblock_thread+0x124> 201b4c8: c2 07 20 d0 ld [ %i4 + 0xd0 ], %g1 the_thread->Wait.return_code = EINTR; 201b4cc: 82 10 20 04 mov 4, %g1 201b4d0: c2 26 20 34 st %g1, [ %i0 + 0x34 ] the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { 201b4d4: 80 a6 a0 00 cmp %i2, 0 201b4d8: 02 80 00 19 be 201b53c <_POSIX_signals_Unblock_thread+0x150> 201b4dc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 the_info->si_signo = signo; the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; } else { *the_info = *info; 201b4e0: c4 06 80 00 ld [ %i2 ], %g2 201b4e4: c4 20 40 00 st %g2, [ %g1 ] 201b4e8: c4 06 a0 04 ld [ %i2 + 4 ], %g2 201b4ec: c4 20 60 04 st %g2, [ %g1 + 4 ] 201b4f0: c4 06 a0 08 ld [ %i2 + 8 ], %g2 201b4f4: c4 20 60 08 st %g2, [ %g1 + 8 ] } _Thread_queue_Extract_with_proxy( the_thread ); 201b4f8: 90 10 00 18 mov %i0, %o0 201b4fc: 7f ff be f1 call 200b0c0 <_Thread_queue_Extract_with_proxy> 201b500: b0 10 20 01 mov 1, %i0 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; } 201b504: b0 0e 20 01 and %i0, 1, %i0 201b508: 81 c7 e0 08 ret 201b50c: 81 e8 00 00 restore * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 201b510: 80 a8 c0 01 andncc %g3, %g1, %g0 201b514: 32 bf ff ef bne,a 201b4d0 <_POSIX_signals_Unblock_thread+0xe4> 201b518: 82 10 20 04 mov 4, %g1 } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; 201b51c: 10 bf ff e5 b 201b4b0 <_POSIX_signals_Unblock_thread+0xc4> 201b520: b0 10 20 00 clr %i0 /* * In pthread_cond_wait, a thread will be blocking on a thread * queue, but is also interruptible by a POSIX signal. */ if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); 201b524: 90 10 00 18 mov %i0, %o0 201b528: 7f ff be e6 call 200b0c0 <_Thread_queue_Extract_with_proxy> 201b52c: b0 10 20 00 clr %i0 201b530: b0 0e 20 01 and %i0, 1, %i0 201b534: 81 c7 e0 08 ret 201b538: 81 e8 00 00 restore the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; the_info->si_code = SI_USER; 201b53c: 84 10 20 01 mov 1, %g2 the_thread->Wait.return_code = EINTR; the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; 201b540: f2 20 40 00 st %i1, [ %g1 ] the_info->si_code = SI_USER; 201b544: c4 20 60 04 st %g2, [ %g1 + 4 ] the_info->si_value.sival_int = 0; 201b548: 10 bf ff ec b 201b4f8 <_POSIX_signals_Unblock_thread+0x10c> 201b54c: c0 20 60 08 clr [ %g1 + 8 ] =============================================================================== 0200ab28 <_RBTree_Extract_unprotected>: */ void _RBTree_Extract_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { 200ab28: 9d e3 bf a0 save %sp, -96, %sp RBTree_Node *leaf, *target; RBTree_Color victim_color; RBTree_Direction dir; if (!the_node) return; 200ab2c: 80 a6 60 00 cmp %i1, 0 200ab30: 02 80 00 4c be 200ac60 <_RBTree_Extract_unprotected+0x138> 200ab34: 01 00 00 00 nop /* check if min needs to be updated */ if (the_node == the_rbtree->first[RBT_LEFT]) { 200ab38: c2 06 20 08 ld [ %i0 + 8 ], %g1 200ab3c: 80 a0 40 19 cmp %g1, %i1 200ab40: 02 80 00 56 be 200ac98 <_RBTree_Extract_unprotected+0x170> 200ab44: 90 10 00 19 mov %i1, %o0 the_rbtree->first[RBT_LEFT] = next; } /* Check if max needs to be updated. min=max for 1 element trees so * do not use else if here. */ if (the_node == the_rbtree->first[RBT_RIGHT]) { 200ab48: c2 06 20 0c ld [ %i0 + 0xc ], %g1 200ab4c: 80 a0 40 19 cmp %g1, %i1 200ab50: 02 80 00 56 be 200aca8 <_RBTree_Extract_unprotected+0x180> 200ab54: 90 10 00 19 mov %i1, %o0 * either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT], * and replace the_node with the target node. This maintains the binary * search tree property, but may violate the red-black properties. */ if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) { 200ab58: fa 06 60 04 ld [ %i1 + 4 ], %i5 200ab5c: 80 a7 60 00 cmp %i5, 0 200ab60: 22 80 00 5a be,a 200acc8 <_RBTree_Extract_unprotected+0x1a0> 200ab64: f8 06 60 08 ld [ %i1 + 8 ], %i4 200ab68: c2 06 60 08 ld [ %i1 + 8 ], %g1 200ab6c: 80 a0 60 00 cmp %g1, 0 200ab70: 32 80 00 05 bne,a 200ab84 <_RBTree_Extract_unprotected+0x5c> 200ab74: c2 07 60 08 ld [ %i5 + 8 ], %g1 200ab78: 10 80 00 3c b 200ac68 <_RBTree_Extract_unprotected+0x140> 200ab7c: b8 10 00 1d mov %i5, %i4 target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */ while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT]; 200ab80: c2 07 60 08 ld [ %i5 + 8 ], %g1 200ab84: 80 a0 60 00 cmp %g1, 0 200ab88: 32 bf ff fe bne,a 200ab80 <_RBTree_Extract_unprotected+0x58> 200ab8c: ba 10 00 01 mov %g1, %i5 * target's position (target is the right child of target->parent) * when target vacates it. if there is no child, then target->parent * should become NULL. This may cause the coloring to be violated. * For now we store the color of the node being deleted in victim_color. */ leaf = target->child[RBT_LEFT]; 200ab90: f8 07 60 04 ld [ %i5 + 4 ], %i4 if(leaf) { 200ab94: 80 a7 20 00 cmp %i4, 0 200ab98: 02 80 00 48 be 200acb8 <_RBTree_Extract_unprotected+0x190> 200ab9c: 01 00 00 00 nop leaf->parent = target->parent; 200aba0: c2 07 40 00 ld [ %i5 ], %g1 200aba4: c2 27 00 00 st %g1, [ %i4 ] } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(target); } victim_color = target->color; dir = target != target->parent->child[0]; 200aba8: c4 07 40 00 ld [ %i5 ], %g2 target->parent->child[dir] = leaf; /* now replace the_node with target */ dir = the_node != the_node->parent->child[0]; 200abac: c2 06 40 00 ld [ %i1 ], %g1 } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(target); } victim_color = target->color; dir = target != target->parent->child[0]; 200abb0: c8 00 a0 04 ld [ %g2 + 4 ], %g4 leaf->parent = target->parent; } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(target); } victim_color = target->color; 200abb4: c6 07 60 0c ld [ %i5 + 0xc ], %g3 dir = target != target->parent->child[0]; 200abb8: 88 1f 40 04 xor %i5, %g4, %g4 200abbc: 80 a0 00 04 cmp %g0, %g4 200abc0: 88 40 20 00 addx %g0, 0, %g4 target->parent->child[dir] = leaf; 200abc4: 89 29 20 02 sll %g4, 2, %g4 200abc8: 84 00 80 04 add %g2, %g4, %g2 200abcc: f8 20 a0 04 st %i4, [ %g2 + 4 ] /* now replace the_node with target */ dir = the_node != the_node->parent->child[0]; 200abd0: c4 00 60 04 ld [ %g1 + 4 ], %g2 200abd4: 84 18 80 19 xor %g2, %i1, %g2 200abd8: 80 a0 00 02 cmp %g0, %g2 200abdc: 84 40 20 00 addx %g0, 0, %g2 the_node->parent->child[dir] = target; 200abe0: 85 28 a0 02 sll %g2, 2, %g2 200abe4: 82 00 40 02 add %g1, %g2, %g1 200abe8: fa 20 60 04 st %i5, [ %g1 + 4 ] /* set target's new children to the original node's children */ target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT]; 200abec: c2 06 60 08 ld [ %i1 + 8 ], %g1 200abf0: c2 27 60 08 st %g1, [ %i5 + 8 ] if (the_node->child[RBT_RIGHT]) 200abf4: c2 06 60 08 ld [ %i1 + 8 ], %g1 200abf8: 80 a0 60 00 cmp %g1, 0 200abfc: 32 80 00 02 bne,a 200ac04 <_RBTree_Extract_unprotected+0xdc><== ALWAYS TAKEN 200ac00: fa 20 40 00 st %i5, [ %g1 ] the_node->child[RBT_RIGHT]->parent = target; target->child[RBT_LEFT] = the_node->child[RBT_LEFT]; 200ac04: c2 06 60 04 ld [ %i1 + 4 ], %g1 200ac08: c2 27 60 04 st %g1, [ %i5 + 4 ] if (the_node->child[RBT_LEFT]) 200ac0c: c2 06 60 04 ld [ %i1 + 4 ], %g1 200ac10: 80 a0 60 00 cmp %g1, 0 200ac14: 32 80 00 02 bne,a 200ac1c <_RBTree_Extract_unprotected+0xf4> 200ac18: fa 20 40 00 st %i5, [ %g1 ] /* finally, update the parent node and recolor. target has completely * replaced the_node, and target's child has moved up the tree if needed. * the_node is no longer part of the tree, although it has valid pointers * still. */ target->parent = the_node->parent; 200ac1c: c4 06 40 00 ld [ %i1 ], %g2 target->color = the_node->color; 200ac20: c2 06 60 0c ld [ %i1 + 0xc ], %g1 /* finally, update the parent node and recolor. target has completely * replaced the_node, and target's child has moved up the tree if needed. * the_node is no longer part of the tree, although it has valid pointers * still. */ target->parent = the_node->parent; 200ac24: c4 27 40 00 st %g2, [ %i5 ] target->color = the_node->color; 200ac28: c2 27 60 0c st %g1, [ %i5 + 0xc ] /* fix coloring. leaf has moved up the tree. The color of the deleted * node is in victim_color. There are two cases: * 1. Deleted a red node, its child must be black. Nothing must be done. * 2. Deleted a black node, its child must be red. Paint child black. */ if (victim_color == RBT_BLACK) { /* eliminate case 1 */ 200ac2c: 80 a0 e0 00 cmp %g3, 0 200ac30: 32 80 00 06 bne,a 200ac48 <_RBTree_Extract_unprotected+0x120> 200ac34: c2 06 20 04 ld [ %i0 + 4 ], %g1 if (leaf) { 200ac38: 80 a7 20 00 cmp %i4, 0 200ac3c: 32 80 00 02 bne,a 200ac44 <_RBTree_Extract_unprotected+0x11c> 200ac40: c0 27 20 0c clr [ %i4 + 0xc ] /* Wipe the_node */ _RBTree_Set_off_rbtree(the_node); /* set root to black, if it exists */ if (the_rbtree->root) the_rbtree->root->color = RBT_BLACK; 200ac44: c2 06 20 04 ld [ %i0 + 4 ], %g1 */ RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree( RBTree_Node *node ) { node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL; 200ac48: c0 26 60 08 clr [ %i1 + 8 ] 200ac4c: c0 26 60 04 clr [ %i1 + 4 ] 200ac50: 80 a0 60 00 cmp %g1, 0 200ac54: 02 80 00 03 be 200ac60 <_RBTree_Extract_unprotected+0x138> 200ac58: c0 26 40 00 clr [ %i1 ] 200ac5c: c0 20 60 0c clr [ %g1 + 0xc ] 200ac60: 81 c7 e0 08 ret 200ac64: 81 e8 00 00 restore * For now we store the color of the node being deleted in victim_color. */ leaf = the_node->child[RBT_LEFT] ? the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT]; if( leaf ) { leaf->parent = the_node->parent; 200ac68: c2 06 40 00 ld [ %i1 ], %g1 200ac6c: c2 27 00 00 st %g1, [ %i4 ] _RBTree_Extract_validate_unprotected(the_node); } victim_color = the_node->color; /* remove the_node from the tree */ dir = the_node != the_node->parent->child[0]; 200ac70: c2 06 40 00 ld [ %i1 ], %g1 leaf->parent = the_node->parent; } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(the_node); } victim_color = the_node->color; 200ac74: c6 06 60 0c ld [ %i1 + 0xc ], %g3 /* remove the_node from the tree */ dir = the_node != the_node->parent->child[0]; 200ac78: c4 00 60 04 ld [ %g1 + 4 ], %g2 200ac7c: 84 18 80 19 xor %g2, %i1, %g2 200ac80: 80 a0 00 02 cmp %g0, %g2 200ac84: 84 40 20 00 addx %g0, 0, %g2 the_node->parent->child[dir] = leaf; 200ac88: 85 28 a0 02 sll %g2, 2, %g2 200ac8c: 82 00 40 02 add %g1, %g2, %g1 200ac90: 10 bf ff e7 b 200ac2c <_RBTree_Extract_unprotected+0x104> 200ac94: f8 20 60 04 st %i4, [ %g1 + 4 ] */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected( const RBTree_Node *node ) { return _RBTree_Next_unprotected( node, RBT_RIGHT ); 200ac98: 40 00 00 eb call 200b044 <_RBTree_Next_unprotected> 200ac9c: 92 10 20 01 mov 1, %o1 /* check if min needs to be updated */ if (the_node == the_rbtree->first[RBT_LEFT]) { RBTree_Node *next; next = _RBTree_Successor_unprotected(the_node); the_rbtree->first[RBT_LEFT] = next; 200aca0: 10 bf ff aa b 200ab48 <_RBTree_Extract_unprotected+0x20> 200aca4: d0 26 20 08 st %o0, [ %i0 + 8 ] */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected( const RBTree_Node *node ) { return _RBTree_Next_unprotected( node, RBT_LEFT ); 200aca8: 40 00 00 e7 call 200b044 <_RBTree_Next_unprotected> 200acac: 92 10 20 00 clr %o1 /* Check if max needs to be updated. min=max for 1 element trees so * do not use else if here. */ if (the_node == the_rbtree->first[RBT_RIGHT]) { RBTree_Node *previous; previous = _RBTree_Predecessor_unprotected(the_node); the_rbtree->first[RBT_RIGHT] = previous; 200acb0: 10 bf ff aa b 200ab58 <_RBTree_Extract_unprotected+0x30> 200acb4: d0 26 20 0c st %o0, [ %i0 + 0xc ] leaf = target->child[RBT_LEFT]; if(leaf) { leaf->parent = target->parent; } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(target); 200acb8: 7f ff fe d3 call 200a804 <_RBTree_Extract_validate_unprotected> 200acbc: 90 10 00 1d mov %i5, %o0 } victim_color = target->color; dir = target != target->parent->child[0]; 200acc0: 10 bf ff bb b 200abac <_RBTree_Extract_unprotected+0x84> 200acc4: c4 07 40 00 ld [ %i5 ], %g2 * violated. We will fix it later. * For now we store the color of the node being deleted in victim_color. */ leaf = the_node->child[RBT_LEFT] ? the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT]; if( leaf ) { 200acc8: 80 a7 20 00 cmp %i4, 0 200accc: 32 bf ff e8 bne,a 200ac6c <_RBTree_Extract_unprotected+0x144> 200acd0: c2 06 40 00 ld [ %i1 ], %g1 leaf->parent = the_node->parent; } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(the_node); 200acd4: 7f ff fe cc call 200a804 <_RBTree_Extract_validate_unprotected> 200acd8: 90 10 00 19 mov %i1, %o0 } victim_color = the_node->color; /* remove the_node from the tree */ dir = the_node != the_node->parent->child[0]; 200acdc: 10 bf ff e6 b 200ac74 <_RBTree_Extract_unprotected+0x14c> 200ace0: c2 06 40 00 ld [ %i1 ], %g1 =============================================================================== 0200a804 <_RBTree_Extract_validate_unprotected>: ) { RBTree_Node *parent, *sibling; RBTree_Direction dir; parent = the_node->parent; 200a804: c2 02 00 00 ld [ %o0 ], %g1 if(!parent->parent) return; 200a808: c4 00 40 00 ld [ %g1 ], %g2 200a80c: 80 a0 a0 00 cmp %g2, 0 200a810: 02 80 00 3f be 200a90c <_RBTree_Extract_validate_unprotected+0x108> 200a814: 01 00 00 00 nop { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; if(the_node == the_node->parent->child[RBT_LEFT]) 200a818: c4 00 60 04 ld [ %g1 + 4 ], %g2 200a81c: 80 a2 00 02 cmp %o0, %g2 200a820: 22 80 00 02 be,a 200a828 <_RBTree_Extract_validate_unprotected+0x24> 200a824: c4 00 60 08 ld [ %g1 + 8 ], %g2 */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 200a828: c6 02 20 0c ld [ %o0 + 0xc ], %g3 200a82c: 80 a0 e0 01 cmp %g3, 1 200a830: 02 80 00 32 be 200a8f8 <_RBTree_Extract_validate_unprotected+0xf4> 200a834: 9a 10 20 01 mov 1, %o5 sibling = _RBTree_Sibling(the_node); /* continue to correct tree as long as the_node is black and not the root */ while (!_RBTree_Is_red(the_node) && parent->parent) { 200a838: c6 00 40 00 ld [ %g1 ], %g3 200a83c: 80 a0 e0 00 cmp %g3, 0 200a840: 02 80 00 2e be 200a8f8 <_RBTree_Extract_validate_unprotected+0xf4> 200a844: 80 a0 a0 00 cmp %g2, 0 200a848: 22 80 00 07 be,a 200a864 <_RBTree_Extract_validate_unprotected+0x60><== NEVER TAKEN 200a84c: c6 00 a0 08 ld [ %g2 + 8 ], %g3 <== NOT EXECUTED 200a850: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 200a854: 80 a1 20 01 cmp %g4, 1 200a858: 22 80 00 63 be,a 200a9e4 <_RBTree_Extract_validate_unprotected+0x1e0> 200a85c: d8 00 60 04 ld [ %g1 + 4 ], %o4 _RBTree_Rotate(parent, dir); sibling = parent->child[_RBTree_Opposite_direction(dir)]; } /* sibling is black, see if both of its children are also black. */ if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) && 200a860: c6 00 a0 08 ld [ %g2 + 8 ], %g3 200a864: 80 a0 e0 00 cmp %g3, 0 200a868: 22 80 00 07 be,a 200a884 <_RBTree_Extract_validate_unprotected+0x80> 200a86c: c6 00 a0 04 ld [ %g2 + 4 ], %g3 200a870: c6 00 e0 0c ld [ %g3 + 0xc ], %g3 200a874: 80 a0 e0 01 cmp %g3, 1 200a878: 22 80 00 29 be,a 200a91c <_RBTree_Extract_validate_unprotected+0x118> 200a87c: c6 00 60 04 ld [ %g1 + 4 ], %g3 !_RBTree_Is_red(sibling->child[RBT_LEFT])) { 200a880: c6 00 a0 04 ld [ %g2 + 4 ], %g3 200a884: 80 a0 e0 00 cmp %g3, 0 200a888: 22 80 00 07 be,a 200a8a4 <_RBTree_Extract_validate_unprotected+0xa0> 200a88c: da 20 a0 0c st %o5, [ %g2 + 0xc ] 200a890: c6 00 e0 0c ld [ %g3 + 0xc ], %g3 200a894: 80 a0 e0 01 cmp %g3, 1 200a898: 22 80 00 21 be,a 200a91c <_RBTree_Extract_validate_unprotected+0x118> 200a89c: c6 00 60 04 ld [ %g1 + 4 ], %g3 sibling->color = RBT_RED; 200a8a0: da 20 a0 0c st %o5, [ %g2 + 0xc ] 200a8a4: c4 00 60 0c ld [ %g1 + 0xc ], %g2 200a8a8: 80 a0 a0 01 cmp %g2, 1 200a8ac: 22 80 00 99 be,a 200ab10 <_RBTree_Extract_validate_unprotected+0x30c> 200a8b0: c0 20 60 0c clr [ %g1 + 0xc ] if (_RBTree_Is_red(parent)) { parent->color = RBT_BLACK; break; } the_node = parent; /* done if parent is red */ parent = the_node->parent; 200a8b4: c6 00 40 00 ld [ %g1 ], %g3 RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; 200a8b8: 80 a0 e0 00 cmp %g3, 0 200a8bc: 02 80 00 6c be 200aa6c <_RBTree_Extract_validate_unprotected+0x268><== NEVER TAKEN 200a8c0: 90 10 00 01 mov %g1, %o0 if(!(the_node->parent->parent)) return NULL; 200a8c4: c4 00 c0 00 ld [ %g3 ], %g2 200a8c8: 80 a0 a0 00 cmp %g2, 0 200a8cc: 02 80 00 69 be 200aa70 <_RBTree_Extract_validate_unprotected+0x26c> 200a8d0: 84 10 20 00 clr %g2 if(the_node == the_node->parent->child[RBT_LEFT]) 200a8d4: c4 00 e0 04 ld [ %g3 + 4 ], %g2 200a8d8: 80 a0 40 02 cmp %g1, %g2 200a8dc: 22 80 00 0e be,a 200a914 <_RBTree_Extract_validate_unprotected+0x110> 200a8e0: c4 00 e0 08 ld [ %g3 + 8 ], %g2 RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; 200a8e4: 82 10 00 03 mov %g3, %g1 */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 200a8e8: c6 02 20 0c ld [ %o0 + 0xc ], %g3 200a8ec: 80 a0 e0 01 cmp %g3, 1 200a8f0: 32 bf ff d3 bne,a 200a83c <_RBTree_Extract_validate_unprotected+0x38><== ALWAYS TAKEN 200a8f4: c6 00 40 00 ld [ %g1 ], %g3 sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK; _RBTree_Rotate(parent, dir); break; /* done */ } } /* while */ if(!the_node->parent->parent) the_node->color = RBT_BLACK; 200a8f8: c2 02 00 00 ld [ %o0 ], %g1 200a8fc: c2 00 40 00 ld [ %g1 ], %g1 200a900: 80 a0 60 00 cmp %g1, 0 200a904: 02 80 00 5f be 200aa80 <_RBTree_Extract_validate_unprotected+0x27c> 200a908: 01 00 00 00 nop 200a90c: 81 c3 e0 08 retl 200a910: 01 00 00 00 nop RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; 200a914: 10 bf ff f5 b 200a8e8 <_RBTree_Extract_validate_unprotected+0xe4> 200a918: 82 10 00 03 mov %g3, %g1 * cases, either the_node is to the left or the right of the parent. * In both cases, first check if one of sibling's children is black, * and if so rotate in the proper direction and update sibling pointer. * Then switch the sibling and parent colors, and rotate through parent. */ dir = the_node != parent->child[0]; 200a91c: 86 1a 00 03 xor %o0, %g3, %g3 200a920: 80 a0 00 03 cmp %g0, %g3 200a924: 9a 40 20 00 addx %g0, 0, %o5 */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 200a928: 86 1b 60 01 xor %o5, 1, %g3 if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) { 200a92c: 87 28 e0 02 sll %g3, 2, %g3 200a930: 88 00 80 03 add %g2, %g3, %g4 200a934: c8 01 20 04 ld [ %g4 + 4 ], %g4 */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 200a938: 80 a1 20 00 cmp %g4, 0 200a93c: 22 80 00 07 be,a 200a958 <_RBTree_Extract_validate_unprotected+0x154> 200a940: 9b 2b 60 02 sll %o5, 2, %o5 200a944: d8 01 20 0c ld [ %g4 + 0xc ], %o4 200a948: 80 a3 20 01 cmp %o4, 1 200a94c: 22 80 00 4f be,a 200aa88 <_RBTree_Extract_validate_unprotected+0x284> 200a950: d6 00 60 0c ld [ %g1 + 0xc ], %o3 sibling->color = RBT_RED; sibling->child[dir]->color = RBT_BLACK; 200a954: 9b 2b 60 02 sll %o5, 2, %o5 200a958: 98 00 80 0d add %g2, %o5, %o4 200a95c: c8 03 20 04 ld [ %o4 + 4 ], %g4 * and if so rotate in the proper direction and update sibling pointer. * Then switch the sibling and parent colors, and rotate through parent. */ dir = the_node != parent->child[0]; if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) { sibling->color = RBT_RED; 200a960: 96 10 20 01 mov 1, %o3 200a964: d6 20 a0 0c st %o3, [ %g2 + 0xc ] RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 200a968: 80 a1 20 00 cmp %g4, 0 200a96c: 02 80 00 15 be 200a9c0 <_RBTree_Extract_validate_unprotected+0x1bc><== NEVER TAKEN 200a970: c0 21 20 0c clr [ %g4 + 0xc ] c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 200a974: 96 01 00 03 add %g4, %g3, %o3 200a978: d4 02 e0 04 ld [ %o3 + 4 ], %o2 200a97c: d4 23 20 04 st %o2, [ %o4 + 4 ] if (c->child[dir]) 200a980: d8 02 e0 04 ld [ %o3 + 4 ], %o4 200a984: 80 a3 20 00 cmp %o4, 0 200a988: 32 80 00 02 bne,a 200a990 <_RBTree_Extract_validate_unprotected+0x18c> 200a98c: c4 23 00 00 st %g2, [ %o4 ] c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200a990: d8 00 80 00 ld [ %g2 ], %o4 the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; 200a994: 96 01 00 03 add %g4, %g3, %o3 200a998: c4 22 e0 04 st %g2, [ %o3 + 4 ] the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200a99c: d6 03 20 04 ld [ %o4 + 4 ], %o3 c->parent = the_node->parent; 200a9a0: d8 21 00 00 st %o4, [ %g4 ] if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200a9a4: 96 18 80 0b xor %g2, %o3, %o3 c->parent = the_node->parent; the_node->parent = c; 200a9a8: c8 20 80 00 st %g4, [ %g2 ] if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200a9ac: 80 a0 00 0b cmp %g0, %o3 200a9b0: 84 40 20 00 addx %g0, 0, %g2 200a9b4: 85 28 a0 02 sll %g2, 2, %g2 200a9b8: 98 03 00 02 add %o4, %g2, %o4 200a9bc: c8 23 20 04 st %g4, [ %o4 + 4 ] sibling->child[dir]->color = RBT_BLACK; _RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir)); sibling = parent->child[_RBTree_Opposite_direction(dir)]; } sibling->color = parent->color; 200a9c0: c8 00 60 0c ld [ %g1 + 0xc ], %g4 dir = the_node != parent->child[0]; if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) { sibling->color = RBT_RED; sibling->child[dir]->color = RBT_BLACK; _RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir)); sibling = parent->child[_RBTree_Opposite_direction(dir)]; 200a9c4: 84 00 40 03 add %g1, %g3, %g2 200a9c8: c4 00 a0 04 ld [ %g2 + 4 ], %g2 } sibling->color = parent->color; 200a9cc: c8 20 a0 0c st %g4, [ %g2 + 0xc ] 200a9d0: 88 00 80 03 add %g2, %g3, %g4 200a9d4: c8 01 20 04 ld [ %g4 + 4 ], %g4 parent->color = RBT_BLACK; 200a9d8: c0 20 60 0c clr [ %g1 + 0xc ] sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK; 200a9dc: 10 80 00 33 b 200aaa8 <_RBTree_Extract_validate_unprotected+0x2a4> 200a9e0: c0 21 20 0c clr [ %g4 + 0xc ] * then rotate parent left, making the sibling be the_node's grandparent. * Now the_node has a black sibling and red parent. After rotation, * update sibling pointer. */ if (_RBTree_Is_red(sibling)) { parent->color = RBT_RED; 200a9e4: c8 20 60 0c st %g4, [ %g1 + 0xc ] sibling->color = RBT_BLACK; dir = the_node != parent->child[0]; 200a9e8: 88 1b 00 08 xor %o4, %o0, %g4 200a9ec: 80 a0 00 04 cmp %g0, %g4 200a9f0: 94 40 20 00 addx %g0, 0, %o2 */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 200a9f4: 96 1a a0 01 xor %o2, 1, %o3 RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 200a9f8: 97 2a e0 02 sll %o3, 2, %o3 200a9fc: 98 00 40 0b add %g1, %o3, %o4 200aa00: c8 03 20 04 ld [ %o4 + 4 ], %g4 200aa04: 80 a1 20 00 cmp %g4, 0 200aa08: 02 80 00 1c be 200aa78 <_RBTree_Extract_validate_unprotected+0x274><== NEVER TAKEN 200aa0c: c0 20 a0 0c clr [ %g2 + 0xc ] c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 200aa10: 95 2a a0 02 sll %o2, 2, %o2 200aa14: 84 01 00 0a add %g4, %o2, %g2 200aa18: d2 00 a0 04 ld [ %g2 + 4 ], %o1 200aa1c: d2 23 20 04 st %o1, [ %o4 + 4 ] if (c->child[dir]) 200aa20: c4 00 a0 04 ld [ %g2 + 4 ], %g2 200aa24: 80 a0 a0 00 cmp %g2, 0 200aa28: 02 80 00 04 be 200aa38 <_RBTree_Extract_validate_unprotected+0x234><== NEVER TAKEN 200aa2c: 94 01 00 0a add %g4, %o2, %o2 c->child[dir]->parent = the_node; 200aa30: c2 20 80 00 st %g1, [ %g2 ] 200aa34: c6 00 40 00 ld [ %g1 ], %g3 c->child[dir] = the_node; 200aa38: c2 22 a0 04 st %g1, [ %o2 + 4 ] the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200aa3c: c4 00 e0 04 ld [ %g3 + 4 ], %g2 c->parent = the_node->parent; 200aa40: c6 21 00 00 st %g3, [ %g4 ] if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200aa44: 84 18 40 02 xor %g1, %g2, %g2 200aa48: 80 a0 00 02 cmp %g0, %g2 200aa4c: 84 40 20 00 addx %g0, 0, %g2 200aa50: 85 28 a0 02 sll %g2, 2, %g2 200aa54: 96 00 40 0b add %g1, %o3, %o3 200aa58: 86 00 c0 02 add %g3, %g2, %g3 c->parent = the_node->parent; the_node->parent = c; 200aa5c: c8 20 40 00 st %g4, [ %g1 ] if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200aa60: c8 20 e0 04 st %g4, [ %g3 + 4 ] 200aa64: 10 bf ff 7f b 200a860 <_RBTree_Extract_validate_unprotected+0x5c> 200aa68: c4 02 e0 04 ld [ %o3 + 4 ], %g2 RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; 200aa6c: 84 10 20 00 clr %g2 <== NOT EXECUTED 200aa70: 10 bf ff 9e b 200a8e8 <_RBTree_Extract_validate_unprotected+0xe4> 200aa74: 82 10 00 03 mov %g3, %g1 RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 200aa78: 10 bf ff 7a b 200a860 <_RBTree_Extract_validate_unprotected+0x5c><== NOT EXECUTED 200aa7c: 84 10 20 00 clr %g2 <== NOT EXECUTED sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK; _RBTree_Rotate(parent, dir); break; /* done */ } } /* while */ if(!the_node->parent->parent) the_node->color = RBT_BLACK; 200aa80: 81 c3 e0 08 retl 200aa84: c0 22 20 0c clr [ %o0 + 0xc ] 200aa88: 98 00 40 03 add %g1, %g3, %o4 sibling->color = RBT_RED; sibling->child[dir]->color = RBT_BLACK; _RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir)); sibling = parent->child[_RBTree_Opposite_direction(dir)]; } sibling->color = parent->color; 200aa8c: d6 20 a0 0c st %o3, [ %g2 + 0xc ] parent->color = RBT_BLACK; 200aa90: c0 20 60 0c clr [ %g1 + 0xc ] 200aa94: c4 03 20 04 ld [ %o4 + 4 ], %g2 200aa98: 80 a0 a0 00 cmp %g2, 0 200aa9c: 02 bf ff 97 be 200a8f8 <_RBTree_Extract_validate_unprotected+0xf4><== NEVER TAKEN 200aaa0: c0 21 20 0c clr [ %g4 + 0xc ] 200aaa4: 9b 2b 60 02 sll %o5, 2, %o5 c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 200aaa8: 88 00 80 0d add %g2, %o5, %g4 200aaac: d8 01 20 04 ld [ %g4 + 4 ], %o4 200aab0: 86 00 40 03 add %g1, %g3, %g3 200aab4: d8 20 e0 04 st %o4, [ %g3 + 4 ] if (c->child[dir]) 200aab8: c6 01 20 04 ld [ %g4 + 4 ], %g3 200aabc: 80 a0 e0 00 cmp %g3, 0 200aac0: 32 80 00 02 bne,a 200aac8 <_RBTree_Extract_validate_unprotected+0x2c4> 200aac4: c2 20 c0 00 st %g1, [ %g3 ] c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200aac8: c6 00 40 00 ld [ %g1 ], %g3 the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; 200aacc: 9a 00 80 0d add %g2, %o5, %o5 200aad0: c2 23 60 04 st %g1, [ %o5 + 4 ] the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200aad4: c8 00 e0 04 ld [ %g3 + 4 ], %g4 c->parent = the_node->parent; 200aad8: c6 20 80 00 st %g3, [ %g2 ] the_node->parent = c; 200aadc: c4 20 40 00 st %g2, [ %g1 ] if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200aae0: 88 18 40 04 xor %g1, %g4, %g4 200aae4: 80 a0 00 04 cmp %g0, %g4 200aae8: 82 40 20 00 addx %g0, 0, %g1 200aaec: 83 28 60 02 sll %g1, 2, %g1 200aaf0: 86 00 c0 01 add %g3, %g1, %g3 sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK; _RBTree_Rotate(parent, dir); break; /* done */ } } /* while */ if(!the_node->parent->parent) the_node->color = RBT_BLACK; 200aaf4: c2 02 00 00 ld [ %o0 ], %g1 200aaf8: c4 20 e0 04 st %g2, [ %g3 + 4 ] 200aafc: c2 00 40 00 ld [ %g1 ], %g1 200ab00: 80 a0 60 00 cmp %g1, 0 200ab04: 12 bf ff 82 bne 200a90c <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN 200ab08: 01 00 00 00 nop 200ab0c: 30 bf ff dd b,a 200aa80 <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED 200ab10: c2 02 00 00 ld [ %o0 ], %g1 200ab14: c2 00 40 00 ld [ %g1 ], %g1 200ab18: 80 a0 60 00 cmp %g1, 0 200ab1c: 12 bf ff 7c bne 200a90c <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN 200ab20: 01 00 00 00 nop 200ab24: 30 bf ff d7 b,a 200aa80 <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED =============================================================================== 0200b71c <_RBTree_Find>: RBTree_Node *_RBTree_Find( RBTree_Control *the_rbtree, RBTree_Node *search_node ) { 200b71c: 9d e3 bf a0 save %sp, -96, %sp ISR_Level level; RBTree_Node *return_node; return_node = NULL; _ISR_Disable( level ); 200b720: 7f ff e1 b3 call 2003dec 200b724: b8 10 00 18 mov %i0, %i4 200b728: b6 10 00 08 mov %o0, %i3 RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; 200b72c: fa 06 20 04 ld [ %i0 + 4 ], %i5 RBTree_Node* found = NULL; int compare_result; while (iter_node) { 200b730: 80 a7 60 00 cmp %i5, 0 200b734: 02 80 00 15 be 200b788 <_RBTree_Find+0x6c> <== NEVER TAKEN 200b738: b0 10 20 00 clr %i0 compare_result = the_rbtree->compare_function(the_node, iter_node); 200b73c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 200b740: 92 10 00 1d mov %i5, %o1 200b744: 9f c0 40 00 call %g1 200b748: 90 10 00 19 mov %i1, %o0 RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater( int compare_result ) { return compare_result > 0; 200b74c: 83 3a 20 1f sra %o0, 0x1f, %g1 RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); if ( _RBTree_Is_equal( compare_result ) ) { 200b750: 80 a2 20 00 cmp %o0, 0 RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater( int compare_result ) { return compare_result > 0; 200b754: 82 20 40 08 sub %g1, %o0, %g1 200b758: 83 30 60 1f srl %g1, 0x1f, %g1 break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 200b75c: 83 28 60 02 sll %g1, 2, %g1 RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); if ( _RBTree_Is_equal( compare_result ) ) { 200b760: 12 80 00 06 bne 200b778 <_RBTree_Find+0x5c> 200b764: 82 07 40 01 add %i5, %g1, %g1 found = iter_node; if ( the_rbtree->is_unique ) 200b768: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2 200b76c: 80 a0 a0 00 cmp %g2, 0 200b770: 12 80 00 0a bne 200b798 <_RBTree_Find+0x7c> 200b774: b0 10 00 1d mov %i5, %i0 break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 200b778: fa 00 60 04 ld [ %g1 + 4 ], %i5 ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { 200b77c: 80 a7 60 00 cmp %i5, 0 200b780: 32 bf ff f0 bne,a 200b740 <_RBTree_Find+0x24> 200b784: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 return_node = _RBTree_Find_unprotected( the_rbtree, search_node ); _ISR_Enable( level ); 200b788: 7f ff e1 9d call 2003dfc 200b78c: 90 10 00 1b mov %i3, %o0 return return_node; } 200b790: 81 c7 e0 08 ret 200b794: 81 e8 00 00 restore RBTree_Node *return_node; return_node = NULL; _ISR_Disable( level ); return_node = _RBTree_Find_unprotected( the_rbtree, search_node ); _ISR_Enable( level ); 200b798: 7f ff e1 99 call 2003dfc 200b79c: 90 10 00 1b mov %i3, %o0 return return_node; } 200b7a0: 81 c7 e0 08 ret 200b7a4: 81 e8 00 00 restore =============================================================================== 0200bb88 <_RBTree_Initialize>: void *starting_address, size_t number_nodes, size_t node_size, bool is_unique ) { 200bb88: 9d e3 bf a0 save %sp, -96, %sp size_t count; RBTree_Node *next; /* TODO: Error message? */ if (!the_rbtree) return; 200bb8c: 80 a6 20 00 cmp %i0, 0 200bb90: 02 80 00 0f be 200bbcc <_RBTree_Initialize+0x44> <== NEVER TAKEN 200bb94: 80 a6 e0 00 cmp %i3, 0 RBTree_Control *the_rbtree, RBTree_Compare_function compare_function, bool is_unique ) { the_rbtree->permanent_null = NULL; 200bb98: c0 26 00 00 clr [ %i0 ] the_rbtree->root = NULL; 200bb9c: c0 26 20 04 clr [ %i0 + 4 ] the_rbtree->first[0] = NULL; 200bba0: c0 26 20 08 clr [ %i0 + 8 ] the_rbtree->first[1] = NULL; 200bba4: c0 26 20 0c clr [ %i0 + 0xc ] the_rbtree->compare_function = compare_function; 200bba8: f2 26 20 10 st %i1, [ %i0 + 0x10 ] /* could do sanity checks here */ _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique); count = number_nodes; next = starting_address; while ( count-- ) { 200bbac: 02 80 00 08 be 200bbcc <_RBTree_Initialize+0x44> <== NEVER TAKEN 200bbb0: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ] _RBTree_Insert_unprotected(the_rbtree, next); 200bbb4: 92 10 00 1a mov %i2, %o1 200bbb8: 7f ff ff 0b call 200b7e4 <_RBTree_Insert_unprotected> 200bbbc: 90 10 00 18 mov %i0, %o0 /* could do sanity checks here */ _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique); count = number_nodes; next = starting_address; while ( count-- ) { 200bbc0: b6 86 ff ff addcc %i3, -1, %i3 200bbc4: 12 bf ff fc bne 200bbb4 <_RBTree_Initialize+0x2c> 200bbc8: b4 06 80 1c add %i2, %i4, %i2 200bbcc: 81 c7 e0 08 ret 200bbd0: 81 e8 00 00 restore =============================================================================== 0200ad08 <_RBTree_Insert_unprotected>: */ RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { 200ad08: 9d e3 bf a0 save %sp, -96, %sp if(!the_node) return (RBTree_Node*)-1; 200ad0c: 80 a6 60 00 cmp %i1, 0 200ad10: 02 80 00 9c be 200af80 <_RBTree_Insert_unprotected+0x278> 200ad14: b8 10 00 18 mov %i0, %i4 RBTree_Node *iter_node = the_rbtree->root; 200ad18: fa 06 20 04 ld [ %i0 + 4 ], %i5 int compare_result; if (!iter_node) { /* special case: first node inserted */ 200ad1c: 80 a7 60 00 cmp %i5, 0 200ad20: 32 80 00 05 bne,a 200ad34 <_RBTree_Insert_unprotected+0x2c> 200ad24: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 the_node->color = RBT_BLACK; 200ad28: 10 80 00 9a b 200af90 <_RBTree_Insert_unprotected+0x288> 200ad2c: c0 26 60 0c clr [ %i1 + 0xc ] the_node->parent = (RBTree_Node *) the_rbtree; the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; } else { /* typical binary search tree insert, descend tree to leaf and insert */ while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); 200ad30: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 200ad34: 92 10 00 1d mov %i5, %o1 200ad38: 9f c0 40 00 call %g1 200ad3c: 90 10 00 19 mov %i1, %o0 if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) 200ad40: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2 return iter_node; RBTree_Direction dir = !_RBTree_Is_lesser( compare_result ); 200ad44: b6 38 00 08 xnor %g0, %o0, %i3 the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; } else { /* typical binary search tree insert, descend tree to leaf and insert */ while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) 200ad48: 80 a0 a0 00 cmp %g2, 0 return iter_node; RBTree_Direction dir = !_RBTree_Is_lesser( compare_result ); 200ad4c: b7 36 e0 1f srl %i3, 0x1f, %i3 if (!iter_node->child[dir]) { 200ad50: 83 2e e0 02 sll %i3, 2, %g1 the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; } else { /* typical binary search tree insert, descend tree to leaf and insert */ while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) 200ad54: 02 80 00 05 be 200ad68 <_RBTree_Insert_unprotected+0x60> 200ad58: 82 07 40 01 add %i5, %g1, %g1 200ad5c: 80 a2 20 00 cmp %o0, 0 200ad60: 02 80 00 8a be 200af88 <_RBTree_Insert_unprotected+0x280> 200ad64: 01 00 00 00 nop return iter_node; RBTree_Direction dir = !_RBTree_Is_lesser( compare_result ); if (!iter_node->child[dir]) { 200ad68: f0 00 60 04 ld [ %g1 + 4 ], %i0 200ad6c: 80 a6 20 00 cmp %i0, 0 200ad70: 32 bf ff f0 bne,a 200ad30 <_RBTree_Insert_unprotected+0x28> 200ad74: ba 10 00 18 mov %i0, %i5 the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; the_node->color = RBT_RED; iter_node->child[dir] = the_node; the_node->parent = iter_node; /* update min/max */ compare_result = the_rbtree->compare_function( 200ad78: c4 07 20 10 ld [ %i4 + 0x10 ], %g2 RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First( const RBTree_Control *the_rbtree, RBTree_Direction dir ) { return the_rbtree->first[dir]; 200ad7c: b4 06 e0 02 add %i3, 2, %i2 200ad80: 87 2e a0 02 sll %i2, 2, %g3 200ad84: d2 07 00 03 ld [ %i4 + %g3 ], %o1 compare_result = the_rbtree->compare_function(the_node, iter_node); if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) return iter_node; RBTree_Direction dir = !_RBTree_Is_lesser( compare_result ); if (!iter_node->child[dir]) { the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; 200ad88: c0 26 60 08 clr [ %i1 + 8 ] 200ad8c: c0 26 60 04 clr [ %i1 + 4 ] the_node->color = RBT_RED; iter_node->child[dir] = the_node; 200ad90: f2 20 60 04 st %i1, [ %g1 + 4 ] if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) return iter_node; RBTree_Direction dir = !_RBTree_Is_lesser( compare_result ); if (!iter_node->child[dir]) { the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; the_node->color = RBT_RED; 200ad94: 82 10 20 01 mov 1, %g1 iter_node->child[dir] = the_node; the_node->parent = iter_node; 200ad98: fa 26 40 00 st %i5, [ %i1 ] if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) return iter_node; RBTree_Direction dir = !_RBTree_Is_lesser( compare_result ); if (!iter_node->child[dir]) { the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; the_node->color = RBT_RED; 200ad9c: c2 26 60 0c st %g1, [ %i1 + 0xc ] iter_node->child[dir] = the_node; the_node->parent = iter_node; /* update min/max */ compare_result = the_rbtree->compare_function( 200ada0: 9f c0 80 00 call %g2 200ada4: 90 10 00 19 mov %i1, %o0 the_node, _RBTree_First(the_rbtree, dir) ); if ( (!dir && _RBTree_Is_lesser(compare_result)) || 200ada8: 80 a6 e0 00 cmp %i3, 0 200adac: 12 80 00 10 bne 200adec <_RBTree_Insert_unprotected+0xe4> 200adb0: 80 a2 20 00 cmp %o0, 0 200adb4: 06 80 00 10 bl 200adf4 <_RBTree_Insert_unprotected+0xec> 200adb8: b5 2e a0 02 sll %i2, 2, %i2 200adbc: c2 06 40 00 ld [ %i1 ], %g1 if (dir != pdir) { _RBTree_Rotate(the_node->parent, pdir); the_node = the_node->child[pdir]; } the_node->parent->color = RBT_BLACK; g->color = RBT_RED; 200adc0: b4 10 20 01 mov 1, %i2 */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent( const RBTree_Node *the_node ) { if (!the_node->parent->parent) return NULL; 200adc4: c4 00 40 00 ld [ %g1 ], %g2 200adc8: 86 90 a0 00 orcc %g2, 0, %g3 200adcc: 22 80 00 06 be,a 200ade4 <_RBTree_Insert_unprotected+0xdc> 200add0: c0 26 60 0c clr [ %i1 + 0xc ] */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 200add4: c8 00 60 0c ld [ %g1 + 0xc ], %g4 200add8: 80 a1 20 01 cmp %g4, 1 200addc: 22 80 00 08 be,a 200adfc <_RBTree_Insert_unprotected+0xf4> 200ade0: f6 00 80 00 ld [ %g2 ], %i3 /* verify red-black properties */ _RBTree_Validate_insert_unprotected(the_node); } return (RBTree_Node*)0; } 200ade4: 81 c7 e0 08 ret 200ade8: 81 e8 00 00 restore compare_result = the_rbtree->compare_function( the_node, _RBTree_First(the_rbtree, dir) ); if ( (!dir && _RBTree_Is_lesser(compare_result)) || (dir && _RBTree_Is_greater(compare_result)) ) { 200adec: 04 bf ff f4 ble 200adbc <_RBTree_Insert_unprotected+0xb4> 200adf0: b5 2e a0 02 sll %i2, 2, %i2 the_rbtree->first[dir] = the_node; 200adf4: 10 bf ff f2 b 200adbc <_RBTree_Insert_unprotected+0xb4> 200adf8: f2 27 00 1a st %i1, [ %i4 + %i2 ] ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; if(!(the_node->parent->parent->parent)) return NULL; 200adfc: 80 a6 e0 00 cmp %i3, 0 200ae00: 02 80 00 0c be 200ae30 <_RBTree_Insert_unprotected+0x128> <== NEVER TAKEN 200ae04: c8 00 a0 04 ld [ %g2 + 4 ], %g4 { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; if(the_node == the_node->parent->child[RBT_LEFT]) 200ae08: 80 a1 00 01 cmp %g4, %g1 200ae0c: 02 80 00 5b be 200af78 <_RBTree_Insert_unprotected+0x270> 200ae10: ba 10 00 04 mov %g4, %i5 */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 200ae14: 80 a7 60 00 cmp %i5, 0 200ae18: 22 80 00 07 be,a 200ae34 <_RBTree_Insert_unprotected+0x12c> 200ae1c: fa 00 60 04 ld [ %g1 + 4 ], %i5 200ae20: f8 07 60 0c ld [ %i5 + 0xc ], %i4 200ae24: 80 a7 20 01 cmp %i4, 1 200ae28: 22 80 00 4f be,a 200af64 <_RBTree_Insert_unprotected+0x25c> 200ae2c: c0 20 60 0c clr [ %g1 + 0xc ] the_node->parent->color = RBT_BLACK; u->color = RBT_BLACK; g->color = RBT_RED; the_node = g; } else { /* if uncle is black */ RBTree_Direction dir = the_node != the_node->parent->child[0]; 200ae30: fa 00 60 04 ld [ %g1 + 4 ], %i5 RBTree_Direction pdir = the_node->parent != g->child[0]; 200ae34: 88 18 40 04 xor %g1, %g4, %g4 200ae38: 80 a0 00 04 cmp %g0, %g4 the_node->parent->color = RBT_BLACK; u->color = RBT_BLACK; g->color = RBT_RED; the_node = g; } else { /* if uncle is black */ RBTree_Direction dir = the_node != the_node->parent->child[0]; 200ae3c: ba 1e 40 1d xor %i1, %i5, %i5 RBTree_Direction pdir = the_node->parent != g->child[0]; 200ae40: 88 40 20 00 addx %g0, 0, %g4 the_node->parent->color = RBT_BLACK; u->color = RBT_BLACK; g->color = RBT_RED; the_node = g; } else { /* if uncle is black */ RBTree_Direction dir = the_node != the_node->parent->child[0]; 200ae44: 80 a0 00 1d cmp %g0, %i5 200ae48: ba 40 20 00 addx %g0, 0, %i5 RBTree_Direction pdir = the_node->parent != g->child[0]; /* ensure node is on the same branch direction as parent */ if (dir != pdir) { 200ae4c: 80 a7 40 04 cmp %i5, %g4 200ae50: 02 80 00 20 be 200aed0 <_RBTree_Insert_unprotected+0x1c8> 200ae54: 80 a0 00 04 cmp %g0, %g4 */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 200ae58: b6 60 3f ff subx %g0, -1, %i3 RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 200ae5c: b7 2e e0 02 sll %i3, 2, %i3 200ae60: b6 00 40 1b add %g1, %i3, %i3 200ae64: fa 06 e0 04 ld [ %i3 + 4 ], %i5 200ae68: 80 a7 60 00 cmp %i5, 0 200ae6c: 02 80 00 16 be 200aec4 <_RBTree_Insert_unprotected+0x1bc> <== NEVER TAKEN 200ae70: b9 29 20 02 sll %g4, 2, %i4 c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 200ae74: 9e 07 40 1c add %i5, %i4, %o7 200ae78: da 03 e0 04 ld [ %o7 + 4 ], %o5 200ae7c: da 26 e0 04 st %o5, [ %i3 + 4 ] if (c->child[dir]) 200ae80: f6 03 e0 04 ld [ %o7 + 4 ], %i3 200ae84: 80 a6 e0 00 cmp %i3, 0 200ae88: 22 80 00 05 be,a 200ae9c <_RBTree_Insert_unprotected+0x194> 200ae8c: b6 07 40 1c add %i5, %i4, %i3 c->child[dir]->parent = the_node; 200ae90: c2 26 c0 00 st %g1, [ %i3 ] 200ae94: c4 00 40 00 ld [ %g1 ], %g2 c->child[dir] = the_node; 200ae98: b6 07 40 1c add %i5, %i4, %i3 200ae9c: c2 26 e0 04 st %g1, [ %i3 + 4 ] the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200aea0: f6 00 a0 04 ld [ %g2 + 4 ], %i3 c->parent = the_node->parent; 200aea4: c4 27 40 00 st %g2, [ %i5 ] if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200aea8: b6 1e c0 01 xor %i3, %g1, %i3 c->parent = the_node->parent; the_node->parent = c; 200aeac: fa 20 40 00 st %i5, [ %g1 ] if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200aeb0: 80 a0 00 1b cmp %g0, %i3 200aeb4: 82 40 20 00 addx %g0, 0, %g1 200aeb8: 83 28 60 02 sll %g1, 2, %g1 200aebc: 84 00 80 01 add %g2, %g1, %g2 200aec0: fa 20 a0 04 st %i5, [ %g2 + 4 ] _RBTree_Rotate(the_node->parent, pdir); the_node = the_node->child[pdir]; 200aec4: b2 06 40 1c add %i1, %i4, %i1 200aec8: f2 06 60 04 ld [ %i1 + 4 ], %i1 200aecc: c2 06 40 00 ld [ %i1 ], %g1 } the_node->parent->color = RBT_BLACK; 200aed0: c0 20 60 0c clr [ %g1 + 0xc ] g->color = RBT_RED; /* now rotate grandparent in the other branch direction (toward uncle) */ _RBTree_Rotate(g, (1-pdir)); 200aed4: 88 26 80 04 sub %i2, %g4, %g4 200aed8: ba 19 20 01 xor %g4, 1, %i5 RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 200aedc: bb 2f 60 02 sll %i5, 2, %i5 200aee0: ba 00 c0 1d add %g3, %i5, %i5 200aee4: c4 07 60 04 ld [ %i5 + 4 ], %g2 200aee8: 80 a0 a0 00 cmp %g2, 0 200aeec: 02 bf ff b6 be 200adc4 <_RBTree_Insert_unprotected+0xbc> <== NEVER TAKEN 200aef0: f4 20 e0 0c st %i2, [ %g3 + 0xc ] c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 200aef4: 89 29 20 02 sll %g4, 2, %g4 200aef8: 82 00 80 04 add %g2, %g4, %g1 200aefc: f8 00 60 04 ld [ %g1 + 4 ], %i4 200af00: f8 27 60 04 st %i4, [ %i5 + 4 ] if (c->child[dir]) 200af04: c2 00 60 04 ld [ %g1 + 4 ], %g1 200af08: 80 a0 60 00 cmp %g1, 0 200af0c: 32 80 00 02 bne,a 200af14 <_RBTree_Insert_unprotected+0x20c> 200af10: c6 20 40 00 st %g3, [ %g1 ] c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200af14: fa 00 c0 00 ld [ %g3 ], %i5 the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; 200af18: 88 00 80 04 add %g2, %g4, %g4 the_node->parent->child[the_node != the_node->parent->child[0]] = c; c->parent = the_node->parent; 200af1c: fa 20 80 00 st %i5, [ %g2 ] the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; 200af20: c6 21 20 04 st %g3, [ %g4 + 4 ] the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200af24: c8 07 60 04 ld [ %i5 + 4 ], %g4 c->parent = the_node->parent; the_node->parent = c; 200af28: c4 20 c0 00 st %g2, [ %g3 ] 200af2c: c2 06 40 00 ld [ %i1 ], %g1 if (c->child[dir]) c->child[dir]->parent = the_node; c->child[dir] = the_node; the_node->parent->child[the_node != the_node->parent->child[0]] = c; 200af30: 86 18 c0 04 xor %g3, %g4, %g3 200af34: 80 a0 00 03 cmp %g0, %g3 200af38: 86 40 20 00 addx %g0, 0, %g3 200af3c: 87 28 e0 02 sll %g3, 2, %g3 200af40: ba 07 40 03 add %i5, %g3, %i5 200af44: c4 27 60 04 st %g2, [ %i5 + 4 ] */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent( const RBTree_Node *the_node ) { if (!the_node->parent->parent) return NULL; 200af48: c4 00 40 00 ld [ %g1 ], %g2 200af4c: 86 90 a0 00 orcc %g2, 0, %g3 200af50: 32 bf ff a2 bne,a 200add8 <_RBTree_Insert_unprotected+0xd0><== ALWAYS TAKEN 200af54: c8 00 60 0c ld [ %g1 + 0xc ], %g4 } } if(!the_node->parent->parent) the_node->color = RBT_BLACK; 200af58: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED /* verify red-black properties */ _RBTree_Validate_insert_unprotected(the_node); } return (RBTree_Node*)0; } 200af5c: 81 c7 e0 08 ret <== NOT EXECUTED 200af60: 81 e8 00 00 restore <== NOT EXECUTED g = the_node->parent->parent; /* if uncle is red, repaint uncle/parent black and grandparent red */ if(_RBTree_Is_red(u)) { the_node->parent->color = RBT_BLACK; u->color = RBT_BLACK; 200af64: c0 27 60 0c clr [ %i5 + 0xc ] g->color = RBT_RED; 200af68: f8 20 a0 0c st %i4, [ %g2 + 0xc ] 200af6c: 82 10 00 1b mov %i3, %g1 200af70: 10 bf ff 95 b 200adc4 <_RBTree_Insert_unprotected+0xbc> 200af74: b2 10 00 02 mov %g2, %i1 if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; if(the_node == the_node->parent->child[RBT_LEFT]) return the_node->parent->child[RBT_RIGHT]; 200af78: 10 bf ff a7 b 200ae14 <_RBTree_Insert_unprotected+0x10c> 200af7c: fa 00 a0 08 ld [ %g2 + 8 ], %i5 RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { if(!the_node) return (RBTree_Node*)-1; 200af80: 81 c7 e0 08 ret 200af84: 91 e8 3f ff restore %g0, -1, %o0 the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; } else { /* typical binary search tree insert, descend tree to leaf and insert */ while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) 200af88: 81 c7 e0 08 ret 200af8c: 91 e8 00 1d restore %g0, %i5, %o0 RBTree_Node *iter_node = the_rbtree->root; int compare_result; if (!iter_node) { /* special case: first node inserted */ the_node->color = RBT_BLACK; the_rbtree->root = the_node; 200af90: f2 26 20 04 st %i1, [ %i0 + 4 ] the_rbtree->first[0] = the_rbtree->first[1] = the_node; 200af94: f2 26 20 0c st %i1, [ %i0 + 0xc ] 200af98: f2 26 20 08 st %i1, [ %i0 + 8 ] the_node->parent = (RBTree_Node *) the_rbtree; 200af9c: f0 26 40 00 st %i0, [ %i1 ] the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; 200afa0: c0 26 60 08 clr [ %i1 + 8 ] 200afa4: c0 26 60 04 clr [ %i1 + 4 ] } /* while(iter_node) */ /* verify red-black properties */ _RBTree_Validate_insert_unprotected(the_node); } return (RBTree_Node*)0; 200afa8: 81 c7 e0 08 ret 200afac: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 0200afe0 <_RBTree_Iterate_unprotected>: const RBTree_Control *rbtree, RBTree_Direction dir, RBTree_Visitor visitor, void *visitor_arg ) { 200afe0: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 200afe4: 80 a0 00 19 cmp %g0, %i1 200afe8: 82 60 3f ff subx %g0, -1, %g1 RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First( const RBTree_Control *the_rbtree, RBTree_Direction dir ) { return the_rbtree->first[dir]; 200afec: 82 00 60 02 add %g1, 2, %g1 200aff0: 83 28 60 02 sll %g1, 2, %g1 200aff4: fa 06 00 01 ld [ %i0 + %g1 ], %i5 RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { 200aff8: 80 a7 60 00 cmp %i5, 0 200affc: 12 80 00 06 bne 200b014 <_RBTree_Iterate_unprotected+0x34><== ALWAYS TAKEN 200b000: 94 10 00 1b mov %i3, %o2 200b004: 30 80 00 0e b,a 200b03c <_RBTree_Iterate_unprotected+0x5c><== NOT EXECUTED 200b008: 80 8f 20 ff btst 0xff, %i4 200b00c: 02 80 00 0c be 200b03c <_RBTree_Iterate_unprotected+0x5c> <== NEVER TAKEN 200b010: 94 10 00 1b mov %i3, %o2 stop = (*visitor)( current, dir, visitor_arg ); 200b014: 90 10 00 1d mov %i5, %o0 200b018: 9f c6 80 00 call %i2 200b01c: 92 10 00 19 mov %i1, %o1 current = _RBTree_Next_unprotected( current, dir ); 200b020: 92 10 00 19 mov %i1, %o1 RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { stop = (*visitor)( current, dir, visitor_arg ); 200b024: b8 10 00 08 mov %o0, %i4 current = _RBTree_Next_unprotected( current, dir ); 200b028: 40 00 00 07 call 200b044 <_RBTree_Next_unprotected> 200b02c: 90 10 00 1d mov %i5, %o0 { RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { 200b030: ba 92 20 00 orcc %o0, 0, %i5 200b034: 12 bf ff f5 bne 200b008 <_RBTree_Iterate_unprotected+0x28> 200b038: b8 1f 20 01 xor %i4, 1, %i4 200b03c: 81 c7 e0 08 ret 200b040: 81 e8 00 00 restore =============================================================================== 02008190 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 2008190: 9d e3 bf 98 save %sp, -104, %sp rtems_initialization_tasks_table *user_tasks; /* * Move information into local variables */ user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table; 2008194: 03 00 80 76 sethi %hi(0x201d800), %g1 2008198: 82 10 63 20 or %g1, 0x320, %g1 ! 201db20 200819c: fa 00 60 2c ld [ %g1 + 0x2c ], %i5 maximum = Configuration_RTEMS_API.number_of_initialization_tasks; /* * Verify that we have a set of user tasks to iterate */ if ( !user_tasks ) 20081a0: 80 a7 60 00 cmp %i5, 0 20081a4: 02 80 00 18 be 2008204 <_RTEMS_tasks_Initialize_user_tasks_body+0x74> 20081a8: f6 00 60 28 ld [ %g1 + 0x28 ], %i3 return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 20081ac: 80 a6 e0 00 cmp %i3, 0 20081b0: 02 80 00 15 be 2008204 <_RTEMS_tasks_Initialize_user_tasks_body+0x74><== NEVER TAKEN 20081b4: b8 10 20 00 clr %i4 return_value = rtems_task_create( 20081b8: d4 07 60 04 ld [ %i5 + 4 ], %o2 20081bc: d0 07 40 00 ld [ %i5 ], %o0 20081c0: d2 07 60 08 ld [ %i5 + 8 ], %o1 20081c4: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 20081c8: d8 07 60 0c ld [ %i5 + 0xc ], %o4 20081cc: 7f ff ff 70 call 2007f8c 20081d0: 9a 07 bf fc add %fp, -4, %o5 user_tasks[ index ].stack_size, user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 20081d4: 94 92 20 00 orcc %o0, 0, %o2 20081d8: 12 80 00 0d bne 200820c <_RTEMS_tasks_Initialize_user_tasks_body+0x7c> 20081dc: d0 07 bf fc ld [ %fp + -4 ], %o0 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); return_value = rtems_task_start( 20081e0: d4 07 60 18 ld [ %i5 + 0x18 ], %o2 20081e4: 40 00 00 0e call 200821c 20081e8: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 20081ec: 94 92 20 00 orcc %o0, 0, %o2 20081f0: 12 80 00 07 bne 200820c <_RTEMS_tasks_Initialize_user_tasks_body+0x7c> 20081f4: b8 07 20 01 inc %i4 return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 20081f8: 80 a7 00 1b cmp %i4, %i3 20081fc: 12 bf ff ef bne 20081b8 <_RTEMS_tasks_Initialize_user_tasks_body+0x28><== NEVER TAKEN 2008200: ba 07 60 1c add %i5, 0x1c, %i5 2008204: 81 c7 e0 08 ret 2008208: 81 e8 00 00 restore id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); 200820c: 90 10 20 01 mov 1, %o0 2008210: 40 00 04 2a call 20092b8 <_Internal_error_Occurred> 2008214: 92 10 20 01 mov 1, %o1 =============================================================================== 0200dba8 <_RTEMS_tasks_Switch_extension>: /* * Per Task Variables */ tvp = executing->task_variables; 200dba8: c2 02 21 64 ld [ %o0 + 0x164 ], %g1 while (tvp) { 200dbac: 80 a0 60 00 cmp %g1, 0 200dbb0: 22 80 00 0c be,a 200dbe0 <_RTEMS_tasks_Switch_extension+0x38> 200dbb4: c2 02 61 64 ld [ %o1 + 0x164 ], %g1 tvp->tval = *tvp->ptr; 200dbb8: c4 00 60 04 ld [ %g1 + 4 ], %g2 *tvp->ptr = tvp->gval; 200dbbc: c6 00 60 08 ld [ %g1 + 8 ], %g3 * Per Task Variables */ tvp = executing->task_variables; while (tvp) { tvp->tval = *tvp->ptr; 200dbc0: c8 00 80 00 ld [ %g2 ], %g4 200dbc4: c8 20 60 0c st %g4, [ %g1 + 0xc ] *tvp->ptr = tvp->gval; 200dbc8: c6 20 80 00 st %g3, [ %g2 ] tvp = (rtems_task_variable_t *)tvp->next; 200dbcc: c2 00 40 00 ld [ %g1 ], %g1 /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 200dbd0: 80 a0 60 00 cmp %g1, 0 200dbd4: 32 bf ff fa bne,a 200dbbc <_RTEMS_tasks_Switch_extension+0x14><== NEVER TAKEN 200dbd8: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 200dbdc: c2 02 61 64 ld [ %o1 + 0x164 ], %g1 while (tvp) { 200dbe0: 80 a0 60 00 cmp %g1, 0 200dbe4: 02 80 00 0d be 200dc18 <_RTEMS_tasks_Switch_extension+0x70> 200dbe8: 01 00 00 00 nop tvp->gval = *tvp->ptr; 200dbec: c4 00 60 04 ld [ %g1 + 4 ], %g2 *tvp->ptr = tvp->tval; 200dbf0: c6 00 60 0c ld [ %g1 + 0xc ], %g3 tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { tvp->gval = *tvp->ptr; 200dbf4: c8 00 80 00 ld [ %g2 ], %g4 200dbf8: c8 20 60 08 st %g4, [ %g1 + 8 ] *tvp->ptr = tvp->tval; 200dbfc: c6 20 80 00 st %g3, [ %g2 ] tvp = (rtems_task_variable_t *)tvp->next; 200dc00: c2 00 40 00 ld [ %g1 ], %g1 *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 200dc04: 80 a0 60 00 cmp %g1, 0 200dc08: 32 bf ff fa bne,a 200dbf0 <_RTEMS_tasks_Switch_extension+0x48><== NEVER TAKEN 200dc0c: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED 200dc10: 81 c3 e0 08 retl 200dc14: 01 00 00 00 nop 200dc18: 81 c3 e0 08 retl =============================================================================== 020453d0 <_Rate_monotonic_Get_status>: bool _Rate_monotonic_Get_status( Rate_monotonic_Control *the_period, Rate_monotonic_Period_time_t *wall_since_last_period, Thread_CPU_usage_t *cpu_since_last_period ) { 20453d0: 9d e3 bf 98 save %sp, -104, %sp #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ Timestamp_Control uptime; #endif Thread_Control *owning_thread = the_period->owner; 20453d4: f6 06 20 40 ld [ %i0 + 0x40 ], %i3 /* * Determine elapsed wall time since period initiated. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _TOD_Get_uptime( &uptime ); 20453d8: 7f ff a7 b4 call 202f2a8 <_TOD_Get_uptime> 20453dc: 90 07 bf f8 add %fp, -8, %o0 _Timestamp_Subtract( 20453e0: c4 1f bf f8 ldd [ %fp + -8 ], %g2 const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 20453e4: f8 1e 20 50 ldd [ %i0 + 0x50 ], %i4 * Determine cpu usage since period initiated. */ used = owning_thread->cpu_time_used; #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ if (owning_thread == _Thread_Executing) { 20453e8: 03 00 81 d8 sethi %hi(0x2076000), %g1 20453ec: 82 10 62 c0 or %g1, 0x2c0, %g1 ! 20762c0 <_Per_CPU_Information> 20453f0: de 00 60 0c ld [ %g1 + 0xc ], %o7 20453f4: ba a0 c0 1d subcc %g3, %i5, %i5 20453f8: b8 60 80 1c subx %g2, %i4, %i4 20453fc: f8 3e 40 00 std %i4, [ %i1 ] if (used < the_period->cpu_usage_period_initiated) return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; 2045400: 88 10 20 01 mov 1, %g4 * Determine cpu usage since period initiated. */ used = owning_thread->cpu_time_used; #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ if (owning_thread == _Thread_Executing) { 2045404: 80 a3 c0 1b cmp %o7, %i3 2045408: 02 80 00 05 be 204541c <_Rate_monotonic_Get_status+0x4c> 204540c: f8 1e e0 80 ldd [ %i3 + 0x80 ], %i4 return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; } 2045410: b0 09 20 01 and %g4, 1, %i0 2045414: 81 c7 e0 08 ret 2045418: 81 e8 00 00 restore 204541c: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2045420: f0 1e 20 48 ldd [ %i0 + 0x48 ], %i0 2045424: 86 a0 c0 0d subcc %g3, %o5, %g3 2045428: 84 60 80 0c subx %g2, %o4, %g2 static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 204542c: ba 87 40 03 addcc %i5, %g3, %i5 2045430: b8 47 00 02 addx %i4, %g2, %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)) 2045434: 80 a6 00 1c cmp %i0, %i4 2045438: 14 bf ff f6 bg 2045410 <_Rate_monotonic_Get_status+0x40> <== NEVER TAKEN 204543c: 88 10 20 00 clr %g4 2045440: 02 80 00 09 be 2045464 <_Rate_monotonic_Get_status+0x94> 2045444: 80 a6 40 1d cmp %i1, %i5 const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 2045448: ba a7 40 19 subcc %i5, %i1, %i5 if (used < the_period->cpu_usage_period_initiated) return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; 204544c: 88 10 20 01 mov 1, %g4 2045450: b8 67 00 18 subx %i4, %i0, %i4 } 2045454: b0 09 20 01 and %g4, 1, %i0 2045458: f8 3e 80 00 std %i4, [ %i2 ] 204545c: 81 c7 e0 08 ret 2045460: 81 e8 00 00 restore /* * The cpu usage info was reset while executing. Can't * determine a status. */ if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated)) 2045464: 28 bf ff fa bleu,a 204544c <_Rate_monotonic_Get_status+0x7c> 2045468: ba a7 40 19 subcc %i5, %i1, %i5 return false; 204546c: 10 bf ff e9 b 2045410 <_Rate_monotonic_Get_status+0x40> 2045470: 88 10 20 00 clr %g4 =============================================================================== 02045810 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 2045810: 9d e3 bf 98 save %sp, -104, %sp 2045814: 11 00 81 da sethi %hi(0x2076800), %o0 2045818: 92 10 00 18 mov %i0, %o1 204581c: 90 12 21 30 or %o0, 0x130, %o0 2045820: 7f ff 29 dd call 200ff94 <_Objects_Get> 2045824: 94 07 bf fc add %fp, -4, %o2 /* * When we get here, the Timer is already off the chain so we do not * have to worry about that -- hence no _Watchdog_Remove(). */ the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 2045828: c2 07 bf fc ld [ %fp + -4 ], %g1 204582c: 80 a0 60 00 cmp %g1, 0 2045830: 12 80 00 17 bne 204588c <_Rate_monotonic_Timeout+0x7c> <== NEVER TAKEN 2045834: ba 10 00 08 mov %o0, %i5 case OBJECTS_LOCAL: the_thread = the_period->owner; 2045838: d0 02 20 40 ld [ %o0 + 0x40 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 204583c: 03 00 00 10 sethi %hi(0x4000), %g1 */ RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period ( States_Control the_states ) { return (the_states & STATES_WAITING_FOR_PERIOD); 2045840: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 2045844: 80 88 80 01 btst %g2, %g1 2045848: 22 80 00 08 be,a 2045868 <_Rate_monotonic_Timeout+0x58> 204584c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 2045850: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2045854: c2 07 60 08 ld [ %i5 + 8 ], %g1 2045858: 80 a0 80 01 cmp %g2, %g1 204585c: 02 80 00 1a be 20458c4 <_Rate_monotonic_Timeout+0xb4> 2045860: 13 04 00 ff sethi %hi(0x1003fc00), %o1 _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 2045864: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 2045868: 80 a0 60 01 cmp %g1, 1 204586c: 02 80 00 0a be 2045894 <_Rate_monotonic_Timeout+0x84> 2045870: 82 10 20 04 mov 4, %g1 _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 2045874: c2 27 60 38 st %g1, [ %i5 + 0x38 ] * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 2045878: 03 00 81 d7 sethi %hi(0x2075c00), %g1 204587c: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 2075d90 <_Thread_Dispatch_disable_level> 2045880: 84 00 bf ff add %g2, -1, %g2 2045884: c4 20 61 90 st %g2, [ %g1 + 0x190 ] return _Thread_Dispatch_disable_level; 2045888: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 204588c: 81 c7 e0 08 ret 2045890: 81 e8 00 00 restore _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 2045894: 82 10 20 03 mov 3, %g1 _Rate_monotonic_Initiate_statistics( the_period ); 2045898: 90 10 00 1d mov %i5, %o0 _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 204589c: c2 27 60 38 st %g1, [ %i5 + 0x38 ] _Rate_monotonic_Initiate_statistics( the_period ); 20458a0: 7f ff ff 44 call 20455b0 <_Rate_monotonic_Initiate_statistics> 20458a4: 01 00 00 00 nop Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20458a8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20458ac: 11 00 81 d7 sethi %hi(0x2075c00), %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20458b0: c2 27 60 1c st %g1, [ %i5 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20458b4: 90 12 22 38 or %o0, 0x238, %o0 20458b8: 7f ff 31 23 call 2011d44 <_Watchdog_Insert> 20458bc: 92 07 60 10 add %i5, 0x10, %o1 20458c0: 30 bf ff ee b,a 2045878 <_Rate_monotonic_Timeout+0x68> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 20458c4: 7f ff 2c ab call 2010b70 <_Thread_Clear_state> 20458c8: 92 12 63 f8 or %o1, 0x3f8, %o1 the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 20458cc: 10 bf ff f5 b 20458a0 <_Rate_monotonic_Timeout+0x90> 20458d0: 90 10 00 1d mov %i5, %o0 =============================================================================== 02045474 <_Rate_monotonic_Update_statistics>: } static void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 2045474: 9d e3 bf 90 save %sp, -112, %sp /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 2045478: c4 06 20 58 ld [ %i0 + 0x58 ], %g2 if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 204547c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 2045480: 84 00 a0 01 inc %g2 if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 2045484: 80 a0 60 04 cmp %g1, 4 2045488: 02 80 00 32 be 2045550 <_Rate_monotonic_Update_statistics+0xdc> 204548c: c4 26 20 58 st %g2, [ %i0 + 0x58 ] stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 2045490: 90 10 00 18 mov %i0, %o0 2045494: 92 07 bf f8 add %fp, -8, %o1 2045498: 7f ff ff ce call 20453d0 <_Rate_monotonic_Get_status> 204549c: 94 07 bf f0 add %fp, -16, %o2 _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) 20454a0: 80 8a 20 ff btst 0xff, %o0 20454a4: 02 80 00 21 be 2045528 <_Rate_monotonic_Update_statistics+0xb4> 20454a8: c4 1f bf f0 ldd [ %fp + -16 ], %g2 static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 20454ac: f8 1e 20 70 ldd [ %i0 + 0x70 ], %i4 * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 20454b0: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 20454b4: ba 87 40 03 addcc %i5, %g3, %i5 20454b8: b8 47 00 02 addx %i4, %g2, %i4 20454bc: 80 a0 40 02 cmp %g1, %g2 20454c0: 04 80 00 1c ble 2045530 <_Rate_monotonic_Update_statistics+0xbc> 20454c4: f8 3e 20 70 std %i4, [ %i0 + 0x70 ] stats->min_cpu_time = executed; 20454c8: c4 3e 20 60 std %g2, [ %i0 + 0x60 ] if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 20454cc: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 20454d0: 80 a0 40 02 cmp %g1, %g2 20454d4: 26 80 00 05 bl,a 20454e8 <_Rate_monotonic_Update_statistics+0x74><== NEVER TAKEN 20454d8: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED 20454dc: 80 a0 40 02 cmp %g1, %g2 20454e0: 22 80 00 28 be,a 2045580 <_Rate_monotonic_Update_statistics+0x10c><== ALWAYS TAKEN 20454e4: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 /* * Update Wall time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 20454e8: c4 1f bf f8 ldd [ %fp + -8 ], %g2 20454ec: f8 1e 20 88 ldd [ %i0 + 0x88 ], %i4 if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 20454f0: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 20454f4: ba 87 40 03 addcc %i5, %g3, %i5 20454f8: b8 47 00 02 addx %i4, %g2, %i4 20454fc: 80 a0 40 02 cmp %g1, %g2 2045500: 14 80 00 1b bg 204556c <_Rate_monotonic_Update_statistics+0xf8> 2045504: f8 3e 20 88 std %i4, [ %i0 + 0x88 ] 2045508: 80 a0 40 02 cmp %g1, %g2 204550c: 22 80 00 15 be,a 2045560 <_Rate_monotonic_Update_statistics+0xec><== ALWAYS TAKEN 2045510: c2 06 20 7c ld [ %i0 + 0x7c ], %g1 stats->min_wall_time = since_last_period; if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 2045514: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 2045518: 80 a0 40 02 cmp %g1, %g2 204551c: 16 80 00 1e bge 2045594 <_Rate_monotonic_Update_statistics+0x120><== ALWAYS TAKEN 2045520: 01 00 00 00 nop stats->max_wall_time = since_last_period; 2045524: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED 2045528: 81 c7 e0 08 ret 204552c: 81 e8 00 00 restore * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 2045530: 32 bf ff e8 bne,a 20454d0 <_Rate_monotonic_Update_statistics+0x5c><== NEVER TAKEN 2045534: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED 2045538: c2 06 20 64 ld [ %i0 + 0x64 ], %g1 204553c: 80 a0 40 03 cmp %g1, %g3 2045540: 28 bf ff e4 bleu,a 20454d0 <_Rate_monotonic_Update_statistics+0x5c> 2045544: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 stats->min_cpu_time = executed; 2045548: 10 bf ff e1 b 20454cc <_Rate_monotonic_Update_statistics+0x58> 204554c: c4 3e 20 60 std %g2, [ %i0 + 0x60 ] */ stats = &the_period->Statistics; stats->count++; if ( the_period->state == RATE_MONOTONIC_EXPIRED ) stats->missed_count++; 2045550: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 2045554: 82 00 60 01 inc %g1 2045558: 10 bf ff ce b 2045490 <_Rate_monotonic_Update_statistics+0x1c> 204555c: c2 26 20 5c st %g1, [ %i0 + 0x5c ] * Update Wall time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 2045560: 80 a0 40 03 cmp %g1, %g3 2045564: 28 bf ff ed bleu,a 2045518 <_Rate_monotonic_Update_statistics+0xa4> 2045568: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 stats->min_wall_time = since_last_period; if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 204556c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 2045570: 80 a0 40 02 cmp %g1, %g2 2045574: 06 bf ff ec bl 2045524 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN 2045578: c4 3e 20 78 std %g2, [ %i0 + 0x78 ] 204557c: 30 80 00 06 b,a 2045594 <_Rate_monotonic_Update_statistics+0x120> _Timestamp_Add_to( &stats->total_cpu_time, &executed ); if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) stats->min_cpu_time = executed; if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 2045580: 80 a0 40 03 cmp %g1, %g3 2045584: 3a bf ff da bcc,a 20454ec <_Rate_monotonic_Update_statistics+0x78> 2045588: c4 1f bf f8 ldd [ %fp + -8 ], %g2 stats->max_cpu_time = executed; 204558c: 10 bf ff d7 b 20454e8 <_Rate_monotonic_Update_statistics+0x74> 2045590: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) stats->min_wall_time = since_last_period; if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 2045594: 12 bf ff e5 bne 2045528 <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN 2045598: 01 00 00 00 nop 204559c: c2 06 20 84 ld [ %i0 + 0x84 ], %g1 20455a0: 80 a0 40 03 cmp %g1, %g3 20455a4: 2a bf ff e1 bcs,a 2045528 <_Rate_monotonic_Update_statistics+0xb4> 20455a8: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] 20455ac: 30 bf ff df b,a 2045528 <_Rate_monotonic_Update_statistics+0xb4> =============================================================================== 0200a7d0 <_Scheduler_CBS_Allocate>: #include void *_Scheduler_CBS_Allocate( Thread_Control *the_thread ) { 200a7d0: 9d e3 bf a0 save %sp, -96, %sp void *sched; Scheduler_CBS_Per_thread *schinfo; sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread)); 200a7d4: 40 00 07 2a call 200c47c <_Workspace_Allocate> 200a7d8: 90 10 20 1c mov 0x1c, %o0 if ( sched ) { 200a7dc: 80 a2 20 00 cmp %o0, 0 200a7e0: 02 80 00 06 be 200a7f8 <_Scheduler_CBS_Allocate+0x28> <== NEVER TAKEN 200a7e4: 82 10 20 02 mov 2, %g1 the_thread->scheduler_info = sched; 200a7e8: d0 26 20 88 st %o0, [ %i0 + 0x88 ] schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info); schinfo->edf_per_thread.thread = the_thread; 200a7ec: f0 22 00 00 st %i0, [ %o0 ] schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN; 200a7f0: c2 22 20 14 st %g1, [ %o0 + 0x14 ] schinfo->cbs_server = NULL; 200a7f4: c0 22 20 18 clr [ %o0 + 0x18 ] } return sched; } 200a7f8: 81 c7 e0 08 ret 200a7fc: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 0200bc0c <_Scheduler_CBS_Budget_callout>: Scheduler_CBS_Server **_Scheduler_CBS_Server_list; void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) { 200bc0c: 9d e3 bf 98 save %sp, -104, %sp Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info; Scheduler_CBS_Server_id server_id; /* Put violating task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; 200bc10: d2 06 20 ac ld [ %i0 + 0xac ], %o1 if ( the_thread->real_priority != new_priority ) 200bc14: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 200bc18: 80 a0 40 09 cmp %g1, %o1 200bc1c: 32 80 00 02 bne,a 200bc24 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN 200bc20: d2 26 20 18 st %o1, [ %i0 + 0x18 ] the_thread->real_priority = new_priority; if ( the_thread->current_priority != new_priority ) 200bc24: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 200bc28: 80 a0 40 09 cmp %g1, %o1 200bc2c: 02 80 00 04 be 200bc3c <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN 200bc30: 90 10 00 18 mov %i0, %o0 _Thread_Change_priority(the_thread, new_priority, true); 200bc34: 40 00 01 92 call 200c27c <_Thread_Change_priority> 200bc38: 94 10 20 01 mov 1, %o2 /* Invoke callback function if any. */ sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; 200bc3c: fa 06 20 88 ld [ %i0 + 0x88 ], %i5 if ( sched_info->cbs_server->cbs_budget_overrun ) { 200bc40: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 200bc44: c4 00 60 0c ld [ %g1 + 0xc ], %g2 200bc48: 80 a0 a0 00 cmp %g2, 0 200bc4c: 02 80 00 09 be 200bc70 <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN 200bc50: 01 00 00 00 nop _Scheduler_CBS_Get_server_id( 200bc54: d0 00 40 00 ld [ %g1 ], %o0 200bc58: 7f ff ff d5 call 200bbac <_Scheduler_CBS_Get_server_id> 200bc5c: 92 07 bf fc add %fp, -4, %o1 sched_info->cbs_server->task_id, &server_id ); sched_info->cbs_server->cbs_budget_overrun( server_id ); 200bc60: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 200bc64: c2 00 60 0c ld [ %g1 + 0xc ], %g1 200bc68: 9f c0 40 00 call %g1 200bc6c: d0 07 bf fc ld [ %fp + -4 ], %o0 200bc70: 81 c7 e0 08 ret 200bc74: 81 e8 00 00 restore =============================================================================== 0200b764 <_Scheduler_CBS_Cleanup>: #include #include #include int _Scheduler_CBS_Cleanup (void) { 200b764: 9d e3 bf a0 save %sp, -96, %sp unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 200b768: 39 00 80 84 sethi %hi(0x2021000), %i4 200b76c: c2 07 23 ac ld [ %i4 + 0x3ac ], %g1 ! 20213ac <_Scheduler_CBS_Maximum_servers> 200b770: 80 a0 60 00 cmp %g1, 0 200b774: 02 80 00 18 be 200b7d4 <_Scheduler_CBS_Cleanup+0x70> <== NEVER TAKEN 200b778: 03 00 80 89 sethi %hi(0x2022400), %g1 200b77c: 37 00 80 89 sethi %hi(0x2022400), %i3 200b780: c4 06 e2 78 ld [ %i3 + 0x278 ], %g2 ! 2022678 <_Scheduler_CBS_Server_list> 200b784: ba 10 20 00 clr %i5 200b788: b8 17 23 ac or %i4, 0x3ac, %i4 if ( _Scheduler_CBS_Server_list[ i ] ) 200b78c: 83 2f 60 02 sll %i5, 2, %g1 200b790: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200b794: 80 a0 60 00 cmp %g1, 0 200b798: 02 80 00 05 be 200b7ac <_Scheduler_CBS_Cleanup+0x48> 200b79c: 90 10 00 1d mov %i5, %o0 _Scheduler_CBS_Destroy_server( i ); 200b7a0: 40 00 00 46 call 200b8b8 <_Scheduler_CBS_Destroy_server> 200b7a4: 01 00 00 00 nop 200b7a8: c4 06 e2 78 ld [ %i3 + 0x278 ], %g2 int _Scheduler_CBS_Cleanup (void) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 200b7ac: c2 07 00 00 ld [ %i4 ], %g1 200b7b0: ba 07 60 01 inc %i5 200b7b4: 80 a0 40 1d cmp %g1, %i5 200b7b8: 18 bf ff f6 bgu 200b790 <_Scheduler_CBS_Cleanup+0x2c> 200b7bc: 83 2f 60 02 sll %i5, 2, %g1 if ( _Scheduler_CBS_Server_list[ i ] ) _Scheduler_CBS_Destroy_server( i ); } _Workspace_Free( _Scheduler_CBS_Server_list ); return SCHEDULER_CBS_OK; } 200b7c0: b0 10 20 00 clr %i0 for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { if ( _Scheduler_CBS_Server_list[ i ] ) _Scheduler_CBS_Destroy_server( i ); } _Workspace_Free( _Scheduler_CBS_Server_list ); 200b7c4: 40 00 08 5a call 200d92c <_Workspace_Free> 200b7c8: 90 10 00 02 mov %g2, %o0 return SCHEDULER_CBS_OK; } 200b7cc: 81 c7 e0 08 ret 200b7d0: 81 e8 00 00 restore 200b7d4: 10 bf ff fb b 200b7c0 <_Scheduler_CBS_Cleanup+0x5c> <== NOT EXECUTED 200b7d8: c4 00 62 78 ld [ %g1 + 0x278 ], %g2 <== NOT EXECUTED =============================================================================== 0200b7dc <_Scheduler_CBS_Create_server>: int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) { 200b7dc: 9d e3 bf a0 save %sp, -96, %sp unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 200b7e0: c2 06 20 04 ld [ %i0 + 4 ], %g1 200b7e4: 80 a0 60 00 cmp %g1, 0 200b7e8: 04 80 00 30 ble 200b8a8 <_Scheduler_CBS_Create_server+0xcc> 200b7ec: b8 10 00 18 mov %i0, %i4 200b7f0: c2 06 00 00 ld [ %i0 ], %g1 200b7f4: 80 a0 60 00 cmp %g1, 0 200b7f8: 04 80 00 2c ble 200b8a8 <_Scheduler_CBS_Create_server+0xcc> 200b7fc: 03 00 80 84 sethi %hi(0x2021000), %g1 params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 200b800: c8 00 63 ac ld [ %g1 + 0x3ac ], %g4 ! 20213ac <_Scheduler_CBS_Maximum_servers> 200b804: 80 a1 20 00 cmp %g4, 0 200b808: 02 80 00 11 be 200b84c <_Scheduler_CBS_Create_server+0x70><== NEVER TAKEN 200b80c: 37 00 80 89 sethi %hi(0x2022400), %i3 if ( !_Scheduler_CBS_Server_list[i] ) 200b810: fa 06 e2 78 ld [ %i3 + 0x278 ], %i5 ! 2022678 <_Scheduler_CBS_Server_list> 200b814: c2 07 40 00 ld [ %i5 ], %g1 200b818: 80 a0 60 00 cmp %g1, 0 200b81c: 02 80 00 21 be 200b8a0 <_Scheduler_CBS_Create_server+0xc4> 200b820: b0 10 20 00 clr %i0 200b824: 10 80 00 06 b 200b83c <_Scheduler_CBS_Create_server+0x60> 200b828: 82 10 20 00 clr %g1 200b82c: c6 07 40 02 ld [ %i5 + %g2 ], %g3 200b830: 80 a0 e0 00 cmp %g3, 0 200b834: 02 80 00 08 be 200b854 <_Scheduler_CBS_Create_server+0x78> 200b838: b0 10 00 02 mov %g2, %i0 params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 200b83c: 82 00 60 01 inc %g1 200b840: 80 a0 40 04 cmp %g1, %g4 200b844: 12 bf ff fa bne 200b82c <_Scheduler_CBS_Create_server+0x50> 200b848: 85 28 60 02 sll %g1, 2, %g2 if ( !_Scheduler_CBS_Server_list[i] ) break; } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; 200b84c: 81 c7 e0 08 ret 200b850: 91 e8 3f e6 restore %g0, -26, %o0 *server_id = i; 200b854: c2 26 80 00 st %g1, [ %i2 ] _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); 200b858: 40 00 08 2d call 200d90c <_Workspace_Allocate> 200b85c: 90 10 20 10 mov 0x10, %o0 the_server = _Scheduler_CBS_Server_list[*server_id]; 200b860: c2 06 80 00 ld [ %i2 ], %g1 if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 200b864: d0 27 40 18 st %o0, [ %i5 + %i0 ] _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; 200b868: c4 06 e2 78 ld [ %i3 + 0x278 ], %g2 200b86c: 83 28 60 02 sll %g1, 2, %g1 200b870: c2 00 80 01 ld [ %g2 + %g1 ], %g1 if ( !the_server ) 200b874: 80 a0 60 00 cmp %g1, 0 200b878: 02 80 00 0e be 200b8b0 <_Scheduler_CBS_Create_server+0xd4><== NEVER TAKEN 200b87c: 86 10 3f ff mov -1, %g3 return SCHEDULER_CBS_ERROR_NO_MEMORY; the_server->parameters = *params; 200b880: c4 07 00 00 ld [ %i4 ], %g2 200b884: c4 20 60 04 st %g2, [ %g1 + 4 ] 200b888: c4 07 20 04 ld [ %i4 + 4 ], %g2 the_server->task_id = -1; 200b88c: c6 20 40 00 st %g3, [ %g1 ] _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; the_server->parameters = *params; 200b890: c4 20 60 08 st %g2, [ %g1 + 8 ] the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback; 200b894: f2 20 60 0c st %i1, [ %g1 + 0xc ] return SCHEDULER_CBS_OK; 200b898: 81 c7 e0 08 ret 200b89c: 91 e8 20 00 restore %g0, 0, %o0 params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { if ( !_Scheduler_CBS_Server_list[i] ) 200b8a0: 10 bf ff ed b 200b854 <_Scheduler_CBS_Create_server+0x78> 200b8a4: 82 10 20 00 clr %g1 if ( params->budget <= 0 || params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 200b8a8: 81 c7 e0 08 ret 200b8ac: 91 e8 3f ee restore %g0, -18, %o0 the_server->parameters = *params; the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback; return SCHEDULER_CBS_OK; } 200b8b0: 81 c7 e0 08 ret <== NOT EXECUTED 200b8b4: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED =============================================================================== 0200b938 <_Scheduler_CBS_Detach_thread>: int _Scheduler_CBS_Detach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 200b938: 9d e3 bf 98 save %sp, -104, %sp Objects_Locations location; Thread_Control *the_thread; Scheduler_CBS_Per_thread *sched_info; the_thread = _Thread_Get(task_id, &location); 200b93c: 92 07 bf fc add %fp, -4, %o1 200b940: 40 00 03 9d call 200c7b4 <_Thread_Get> 200b944: 90 10 00 19 mov %i1, %o0 /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 200b948: ba 92 20 00 orcc %o0, 0, %i5 200b94c: 02 80 00 1e be 200b9c4 <_Scheduler_CBS_Detach_thread+0x8c> 200b950: 01 00 00 00 nop _Thread_Enable_dispatch(); 200b954: 40 00 03 8b call 200c780 <_Thread_Enable_dispatch> 200b958: 01 00 00 00 nop } if ( server_id >= _Scheduler_CBS_Maximum_servers ) 200b95c: 03 00 80 84 sethi %hi(0x2021000), %g1 200b960: c2 00 63 ac ld [ %g1 + 0x3ac ], %g1 ! 20213ac <_Scheduler_CBS_Maximum_servers> 200b964: 80 a6 00 01 cmp %i0, %g1 200b968: 1a 80 00 17 bcc 200b9c4 <_Scheduler_CBS_Detach_thread+0x8c> 200b96c: 03 00 80 89 sethi %hi(0x2022400), %g1 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !the_thread ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) 200b970: c2 00 62 78 ld [ %g1 + 0x278 ], %g1 ! 2022678 <_Scheduler_CBS_Server_list> 200b974: b1 2e 20 02 sll %i0, 2, %i0 200b978: c2 00 40 18 ld [ %g1 + %i0 ], %g1 200b97c: 80 a0 60 00 cmp %g1, 0 200b980: 02 80 00 13 be 200b9cc <_Scheduler_CBS_Detach_thread+0x94> 200b984: 01 00 00 00 nop return SCHEDULER_CBS_ERROR_NOSERVER; /* Thread and server are not attached. */ if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id ) 200b988: c4 00 40 00 ld [ %g1 ], %g2 200b98c: 80 a0 80 19 cmp %g2, %i1 200b990: 12 80 00 0d bne 200b9c4 <_Scheduler_CBS_Detach_thread+0x8c><== NEVER TAKEN 200b994: 84 10 3f ff mov -1, %g2 return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; _Scheduler_CBS_Server_list[server_id]->task_id = -1; sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL; 200b998: c8 07 60 88 ld [ %i5 + 0x88 ], %g4 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 200b99c: c6 07 60 a0 ld [ %i5 + 0xa0 ], %g3 return SCHEDULER_CBS_ERROR_NOSERVER; /* Thread and server are not attached. */ if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; _Scheduler_CBS_Server_list[server_id]->task_id = -1; 200b9a0: c4 20 40 00 st %g2, [ %g1 ] sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL; the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout; 200b9a4: c4 07 60 a4 ld [ %i5 + 0xa4 ], %g2 the_thread->is_preemptible = the_thread->Start.is_preemptible; 200b9a8: c2 0f 60 9c ldub [ %i5 + 0x9c ], %g1 if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; _Scheduler_CBS_Server_list[server_id]->task_id = -1; sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL; 200b9ac: c0 21 20 18 clr [ %g4 + 0x18 ] the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 200b9b0: c6 27 60 78 st %g3, [ %i5 + 0x78 ] the_thread->budget_callout = the_thread->Start.budget_callout; 200b9b4: c4 27 60 7c st %g2, [ %i5 + 0x7c ] the_thread->is_preemptible = the_thread->Start.is_preemptible; 200b9b8: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ] return SCHEDULER_CBS_OK; 200b9bc: 81 c7 e0 08 ret 200b9c0: 91 e8 20 00 restore %g0, 0, %o0 if ( the_thread ) { _Thread_Enable_dispatch(); } if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 200b9c4: 81 c7 e0 08 ret 200b9c8: 91 e8 3f ee restore %g0, -18, %o0 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout; the_thread->is_preemptible = the_thread->Start.is_preemptible; return SCHEDULER_CBS_OK; } 200b9cc: 81 c7 e0 08 ret 200b9d0: 91 e8 3f e7 restore %g0, -25, %o0 =============================================================================== 0200bbac <_Scheduler_CBS_Get_server_id>: rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 200bbac: 03 00 80 84 sethi %hi(0x2021000), %g1 200bbb0: c6 00 63 ac ld [ %g1 + 0x3ac ], %g3 ! 20213ac <_Scheduler_CBS_Maximum_servers> 200bbb4: 80 a0 e0 00 cmp %g3, 0 200bbb8: 02 80 00 11 be 200bbfc <_Scheduler_CBS_Get_server_id+0x50><== NEVER TAKEN 200bbbc: 03 00 80 89 sethi %hi(0x2022400), %g1 200bbc0: c8 00 62 78 ld [ %g1 + 0x278 ], %g4 ! 2022678 <_Scheduler_CBS_Server_list> 200bbc4: 82 10 20 00 clr %g1 #include #include #include #include int _Scheduler_CBS_Get_server_id ( 200bbc8: 85 28 60 02 sll %g1, 2, %g2 Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { if ( _Scheduler_CBS_Server_list[i] && 200bbcc: c4 01 00 02 ld [ %g4 + %g2 ], %g2 200bbd0: 80 a0 a0 00 cmp %g2, 0 200bbd4: 22 80 00 07 be,a 200bbf0 <_Scheduler_CBS_Get_server_id+0x44> 200bbd8: 82 00 60 01 inc %g1 200bbdc: c4 00 80 00 ld [ %g2 ], %g2 200bbe0: 80 a0 80 08 cmp %g2, %o0 200bbe4: 22 80 00 08 be,a 200bc04 <_Scheduler_CBS_Get_server_id+0x58> 200bbe8: c2 22 40 00 st %g1, [ %o1 ] rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 200bbec: 82 00 60 01 inc %g1 200bbf0: 80 a0 40 03 cmp %g1, %g3 200bbf4: 12 bf ff f6 bne 200bbcc <_Scheduler_CBS_Get_server_id+0x20> 200bbf8: 85 28 60 02 sll %g1, 2, %g2 *server_id = i; return SCHEDULER_CBS_OK; } } return SCHEDULER_CBS_ERROR_NOSERVER; } 200bbfc: 81 c3 e0 08 retl 200bc00: 90 10 3f e7 mov -25, %o0 unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { if ( _Scheduler_CBS_Server_list[i] && _Scheduler_CBS_Server_list[i]->task_id == task_id ) { *server_id = i; return SCHEDULER_CBS_OK; 200bc04: 81 c3 e0 08 retl 200bc08: 90 10 20 00 clr %o0 =============================================================================== 0200bc78 <_Scheduler_CBS_Initialize>: } } int _Scheduler_CBS_Initialize(void) { 200bc78: 9d e3 bf a0 save %sp, -96, %sp unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); 200bc7c: 3b 00 80 84 sethi %hi(0x2021000), %i5 200bc80: d0 07 63 ac ld [ %i5 + 0x3ac ], %o0 ! 20213ac <_Scheduler_CBS_Maximum_servers> } int _Scheduler_CBS_Initialize(void) { unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( 200bc84: 40 00 07 22 call 200d90c <_Workspace_Allocate> 200bc88: 91 2a 20 02 sll %o0, 2, %o0 200bc8c: 09 00 80 89 sethi %hi(0x2022400), %g4 _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) 200bc90: 80 a2 20 00 cmp %o0, 0 200bc94: 02 80 00 10 be 200bcd4 <_Scheduler_CBS_Initialize+0x5c> <== NEVER TAKEN 200bc98: d0 21 22 78 st %o0, [ %g4 + 0x278 ] return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 200bc9c: c6 07 63 ac ld [ %i5 + 0x3ac ], %g3 200bca0: 80 a0 e0 00 cmp %g3, 0 200bca4: 12 80 00 05 bne 200bcb8 <_Scheduler_CBS_Initialize+0x40> <== ALWAYS TAKEN 200bca8: 82 10 20 00 clr %g1 _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; 200bcac: 81 c7 e0 08 ret <== NOT EXECUTED 200bcb0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 200bcb4: d0 01 22 78 ld [ %g4 + 0x278 ], %o0 _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { _Scheduler_CBS_Server_list[i] = NULL; 200bcb8: 85 28 60 02 sll %g1, 2, %g2 unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 200bcbc: 82 00 60 01 inc %g1 200bcc0: 80 a0 40 03 cmp %g1, %g3 200bcc4: 12 bf ff fc bne 200bcb4 <_Scheduler_CBS_Initialize+0x3c> 200bcc8: c0 22 00 02 clr [ %o0 + %g2 ] _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; 200bccc: 81 c7 e0 08 ret 200bcd0: 91 e8 20 00 restore %g0, 0, %o0 { unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; 200bcd4: b0 10 3f ef mov -17, %i0 <== NOT EXECUTED for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; } 200bcd8: 81 c7 e0 08 ret <== NOT EXECUTED 200bcdc: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 0200a800 <_Scheduler_CBS_Release_job>: { Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; Scheduler_CBS_Server *serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server; 200a800: c2 02 20 88 ld [ %o0 + 0x88 ], %g1 if (deadline) { 200a804: 80 a2 60 00 cmp %o1, 0 200a808: 02 80 00 11 be 200a84c <_Scheduler_CBS_Release_job+0x4c> 200a80c: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 /* Initializing or shifting deadline. */ if (serv_info) 200a810: 80 a0 60 00 cmp %g1, 0 200a814: 02 80 00 13 be 200a860 <_Scheduler_CBS_Release_job+0x60> 200a818: 07 00 80 81 sethi %hi(0x2020400), %g3 new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline) 200a81c: c4 00 60 04 ld [ %g1 + 4 ], %g2 200a820: d2 00 e2 28 ld [ %g3 + 0x228 ], %o1 200a824: 92 02 40 02 add %o1, %g2, %o1 200a828: 05 20 00 00 sethi %hi(0x80000000), %g2 200a82c: 92 2a 40 02 andn %o1, %g2, %o1 new_priority = the_thread->Start.initial_priority; } /* Budget replenishment for the next job. */ if (serv_info) the_thread->cpu_time_budget = serv_info->parameters.budget; 200a830: c2 00 60 08 ld [ %g1 + 8 ], %g1 200a834: c2 22 20 74 st %g1, [ %o0 + 0x74 ] the_thread->real_priority = new_priority; 200a838: d2 22 20 18 st %o1, [ %o0 + 0x18 ] _Thread_Change_priority(the_thread, new_priority, true); 200a83c: 94 10 20 01 mov 1, %o2 200a840: 82 13 c0 00 mov %o7, %g1 200a844: 40 00 01 3a call 200ad2c <_Thread_Change_priority> 200a848: 9e 10 40 00 mov %g1, %o7 /* Switch back to background priority. */ new_priority = the_thread->Start.initial_priority; } /* Budget replenishment for the next job. */ if (serv_info) 200a84c: 80 a0 60 00 cmp %g1, 0 200a850: 12 bf ff f8 bne 200a830 <_Scheduler_CBS_Release_job+0x30> <== ALWAYS TAKEN 200a854: d2 02 20 ac ld [ %o0 + 0xac ], %o1 the_thread->cpu_time_budget = serv_info->parameters.budget; the_thread->real_priority = new_priority; 200a858: 10 bf ff f9 b 200a83c <_Scheduler_CBS_Release_job+0x3c> <== NOT EXECUTED 200a85c: d2 22 20 18 st %o1, [ %o0 + 0x18 ] <== NOT EXECUTED /* Initializing or shifting deadline. */ if (serv_info) new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline) & ~SCHEDULER_EDF_PRIO_MSB; else new_priority = (_Watchdog_Ticks_since_boot + deadline) 200a860: 03 00 80 81 sethi %hi(0x2020400), %g1 200a864: c2 00 62 28 ld [ %g1 + 0x228 ], %g1 ! 2020628 <_Watchdog_Ticks_since_boot> 200a868: 92 02 40 01 add %o1, %g1, %o1 200a86c: 03 20 00 00 sethi %hi(0x80000000), %g1 200a870: 10 bf ff f2 b 200a838 <_Scheduler_CBS_Release_job+0x38> 200a874: 92 2a 40 01 andn %o1, %g1, %o1 =============================================================================== 0200a878 <_Scheduler_CBS_Unblock>: #include void _Scheduler_CBS_Unblock( Thread_Control *the_thread ) { 200a878: 9d e3 bf a0 save %sp, -96, %sp Scheduler_CBS_Per_thread *sched_info; Scheduler_CBS_Server *serv_info; Priority_Control new_priority; _Scheduler_EDF_Enqueue(the_thread); 200a87c: 40 00 00 50 call 200a9bc <_Scheduler_EDF_Enqueue> 200a880: 90 10 00 18 mov %i0, %o0 /* TODO: flash critical section? */ sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server; 200a884: c2 06 20 88 ld [ %i0 + 0x88 ], %g1 200a888: fa 00 60 18 ld [ %g1 + 0x18 ], %i5 * Late unblock rule for deadline-driven tasks. The remaining time to * deadline must be sufficient to serve the remaining computation time * without increased utilization of this task. It might cause a deadline * miss of another task. */ if (serv_info) { 200a88c: 80 a7 60 00 cmp %i5, 0 200a890: 02 80 00 19 be 200a8f4 <_Scheduler_CBS_Unblock+0x7c> 200a894: 03 00 80 81 sethi %hi(0x2020400), %g1 time_t budget = serv_info->parameters.budget; time_t deadline_left = the_thread->cpu_time_budget; time_t budget_left = the_thread->real_priority - _Watchdog_Ticks_since_boot; if ( deadline*budget_left > budget*deadline_left ) { 200a898: d2 07 60 04 ld [ %i5 + 4 ], %o1 */ if (serv_info) { time_t deadline = serv_info->parameters.deadline; time_t budget = serv_info->parameters.budget; time_t deadline_left = the_thread->cpu_time_budget; time_t budget_left = the_thread->real_priority - 200a89c: d0 00 62 28 ld [ %g1 + 0x228 ], %o0 200a8a0: f8 06 20 18 ld [ %i0 + 0x18 ], %i4 _Watchdog_Ticks_since_boot; if ( deadline*budget_left > budget*deadline_left ) { 200a8a4: 40 00 41 a0 call 201af24 <.umul> 200a8a8: 90 27 00 08 sub %i4, %o0, %o0 200a8ac: d2 06 20 74 ld [ %i0 + 0x74 ], %o1 200a8b0: b6 10 00 08 mov %o0, %i3 200a8b4: 40 00 41 9c call 201af24 <.umul> 200a8b8: d0 07 60 08 ld [ %i5 + 8 ], %o0 200a8bc: 80 a6 c0 08 cmp %i3, %o0 200a8c0: 24 80 00 0e ble,a 200a8f8 <_Scheduler_CBS_Unblock+0x80> 200a8c4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 /* Put late unblocked task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; 200a8c8: d2 06 20 ac ld [ %i0 + 0xac ], %o1 if ( the_thread->real_priority != new_priority ) 200a8cc: 80 a7 00 09 cmp %i4, %o1 200a8d0: 32 80 00 02 bne,a 200a8d8 <_Scheduler_CBS_Unblock+0x60> 200a8d4: d2 26 20 18 st %o1, [ %i0 + 0x18 ] the_thread->real_priority = new_priority; if ( the_thread->current_priority != new_priority ) 200a8d8: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 200a8dc: 80 a2 00 09 cmp %o0, %o1 200a8e0: 02 80 00 07 be 200a8fc <_Scheduler_CBS_Unblock+0x84> 200a8e4: 3b 00 80 82 sethi %hi(0x2020800), %i5 _Thread_Change_priority(the_thread, new_priority, true); 200a8e8: 90 10 00 18 mov %i0, %o0 200a8ec: 40 00 01 10 call 200ad2c <_Thread_Change_priority> 200a8f0: 94 10 20 01 mov 1, %o2 200a8f4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority, 200a8f8: 3b 00 80 82 sethi %hi(0x2020800), %i5 200a8fc: ba 17 62 60 or %i5, 0x260, %i5 ! 2020a60 <_Per_CPU_Information> 200a900: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 200a904: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 200a908: 03 00 80 7d sethi %hi(0x201f400), %g1 200a90c: c2 00 63 f0 ld [ %g1 + 0x3f0 ], %g1 ! 201f7f0 <_Scheduler+0x30> 200a910: 9f c0 40 00 call %g1 200a914: 01 00 00 00 nop 200a918: 80 a2 20 00 cmp %o0, 0 200a91c: 04 80 00 0a ble 200a944 <_Scheduler_CBS_Unblock+0xcc> 200a920: 01 00 00 00 nop _Thread_Heir->current_priority)) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200a924: c2 07 60 0c ld [ %i5 + 0xc ], %g1 * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority, _Thread_Heir->current_priority)) { _Thread_Heir = the_thread; 200a928: f0 27 60 10 st %i0, [ %i5 + 0x10 ] if ( _Thread_Executing->is_preemptible || 200a92c: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1 200a930: 80 a0 60 00 cmp %g1, 0 200a934: 22 80 00 06 be,a 200a94c <_Scheduler_CBS_Unblock+0xd4> 200a938: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 200a93c: 82 10 20 01 mov 1, %g1 200a940: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ] 200a944: 81 c7 e0 08 ret 200a948: 81 e8 00 00 restore * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority, _Thread_Heir->current_priority)) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200a94c: 80 a0 60 00 cmp %g1, 0 200a950: 12 bf ff fd bne 200a944 <_Scheduler_CBS_Unblock+0xcc> <== ALWAYS TAKEN 200a954: 82 10 20 01 mov 1, %g1 the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 200a958: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ] <== NOT EXECUTED 200a95c: 30 bf ff fa b,a 200a944 <_Scheduler_CBS_Unblock+0xcc> <== NOT EXECUTED =============================================================================== 0200a7d0 <_Scheduler_EDF_Allocate>: #include void *_Scheduler_EDF_Allocate( Thread_Control *the_thread ) { 200a7d0: 9d e3 bf a0 save %sp, -96, %sp void *sched; Scheduler_EDF_Per_thread *schinfo; sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) ); 200a7d4: 40 00 07 01 call 200c3d8 <_Workspace_Allocate> 200a7d8: 90 10 20 18 mov 0x18, %o0 if ( sched ) { 200a7dc: 80 a2 20 00 cmp %o0, 0 200a7e0: 02 80 00 05 be 200a7f4 <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN 200a7e4: 82 10 20 02 mov 2, %g1 the_thread->scheduler_info = sched; 200a7e8: d0 26 20 88 st %o0, [ %i0 + 0x88 ] schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info); schinfo->thread = the_thread; 200a7ec: f0 22 00 00 st %i0, [ %o0 ] schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN; 200a7f0: c2 22 20 14 st %g1, [ %o0 + 0x14 ] } return sched; } 200a7f4: 81 c7 e0 08 ret 200a7f8: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 0200a9b4 <_Scheduler_EDF_Unblock>: #include void _Scheduler_EDF_Unblock( Thread_Control *the_thread ) { 200a9b4: 9d e3 bf a0 save %sp, -96, %sp _Scheduler_EDF_Enqueue(the_thread); 200a9b8: 7f ff ff a8 call 200a858 <_Scheduler_EDF_Enqueue> 200a9bc: 90 10 00 18 mov %i0, %o0 * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_lower_than( 200a9c0: 3b 00 80 82 sethi %hi(0x2020800), %i5 200a9c4: ba 17 61 b0 or %i5, 0x1b0, %i5 ! 20209b0 <_Per_CPU_Information> 200a9c8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 200a9cc: d0 00 60 14 ld [ %g1 + 0x14 ], %o0 200a9d0: 03 00 80 7d sethi %hi(0x201f400), %g1 200a9d4: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 201f740 <_Scheduler+0x30> 200a9d8: 9f c0 40 00 call %g1 200a9dc: d2 06 20 14 ld [ %i0 + 0x14 ], %o1 200a9e0: 80 a2 20 00 cmp %o0, 0 200a9e4: 26 80 00 04 bl,a 200a9f4 <_Scheduler_EDF_Unblock+0x40> 200a9e8: c2 07 60 0c ld [ %i5 + 0xc ], %g1 200a9ec: 81 c7 e0 08 ret 200a9f0: 81 e8 00 00 restore _Thread_Heir->current_priority, the_thread->current_priority )) { _Thread_Heir = the_thread; 200a9f4: f0 27 60 10 st %i0, [ %i5 + 0x10 ] if ( _Thread_Executing->is_preemptible || 200a9f8: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1 200a9fc: 80 a0 60 00 cmp %g1, 0 200aa00: 22 80 00 06 be,a 200aa18 <_Scheduler_EDF_Unblock+0x64> 200aa04: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 200aa08: 82 10 20 01 mov 1, %g1 200aa0c: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ] 200aa10: 81 c7 e0 08 ret 200aa14: 81 e8 00 00 restore */ if ( _Scheduler_Is_priority_lower_than( _Thread_Heir->current_priority, the_thread->current_priority )) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200aa18: 80 a0 60 00 cmp %g1, 0 200aa1c: 12 bf ff f4 bne 200a9ec <_Scheduler_EDF_Unblock+0x38> <== ALWAYS TAKEN 200aa20: 82 10 20 01 mov 1, %g1 the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 200aa24: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ] <== NOT EXECUTED 200aa28: 30 bf ff fa b,a 200aa10 <_Scheduler_EDF_Unblock+0x5c> <== NOT EXECUTED =============================================================================== 0200a10c <_Scheduler_priority_Tick>: #include #include void _Scheduler_priority_Tick( void ) { 200a10c: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; 200a110: 03 00 80 7b sethi %hi(0x201ec00), %g1 200a114: d0 00 61 ec ld [ %g1 + 0x1ec ], %o0 ! 201edec <_Per_CPU_Information+0xc> /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 200a118: c2 0a 20 70 ldub [ %o0 + 0x70 ], %g1 200a11c: 80 a0 60 00 cmp %g1, 0 200a120: 02 80 00 26 be 200a1b8 <_Scheduler_priority_Tick+0xac> 200a124: 01 00 00 00 nop return; if ( !_States_Is_ready( executing->current_state ) ) 200a128: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 200a12c: 80 a0 60 00 cmp %g1, 0 200a130: 12 80 00 22 bne 200a1b8 <_Scheduler_priority_Tick+0xac> 200a134: 01 00 00 00 nop /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 200a138: c2 02 20 78 ld [ %o0 + 0x78 ], %g1 200a13c: 80 a0 60 01 cmp %g1, 1 200a140: 0a 80 00 07 bcs 200a15c <_Scheduler_priority_Tick+0x50> 200a144: 80 a0 60 02 cmp %g1, 2 200a148: 28 80 00 10 bleu,a 200a188 <_Scheduler_priority_Tick+0x7c> 200a14c: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 200a150: 80 a0 60 03 cmp %g1, 3 200a154: 22 80 00 04 be,a 200a164 <_Scheduler_priority_Tick+0x58> <== ALWAYS TAKEN 200a158: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 200a15c: 81 c7 e0 08 ret 200a160: 81 e8 00 00 restore } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 200a164: 82 00 7f ff add %g1, -1, %g1 200a168: 80 a0 60 00 cmp %g1, 0 200a16c: 12 bf ff fc bne 200a15c <_Scheduler_priority_Tick+0x50> 200a170: c2 22 20 74 st %g1, [ %o0 + 0x74 ] (*executing->budget_callout)( executing ); 200a174: c2 02 20 7c ld [ %o0 + 0x7c ], %g1 200a178: 9f c0 40 00 call %g1 200a17c: 01 00 00 00 nop 200a180: 81 c7 e0 08 ret 200a184: 81 e8 00 00 restore case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: #endif if ( (int)(--executing->cpu_time_budget) <= 0 ) { 200a188: 82 00 7f ff add %g1, -1, %g1 200a18c: 80 a0 60 00 cmp %g1, 0 200a190: 14 bf ff f3 bg 200a15c <_Scheduler_priority_Tick+0x50> 200a194: c2 22 20 74 st %g1, [ %o0 + 0x74 ] * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield(); 200a198: 03 00 80 76 sethi %hi(0x201d800), %g1 200a19c: c2 00 63 cc ld [ %g1 + 0x3cc ], %g1 ! 201dbcc <_Scheduler+0xc> 200a1a0: 9f c0 40 00 call %g1 200a1a4: d0 27 bf fc st %o0, [ %fp + -4 ] * executing thread's timeslice is reset. Otherwise, the * currently executing thread is placed at the rear of the * FIFO for this priority and a new heir is selected. */ _Scheduler_Yield(); executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 200a1a8: 03 00 80 7a sethi %hi(0x201e800), %g1 200a1ac: d0 07 bf fc ld [ %fp + -4 ], %o0 200a1b0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 200a1b4: c2 22 20 74 st %g1, [ %o0 + 0x74 ] 200a1b8: 81 c7 e0 08 ret 200a1bc: 81 e8 00 00 restore =============================================================================== 0200a9cc <_Scheduler_simple_Ready_queue_enqueue_first>: { Chain_Control *ready; Chain_Node *the_node; Thread_Control *current; ready = (Chain_Control *)_Scheduler.information; 200a9cc: 03 00 80 7a sethi %hi(0x201e800), %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 200a9d0: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 201ebc0 <_Scheduler> */ for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) { current = (Thread_Control *) the_node; /* break when AT HEAD OF (or PAST) our priority */ if ( the_thread->current_priority <= current->current_priority ) { 200a9d4: c6 02 20 14 ld [ %o0 + 0x14 ], %g3 200a9d8: c2 00 40 00 ld [ %g1 ], %g1 200a9dc: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 200a9e0: 80 a0 80 03 cmp %g2, %g3 200a9e4: 3a 80 00 08 bcc,a 200aa04 <_Scheduler_simple_Ready_queue_enqueue_first+0x38> 200a9e8: c2 00 60 04 ld [ %g1 + 4 ], %g1 * Do NOT need to check for end of chain because there is always * at least one task on the ready chain -- the IDLE task. It can * never block, should never attempt to obtain a semaphore or mutex, * and thus will always be there. */ for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) { 200a9ec: c2 00 40 00 ld [ %g1 ], %g1 current = (Thread_Control *) the_node; /* break when AT HEAD OF (or PAST) our priority */ if ( the_thread->current_priority <= current->current_priority ) { 200a9f0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 200a9f4: 80 a0 80 03 cmp %g2, %g3 200a9f8: 2a bf ff fe bcs,a 200a9f0 <_Scheduler_simple_Ready_queue_enqueue_first+0x24><== NEVER TAKEN 200a9fc: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED current = (Thread_Control *)current->Object.Node.previous; 200aa00: c2 00 60 04 ld [ %g1 + 4 ], %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 200aa04: c4 00 40 00 ld [ %g1 ], %g2 Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 200aa08: c2 22 20 04 st %g1, [ %o0 + 4 ] before_node = after_node->next; after_node->next = the_node; 200aa0c: d0 20 40 00 st %o0, [ %g1 ] the_node->next = before_node; 200aa10: c4 22 00 00 st %g2, [ %o0 ] before_node->previous = the_node; 200aa14: 81 c3 e0 08 retl 200aa18: d0 20 a0 04 st %o0, [ %g2 + 4 ] =============================================================================== 02008a20 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 2008a20: 9d e3 bf a0 save %sp, -96, %sp uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); 2008a24: 03 00 80 80 sethi %hi(0x2020000), %g1 ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 2008a28: d2 00 61 7c ld [ %g1 + 0x17c ], %o1 ! 202017c 2008a2c: 11 00 03 d0 sethi %hi(0xf4000), %o0 2008a30: 40 00 4a ef call 201b5ec <.udiv> 2008a34: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 2008a38: 80 a6 20 00 cmp %i0, 0 2008a3c: 02 80 00 2c be 2008aec <_TOD_Validate+0xcc> <== NEVER TAKEN 2008a40: 82 10 20 00 clr %g1 2008a44: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 2008a48: 80 a2 00 02 cmp %o0, %g2 2008a4c: 28 80 00 26 bleu,a 2008ae4 <_TOD_Validate+0xc4> 2008a50: b0 08 60 01 and %g1, 1, %i0 (the_tod->ticks >= ticks_per_second) || 2008a54: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 2008a58: 80 a0 a0 3b cmp %g2, 0x3b 2008a5c: 38 80 00 22 bgu,a 2008ae4 <_TOD_Validate+0xc4> 2008a60: b0 08 60 01 and %g1, 1, %i0 (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 2008a64: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 2008a68: 80 a0 a0 3b cmp %g2, 0x3b 2008a6c: 38 80 00 1e bgu,a 2008ae4 <_TOD_Validate+0xc4> 2008a70: b0 08 60 01 and %g1, 1, %i0 (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 2008a74: c4 06 20 0c ld [ %i0 + 0xc ], %g2 2008a78: 80 a0 a0 17 cmp %g2, 0x17 2008a7c: 38 80 00 1a bgu,a 2008ae4 <_TOD_Validate+0xc4> 2008a80: b0 08 60 01 and %g1, 1, %i0 (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 2008a84: c4 06 20 04 ld [ %i0 + 4 ], %g2 rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || 2008a88: 80 a0 a0 00 cmp %g2, 0 2008a8c: 02 80 00 15 be 2008ae0 <_TOD_Validate+0xc0> <== NEVER TAKEN 2008a90: 80 a0 a0 0c cmp %g2, 0xc (the_tod->month == 0) || 2008a94: 38 80 00 14 bgu,a 2008ae4 <_TOD_Validate+0xc4> 2008a98: b0 08 60 01 and %g1, 1, %i0 (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 2008a9c: c6 06 00 00 ld [ %i0 ], %g3 (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || 2008aa0: 80 a0 e7 c3 cmp %g3, 0x7c3 2008aa4: 28 80 00 10 bleu,a 2008ae4 <_TOD_Validate+0xc4> 2008aa8: b0 08 60 01 and %g1, 1, %i0 (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 2008aac: c8 06 20 08 ld [ %i0 + 8 ], %g4 (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 2008ab0: 80 a1 20 00 cmp %g4, 0 2008ab4: 02 80 00 0b be 2008ae0 <_TOD_Validate+0xc0> <== NEVER TAKEN 2008ab8: 80 88 e0 03 btst 3, %g3 (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 2008abc: 32 80 00 0f bne,a 2008af8 <_TOD_Validate+0xd8> 2008ac0: 85 28 a0 02 sll %g2, 2, %g2 days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 2008ac4: 82 00 a0 0d add %g2, 0xd, %g1 2008ac8: 05 00 80 7a sethi %hi(0x201e800), %g2 2008acc: 83 28 60 02 sll %g1, 2, %g1 2008ad0: 84 10 a3 b8 or %g2, 0x3b8, %g2 2008ad4: 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 ) 2008ad8: 80 a0 40 04 cmp %g1, %g4 2008adc: 82 60 3f ff subx %g0, -1, %g1 return false; return true; } 2008ae0: b0 08 60 01 and %g1, 1, %i0 2008ae4: 81 c7 e0 08 ret 2008ae8: 81 e8 00 00 restore 2008aec: b0 08 60 01 and %g1, 1, %i0 <== NOT EXECUTED 2008af0: 81 c7 e0 08 ret <== NOT EXECUTED 2008af4: 81 e8 00 00 restore <== NOT EXECUTED return false; if ( (the_tod->year % 4) == 0 ) days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 2008af8: 03 00 80 7a sethi %hi(0x201e800), %g1 2008afc: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 201ebb8 <_TOD_Days_per_month> 2008b00: c2 00 40 02 ld [ %g1 + %g2 ], %g1 if ( the_tod->day > days_in_month ) 2008b04: 80 a0 40 04 cmp %g1, %g4 2008b08: 10 bf ff f6 b 2008ae0 <_TOD_Validate+0xc0> 2008b0c: 82 60 3f ff subx %g0, -1, %g1 =============================================================================== 0200a3dc <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 200a3dc: 9d e3 bf a0 save %sp, -96, %sp States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 200a3e0: f6 06 20 10 ld [ %i0 + 0x10 ], %i3 /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 200a3e4: 40 00 03 b1 call 200b2a8 <_Thread_Set_transient> 200a3e8: 90 10 00 18 mov %i0, %o0 /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 200a3ec: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 200a3f0: 80 a0 40 19 cmp %g1, %i1 200a3f4: 02 80 00 05 be 200a408 <_Thread_Change_priority+0x2c> 200a3f8: ba 10 00 18 mov %i0, %i5 _Thread_Set_priority( the_thread, new_priority ); 200a3fc: 90 10 00 18 mov %i0, %o0 200a400: 40 00 03 90 call 200b240 <_Thread_Set_priority> 200a404: 92 10 00 19 mov %i1, %o1 _ISR_Disable( level ); 200a408: 7f ff e0 d7 call 2002764 200a40c: 01 00 00 00 nop 200a410: b2 10 00 08 mov %o0, %i1 /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 200a414: f8 07 60 10 ld [ %i5 + 0x10 ], %i4 if ( state != STATES_TRANSIENT ) { 200a418: 80 a7 20 04 cmp %i4, 4 200a41c: 02 80 00 18 be 200a47c <_Thread_Change_priority+0xa0> 200a420: 80 8e e0 04 btst 4, %i3 /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 200a424: 02 80 00 0b be 200a450 <_Thread_Change_priority+0x74> <== ALWAYS TAKEN 200a428: 82 0f 3f fb and %i4, -5, %g1 the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 200a42c: 7f ff e0 d2 call 2002774 <== NOT EXECUTED 200a430: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue ( States_Control the_states ) { return (the_states & STATES_WAITING_ON_THREAD_QUEUE); 200a434: 03 00 00 ef sethi %hi(0x3bc00), %g1 <== NOT EXECUTED 200a438: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( state ) ) { 200a43c: 80 8f 00 01 btst %i4, %g1 <== NOT EXECUTED 200a440: 32 80 00 0d bne,a 200a474 <_Thread_Change_priority+0x98> <== NOT EXECUTED 200a444: f0 07 60 44 ld [ %i5 + 0x44 ], %i0 <== NOT EXECUTED 200a448: 81 c7 e0 08 ret 200a44c: 81 e8 00 00 restore */ state = the_thread->current_state; if ( state != STATES_TRANSIENT ) { /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 200a450: c2 27 60 10 st %g1, [ %i5 + 0x10 ] _ISR_Enable( level ); 200a454: 7f ff e0 c8 call 2002774 200a458: 90 10 00 19 mov %i1, %o0 200a45c: 03 00 00 ef sethi %hi(0x3bc00), %g1 200a460: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 if ( _States_Is_waiting_on_thread_queue( state ) ) { 200a464: 80 8f 00 01 btst %i4, %g1 200a468: 02 bf ff f8 be 200a448 <_Thread_Change_priority+0x6c> 200a46c: 01 00 00 00 nop _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 200a470: f0 07 60 44 ld [ %i5 + 0x44 ], %i0 200a474: 40 00 03 42 call 200b17c <_Thread_queue_Requeue> 200a478: 93 e8 00 1d restore %g0, %i5, %o1 } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 200a47c: 22 80 00 1a be,a 200a4e4 <_Thread_Change_priority+0x108> <== ALWAYS TAKEN 200a480: c0 27 60 10 clr [ %i5 + 0x10 ] 200a484: 39 00 80 76 sethi %hi(0x201d800), %i4 <== NOT EXECUTED 200a488: b8 17 23 c0 or %i4, 0x3c0, %i4 ! 201dbc0 <_Scheduler> <== NOT EXECUTED _Scheduler_Enqueue_first( the_thread ); else _Scheduler_Enqueue( the_thread ); } _ISR_Flash( level ); 200a48c: 7f ff e0 ba call 2002774 200a490: 90 10 00 19 mov %i1, %o0 200a494: 7f ff e0 b4 call 2002764 200a498: 01 00 00 00 nop 200a49c: b0 10 00 08 mov %o0, %i0 * This kernel routine implements the scheduling decision logic for * the scheduler. It does NOT dispatch. */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void ) { _Scheduler.Operations.schedule(); 200a4a0: c2 07 20 08 ld [ %i4 + 8 ], %g1 200a4a4: 9f c0 40 00 call %g1 200a4a8: 01 00 00 00 nop * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 200a4ac: 03 00 80 7b sethi %hi(0x201ec00), %g1 200a4b0: 82 10 61 e0 or %g1, 0x1e0, %g1 ! 201ede0 <_Per_CPU_Information> 200a4b4: c4 00 60 0c ld [ %g1 + 0xc ], %g2 * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Scheduler_Schedule(); if ( !_Thread_Is_executing_also_the_heir() && 200a4b8: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 200a4bc: 80 a0 80 03 cmp %g2, %g3 200a4c0: 02 80 00 07 be 200a4dc <_Thread_Change_priority+0x100> 200a4c4: 01 00 00 00 nop 200a4c8: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2 200a4cc: 80 a0 a0 00 cmp %g2, 0 200a4d0: 02 80 00 03 be 200a4dc <_Thread_Change_priority+0x100> 200a4d4: 84 10 20 01 mov 1, %g2 _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 200a4d8: c4 28 60 18 stb %g2, [ %g1 + 0x18 ] _ISR_Enable( level ); 200a4dc: 7f ff e0 a6 call 2002774 200a4e0: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 200a4e4: 39 00 80 76 sethi %hi(0x201d800), %i4 * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); if ( prepend_it ) 200a4e8: 80 a6 a0 00 cmp %i2, 0 200a4ec: 02 80 00 06 be 200a504 <_Thread_Change_priority+0x128> 200a4f0: b8 17 23 c0 or %i4, 0x3c0, %i4 200a4f4: c2 07 20 28 ld [ %i4 + 0x28 ], %g1 200a4f8: 9f c0 40 00 call %g1 200a4fc: 90 10 00 1d mov %i5, %o0 200a500: 30 bf ff e3 b,a 200a48c <_Thread_Change_priority+0xb0> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 200a504: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 200a508: 9f c0 40 00 call %g1 200a50c: 90 10 00 1d mov %i5, %o0 200a510: 30 bf ff df b,a 200a48c <_Thread_Change_priority+0xb0> =============================================================================== 0200a730 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 200a730: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 200a734: 90 10 00 18 mov %i0, %o0 200a738: 40 00 00 77 call 200a914 <_Thread_Get> 200a73c: 92 07 bf fc add %fp, -4, %o1 switch ( location ) { 200a740: c2 07 bf fc ld [ %fp + -4 ], %g1 200a744: 80 a0 60 00 cmp %g1, 0 200a748: 12 80 00 09 bne 200a76c <_Thread_Delay_ended+0x3c> <== NEVER TAKEN 200a74c: 13 04 00 00 sethi %hi(0x10000000), %o1 #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 200a750: 7f ff ff 71 call 200a514 <_Thread_Clear_state> 200a754: 92 12 60 18 or %o1, 0x18, %o1 ! 10000018 * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 200a758: 03 00 80 7a sethi %hi(0x201e800), %g1 200a75c: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 201e8b0 <_Thread_Dispatch_disable_level> 200a760: 84 00 bf ff add %g2, -1, %g2 200a764: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] return _Thread_Dispatch_disable_level; 200a768: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 200a76c: 81 c7 e0 08 ret 200a770: 81 e8 00 00 restore =============================================================================== 0200a774 <_Thread_Dispatch>: * INTERRUPT LATENCY: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 200a774: 9d e3 bf 98 save %sp, -104, %sp * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 200a778: 27 00 80 7a sethi %hi(0x201e800), %l3 200a77c: c2 04 e0 b0 ld [ %l3 + 0xb0 ], %g1 ! 201e8b0 <_Thread_Dispatch_disable_level> 200a780: 82 00 60 01 inc %g1 200a784: c2 24 e0 b0 st %g1, [ %l3 + 0xb0 ] return _Thread_Dispatch_disable_level; 200a788: c2 04 e0 b0 ld [ %l3 + 0xb0 ], %g1 #endif /* * Now determine if we need to perform a dispatch on the current CPU. */ executing = _Thread_Executing; 200a78c: 31 00 80 7b sethi %hi(0x201ec00), %i0 200a790: b0 16 21 e0 or %i0, 0x1e0, %i0 ! 201ede0 <_Per_CPU_Information> _ISR_Disable( level ); 200a794: 7f ff df f4 call 2002764 200a798: f2 06 20 0c ld [ %i0 + 0xc ], %i1 while ( _Thread_Dispatch_necessary == true ) { 200a79c: c2 0e 20 18 ldub [ %i0 + 0x18 ], %g1 200a7a0: 80 a0 60 00 cmp %g1, 0 200a7a4: 02 80 00 45 be 200a8b8 <_Thread_Dispatch+0x144> 200a7a8: 01 00 00 00 nop heir = _Thread_Heir; 200a7ac: e0 06 20 10 ld [ %i0 + 0x10 ], %l0 _Thread_Dispatch_necessary = false; 200a7b0: c0 2e 20 18 clrb [ %i0 + 0x18 ] /* * When the heir and executing are the same, then we are being * requested to do the post switch dispatching. This is normally * done to dispatch signals. */ if ( heir == executing ) 200a7b4: 80 a6 40 10 cmp %i1, %l0 200a7b8: 02 80 00 40 be 200a8b8 <_Thread_Dispatch+0x144> 200a7bc: e0 26 20 0c st %l0, [ %i0 + 0xc ] 200a7c0: 25 00 80 7a sethi %hi(0x201e800), %l2 #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 200a7c4: 29 00 80 7a sethi %hi(0x201e800), %l4 200a7c8: a4 14 a1 2c or %l2, 0x12c, %l2 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 200a7cc: 10 80 00 35 b 200a8a0 <_Thread_Dispatch+0x12c> 200a7d0: 23 00 80 7a sethi %hi(0x201e800), %l1 _ISR_Enable( level ); 200a7d4: 7f ff df e8 call 2002774 200a7d8: 01 00 00 00 nop #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 200a7dc: 40 00 0e 26 call 200e074 <_TOD_Get_uptime> 200a7e0: 90 07 bf f8 add %fp, -8, %o0 _Timestamp_Subtract( 200a7e4: c4 1f bf f8 ldd [ %fp + -8 ], %g2 const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 200a7e8: f4 1e 20 20 ldd [ %i0 + 0x20 ], %i2 static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 200a7ec: f8 1e 60 80 ldd [ %i1 + 0x80 ], %i4 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 200a7f0: c2 04 80 00 ld [ %l2 ], %g1 const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 200a7f4: b6 a0 c0 1b subcc %g3, %i3, %i3 200a7f8: b4 60 80 1a subx %g2, %i2, %i2 static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 200a7fc: ba 87 40 1b addcc %i5, %i3, %i5 200a800: b8 47 00 1a addx %i4, %i2, %i4 200a804: f8 3e 60 80 std %i4, [ %i1 + 0x80 ] 200a808: 80 a0 60 00 cmp %g1, 0 200a80c: 02 80 00 06 be 200a824 <_Thread_Dispatch+0xb0> <== NEVER TAKEN 200a810: c4 3e 20 20 std %g2, [ %i0 + 0x20 ] executing->libc_reent = *_Thread_libc_reent; 200a814: c4 00 40 00 ld [ %g1 ], %g2 200a818: c4 26 61 54 st %g2, [ %i1 + 0x154 ] *_Thread_libc_reent = heir->libc_reent; 200a81c: c4 04 21 54 ld [ %l0 + 0x154 ], %g2 200a820: c4 20 40 00 st %g2, [ %g1 ] } _User_extensions_Thread_switch( executing, heir ); 200a824: 90 10 00 19 mov %i1, %o0 200a828: 40 00 03 9e call 200b6a0 <_User_extensions_Thread_switch> 200a82c: 92 10 00 10 mov %l0, %o1 if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 200a830: 90 06 60 c8 add %i1, 0xc8, %o0 200a834: 40 00 04 e5 call 200bbc8 <_CPU_Context_switch> 200a838: 92 04 20 c8 add %l0, 0xc8, %o1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 200a83c: c2 06 61 50 ld [ %i1 + 0x150 ], %g1 200a840: 80 a0 60 00 cmp %g1, 0 200a844: 02 80 00 0c be 200a874 <_Thread_Dispatch+0x100> 200a848: d0 04 61 28 ld [ %l1 + 0x128 ], %o0 200a84c: 80 a6 40 08 cmp %i1, %o0 200a850: 02 80 00 09 be 200a874 <_Thread_Dispatch+0x100> 200a854: 80 a2 20 00 cmp %o0, 0 !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 200a858: 02 80 00 04 be 200a868 <_Thread_Dispatch+0xf4> 200a85c: 01 00 00 00 nop _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 200a860: 40 00 04 a0 call 200bae0 <_CPU_Context_save_fp> 200a864: 90 02 21 50 add %o0, 0x150, %o0 _Context_Restore_fp( &executing->fp_context ); 200a868: 40 00 04 bb call 200bb54 <_CPU_Context_restore_fp> 200a86c: 90 06 61 50 add %i1, 0x150, %o0 _Thread_Allocated_fp = executing; 200a870: f2 24 61 28 st %i1, [ %l1 + 0x128 ] #endif #endif executing = _Thread_Executing; _ISR_Disable( level ); 200a874: 7f ff df bc call 2002764 200a878: f2 06 20 0c ld [ %i0 + 0xc ], %i1 /* * Now determine if we need to perform a dispatch on the current CPU. */ executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 200a87c: c2 0e 20 18 ldub [ %i0 + 0x18 ], %g1 200a880: 80 a0 60 00 cmp %g1, 0 200a884: 02 80 00 0d be 200a8b8 <_Thread_Dispatch+0x144> 200a888: 01 00 00 00 nop heir = _Thread_Heir; 200a88c: e0 06 20 10 ld [ %i0 + 0x10 ], %l0 _Thread_Dispatch_necessary = false; 200a890: c0 2e 20 18 clrb [ %i0 + 0x18 ] /* * When the heir and executing are the same, then we are being * requested to do the post switch dispatching. This is normally * done to dispatch signals. */ if ( heir == executing ) 200a894: 80 a4 00 19 cmp %l0, %i1 200a898: 02 80 00 08 be 200a8b8 <_Thread_Dispatch+0x144> <== NEVER TAKEN 200a89c: e0 26 20 0c st %l0, [ %i0 + 0xc ] */ #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 200a8a0: c2 04 20 78 ld [ %l0 + 0x78 ], %g1 200a8a4: 80 a0 60 01 cmp %g1, 1 200a8a8: 12 bf ff cb bne 200a7d4 <_Thread_Dispatch+0x60> 200a8ac: c2 05 20 10 ld [ %l4 + 0x10 ], %g1 heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 200a8b0: 10 bf ff c9 b 200a7d4 <_Thread_Dispatch+0x60> 200a8b4: c2 24 20 74 st %g1, [ %l0 + 0x74 ] _ISR_Disable( level ); } post_switch: _ISR_Enable( level ); 200a8b8: 7f ff df af call 2002774 200a8bc: 01 00 00 00 nop * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 200a8c0: c2 04 e0 b0 ld [ %l3 + 0xb0 ], %g1 200a8c4: 82 00 7f ff add %g1, -1, %g1 200a8c8: c2 24 e0 b0 st %g1, [ %l3 + 0xb0 ] return _Thread_Dispatch_disable_level; 200a8cc: c2 04 e0 b0 ld [ %l3 + 0xb0 ], %g1 _Thread_Unnest_dispatch(); _API_extensions_Run_postswitch(); 200a8d0: 7f ff f7 a2 call 2008758 <_API_extensions_Run_postswitch> 200a8d4: 01 00 00 00 nop 200a8d8: 81 c7 e0 08 ret 200a8dc: 81 e8 00 00 restore =============================================================================== 02010594 <_Thread_Handler>: * Input parameters: NONE * * Output parameters: NONE */ void _Thread_Handler( void ) { 2010594: 9d e3 bf a0 save %sp, -96, %sp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static bool doneConstructors; bool doCons; #endif executing = _Thread_Executing; 2010598: 03 00 80 7b sethi %hi(0x201ec00), %g1 201059c: fa 00 61 ec ld [ %g1 + 0x1ec ], %i5 ! 201edec <_Per_CPU_Information+0xc> /* * Some CPUs need to tinker with the call frame or registers when the * thread actually begins to execute for the first time. This is a * hook point where the port gets a shot at doing whatever it requires. */ _Context_Initialization_at_thread_begin(); 20105a0: 3f 00 80 41 sethi %hi(0x2010400), %i7 20105a4: be 17 e1 94 or %i7, 0x194, %i7 ! 2010594 <_Thread_Handler> /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 20105a8: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0 _ISR_Set_level(level); 20105ac: 7f ff c8 72 call 2002774 20105b0: 91 2a 20 08 sll %o0, 8, %o0 #endif #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 20105b4: c4 07 61 50 ld [ %i5 + 0x150 ], %g2 doCons = !doneConstructors && _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API; if (doCons) doneConstructors = true; #else doCons = !doneConstructors; 20105b8: 03 00 80 79 sethi %hi(0x201e400), %g1 doneConstructors = true; 20105bc: 86 10 20 01 mov 1, %g3 doCons = !doneConstructors && _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API; if (doCons) doneConstructors = true; #else doCons = !doneConstructors; 20105c0: f6 08 60 b8 ldub [ %g1 + 0xb8 ], %i3 #endif #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 20105c4: 80 a0 a0 00 cmp %g2, 0 20105c8: 02 80 00 0c be 20105f8 <_Thread_Handler+0x64> 20105cc: c6 28 60 b8 stb %g3, [ %g1 + 0xb8 ] #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 20105d0: 39 00 80 7a sethi %hi(0x201e800), %i4 20105d4: d0 07 21 28 ld [ %i4 + 0x128 ], %o0 ! 201e928 <_Thread_Allocated_fp> 20105d8: 80 a7 40 08 cmp %i5, %o0 20105dc: 02 80 00 07 be 20105f8 <_Thread_Handler+0x64> 20105e0: 80 a2 20 00 cmp %o0, 0 !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 20105e4: 22 80 00 05 be,a 20105f8 <_Thread_Handler+0x64> 20105e8: fa 27 21 28 st %i5, [ %i4 + 0x128 ] _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 20105ec: 7f ff ed 3d call 200bae0 <_CPU_Context_save_fp> 20105f0: 90 02 21 50 add %o0, 0x150, %o0 _Thread_Allocated_fp = executing; 20105f4: fa 27 21 28 st %i5, [ %i4 + 0x128 ] /* * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing ); 20105f8: 7f ff eb a9 call 200b49c <_User_extensions_Thread_begin> 20105fc: 90 10 00 1d mov %i5, %o0 /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 2010600: 7f ff e8 b8 call 200a8e0 <_Thread_Enable_dispatch> 2010604: 01 00 00 00 nop /* * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (doCons) /* && (volatile void *)_init) */ { 2010608: 80 8e e0 ff btst 0xff, %i3 201060c: 02 80 00 0e be 2010644 <_Thread_Handler+0xb0> 2010610: 01 00 00 00 nop _Thread_Enable_dispatch(); #endif } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 2010614: c2 07 60 90 ld [ %i5 + 0x90 ], %g1 2010618: 80 a0 60 00 cmp %g1, 0 201061c: 02 80 00 0e be 2010654 <_Thread_Handler+0xc0> 2010620: 80 a0 60 01 cmp %g1, 1 (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 2010624: 22 80 00 11 be,a 2010668 <_Thread_Handler+0xd4> <== ALWAYS TAKEN 2010628: c2 07 60 8c ld [ %i5 + 0x8c ], %g1 * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 201062c: 7f ff eb b0 call 200b4ec <_User_extensions_Thread_exitted> 2010630: 90 10 00 1d mov %i5, %o0 _Internal_error_Occurred( 2010634: 90 10 20 00 clr %o0 2010638: 92 10 20 01 mov 1, %o1 201063c: 7f ff e3 1f call 20092b8 <_Internal_error_Occurred> 2010640: 94 10 20 05 mov 5, %o2 * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (doCons) /* && (volatile void *)_init) */ { INIT_NAME (); 2010644: 40 00 35 0f call 201da80 <_init> 2010648: 01 00 00 00 nop _Thread_Enable_dispatch(); #endif } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 201064c: 10 bf ff f3 b 2010618 <_Thread_Handler+0x84> 2010650: c2 07 60 90 ld [ %i5 + 0x90 ], %g1 executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 2010654: c2 07 60 8c ld [ %i5 + 0x8c ], %g1 2010658: 9f c0 40 00 call %g1 201065c: d0 07 60 98 ld [ %i5 + 0x98 ], %o0 #endif } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { executing->Wait.return_argument = 2010660: 10 bf ff f3 b 201062c <_Thread_Handler+0x98> 2010664: d0 27 60 28 st %o0, [ %i5 + 0x28 ] ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 2010668: 9f c0 40 00 call %g1 201066c: d0 07 60 94 ld [ %i5 + 0x94 ], %o0 executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = 2010670: 10 bf ff ef b 201062c <_Thread_Handler+0x98> 2010674: d0 27 60 28 st %o0, [ %i5 + 0x28 ] =============================================================================== 0200abcc <_Thread_Handler_initialization>: * * Output parameters: NONE */ void _Thread_Handler_initialization(void) { 200abcc: 9d e3 bf 98 save %sp, -104, %sp uint32_t ticks_per_timeslice = 200abd0: 03 00 80 76 sethi %hi(0x201d800), %g1 200abd4: 82 10 62 cc or %g1, 0x2cc, %g1 ! 201dacc #if defined(RTEMS_MULTIPROCESSING) uint32_t maximum_proxies = _Configuration_MP_table->maximum_proxies; #endif if ( rtems_configuration_get_stack_allocate_hook() == NULL || 200abd8: c6 00 60 2c ld [ %g1 + 0x2c ], %g3 * Output parameters: NONE */ void _Thread_Handler_initialization(void) { uint32_t ticks_per_timeslice = 200abdc: fa 00 60 18 ld [ %g1 + 0x18 ], %i5 rtems_configuration_get_ticks_per_timeslice(); uint32_t maximum_extensions = 200abe0: f8 00 60 0c ld [ %g1 + 0xc ], %i4 #if defined(RTEMS_MULTIPROCESSING) uint32_t maximum_proxies = _Configuration_MP_table->maximum_proxies; #endif if ( rtems_configuration_get_stack_allocate_hook() == NULL || 200abe4: 80 a0 e0 00 cmp %g3, 0 200abe8: 02 80 00 21 be 200ac6c <_Thread_Handler_initialization+0xa0> 200abec: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 200abf0: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 200abf4: 80 a0 e0 00 cmp %g3, 0 200abf8: 02 80 00 1d be 200ac6c <_Thread_Handler_initialization+0xa0><== NEVER TAKEN 200abfc: 80 a0 a0 00 cmp %g2, 0 INTERNAL_ERROR_CORE, true, INTERNAL_ERROR_BAD_STACK_HOOK ); if ( stack_allocate_init_hook != NULL ) 200ac00: 22 80 00 05 be,a 200ac14 <_Thread_Handler_initialization+0x48> 200ac04: 03 00 80 7b sethi %hi(0x201ec00), %g1 (*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() ); 200ac08: 9f c0 80 00 call %g2 200ac0c: d0 00 60 08 ld [ %g1 + 8 ], %o0 ! 201ec08 <_POSIX_Message_queue_Information+0x28> _Thread_Dispatch_necessary = false; 200ac10: 03 00 80 7b sethi %hi(0x201ec00), %g1 200ac14: 82 10 61 e0 or %g1, 0x1e0, %g1 ! 201ede0 <_Per_CPU_Information> 200ac18: c0 28 60 18 clrb [ %g1 + 0x18 ] _Thread_Executing = NULL; 200ac1c: c0 20 60 0c clr [ %g1 + 0xc ] _Thread_Heir = NULL; 200ac20: c0 20 60 10 clr [ %g1 + 0x10 ] #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 200ac24: 03 00 80 7a sethi %hi(0x201e800), %g1 200ac28: c0 20 61 28 clr [ %g1 + 0x128 ] ! 201e928 <_Thread_Allocated_fp> #endif _Thread_Maximum_extensions = maximum_extensions; 200ac2c: 03 00 80 7a sethi %hi(0x201e800), %g1 200ac30: f8 20 61 30 st %i4, [ %g1 + 0x130 ] ! 201e930 <_Thread_Maximum_extensions> _Thread_Ticks_per_timeslice = ticks_per_timeslice; 200ac34: 03 00 80 7a sethi %hi(0x201e800), %g1 200ac38: fa 20 60 10 st %i5, [ %g1 + 0x10 ] ! 201e810 <_Thread_Ticks_per_timeslice> #if defined(RTEMS_MULTIPROCESSING) if ( _System_state_Is_multiprocessing ) maximum_internal_threads += 1; #endif _Objects_Initialize_information( 200ac3c: 82 10 20 08 mov 8, %g1 200ac40: 11 00 80 7a sethi %hi(0x201e800), %o0 200ac44: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 200ac48: 90 12 21 b0 or %o0, 0x1b0, %o0 200ac4c: 92 10 20 01 mov 1, %o1 200ac50: 94 10 20 01 mov 1, %o2 200ac54: 96 10 20 01 mov 1, %o3 200ac58: 98 10 21 68 mov 0x168, %o4 200ac5c: 7f ff fb 35 call 2009930 <_Objects_Initialize_information> 200ac60: 9a 10 20 00 clr %o5 200ac64: 81 c7 e0 08 ret 200ac68: 81 e8 00 00 restore _Configuration_MP_table->maximum_proxies; #endif if ( rtems_configuration_get_stack_allocate_hook() == NULL || rtems_configuration_get_stack_free_hook() == NULL) _Internal_error_Occurred( 200ac6c: 90 10 20 00 clr %o0 200ac70: 92 10 20 01 mov 1, %o1 200ac74: 7f ff f9 91 call 20092b8 <_Internal_error_Occurred> 200ac78: 94 10 20 0e mov 0xe, %o2 =============================================================================== 0200a9c4 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 200a9c4: 9d e3 bf a0 save %sp, -96, %sp 200a9c8: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 200a9cc: c0 26 61 58 clr [ %i1 + 0x158 ] 200a9d0: c0 26 61 5c clr [ %i1 + 0x15c ] extensions_area = NULL; the_thread->libc_reent = NULL; 200a9d4: c0 26 61 54 clr [ %i1 + 0x154 ] Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 200a9d8: e0 07 a0 60 ld [ %fp + 0x60 ], %l0 200a9dc: e2 00 40 00 ld [ %g1 ], %l1 if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { 200a9e0: 80 a6 a0 00 cmp %i2, 0 200a9e4: 02 80 00 6b be 200ab90 <_Thread_Initialize+0x1cc> 200a9e8: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2 stack = the_thread->Start.stack; the_thread->Start.core_allocated_stack = true; } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 200a9ec: c0 2e 60 b0 clrb [ %i1 + 0xb0 ] 200a9f0: 90 10 00 1b mov %i3, %o0 Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 200a9f4: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ] the_stack->size = size; 200a9f8: d0 26 60 b4 st %o0, [ %i1 + 0xb4 ] /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 200a9fc: 80 a7 20 00 cmp %i4, 0 200aa00: 12 80 00 48 bne 200ab20 <_Thread_Initialize+0x15c> 200aa04: b6 10 20 00 clr %i3 #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 200aa08: 39 00 80 7a sethi %hi(0x201e800), %i4 200aa0c: c2 07 21 30 ld [ %i4 + 0x130 ], %g1 ! 201e930 <_Thread_Maximum_extensions> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 200aa10: f6 26 61 50 st %i3, [ %i1 + 0x150 ] the_thread->Start.fp_context = fp_area; 200aa14: f6 26 60 bc st %i3, [ %i1 + 0xbc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200aa18: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 200aa1c: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 200aa20: c0 26 60 68 clr [ %i1 + 0x68 ] #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 200aa24: 80 a0 60 00 cmp %g1, 0 200aa28: 12 80 00 46 bne 200ab40 <_Thread_Initialize+0x17c> 200aa2c: c0 26 60 6c clr [ %i1 + 0x6c ] (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 200aa30: c0 26 61 60 clr [ %i1 + 0x160 ] * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 200aa34: b4 10 20 00 clr %i2 * General initialization */ the_thread->Start.is_preemptible = is_preemptible; the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 200aa38: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 200aa3c: e4 2e 60 9c stb %l2, [ %i1 + 0x9c ] the_thread->Start.budget_algorithm = budget_algorithm; 200aa40: e0 26 60 a0 st %l0, [ %i1 + 0xa0 ] the_thread->Start.budget_callout = budget_callout; switch ( budget_algorithm ) { 200aa44: 80 a4 20 02 cmp %l0, 2 200aa48: 12 80 00 05 bne 200aa5c <_Thread_Initialize+0x98> 200aa4c: c2 26 60 a4 st %g1, [ %i1 + 0xa4 ] case THREAD_CPU_BUDGET_ALGORITHM_NONE: case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 200aa50: 03 00 80 7a sethi %hi(0x201e800), %g1 200aa54: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 201e810 <_Thread_Ticks_per_timeslice> 200aa58: c2 26 60 74 st %g1, [ %i1 + 0x74 ] case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 200aa5c: c4 07 a0 68 ld [ %fp + 0x68 ], %g2 */ RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate( Thread_Control *the_thread ) { return _Scheduler.Operations.allocate( the_thread ); 200aa60: 03 00 80 76 sethi %hi(0x201d800), %g1 200aa64: c2 00 63 d8 ld [ %g1 + 0x3d8 ], %g1 ! 201dbd8 <_Scheduler+0x18> 200aa68: c4 26 60 a8 st %g2, [ %i1 + 0xa8 ] the_thread->current_state = STATES_DORMANT; 200aa6c: 84 10 20 01 mov 1, %g2 the_thread->Wait.queue = NULL; 200aa70: c0 26 60 44 clr [ %i1 + 0x44 ] #endif } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 200aa74: c4 26 60 10 st %g2, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 200aa78: c0 26 60 1c clr [ %i1 + 0x1c ] the_thread->real_priority = priority; 200aa7c: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 200aa80: fa 26 60 ac st %i5, [ %i1 + 0xac ] 200aa84: 9f c0 40 00 call %g1 200aa88: 90 10 00 19 mov %i1, %o0 sched =_Scheduler_Allocate( the_thread ); if ( !sched ) 200aa8c: b8 92 20 00 orcc %o0, 0, %i4 200aa90: 22 80 00 13 be,a 200aadc <_Thread_Initialize+0x118> 200aa94: d0 06 61 54 ld [ %i1 + 0x154 ], %o0 goto failed; _Thread_Set_priority( the_thread, priority ); 200aa98: 90 10 00 19 mov %i1, %o0 200aa9c: 40 00 01 e9 call 200b240 <_Thread_Set_priority> 200aaa0: 92 10 00 1d mov %i5, %o1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200aaa4: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 200aaa8: c2 16 60 0a lduh [ %i1 + 0xa ], %g1 static inline void _Timestamp64_implementation_Set_to_zero( Timestamp64_Control *_time ) { *_time = 0; 200aaac: c0 26 60 80 clr [ %i1 + 0x80 ] 200aab0: c0 26 60 84 clr [ %i1 + 0x84 ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200aab4: 83 28 60 02 sll %g1, 2, %g1 200aab8: f2 20 80 01 st %i1, [ %g2 + %g1 ] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 200aabc: e2 26 60 0c st %l1, [ %i1 + 0xc ] * enabled when we get here. We want to be able to run the * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); 200aac0: 90 10 00 19 mov %i1, %o0 200aac4: 40 00 02 b1 call 200b588 <_User_extensions_Thread_create> 200aac8: b0 10 20 01 mov 1, %i0 if ( extension_status ) 200aacc: 80 8a 20 ff btst 0xff, %o0 200aad0: 32 80 00 12 bne,a 200ab18 <_Thread_Initialize+0x154> 200aad4: b0 0e 20 ff and %i0, 0xff, %i0 return true; failed: _Workspace_Free( the_thread->libc_reent ); 200aad8: d0 06 61 54 ld [ %i1 + 0x154 ], %o0 200aadc: 40 00 03 ec call 200ba8c <_Workspace_Free> 200aae0: b0 10 20 00 clr %i0 for ( i=0 ; i <= THREAD_API_LAST ; i++ ) _Workspace_Free( the_thread->API_Extensions[i] ); 200aae4: 40 00 03 ea call 200ba8c <_Workspace_Free> 200aae8: d0 06 61 58 ld [ %i1 + 0x158 ], %o0 200aaec: 40 00 03 e8 call 200ba8c <_Workspace_Free> 200aaf0: d0 06 61 5c ld [ %i1 + 0x15c ], %o0 _Workspace_Free( extensions_area ); 200aaf4: 40 00 03 e6 call 200ba8c <_Workspace_Free> 200aaf8: 90 10 00 1a mov %i2, %o0 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 200aafc: 40 00 03 e4 call 200ba8c <_Workspace_Free> 200ab00: 90 10 00 1b mov %i3, %o0 #endif _Workspace_Free( sched ); 200ab04: 40 00 03 e2 call 200ba8c <_Workspace_Free> 200ab08: 90 10 00 1c mov %i4, %o0 _Thread_Stack_Free( the_thread ); 200ab0c: 40 00 02 06 call 200b324 <_Thread_Stack_Free> 200ab10: 90 10 00 19 mov %i1, %o0 200ab14: b0 0e 20 ff and %i0, 0xff, %i0 200ab18: 81 c7 e0 08 ret 200ab1c: 81 e8 00 00 restore /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 200ab20: 40 00 03 d3 call 200ba6c <_Workspace_Allocate> 200ab24: 90 10 20 88 mov 0x88, %o0 if ( !fp_area ) 200ab28: b6 92 20 00 orcc %o0, 0, %i3 200ab2c: 32 bf ff b8 bne,a 200aa0c <_Thread_Initialize+0x48> 200ab30: 39 00 80 7a sethi %hi(0x201e800), %i4 * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 200ab34: b4 10 20 00 clr %i2 size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 200ab38: 10 bf ff e8 b 200aad8 <_Thread_Initialize+0x114> 200ab3c: b8 10 20 00 clr %i4 /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 200ab40: 90 00 60 01 add %g1, 1, %o0 200ab44: 40 00 03 ca call 200ba6c <_Workspace_Allocate> 200ab48: 91 2a 20 02 sll %o0, 2, %o0 (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 200ab4c: b4 92 20 00 orcc %o0, 0, %i2 200ab50: 02 80 00 1d be 200abc4 <_Thread_Initialize+0x200> 200ab54: 86 10 00 1a mov %i2, %g3 goto failed; } the_thread->extensions = (void **) extensions_area; 200ab58: f4 26 61 60 st %i2, [ %i1 + 0x160 ] 200ab5c: c8 07 21 30 ld [ %i4 + 0x130 ], %g4 * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 200ab60: 84 10 20 00 clr %g2 (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 200ab64: 10 80 00 03 b 200ab70 <_Thread_Initialize+0x1ac> 200ab68: 82 10 20 00 clr %g1 200ab6c: c6 06 61 60 ld [ %i1 + 0x160 ], %g3 * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) the_thread->extensions[i] = NULL; 200ab70: 85 28 a0 02 sll %g2, 2, %g2 200ab74: c0 20 c0 02 clr [ %g3 + %g2 ] * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 200ab78: 82 00 60 01 inc %g1 200ab7c: 80 a0 40 04 cmp %g1, %g4 200ab80: 08 bf ff fb bleu 200ab6c <_Thread_Initialize+0x1a8> 200ab84: 84 10 00 01 mov %g1, %g2 * General initialization */ the_thread->Start.is_preemptible = is_preemptible; the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 200ab88: 10 bf ff ad b 200aa3c <_Thread_Initialize+0x78> 200ab8c: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 200ab90: 90 10 00 19 mov %i1, %o0 200ab94: 40 00 01 d4 call 200b2e4 <_Thread_Stack_Allocate> 200ab98: 92 10 00 1b mov %i3, %o1 if ( !actual_stack_size || actual_stack_size < stack_size ) 200ab9c: 80 a2 00 1b cmp %o0, %i3 200aba0: 0a 80 00 07 bcs 200abbc <_Thread_Initialize+0x1f8> 200aba4: 80 a2 20 00 cmp %o0, 0 200aba8: 02 80 00 05 be 200abbc <_Thread_Initialize+0x1f8> <== NEVER TAKEN 200abac: 82 10 20 01 mov 1, %g1 return false; /* stack allocation failed */ stack = the_thread->Start.stack; 200abb0: f4 06 60 c0 ld [ %i1 + 0xc0 ], %i2 the_thread->Start.core_allocated_stack = true; 200abb4: 10 bf ff 90 b 200a9f4 <_Thread_Initialize+0x30> 200abb8: c2 2e 60 b0 stb %g1, [ %i1 + 0xb0 ] stack = the_thread->Start.stack; #else if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ 200abbc: 10 bf ff d6 b 200ab14 <_Thread_Initialize+0x150> 200abc0: b0 10 20 00 clr %i0 size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 200abc4: 10 bf ff c5 b 200aad8 <_Thread_Initialize+0x114> 200abc8: b8 10 20 00 clr %i4 =============================================================================== 0200b324 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 200b324: 9d e3 bf a0 save %sp, -96, %sp #if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 200b328: c2 0e 20 b0 ldub [ %i0 + 0xb0 ], %g1 200b32c: 80 a0 60 00 cmp %g1, 0 void _Thread_Stack_Free( Thread_Control *the_thread ) { rtems_stack_free_hook stack_free_hook = 200b330: 03 00 80 76 sethi %hi(0x201d800), %g1 #if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 200b334: 02 80 00 04 be 200b344 <_Thread_Stack_Free+0x20> <== NEVER TAKEN 200b338: c2 00 62 fc ld [ %g1 + 0x2fc ], %g1 ! 201dafc * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ (*stack_free_hook)( the_thread->Start.Initial_stack.area ); 200b33c: 9f c0 40 00 call %g1 200b340: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0 200b344: 81 c7 e0 08 ret 200b348: 81 e8 00 00 restore =============================================================================== 0200b17c <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200b17c: 9d e3 bf 98 save %sp, -104, %sp /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 200b180: 80 a6 20 00 cmp %i0, 0 200b184: 02 80 00 13 be 200b1d0 <_Thread_queue_Requeue+0x54> <== NEVER TAKEN 200b188: 01 00 00 00 nop /* * If queueing by FIFO, there is nothing to do. This only applies to * priority blocking discipline. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 200b18c: fa 06 20 34 ld [ %i0 + 0x34 ], %i5 200b190: 80 a7 60 01 cmp %i5, 1 200b194: 02 80 00 04 be 200b1a4 <_Thread_queue_Requeue+0x28> <== ALWAYS TAKEN 200b198: 01 00 00 00 nop 200b19c: 81 c7 e0 08 ret <== NOT EXECUTED 200b1a0: 81 e8 00 00 restore <== NOT EXECUTED Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 200b1a4: 7f ff dd 70 call 2002764 200b1a8: 01 00 00 00 nop 200b1ac: b8 10 00 08 mov %o0, %i4 200b1b0: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200b1b4: 03 00 00 ef sethi %hi(0x3bc00), %g1 200b1b8: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200b1bc: 80 88 80 01 btst %g2, %g1 200b1c0: 12 80 00 06 bne 200b1d8 <_Thread_queue_Requeue+0x5c> <== ALWAYS TAKEN 200b1c4: 90 10 00 18 mov %i0, %o0 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); 200b1c8: 7f ff dd 6b call 2002774 200b1cc: 90 10 00 1c mov %i4, %o0 200b1d0: 81 c7 e0 08 ret 200b1d4: 81 e8 00 00 restore ISR_Level level_ignored; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 200b1d8: 92 10 00 19 mov %i1, %o1 200b1dc: 94 10 20 01 mov 1, %o2 200b1e0: 40 00 0d 9d call 200e854 <_Thread_queue_Extract_priority_helper> 200b1e4: fa 26 20 30 st %i5, [ %i0 + 0x30 ] (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 200b1e8: 90 10 00 18 mov %i0, %o0 200b1ec: 92 10 00 19 mov %i1, %o1 200b1f0: 7f ff ff 35 call 200aec4 <_Thread_queue_Enqueue_priority> 200b1f4: 94 07 bf fc add %fp, -4, %o2 200b1f8: 30 bf ff f4 b,a 200b1c8 <_Thread_queue_Requeue+0x4c> =============================================================================== 0200b1fc <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 200b1fc: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 200b200: 90 10 00 18 mov %i0, %o0 200b204: 7f ff fd c4 call 200a914 <_Thread_Get> 200b208: 92 07 bf fc add %fp, -4, %o1 switch ( location ) { 200b20c: c2 07 bf fc ld [ %fp + -4 ], %g1 200b210: 80 a0 60 00 cmp %g1, 0 200b214: 12 80 00 09 bne 200b238 <_Thread_queue_Timeout+0x3c> <== NEVER TAKEN 200b218: 01 00 00 00 nop #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 200b21c: 40 00 0d c7 call 200e938 <_Thread_queue_Process_timeout> 200b220: 01 00 00 00 nop * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 200b224: 03 00 80 7a sethi %hi(0x201e800), %g1 200b228: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 201e8b0 <_Thread_Dispatch_disable_level> 200b22c: 84 00 bf ff add %g2, -1, %g2 200b230: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] return _Thread_Dispatch_disable_level; 200b234: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 200b238: 81 c7 e0 08 ret 200b23c: 81 e8 00 00 restore =============================================================================== 02018210 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 2018210: 9d e3 bf 88 save %sp, -120, %sp 2018214: 21 00 80 f3 sethi %hi(0x203cc00), %l0 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 2018218: a4 07 bf e8 add %fp, -24, %l2 201821c: b4 07 bf ec add %fp, -20, %i2 2018220: b8 07 bf f4 add %fp, -12, %i4 2018224: a2 07 bf f8 add %fp, -8, %l1 2018228: 33 00 80 f3 sethi %hi(0x203cc00), %i1 201822c: 27 00 80 f3 sethi %hi(0x203cc00), %l3 2018230: f4 27 bf e8 st %i2, [ %fp + -24 ] head->previous = NULL; 2018234: c0 27 bf ec clr [ %fp + -20 ] tail->previous = head; 2018238: e4 27 bf f0 st %l2, [ %fp + -16 ] ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 201823c: e2 27 bf f4 st %l1, [ %fp + -12 ] head->previous = NULL; 2018240: c0 27 bf f8 clr [ %fp + -8 ] tail->previous = head; 2018244: f8 27 bf fc st %i4, [ %fp + -4 ] 2018248: a0 14 22 28 or %l0, 0x228, %l0 201824c: b6 06 20 30 add %i0, 0x30, %i3 2018250: b2 16 60 78 or %i1, 0x78, %i1 2018254: ba 06 20 68 add %i0, 0x68, %i5 2018258: a6 14 e1 30 or %l3, 0x130, %l3 201825c: ac 06 20 08 add %i0, 8, %l6 2018260: aa 06 20 40 add %i0, 0x40, %l5 _Thread_Set_state( ts->thread, STATES_DELAYING ); _Timer_server_Reset_interval_system_watchdog( ts ); _Timer_server_Reset_tod_system_watchdog( ts ); _Thread_Enable_dispatch(); ts->active = true; 2018264: a8 10 20 01 mov 1, %l4 { /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; 2018268: e4 26 20 78 st %l2, [ %i0 + 0x78 ] static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 201826c: c2 04 00 00 ld [ %l0 ], %g1 /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 2018270: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 2018274: 90 10 00 1b mov %i3, %o0 2018278: 92 20 40 09 sub %g1, %o1, %o1 201827c: 94 10 00 1c mov %i4, %o2 /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; 2018280: c2 26 20 3c st %g1, [ %i0 + 0x3c ] _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 2018284: 40 00 12 ba call 201cd6c <_Watchdog_Adjust_to_chain> 2018288: 01 00 00 00 nop 201828c: d0 1e 40 00 ldd [ %i1 ], %o0 2018290: 94 10 20 00 clr %o2 2018294: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2018298: 40 00 51 b1 call 202c95c <__divdi3> 201829c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 20182a0: d4 06 20 74 ld [ %i0 + 0x74 ], %o2 /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the watchdogs->Chain to indicate this. */ if ( snapshot > last_snapshot ) { 20182a4: 80 a2 40 0a cmp %o1, %o2 20182a8: 18 80 00 2b bgu 2018354 <_Timer_server_Body+0x144> 20182ac: ae 10 00 09 mov %o1, %l7 * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); } else if ( snapshot < last_snapshot ) { 20182b0: 80 a2 40 0a cmp %o1, %o2 20182b4: 0a 80 00 20 bcs 2018334 <_Timer_server_Body+0x124> 20182b8: 90 10 00 1d mov %i5, %o0 */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); } watchdogs->last_snapshot = snapshot; 20182bc: ee 26 20 74 st %l7, [ %i0 + 0x74 ] } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 20182c0: d0 06 20 78 ld [ %i0 + 0x78 ], %o0 20182c4: 40 00 02 bb call 2018db0 <_Chain_Get> 20182c8: 01 00 00 00 nop if ( timer == NULL ) { 20182cc: 92 92 20 00 orcc %o0, 0, %o1 20182d0: 02 80 00 10 be 2018310 <_Timer_server_Body+0x100> 20182d4: 01 00 00 00 nop static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 20182d8: c2 02 60 38 ld [ %o1 + 0x38 ], %g1 20182dc: 80 a0 60 01 cmp %g1, 1 20182e0: 02 80 00 19 be 2018344 <_Timer_server_Body+0x134> 20182e4: 80 a0 60 03 cmp %g1, 3 _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 20182e8: 12 bf ff f6 bne 20182c0 <_Timer_server_Body+0xb0> <== NEVER TAKEN 20182ec: 92 02 60 10 add %o1, 0x10, %o1 _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 20182f0: 40 00 12 d0 call 201ce30 <_Watchdog_Insert> 20182f4: 90 10 00 1d mov %i5, %o0 } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 20182f8: d0 06 20 78 ld [ %i0 + 0x78 ], %o0 20182fc: 40 00 02 ad call 2018db0 <_Chain_Get> 2018300: 01 00 00 00 nop if ( timer == NULL ) { 2018304: 92 92 20 00 orcc %o0, 0, %o1 2018308: 32 bf ff f5 bne,a 20182dc <_Timer_server_Body+0xcc> <== NEVER TAKEN 201830c: c2 02 60 38 ld [ %o1 + 0x38 ], %g1 <== NOT EXECUTED * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 2018310: 7f ff dd 40 call 200f810 2018314: 01 00 00 00 nop if ( _Chain_Is_empty( insert_chain ) ) { 2018318: c2 07 bf e8 ld [ %fp + -24 ], %g1 201831c: 80 a0 40 1a cmp %g1, %i2 2018320: 02 80 00 12 be 2018368 <_Timer_server_Body+0x158> <== ALWAYS TAKEN 2018324: 01 00 00 00 nop ts->insert_chain = NULL; _ISR_Enable( level ); break; } else { _ISR_Enable( level ); 2018328: 7f ff dd 3e call 200f820 <== NOT EXECUTED 201832c: 01 00 00 00 nop <== NOT EXECUTED 2018330: 30 bf ff cf b,a 201826c <_Timer_server_Body+0x5c> <== NOT EXECUTED /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 2018334: 92 10 20 01 mov 1, %o1 ! 1 2018338: 40 00 12 5d call 201ccac <_Watchdog_Adjust> 201833c: 94 22 80 17 sub %o2, %l7, %o2 2018340: 30 bf ff df b,a 20182bc <_Timer_server_Body+0xac> Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 2018344: 90 10 00 1b mov %i3, %o0 2018348: 40 00 12 ba call 201ce30 <_Watchdog_Insert> 201834c: 92 02 60 10 add %o1, 0x10, %o1 2018350: 30 bf ff dc b,a 20182c0 <_Timer_server_Body+0xb0> /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 2018354: 92 22 40 0a sub %o1, %o2, %o1 2018358: 90 10 00 1d mov %i5, %o0 201835c: 40 00 12 84 call 201cd6c <_Watchdog_Adjust_to_chain> 2018360: 94 10 00 1c mov %i4, %o2 2018364: 30 bf ff d6 b,a 20182bc <_Timer_server_Body+0xac> */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); if ( _Chain_Is_empty( insert_chain ) ) { ts->insert_chain = NULL; 2018368: c0 26 20 78 clr [ %i0 + 0x78 ] _ISR_Enable( level ); 201836c: 7f ff dd 2d call 200f820 2018370: 01 00 00 00 nop _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); if ( !_Chain_Is_empty( &fire_chain ) ) { 2018374: c2 07 bf f4 ld [ %fp + -12 ], %g1 2018378: 80 a0 40 11 cmp %g1, %l1 201837c: 12 80 00 0c bne 20183ac <_Timer_server_Body+0x19c> 2018380: 01 00 00 00 nop 2018384: 30 80 00 13 b,a 20183d0 <_Timer_server_Body+0x1c0> Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; head->next = new_first; new_first->previous = head; 2018388: f8 20 60 04 st %i4, [ %g1 + 4 ] { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; head->next = new_first; 201838c: c2 27 bf f4 st %g1, [ %fp + -12 ] * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 2018390: c0 25 e0 08 clr [ %l7 + 8 ] _ISR_Enable( level ); 2018394: 7f ff dd 23 call 200f820 2018398: 01 00 00 00 nop /* * The timer server may block here and wait for resources or time. * The system watchdogs are inactive and will remain inactive since * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); 201839c: d0 05 e0 20 ld [ %l7 + 0x20 ], %o0 20183a0: c2 05 e0 1c ld [ %l7 + 0x1c ], %g1 20183a4: 9f c0 40 00 call %g1 20183a8: d2 05 e0 24 ld [ %l7 + 0x24 ], %o1 /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 20183ac: 7f ff dd 19 call 200f810 20183b0: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 20183b4: ee 07 bf f4 ld [ %fp + -12 ], %l7 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 20183b8: 80 a5 c0 11 cmp %l7, %l1 20183bc: 32 bf ff f3 bne,a 2018388 <_Timer_server_Body+0x178> 20183c0: c2 05 c0 00 ld [ %l7 ], %g1 watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 20183c4: 7f ff dd 17 call 200f820 20183c8: 01 00 00 00 nop 20183cc: 30 bf ff a7 b,a 2018268 <_Timer_server_Body+0x58> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 20183d0: c0 2e 20 7c clrb [ %i0 + 0x7c ] * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 20183d4: c2 04 c0 00 ld [ %l3 ], %g1 20183d8: 82 00 60 01 inc %g1 20183dc: c2 24 c0 00 st %g1, [ %l3 ] return _Thread_Dispatch_disable_level; 20183e0: c2 04 c0 00 ld [ %l3 ], %g1 /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 20183e4: d0 06 00 00 ld [ %i0 ], %o0 20183e8: 40 00 10 fa call 201c7d0 <_Thread_Set_state> 20183ec: 92 10 20 08 mov 8, %o1 _Timer_server_Reset_interval_system_watchdog( ts ); 20183f0: 7f ff ff 05 call 2018004 <_Timer_server_Reset_interval_system_watchdog> 20183f4: 90 10 00 18 mov %i0, %o0 _Timer_server_Reset_tod_system_watchdog( ts ); 20183f8: 7f ff ff 17 call 2018054 <_Timer_server_Reset_tod_system_watchdog> 20183fc: 90 10 00 18 mov %i0, %o0 _Thread_Enable_dispatch(); 2018400: 40 00 0e 70 call 201bdc0 <_Thread_Enable_dispatch> 2018404: 01 00 00 00 nop static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 2018408: 90 10 00 16 mov %l6, %o0 _Thread_Set_state( ts->thread, STATES_DELAYING ); _Timer_server_Reset_interval_system_watchdog( ts ); _Timer_server_Reset_tod_system_watchdog( ts ); _Thread_Enable_dispatch(); ts->active = true; 201840c: e8 2e 20 7c stb %l4, [ %i0 + 0x7c ] static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 2018410: 40 00 12 e7 call 201cfac <_Watchdog_Remove> 2018414: 01 00 00 00 nop static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 2018418: 40 00 12 e5 call 201cfac <_Watchdog_Remove> 201841c: 90 10 00 15 mov %l5, %o0 2018420: 30 bf ff 92 b,a 2018268 <_Timer_server_Body+0x58> =============================================================================== 020180a4 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 20180a4: 9d e3 bf a0 save %sp, -96, %sp if ( ts->insert_chain == NULL ) { 20180a8: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 20180ac: 80 a0 60 00 cmp %g1, 0 20180b0: 02 80 00 05 be 20180c4 <_Timer_server_Schedule_operation_method+0x20> 20180b4: ba 10 00 19 mov %i1, %i5 * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 20180b8: f0 06 20 78 ld [ %i0 + 0x78 ], %i0 20180bc: 40 00 03 32 call 2018d84 <_Chain_Append> 20180c0: 81 e8 00 00 restore * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 20180c4: 03 00 80 f3 sethi %hi(0x203cc00), %g1 20180c8: c4 00 61 30 ld [ %g1 + 0x130 ], %g2 ! 203cd30 <_Thread_Dispatch_disable_level> 20180cc: 84 00 a0 01 inc %g2 20180d0: c4 20 61 30 st %g2, [ %g1 + 0x130 ] return _Thread_Dispatch_disable_level; 20180d4: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 20180d8: c2 06 60 38 ld [ %i1 + 0x38 ], %g1 20180dc: 80 a0 60 01 cmp %g1, 1 20180e0: 02 80 00 2b be 201818c <_Timer_server_Schedule_operation_method+0xe8> 20180e4: 80 a0 60 03 cmp %g1, 3 _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); if ( !ts->active ) { _Timer_server_Reset_interval_system_watchdog( ts ); } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 20180e8: 02 80 00 04 be 20180f8 <_Timer_server_Schedule_operation_method+0x54> 20180ec: 01 00 00 00 nop if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 20180f0: 40 00 0f 34 call 201bdc0 <_Thread_Enable_dispatch> 20180f4: 81 e8 00 00 restore } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 20180f8: 7f ff dd c6 call 200f810 20180fc: 01 00 00 00 nop 2018100: b8 10 00 08 mov %o0, %i4 snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 2018104: 03 00 80 f3 sethi %hi(0x203cc00), %g1 2018108: d0 18 60 78 ldd [ %g1 + 0x78 ], %o0 ! 203cc78 <_TOD> 201810c: 94 10 20 00 clr %o2 2018110: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2018114: 40 00 52 12 call 202c95c <__divdi3> 2018118: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 201811c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 last_snapshot = ts->TOD_watchdogs.last_snapshot; 2018120: c4 06 20 74 ld [ %i0 + 0x74 ], %g2 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 2018124: 86 06 20 6c add %i0, 0x6c, %g3 if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 2018128: 80 a0 40 03 cmp %g1, %g3 201812c: 02 80 00 0a be 2018154 <_Timer_server_Schedule_operation_method+0xb0> 2018130: 80 a2 40 02 cmp %o1, %g2 first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; if ( snapshot > last_snapshot ) { 2018134: 08 80 00 34 bleu 2018204 <_Timer_server_Schedule_operation_method+0x160> 2018138: c8 00 60 10 ld [ %g1 + 0x10 ], %g4 /* * We advanced in time. */ delta = snapshot - last_snapshot; 201813c: 84 22 40 02 sub %o1, %g2, %g2 if (delta_interval > delta) { 2018140: 80 a1 00 02 cmp %g4, %g2 2018144: 08 80 00 03 bleu 2018150 <_Timer_server_Schedule_operation_method+0xac><== NEVER TAKEN 2018148: 86 10 20 00 clr %g3 delta_interval -= delta; 201814c: 86 21 00 02 sub %g4, %g2, %g3 * Someone put us in the past. */ delta = last_snapshot - snapshot; delta_interval += delta; } first_watchdog->delta_interval = delta_interval; 2018150: c6 20 60 10 st %g3, [ %g1 + 0x10 ] } ts->TOD_watchdogs.last_snapshot = snapshot; 2018154: d2 26 20 74 st %o1, [ %i0 + 0x74 ] _ISR_Enable( level ); 2018158: 7f ff dd b2 call 200f820 201815c: 90 10 00 1c mov %i4, %o0 _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 2018160: 90 06 20 68 add %i0, 0x68, %o0 2018164: 40 00 13 33 call 201ce30 <_Watchdog_Insert> 2018168: 92 07 60 10 add %i5, 0x10, %o1 if ( !ts->active ) { 201816c: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1 2018170: 80 a0 60 00 cmp %g1, 0 2018174: 12 bf ff df bne 20180f0 <_Timer_server_Schedule_operation_method+0x4c> 2018178: 01 00 00 00 nop _Timer_server_Reset_tod_system_watchdog( ts ); 201817c: 7f ff ff b6 call 2018054 <_Timer_server_Reset_tod_system_watchdog> 2018180: 90 10 00 18 mov %i0, %o0 } } _Thread_Enable_dispatch(); 2018184: 40 00 0f 0f call 201bdc0 <_Thread_Enable_dispatch> 2018188: 81 e8 00 00 restore if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 201818c: 7f ff dd a1 call 200f810 2018190: 01 00 00 00 nop snapshot = _Watchdog_Ticks_since_boot; 2018194: 05 00 80 f3 sethi %hi(0x203cc00), %g2 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 2018198: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 201819c: c4 00 a2 28 ld [ %g2 + 0x228 ], %g2 last_snapshot = ts->Interval_watchdogs.last_snapshot; 20181a0: c8 06 20 3c ld [ %i0 + 0x3c ], %g4 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 20181a4: 86 06 20 34 add %i0, 0x34, %g3 if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 20181a8: 80 a0 40 03 cmp %g1, %g3 20181ac: 02 80 00 08 be 20181cc <_Timer_server_Schedule_operation_method+0x128> 20181b0: 88 20 80 04 sub %g2, %g4, %g4 /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; delta_interval = first_watchdog->delta_interval; 20181b4: f8 00 60 10 ld [ %g1 + 0x10 ], %i4 if (delta_interval > delta) { 20181b8: 80 a1 00 1c cmp %g4, %i4 20181bc: 1a 80 00 03 bcc 20181c8 <_Timer_server_Schedule_operation_method+0x124> 20181c0: 86 10 20 00 clr %g3 delta_interval -= delta; 20181c4: 86 27 00 04 sub %i4, %g4, %g3 } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 20181c8: c6 20 60 10 st %g3, [ %g1 + 0x10 ] } ts->Interval_watchdogs.last_snapshot = snapshot; 20181cc: c4 26 20 3c st %g2, [ %i0 + 0x3c ] _ISR_Enable( level ); 20181d0: 7f ff dd 94 call 200f820 20181d4: 01 00 00 00 nop _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 20181d8: 90 06 20 30 add %i0, 0x30, %o0 20181dc: 40 00 13 15 call 201ce30 <_Watchdog_Insert> 20181e0: 92 07 60 10 add %i5, 0x10, %o1 if ( !ts->active ) { 20181e4: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1 20181e8: 80 a0 60 00 cmp %g1, 0 20181ec: 12 bf ff c1 bne 20180f0 <_Timer_server_Schedule_operation_method+0x4c> 20181f0: 01 00 00 00 nop _Timer_server_Reset_interval_system_watchdog( ts ); 20181f4: 7f ff ff 84 call 2018004 <_Timer_server_Reset_interval_system_watchdog> 20181f8: 90 10 00 18 mov %i0, %o0 if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 20181fc: 40 00 0e f1 call 201bdc0 <_Thread_Enable_dispatch> 2018200: 81 e8 00 00 restore } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 2018204: 84 01 00 02 add %g4, %g2, %g2 delta_interval += delta; 2018208: 10 bf ff d2 b 2018150 <_Timer_server_Schedule_operation_method+0xac> 201820c: 86 20 80 09 sub %g2, %o1, %g3 =============================================================================== 0200d218 <_Timespec_Add_to>: ) { uint32_t seconds = add->tv_sec; /* Add the basics */ time->tv_sec += add->tv_sec; 200d218: d8 02 00 00 ld [ %o0 ], %o4 uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { uint32_t seconds = add->tv_sec; 200d21c: c4 02 40 00 ld [ %o1 ], %g2 /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; 200d220: c6 02 20 04 ld [ %o0 + 4 ], %g3 200d224: c2 02 60 04 ld [ %o1 + 4 ], %g1 ) { uint32_t seconds = add->tv_sec; /* Add the basics */ time->tv_sec += add->tv_sec; 200d228: 98 03 00 02 add %o4, %g2, %o4 time->tv_nsec += add->tv_nsec; 200d22c: 82 00 c0 01 add %g3, %g1, %g1 ) { uint32_t seconds = add->tv_sec; /* Add the basics */ time->tv_sec += add->tv_sec; 200d230: d8 22 00 00 st %o4, [ %o0 ] time->tv_nsec += add->tv_nsec; /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 200d234: 09 0e e6 b2 sethi %hi(0x3b9ac800), %g4 200d238: 88 11 21 ff or %g4, 0x1ff, %g4 ! 3b9ac9ff 200d23c: 80 a0 40 04 cmp %g1, %g4 200d240: 08 80 00 0d bleu 200d274 <_Timespec_Add_to+0x5c> 200d244: c2 22 20 04 st %g1, [ %o0 + 4 ] 200d248: 98 03 20 01 inc %o4 time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 200d24c: 1b 31 19 4d sethi %hi(0xc4653400), %o5 * * This routines adds two timespecs. The second argument is added * to the first. */ uint32_t _Timespec_Add_to( 200d250: 98 23 00 02 sub %o4, %g2, %o4 time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 200d254: 9a 13 62 00 or %o5, 0x200, %o5 200d258: 82 00 40 0d add %g1, %o5, %g1 * * This routines adds two timespecs. The second argument is added * to the first. */ uint32_t _Timespec_Add_to( 200d25c: 86 03 00 02 add %o4, %g2, %g3 /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 200d260: 80 a0 40 04 cmp %g1, %g4 200d264: 18 bf ff fd bgu 200d258 <_Timespec_Add_to+0x40> <== NEVER TAKEN 200d268: 84 00 a0 01 inc %g2 200d26c: c2 22 20 04 st %g1, [ %o0 + 4 ] 200d270: c6 22 00 00 st %g3, [ %o0 ] time->tv_sec++; seconds++; } return seconds; } 200d274: 81 c3 e0 08 retl 200d278: 90 10 00 02 mov %g2, %o0 =============================================================================== 0200cce0 <_Timestamp64_Divide>: const Timestamp64_Control *_lhs, const Timestamp64_Control *_rhs, uint32_t *_ival_percentage, uint32_t *_fval_percentage ) { 200cce0: 9d e3 bf a0 save %sp, -96, %sp Timestamp64_Control answer; if ( *_rhs == 0 ) { 200cce4: d4 1e 40 00 ldd [ %i1 ], %o2 200cce8: 80 92 80 0b orcc %o2, %o3, %g0 200ccec: 22 80 00 2f be,a 200cda8 <_Timestamp64_Divide+0xc8> <== NEVER TAKEN 200ccf0: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED * This looks odd but gives the results the proper precision. * * TODO: Rounding on the last digit of the fval. */ answer = (*_lhs * 100000) / *_rhs; 200ccf4: d0 1e 00 00 ldd [ %i0 ], %o0 200ccf8: 83 2a 20 02 sll %o0, 2, %g1 200ccfc: 89 32 60 1e srl %o1, 0x1e, %g4 200cd00: 87 2a 60 02 sll %o1, 2, %g3 200cd04: 84 11 00 01 or %g4, %g1, %g2 200cd08: 83 30 e0 1b srl %g3, 0x1b, %g1 200cd0c: 9b 28 e0 05 sll %g3, 5, %o5 200cd10: 99 28 a0 05 sll %g2, 5, %o4 200cd14: 86 a3 40 03 subcc %o5, %g3, %g3 200cd18: 98 10 40 0c or %g1, %o4, %o4 200cd1c: 84 63 00 02 subx %o4, %g2, %g2 200cd20: 92 80 c0 09 addcc %g3, %o1, %o1 200cd24: 83 32 60 1e srl %o1, 0x1e, %g1 200cd28: 90 40 80 08 addx %g2, %o0, %o0 200cd2c: b3 2a 60 02 sll %o1, 2, %i1 200cd30: b1 2a 20 02 sll %o0, 2, %i0 200cd34: 92 82 40 19 addcc %o1, %i1, %o1 200cd38: b0 10 40 18 or %g1, %i0, %i0 200cd3c: 83 32 60 1e srl %o1, 0x1e, %g1 200cd40: 90 42 00 18 addx %o0, %i0, %o0 200cd44: bb 2a 60 02 sll %o1, 2, %i5 200cd48: b9 2a 20 02 sll %o0, 2, %i4 200cd4c: 92 82 40 1d addcc %o1, %i5, %o1 200cd50: b8 10 40 1c or %g1, %i4, %i4 200cd54: 87 32 60 1b srl %o1, 0x1b, %g3 200cd58: 90 42 00 1c addx %o0, %i4, %o0 200cd5c: 83 2a 60 05 sll %o1, 5, %g1 200cd60: 85 2a 20 05 sll %o0, 5, %g2 200cd64: 92 10 00 01 mov %g1, %o1 200cd68: 40 00 3b 79 call 201bb4c <__divdi3> 200cd6c: 90 10 c0 02 or %g3, %g2, %o0 *_ival_percentage = answer / 1000; 200cd70: 94 10 20 00 clr %o2 * This looks odd but gives the results the proper precision. * * TODO: Rounding on the last digit of the fval. */ answer = (*_lhs * 100000) / *_rhs; 200cd74: b8 10 00 08 mov %o0, %i4 200cd78: ba 10 00 09 mov %o1, %i5 *_ival_percentage = answer / 1000; 200cd7c: 40 00 3b 74 call 201bb4c <__divdi3> 200cd80: 96 10 23 e8 mov 0x3e8, %o3 *_fval_percentage = answer % 1000; 200cd84: 90 10 00 1c mov %i4, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (*_lhs * 100000) / *_rhs; *_ival_percentage = answer / 1000; 200cd88: d2 26 80 00 st %o1, [ %i2 ] *_fval_percentage = answer % 1000; 200cd8c: 94 10 20 00 clr %o2 200cd90: 96 10 23 e8 mov 0x3e8, %o3 200cd94: 40 00 3c 59 call 201bef8 <__moddi3> 200cd98: 92 10 00 1d mov %i5, %o1 200cd9c: d2 26 c0 00 st %o1, [ %i3 ] 200cda0: 81 c7 e0 08 ret 200cda4: 81 e8 00 00 restore { Timestamp64_Control answer; if ( *_rhs == 0 ) { *_ival_percentage = 0; *_fval_percentage = 0; 200cda8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED return; 200cdac: 81 c7 e0 08 ret <== NOT EXECUTED 200cdb0: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 0200b538 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 200b538: 9d e3 bf a0 save %sp, -96, %sp 200b53c: 39 00 80 7a sethi %hi(0x201e800), %i4 200b540: b8 17 22 88 or %i4, 0x288, %i4 ! 201ea88 <_User_extensions_List> 200b544: fa 07 20 08 ld [ %i4 + 8 ], %i5 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 200b548: 80 a7 40 1c cmp %i5, %i4 200b54c: 02 80 00 0d be 200b580 <_User_extensions_Fatal+0x48> <== NEVER TAKEN 200b550: 01 00 00 00 nop !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 200b554: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 200b558: 80 a0 60 00 cmp %g1, 0 200b55c: 02 80 00 05 be 200b570 <_User_extensions_Fatal+0x38> 200b560: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 200b564: 92 10 00 19 mov %i1, %o1 200b568: 9f c0 40 00 call %g1 200b56c: 94 10 00 1a mov %i2, %o2 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 200b570: fa 07 60 04 ld [ %i5 + 4 ], %i5 ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 200b574: 80 a7 40 1c cmp %i5, %i4 200b578: 32 bf ff f8 bne,a 200b558 <_User_extensions_Fatal+0x20> 200b57c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 200b580: 81 c7 e0 08 ret 200b584: 81 e8 00 00 restore =============================================================================== 0200b3e4 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 200b3e4: 9d e3 bf a0 save %sp, -96, %sp User_extensions_Control *extension; uint32_t i; uint32_t number_of_extensions; User_extensions_Table *initial_extensions; number_of_extensions = Configuration.number_of_initial_extensions; 200b3e8: 07 00 80 76 sethi %hi(0x201d800), %g3 200b3ec: 86 10 e2 cc or %g3, 0x2cc, %g3 ! 201dacc initial_extensions = Configuration.User_extension_table; 200b3f0: f6 00 e0 48 ld [ %g3 + 0x48 ], %i3 200b3f4: 3b 00 80 7a sethi %hi(0x201e800), %i5 200b3f8: 09 00 80 7a sethi %hi(0x201e800), %g4 200b3fc: 84 17 62 88 or %i5, 0x288, %g2 200b400: 82 11 20 b4 or %g4, 0xb4, %g1 200b404: b4 00 a0 04 add %g2, 4, %i2 200b408: b8 00 60 04 add %g1, 4, %i4 200b40c: f4 27 62 88 st %i2, [ %i5 + 0x288 ] head->previous = NULL; 200b410: c0 20 a0 04 clr [ %g2 + 4 ] tail->previous = head; 200b414: c4 20 a0 08 st %g2, [ %g2 + 8 ] ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 200b418: f8 21 20 b4 st %i4, [ %g4 + 0xb4 ] head->previous = NULL; 200b41c: c0 20 60 04 clr [ %g1 + 4 ] tail->previous = head; 200b420: c2 20 60 08 st %g1, [ %g1 + 8 ] _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 200b424: 80 a6 e0 00 cmp %i3, 0 200b428: 02 80 00 1b be 200b494 <_User_extensions_Handler_initialization+0xb0><== NEVER TAKEN 200b42c: f4 00 e0 44 ld [ %g3 + 0x44 ], %i2 extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) 200b430: 83 2e a0 02 sll %i2, 2, %g1 200b434: b9 2e a0 04 sll %i2, 4, %i4 200b438: b8 27 00 01 sub %i4, %g1, %i4 200b43c: b8 07 00 1a add %i4, %i2, %i4 200b440: b9 2f 20 02 sll %i4, 2, %i4 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { extension = (User_extensions_Control *) 200b444: 40 00 01 98 call 200baa4 <_Workspace_Allocate_or_fatal_error> 200b448: 90 10 00 1c mov %i4, %o0 _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 200b44c: 92 10 20 00 clr %o1 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { extension = (User_extensions_Control *) 200b450: ba 10 00 08 mov %o0, %i5 _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 200b454: 40 00 17 6c call 2011204 200b458: 94 10 00 1c mov %i4, %o2 extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 200b45c: 80 a6 a0 00 cmp %i2, 0 200b460: 02 80 00 0d be 200b494 <_User_extensions_Handler_initialization+0xb0><== NEVER TAKEN 200b464: b8 10 20 00 clr %i4 RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 200b468: 92 10 00 1b mov %i3, %o1 200b46c: 94 10 20 20 mov 0x20, %o2 200b470: 40 00 17 28 call 2011110 200b474: 90 07 60 14 add %i5, 0x14, %o0 _User_extensions_Add_set( extension ); 200b478: 40 00 0d 6f call 200ea34 <_User_extensions_Add_set> 200b47c: 90 10 00 1d mov %i5, %o0 200b480: b8 07 20 01 inc %i4 _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 200b484: ba 07 60 34 add %i5, 0x34, %i5 extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 200b488: 80 a7 00 1a cmp %i4, %i2 200b48c: 12 bf ff f7 bne 200b468 <_User_extensions_Handler_initialization+0x84> 200b490: b6 06 e0 20 add %i3, 0x20, %i3 200b494: 81 c7 e0 08 ret 200b498: 81 e8 00 00 restore =============================================================================== 0200b49c <_User_extensions_Thread_begin>: #include void _User_extensions_Thread_begin ( Thread_Control *executing ) { 200b49c: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 200b4a0: 39 00 80 7a sethi %hi(0x201e800), %i4 200b4a4: fa 07 22 88 ld [ %i4 + 0x288 ], %i5 ! 201ea88 <_User_extensions_List> 200b4a8: b8 17 22 88 or %i4, 0x288, %i4 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 200b4ac: b8 07 20 04 add %i4, 4, %i4 200b4b0: 80 a7 40 1c cmp %i5, %i4 200b4b4: 02 80 00 0c be 200b4e4 <_User_extensions_Thread_begin+0x48><== NEVER TAKEN 200b4b8: 01 00 00 00 nop !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) 200b4bc: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 200b4c0: 80 a0 60 00 cmp %g1, 0 200b4c4: 02 80 00 04 be 200b4d4 <_User_extensions_Thread_begin+0x38> 200b4c8: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.thread_begin)( executing ); 200b4cc: 9f c0 40 00 call %g1 200b4d0: 01 00 00 00 nop Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 200b4d4: fa 07 40 00 ld [ %i5 ], %i5 ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 200b4d8: 80 a7 40 1c cmp %i5, %i4 200b4dc: 32 bf ff f9 bne,a 200b4c0 <_User_extensions_Thread_begin+0x24> 200b4e0: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 200b4e4: 81 c7 e0 08 ret 200b4e8: 81 e8 00 00 restore =============================================================================== 0200b588 <_User_extensions_Thread_create>: #include bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 200b588: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 200b58c: 39 00 80 7a sethi %hi(0x201e800), %i4 200b590: fa 07 22 88 ld [ %i4 + 0x288 ], %i5 ! 201ea88 <_User_extensions_List> 200b594: b8 17 22 88 or %i4, 0x288, %i4 Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 200b598: b8 07 20 04 add %i4, 4, %i4 200b59c: 80 a7 40 1c cmp %i5, %i4 200b5a0: 02 80 00 10 be 200b5e0 <_User_extensions_Thread_create+0x58><== NEVER TAKEN 200b5a4: 37 00 80 7b sethi %hi(0x201ec00), %i3 !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 200b5a8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 200b5ac: 80 a0 60 00 cmp %g1, 0 200b5b0: 02 80 00 08 be 200b5d0 <_User_extensions_Thread_create+0x48> 200b5b4: 84 16 e1 e0 or %i3, 0x1e0, %g2 status = (*the_extension->Callouts.thread_create)( 200b5b8: d0 00 a0 0c ld [ %g2 + 0xc ], %o0 200b5bc: 9f c0 40 00 call %g1 200b5c0: 92 10 00 18 mov %i0, %o1 _Thread_Executing, the_thread ); if ( !status ) 200b5c4: 80 8a 20 ff btst 0xff, %o0 200b5c8: 22 80 00 0a be,a 200b5f0 <_User_extensions_Thread_create+0x68> 200b5cc: b0 10 20 00 clr %i0 User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 200b5d0: fa 07 40 00 ld [ %i5 ], %i5 { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 200b5d4: 80 a7 40 1c cmp %i5, %i4 200b5d8: 32 bf ff f5 bne,a 200b5ac <_User_extensions_Thread_create+0x24> 200b5dc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 if ( !status ) return false; } } return true; 200b5e0: b0 10 20 01 mov 1, %i0 } 200b5e4: b0 0e 20 01 and %i0, 1, %i0 200b5e8: 81 c7 e0 08 ret 200b5ec: 81 e8 00 00 restore 200b5f0: b0 0e 20 01 and %i0, 1, %i0 200b5f4: 81 c7 e0 08 ret 200b5f8: 81 e8 00 00 restore =============================================================================== 0200b5fc <_User_extensions_Thread_delete>: #include void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 200b5fc: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 200b600: 39 00 80 7a sethi %hi(0x201e800), %i4 200b604: b8 17 22 88 or %i4, 0x288, %i4 ! 201ea88 <_User_extensions_List> 200b608: fa 07 20 08 ld [ %i4 + 8 ], %i5 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 200b60c: 80 a7 40 1c cmp %i5, %i4 200b610: 02 80 00 0d be 200b644 <_User_extensions_Thread_delete+0x48><== NEVER TAKEN 200b614: 37 00 80 7b sethi %hi(0x201ec00), %i3 !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) 200b618: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 200b61c: 80 a0 60 00 cmp %g1, 0 200b620: 02 80 00 05 be 200b634 <_User_extensions_Thread_delete+0x38> 200b624: 84 16 e1 e0 or %i3, 0x1e0, %g2 (*the_extension->Callouts.thread_delete)( 200b628: d0 00 a0 0c ld [ %g2 + 0xc ], %o0 200b62c: 9f c0 40 00 call %g1 200b630: 92 10 00 18 mov %i0, %o1 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 200b634: fa 07 60 04 ld [ %i5 + 4 ], %i5 ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 200b638: 80 a7 40 1c cmp %i5, %i4 200b63c: 32 bf ff f8 bne,a 200b61c <_User_extensions_Thread_delete+0x20> 200b640: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 200b644: 81 c7 e0 08 ret 200b648: 81 e8 00 00 restore =============================================================================== 0200b4ec <_User_extensions_Thread_exitted>: } void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 200b4ec: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 200b4f0: 39 00 80 7a sethi %hi(0x201e800), %i4 200b4f4: b8 17 22 88 or %i4, 0x288, %i4 ! 201ea88 <_User_extensions_List> 200b4f8: fa 07 20 08 ld [ %i4 + 8 ], %i5 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 200b4fc: 80 a7 40 1c cmp %i5, %i4 200b500: 02 80 00 0c be 200b530 <_User_extensions_Thread_exitted+0x44><== NEVER TAKEN 200b504: 01 00 00 00 nop !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 200b508: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 200b50c: 80 a0 60 00 cmp %g1, 0 200b510: 02 80 00 04 be 200b520 <_User_extensions_Thread_exitted+0x34> 200b514: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.thread_exitted)( executing ); 200b518: 9f c0 40 00 call %g1 200b51c: 01 00 00 00 nop Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 200b520: fa 07 60 04 ld [ %i5 + 4 ], %i5 ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 200b524: 80 a7 40 1c cmp %i5, %i4 200b528: 32 bf ff f9 bne,a 200b50c <_User_extensions_Thread_exitted+0x20> 200b52c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 200b530: 81 c7 e0 08 ret 200b534: 81 e8 00 00 restore =============================================================================== 0200bea8 <_User_extensions_Thread_restart>: #include void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 200bea8: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 200beac: 39 00 80 7d sethi %hi(0x201f400), %i4 200beb0: fa 07 21 b8 ld [ %i4 + 0x1b8 ], %i5 ! 201f5b8 <_User_extensions_List> 200beb4: b8 17 21 b8 or %i4, 0x1b8, %i4 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 200beb8: b8 07 20 04 add %i4, 4, %i4 200bebc: 80 a7 40 1c cmp %i5, %i4 200bec0: 02 80 00 0d be 200bef4 <_User_extensions_Thread_restart+0x4c><== NEVER TAKEN 200bec4: 37 00 80 7e sethi %hi(0x201f800), %i3 !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) 200bec8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 200becc: 80 a0 60 00 cmp %g1, 0 200bed0: 02 80 00 05 be 200bee4 <_User_extensions_Thread_restart+0x3c> 200bed4: 84 16 e1 10 or %i3, 0x110, %g2 (*the_extension->Callouts.thread_restart)( 200bed8: d0 00 a0 0c ld [ %g2 + 0xc ], %o0 200bedc: 9f c0 40 00 call %g1 200bee0: 92 10 00 18 mov %i0, %o1 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 200bee4: fa 07 40 00 ld [ %i5 ], %i5 ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 200bee8: 80 a7 40 1c cmp %i5, %i4 200beec: 32 bf ff f8 bne,a 200becc <_User_extensions_Thread_restart+0x24> 200bef0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 200bef4: 81 c7 e0 08 ret 200bef8: 81 e8 00 00 restore =============================================================================== 0200b64c <_User_extensions_Thread_start>: #include void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 200b64c: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 200b650: 39 00 80 7a sethi %hi(0x201e800), %i4 200b654: fa 07 22 88 ld [ %i4 + 0x288 ], %i5 ! 201ea88 <_User_extensions_List> 200b658: b8 17 22 88 or %i4, 0x288, %i4 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 200b65c: b8 07 20 04 add %i4, 4, %i4 200b660: 80 a7 40 1c cmp %i5, %i4 200b664: 02 80 00 0d be 200b698 <_User_extensions_Thread_start+0x4c><== NEVER TAKEN 200b668: 37 00 80 7b sethi %hi(0x201ec00), %i3 !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) 200b66c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 200b670: 80 a0 60 00 cmp %g1, 0 200b674: 02 80 00 05 be 200b688 <_User_extensions_Thread_start+0x3c> 200b678: 84 16 e1 e0 or %i3, 0x1e0, %g2 (*the_extension->Callouts.thread_start)( 200b67c: d0 00 a0 0c ld [ %g2 + 0xc ], %o0 200b680: 9f c0 40 00 call %g1 200b684: 92 10 00 18 mov %i0, %o1 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 200b688: fa 07 40 00 ld [ %i5 ], %i5 ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 200b68c: 80 a7 40 1c cmp %i5, %i4 200b690: 32 bf ff f8 bne,a 200b670 <_User_extensions_Thread_start+0x24> 200b694: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 200b698: 81 c7 e0 08 ret 200b69c: 81 e8 00 00 restore =============================================================================== 0200b6a0 <_User_extensions_Thread_switch>: void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 200b6a0: 9d e3 bf a0 save %sp, -96, %sp 200b6a4: 39 00 80 7a sethi %hi(0x201e800), %i4 200b6a8: fa 07 20 b4 ld [ %i4 + 0xb4 ], %i5 ! 201e8b4 <_User_extensions_Switches_list> 200b6ac: b8 17 20 b4 or %i4, 0xb4, %i4 Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 200b6b0: b8 07 20 04 add %i4, 4, %i4 200b6b4: 80 a7 40 1c cmp %i5, %i4 200b6b8: 02 80 00 0a be 200b6e0 <_User_extensions_Thread_switch+0x40><== NEVER TAKEN 200b6bc: 01 00 00 00 nop !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); 200b6c0: c2 07 60 08 ld [ %i5 + 8 ], %g1 200b6c4: 90 10 00 18 mov %i0, %o0 200b6c8: 9f c0 40 00 call %g1 200b6cc: 92 10 00 19 mov %i1, %o1 Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { 200b6d0: fa 07 40 00 ld [ %i5 ], %i5 ) { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 200b6d4: 80 a7 40 1c cmp %i5, %i4 200b6d8: 32 bf ff fb bne,a 200b6c4 <_User_extensions_Thread_switch+0x24> 200b6dc: c2 07 60 08 ld [ %i5 + 8 ], %g1 200b6e0: 81 c7 e0 08 ret 200b6e4: 81 e8 00 00 restore =============================================================================== 0200d0f8 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 200d0f8: 9d e3 bf a0 save %sp, -96, %sp ISR_Level level; _ISR_Disable( level ); 200d0fc: 7f ff d8 e8 call 200349c 200d100: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 200d104: c2 06 00 00 ld [ %i0 ], %g1 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 200d108: b8 06 20 04 add %i0, 4, %i4 * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 200d10c: 80 a0 40 1c cmp %g1, %i4 200d110: 02 80 00 1f be 200d18c <_Watchdog_Adjust+0x94> 200d114: 80 a6 60 00 cmp %i1, 0 switch ( direction ) { 200d118: 12 80 00 1f bne 200d194 <_Watchdog_Adjust+0x9c> 200d11c: 80 a6 60 01 cmp %i1, 1 case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 200d120: 80 a6 a0 00 cmp %i2, 0 200d124: 02 80 00 1a be 200d18c <_Watchdog_Adjust+0x94> <== NEVER TAKEN 200d128: 01 00 00 00 nop if ( units < _Watchdog_First( header )->delta_interval ) { 200d12c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 200d130: 80 a6 80 02 cmp %i2, %g2 200d134: 1a 80 00 0a bcc 200d15c <_Watchdog_Adjust+0x64> <== ALWAYS TAKEN 200d138: b6 10 20 01 mov 1, %i3 _Watchdog_First( header )->delta_interval -= units; 200d13c: 10 80 00 1d b 200d1b0 <_Watchdog_Adjust+0xb8> <== NOT EXECUTED 200d140: 84 20 80 1a sub %g2, %i2, %g2 <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 200d144: 02 80 00 12 be 200d18c <_Watchdog_Adjust+0x94> <== NEVER TAKEN 200d148: 01 00 00 00 nop if ( units < _Watchdog_First( header )->delta_interval ) { 200d14c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 200d150: 80 a0 80 1a cmp %g2, %i2 200d154: 38 80 00 17 bgu,a 200d1b0 <_Watchdog_Adjust+0xb8> 200d158: 84 20 80 1a sub %g2, %i2, %g2 _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 200d15c: f6 20 60 10 st %i3, [ %g1 + 0x10 ] while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; 200d160: b4 26 80 02 sub %i2, %g2, %i2 _Watchdog_First( header )->delta_interval = 1; _ISR_Enable( level ); 200d164: 7f ff d8 d2 call 20034ac 200d168: 01 00 00 00 nop _Watchdog_Tickle( header ); 200d16c: 40 00 00 a8 call 200d40c <_Watchdog_Tickle> 200d170: 90 10 00 18 mov %i0, %o0 _ISR_Disable( level ); 200d174: 7f ff d8 ca call 200349c 200d178: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 200d17c: c2 06 00 00 ld [ %i0 ], %g1 if ( _Chain_Is_empty( header ) ) 200d180: 80 a7 00 01 cmp %i4, %g1 200d184: 12 bf ff f0 bne 200d144 <_Watchdog_Adjust+0x4c> 200d188: 80 a6 a0 00 cmp %i2, 0 } break; } } _ISR_Enable( level ); 200d18c: 7f ff d8 c8 call 20034ac 200d190: 91 e8 00 08 restore %g0, %o0, %o0 * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 200d194: 12 bf ff fe bne 200d18c <_Watchdog_Adjust+0x94> <== NEVER TAKEN 200d198: 01 00 00 00 nop case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 200d19c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 200d1a0: b4 00 80 1a add %g2, %i2, %i2 200d1a4: f4 20 60 10 st %i2, [ %g1 + 0x10 ] } break; } } _ISR_Enable( level ); 200d1a8: 7f ff d8 c1 call 20034ac 200d1ac: 91 e8 00 08 restore %g0, %o0, %o0 break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; break; 200d1b0: 10 bf ff f7 b 200d18c <_Watchdog_Adjust+0x94> 200d1b4: c4 20 60 10 st %g2, [ %g1 + 0x10 ] =============================================================================== 0200b864 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 200b864: 9d e3 bf a0 save %sp, -96, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 200b868: 7f ff db bf call 2002764 200b86c: 01 00 00 00 nop previous_state = the_watchdog->state; 200b870: fa 06 20 08 ld [ %i0 + 8 ], %i5 switch ( previous_state ) { 200b874: 80 a7 60 01 cmp %i5, 1 200b878: 02 80 00 2a be 200b920 <_Watchdog_Remove+0xbc> 200b87c: 03 00 80 7a sethi %hi(0x201e800), %g1 200b880: 1a 80 00 09 bcc 200b8a4 <_Watchdog_Remove+0x40> 200b884: 80 a7 60 03 cmp %i5, 3 _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200b888: 03 00 80 7a sethi %hi(0x201e800), %g1 200b88c: c2 00 61 a8 ld [ %g1 + 0x1a8 ], %g1 ! 201e9a8 <_Watchdog_Ticks_since_boot> 200b890: c2 26 20 18 st %g1, [ %i0 + 0x18 ] _ISR_Enable( level ); 200b894: 7f ff db b8 call 2002774 200b898: b0 10 00 1d mov %i5, %i0 return( previous_state ); } 200b89c: 81 c7 e0 08 ret 200b8a0: 81 e8 00 00 restore Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 200b8a4: 18 bf ff fa bgu 200b88c <_Watchdog_Remove+0x28> <== NEVER TAKEN 200b8a8: 03 00 80 7a sethi %hi(0x201e800), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 200b8ac: c2 06 00 00 ld [ %i0 ], %g1 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 200b8b0: c0 26 20 08 clr [ %i0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 200b8b4: c4 00 40 00 ld [ %g1 ], %g2 200b8b8: 80 a0 a0 00 cmp %g2, 0 200b8bc: 02 80 00 07 be 200b8d8 <_Watchdog_Remove+0x74> 200b8c0: 05 00 80 7a sethi %hi(0x201e800), %g2 next_watchdog->delta_interval += the_watchdog->delta_interval; 200b8c4: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 200b8c8: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 200b8cc: 84 00 c0 02 add %g3, %g2, %g2 200b8d0: c4 20 60 10 st %g2, [ %g1 + 0x10 ] if ( _Watchdog_Sync_count ) 200b8d4: 05 00 80 7a sethi %hi(0x201e800), %g2 200b8d8: c4 00 a1 a4 ld [ %g2 + 0x1a4 ], %g2 ! 201e9a4 <_Watchdog_Sync_count> 200b8dc: 80 a0 a0 00 cmp %g2, 0 200b8e0: 22 80 00 07 be,a 200b8fc <_Watchdog_Remove+0x98> 200b8e4: c4 06 20 04 ld [ %i0 + 4 ], %g2 _Watchdog_Sync_level = _ISR_Nest_level; 200b8e8: 05 00 80 7b sethi %hi(0x201ec00), %g2 200b8ec: c6 00 a1 e8 ld [ %g2 + 0x1e8 ], %g3 ! 201ede8 <_Per_CPU_Information+0x8> 200b8f0: 05 00 80 7a sethi %hi(0x201e800), %g2 200b8f4: c6 20 a1 44 st %g3, [ %g2 + 0x144 ] ! 201e944 <_Watchdog_Sync_level> { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200b8f8: c4 06 20 04 ld [ %i0 + 4 ], %g2 next->previous = previous; 200b8fc: c4 20 60 04 st %g2, [ %g1 + 4 ] previous->next = next; 200b900: c2 20 80 00 st %g1, [ %g2 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200b904: 03 00 80 7a sethi %hi(0x201e800), %g1 200b908: c2 00 61 a8 ld [ %g1 + 0x1a8 ], %g1 ! 201e9a8 <_Watchdog_Ticks_since_boot> 200b90c: c2 26 20 18 st %g1, [ %i0 + 0x18 ] _ISR_Enable( level ); 200b910: 7f ff db 99 call 2002774 200b914: b0 10 00 1d mov %i5, %i0 return( previous_state ); } 200b918: 81 c7 e0 08 ret 200b91c: 81 e8 00 00 restore _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200b920: c2 00 61 a8 ld [ %g1 + 0x1a8 ], %g1 /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 200b924: c0 26 20 08 clr [ %i0 + 8 ] _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200b928: c2 26 20 18 st %g1, [ %i0 + 0x18 ] _ISR_Enable( level ); 200b92c: 7f ff db 92 call 2002774 200b930: b0 10 00 1d mov %i5, %i0 return( previous_state ); } 200b934: 81 c7 e0 08 ret 200b938: 81 e8 00 00 restore =============================================================================== 0200cb08 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 200cb08: 9d e3 bf a0 save %sp, -96, %sp ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 200cb0c: 7f ff d9 62 call 2003094 200cb10: 01 00 00 00 nop 200cb14: b6 10 00 08 mov %o0, %i3 printk( "Watchdog Chain: %s %p\n", name, header ); 200cb18: 11 00 80 79 sethi %hi(0x201e400), %o0 200cb1c: 94 10 00 19 mov %i1, %o2 200cb20: 92 10 00 18 mov %i0, %o1 200cb24: 7f ff e1 6e call 20050dc 200cb28: 90 12 22 50 or %o0, 0x250, %o0 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 200cb2c: fa 06 40 00 ld [ %i1 ], %i5 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 200cb30: b2 06 60 04 add %i1, 4, %i1 if ( !_Chain_Is_empty( header ) ) { 200cb34: 80 a7 40 19 cmp %i5, %i1 200cb38: 02 80 00 0f be 200cb74 <_Watchdog_Report_chain+0x6c> 200cb3c: 11 00 80 79 sethi %hi(0x201e400), %o0 node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 200cb40: 92 10 00 1d mov %i5, %o1 200cb44: 40 00 00 0f call 200cb80 <_Watchdog_Report> 200cb48: 90 10 20 00 clr %o0 _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; node != _Chain_Tail(header) ; node = node->next ) 200cb4c: fa 07 40 00 ld [ %i5 ], %i5 Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; 200cb50: 80 a7 40 19 cmp %i5, %i1 200cb54: 12 bf ff fc bne 200cb44 <_Watchdog_Report_chain+0x3c> <== NEVER TAKEN 200cb58: 92 10 00 1d mov %i5, %o1 { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 200cb5c: 11 00 80 79 sethi %hi(0x201e400), %o0 200cb60: 92 10 00 18 mov %i0, %o1 200cb64: 7f ff e1 5e call 20050dc 200cb68: 90 12 22 68 or %o0, 0x268, %o0 } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); 200cb6c: 7f ff d9 4e call 20030a4 200cb70: 91 e8 00 1b restore %g0, %i3, %o0 _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); 200cb74: 7f ff e1 5a call 20050dc 200cb78: 90 12 22 78 or %o0, 0x278, %o0 200cb7c: 30 bf ff fc b,a 200cb6c <_Watchdog_Report_chain+0x64> =============================================================================== 02007ba0 : int adjtime( const struct timeval *delta, struct timeval *olddelta ) { 2007ba0: 9d e3 bf 98 save %sp, -104, %sp long adjustment; /* * Simple validations */ if ( !delta ) 2007ba4: 80 a6 20 00 cmp %i0, 0 2007ba8: 02 80 00 8c be 2007dd8 2007bac: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) 2007bb0: c4 06 20 04 ld [ %i0 + 4 ], %g2 2007bb4: 03 00 03 d0 sethi %hi(0xf4000), %g1 2007bb8: 82 10 62 3f or %g1, 0x23f, %g1 ! f423f 2007bbc: 80 a0 80 01 cmp %g2, %g1 2007bc0: 18 80 00 86 bgu 2007dd8 2007bc4: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( olddelta ) { 2007bc8: 22 80 00 06 be,a 2007be0 2007bcc: c2 06 00 00 ld [ %i0 ], %g1 olddelta->tv_sec = 0; olddelta->tv_usec = 0; 2007bd0: c0 26 60 04 clr [ %i1 + 4 ] 2007bd4: c4 06 20 04 ld [ %i0 + 4 ], %g2 if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( olddelta ) { olddelta->tv_sec = 0; 2007bd8: c0 26 40 00 clr [ %i1 ] olddelta->tv_usec = 0; } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 2007bdc: c2 06 00 00 ld [ %i0 ], %g1 adjustment += delta->tv_usec; /* too small to account for */ if ( adjustment < rtems_configuration_get_microseconds_per_tick() ) 2007be0: 07 00 80 81 sethi %hi(0x2020400), %g3 2007be4: c8 00 e3 2c ld [ %g3 + 0x32c ], %g4 ! 202072c olddelta->tv_sec = 0; olddelta->tv_usec = 0; } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 2007be8: bb 28 60 08 sll %g1, 8, %i5 2007bec: 87 28 60 03 sll %g1, 3, %g3 2007bf0: 86 27 40 03 sub %i5, %g3, %g3 2007bf4: bb 28 e0 06 sll %g3, 6, %i5 2007bf8: 86 27 40 03 sub %i5, %g3, %g3 2007bfc: 82 00 c0 01 add %g3, %g1, %g1 2007c00: 83 28 60 06 sll %g1, 6, %g1 adjustment += delta->tv_usec; 2007c04: 84 00 40 02 add %g1, %g2, %g2 /* too small to account for */ if ( adjustment < rtems_configuration_get_microseconds_per_tick() ) 2007c08: 80 a0 80 04 cmp %g2, %g4 2007c0c: 1a 80 00 05 bcc 2007c20 2007c10: 03 00 80 85 sethi %hi(0x2021400), %g1 return 0; 2007c14: 82 10 20 00 clr %g1 /* set the user's output */ if ( olddelta ) *olddelta = *delta; return 0; } 2007c18: 81 c7 e0 08 ret 2007c1c: 91 e8 00 01 restore %g0, %g1, %o0 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2007c20: c4 00 62 40 ld [ %g1 + 0x240 ], %g2 2007c24: 84 00 a0 01 inc %g2 2007c28: c4 20 62 40 st %g2, [ %g1 + 0x240 ] return _Thread_Dispatch_disable_level; 2007c2c: c2 00 62 40 ld [ %g1 + 0x240 ], %g1 struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 2007c30: 40 00 07 20 call 20098b0 <_TOD_Get_as_timestamp> 2007c34: 90 07 bf f8 add %fp, -8, %o0 _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 2007c38: f8 1f bf f8 ldd [ %fp + -8 ], %i4 static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 2007c3c: 94 10 20 00 clr %o2 2007c40: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2007c44: 90 10 00 1c mov %i4, %o0 2007c48: 96 12 e2 00 or %o3, 0x200, %o3 2007c4c: 40 00 52 10 call 201c48c <__divdi3> 2007c50: 92 10 00 1d mov %i5, %o1 _Thread_Disable_dispatch(); _TOD_Get( &ts ); ts.tv_sec += delta->tv_sec; 2007c54: f6 06 00 00 ld [ %i0 ], %i3 _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 2007c58: 94 10 20 00 clr %o2 2007c5c: b6 06 c0 09 add %i3, %o1, %i3 2007c60: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2007c64: 90 10 00 1c mov %i4, %o0 2007c68: 96 12 e2 00 or %o3, 0x200, %o3 2007c6c: 40 00 52 f3 call 201c838 <__moddi3> 2007c70: 92 10 00 1d mov %i5, %o1 ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 2007c74: c2 06 20 04 ld [ %i0 + 4 ], %g1 /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 2007c78: 09 31 19 4d sethi %hi(0xc4653400), %g4 _Thread_Disable_dispatch(); _TOD_Get( &ts ); ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 2007c7c: 87 28 60 07 sll %g1, 7, %g3 2007c80: 85 28 60 02 sll %g1, 2, %g2 2007c84: 84 20 c0 02 sub %g3, %g2, %g2 /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 2007c88: 88 11 22 00 or %g4, 0x200, %g4 _Thread_Disable_dispatch(); _TOD_Get( &ts ); ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 2007c8c: 82 00 80 01 add %g2, %g1, %g1 /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 2007c90: 07 0e e6 b2 sethi %hi(0x3b9ac800), %g3 _Thread_Disable_dispatch(); _TOD_Get( &ts ); ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 2007c94: 83 28 60 03 sll %g1, 3, %g1 /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 2007c98: 86 10 e1 ff or %g3, 0x1ff, %g3 _Thread_Disable_dispatch(); _TOD_Get( &ts ); ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 2007c9c: 92 00 40 09 add %g1, %o1, %o1 /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 2007ca0: 80 a2 40 03 cmp %o1, %g3 2007ca4: 08 80 00 07 bleu 2007cc0 2007ca8: 84 06 e0 01 add %i3, 1, %g2 ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 2007cac: 92 02 40 04 add %o1, %g4, %o1 ts.tv_sec++; 2007cb0: b6 10 00 02 mov %g2, %i3 ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 2007cb4: 80 a2 40 03 cmp %o1, %g3 2007cb8: 18 bf ff fd bgu 2007cac <== NEVER TAKEN 2007cbc: 84 00 a0 01 inc %g2 ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; 2007cc0: 3b 0e e6 b2 sethi %hi(0x3b9ac800), %i5 ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 2007cc4: 09 31 19 4d sethi %hi(0xc4653400), %g4 2007cc8: 82 10 00 09 mov %o1, %g1 int _EXFUN(setitimer, (int __which, const struct itimerval *__value, struct itimerval *__ovalue)); #if defined(__rtems__) /* BSD function used by RTEMS code */ int _EXFUN(adjtime,(const struct timeval *, struct timeval *)); 2007ccc: 84 06 ff ff add %i3, -1, %g2 ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; 2007cd0: ba 17 62 00 or %i5, 0x200, %i5 ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 2007cd4: 88 11 22 00 or %g4, 0x200, %g4 ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; 2007cd8: 82 00 40 1d add %g1, %i5, %g1 ts.tv_sec--; 2007cdc: 86 10 00 02 mov %g2, %g3 ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 2007ce0: 80 a0 40 04 cmp %g1, %g4 2007ce4: 08 bf ff fd bleu 2007cd8 2007ce8: 84 00 bf ff add %g2, -1, %g2 const struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _Timestamp_Set( 2007cec: b9 38 e0 1f sra %g3, 0x1f, %i4 2007cf0: ae 10 00 01 mov %g1, %l7 2007cf4: ad 38 60 1f sra %g1, 0x1f, %l6 Timestamp64_Control *_time, Timestamp64_Control _seconds, Timestamp64_Control _nanoseconds ) { *_time = _seconds * 1000000000L + _nanoseconds; 2007cf8: 83 2f 20 03 sll %i4, 3, %g1 2007cfc: b7 28 e0 03 sll %g3, 3, %i3 2007d00: 85 30 e0 1d srl %g3, 0x1d, %g2 2007d04: b4 10 80 01 or %g2, %g1, %i2 2007d08: 83 36 e0 1b srl %i3, 0x1b, %g1 2007d0c: a9 2e a0 05 sll %i2, 5, %l4 2007d10: ab 2e e0 05 sll %i3, 5, %l5 2007d14: a8 10 40 14 or %g1, %l4, %l4 2007d18: b6 a5 40 1b subcc %l5, %i3, %i3 2007d1c: 83 36 e0 1a srl %i3, 0x1a, %g1 2007d20: b4 65 00 1a subx %l4, %i2, %i2 2007d24: a7 2e e0 06 sll %i3, 6, %l3 2007d28: a5 2e a0 06 sll %i2, 6, %l2 2007d2c: b6 a4 c0 1b subcc %l3, %i3, %i3 2007d30: a4 10 40 12 or %g1, %l2, %l2 2007d34: b4 64 80 1a subx %l2, %i2, %i2 2007d38: ba 86 c0 03 addcc %i3, %g3, %i5 2007d3c: 83 37 60 1e srl %i5, 0x1e, %g1 2007d40: b8 46 80 1c addx %i2, %i4, %i4 2007d44: a3 2f 60 02 sll %i5, 2, %l1 2007d48: a1 2f 20 02 sll %i4, 2, %l0 2007d4c: a2 87 40 11 addcc %i5, %l1, %l1 2007d50: a0 10 40 10 or %g1, %l0, %l0 2007d54: 83 34 60 1e srl %l1, 0x1e, %g1 2007d58: a0 47 00 10 addx %i4, %l0, %l0 2007d5c: 97 2c 60 02 sll %l1, 2, %o3 2007d60: 95 2c 20 02 sll %l0, 2, %o2 2007d64: 96 84 40 0b addcc %l1, %o3, %o3 2007d68: 94 10 40 0a or %g1, %o2, %o2 2007d6c: 9b 2a e0 02 sll %o3, 2, %o5 2007d70: 94 44 00 0a addx %l0, %o2, %o2 2007d74: 83 32 e0 1e srl %o3, 0x1e, %g1 2007d78: 86 82 c0 0d addcc %o3, %o5, %g3 2007d7c: 99 2a a0 02 sll %o2, 2, %o4 2007d80: 98 10 40 0c or %g1, %o4, %o4 2007d84: 84 42 80 0c addx %o2, %o4, %g2 2007d88: 83 28 e0 09 sll %g3, 9, %g1 2007d8c: 89 28 a0 09 sll %g2, 9, %g4 &tod_as_timestamp, tod_as_timespec->tv_sec, tod_as_timespec->tv_nsec ); _TOD_Set_with_timestamp( &tod_as_timestamp ); 2007d90: 90 07 bf f8 add %fp, -8, %o0 2007d94: bb 30 e0 17 srl %g3, 0x17, %i5 2007d98: 86 85 c0 01 addcc %l7, %g1, %g3 2007d9c: 84 17 40 04 or %i5, %g4, %g2 2007da0: 84 45 80 02 addx %l6, %g2, %g2 2007da4: 40 00 06 df call 2009920 <_TOD_Set_with_timestamp> 2007da8: c4 3f bf f8 std %g2, [ %fp + -8 ] ts.tv_sec--; } _TOD_Set( &ts ); _Thread_Enable_dispatch(); 2007dac: 40 00 0d a0 call 200b42c <_Thread_Enable_dispatch> 2007db0: 01 00 00 00 nop /* set the user's output */ if ( olddelta ) 2007db4: 80 a6 60 00 cmp %i1, 0 2007db8: 02 bf ff 97 be 2007c14 2007dbc: 82 10 20 00 clr %g1 *olddelta = *delta; 2007dc0: c4 06 00 00 ld [ %i0 ], %g2 2007dc4: c4 26 40 00 st %g2, [ %i1 ] 2007dc8: c4 06 20 04 ld [ %i0 + 4 ], %g2 2007dcc: c4 26 60 04 st %g2, [ %i1 + 4 ] return 0; } 2007dd0: 81 c7 e0 08 ret 2007dd4: 91 e8 00 01 restore %g0, %g1, %o0 */ if ( !delta ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) rtems_set_errno_and_return_minus_one( EINVAL ); 2007dd8: 40 00 25 b2 call 20114a0 <__errno> 2007ddc: 01 00 00 00 nop 2007de0: 84 10 20 16 mov 0x16, %g2 ! 16 2007de4: 82 10 3f ff mov -1, %g1 2007de8: 10 bf ff 8c b 2007c18 2007dec: c4 22 00 00 st %g2, [ %o0 ] =============================================================================== 02007dac : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 2007dac: 9d e3 bf a0 save %sp, -96, %sp rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 2007db0: 3b 00 80 83 sethi %hi(0x2020c00), %i5 2007db4: 40 00 04 85 call 2008fc8 2007db8: 90 17 61 a4 or %i5, 0x1a4, %o0 ! 2020da4 if (fcntl (fildes, F_GETFD) < 0) { 2007dbc: 90 10 00 18 mov %i0, %o0 2007dc0: 40 00 1c 42 call 200eec8 2007dc4: 92 10 20 01 mov 1, %o1 2007dc8: 80 a2 20 00 cmp %o0, 0 2007dcc: 06 80 00 6c bl 2007f7c 2007dd0: 80 a6 60 00 cmp %i1, 0 pthread_mutex_unlock(&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EBADF); } /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { 2007dd4: 02 80 00 3b be 2007ec0 2007dd8: 92 10 00 18 mov %i0, %o1 pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; } else { AIO_printf ("Cancel request\n"); if (aiocbp->aio_fildes != fildes) { 2007ddc: f8 06 40 00 ld [ %i1 ], %i4 2007de0: 80 a7 00 18 cmp %i4, %i0 2007de4: 12 80 00 2f bne 2007ea0 2007de8: 90 17 61 a4 or %i5, 0x1a4, %o0 pthread_mutex_unlock (&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EINVAL); } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 2007dec: 92 10 00 1c mov %i4, %o1 2007df0: 11 00 80 83 sethi %hi(0x2020c00), %o0 2007df4: 94 10 20 00 clr %o2 2007df8: 40 00 01 92 call 2008440 2007dfc: 90 12 21 ec or %o0, 0x1ec, %o0 if (r_chain == NULL) { 2007e00: b6 92 20 00 orcc %o0, 0, %i3 2007e04: 22 80 00 0f be,a 2007e40 2007e08: b6 17 61 a4 or %i5, 0x1a4, %i3 return AIO_ALLDONE; } } AIO_printf ("Request on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 2007e0c: b8 06 e0 1c add %i3, 0x1c, %i4 2007e10: 40 00 04 6e call 2008fc8 2007e14: 90 10 00 1c mov %i4, %o0 result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 2007e18: 92 10 00 19 mov %i1, %o1 2007e1c: 40 00 01 d2 call 2008564 2007e20: 90 06 e0 08 add %i3, 8, %o0 2007e24: b0 10 00 08 mov %o0, %i0 pthread_mutex_unlock (&r_chain->mutex); 2007e28: 40 00 04 88 call 2009048 2007e2c: 90 10 00 1c mov %i4, %o0 pthread_mutex_unlock (&aio_request_queue.mutex); 2007e30: 40 00 04 86 call 2009048 2007e34: 90 17 61 a4 or %i5, 0x1a4, %o0 return result; } return AIO_ALLDONE; } 2007e38: 81 c7 e0 08 ret 2007e3c: 81 e8 00 00 restore rtems_set_errno_and_return_minus_one (EINVAL); } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 2007e40: c4 06 e0 54 ld [ %i3 + 0x54 ], %g2 2007e44: 82 06 e0 58 add %i3, 0x58, %g1 2007e48: 80 a0 80 01 cmp %g2, %g1 2007e4c: 02 80 00 0f be 2007e88 <== NEVER TAKEN 2007e50: 90 06 e0 54 add %i3, 0x54, %o0 r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 2007e54: 92 10 00 1c mov %i4, %o1 2007e58: 40 00 01 7a call 2008440 2007e5c: 94 10 20 00 clr %o2 if (r_chain == NULL) { 2007e60: 80 a2 20 00 cmp %o0, 0 2007e64: 02 80 00 0e be 2007e9c 2007e68: 92 10 00 19 mov %i1, %o1 rtems_set_errno_and_return_minus_one (EINVAL); } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 2007e6c: 40 00 01 be call 2008564 2007e70: 90 02 20 08 add %o0, 8, %o0 2007e74: b0 10 00 08 mov %o0, %i0 pthread_mutex_unlock (&aio_request_queue.mutex); 2007e78: 40 00 04 74 call 2009048 2007e7c: 90 10 00 1b mov %i3, %o0 return result; 2007e80: 81 c7 e0 08 ret 2007e84: 81 e8 00 00 restore if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); if (r_chain == NULL) { pthread_mutex_unlock(&aio_request_queue.mutex); return AIO_ALLDONE; 2007e88: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); if (r_chain == NULL) { pthread_mutex_unlock(&aio_request_queue.mutex); 2007e8c: 40 00 04 6f call 2009048 2007e90: 90 17 61 a4 or %i5, 0x1a4, %o0 return AIO_ALLDONE; 2007e94: 81 c7 e0 08 ret 2007e98: 81 e8 00 00 restore r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); if (r_chain == NULL) { pthread_mutex_unlock (&aio_request_queue.mutex); 2007e9c: 90 10 00 1b mov %i3, %o0 2007ea0: 40 00 04 6a call 2009048 2007ea4: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one (EINVAL); 2007ea8: 40 00 2b 68 call 2012c48 <__errno> 2007eac: 01 00 00 00 nop 2007eb0: 82 10 20 16 mov 0x16, %g1 ! 16 2007eb4: c2 22 00 00 st %g1, [ %o0 ] 2007eb8: 81 c7 e0 08 ret 2007ebc: 81 e8 00 00 restore /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { AIO_printf ("Cancel all requests\n"); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 2007ec0: 11 00 80 83 sethi %hi(0x2020c00), %o0 2007ec4: 94 10 20 00 clr %o2 2007ec8: 40 00 01 5e call 2008440 2007ecc: 90 12 21 ec or %o0, 0x1ec, %o0 if (r_chain == NULL) { 2007ed0: b8 92 20 00 orcc %o0, 0, %i4 2007ed4: 02 80 00 0f be 2007f10 2007ed8: b6 07 20 1c add %i4, 0x1c, %i3 return AIO_ALLDONE; } AIO_printf ("Request chain on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 2007edc: 40 00 04 3b call 2008fc8 2007ee0: 90 10 00 1b mov %i3, %o0 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 2007ee4: 40 00 0b 26 call 200ab7c <_Chain_Extract> 2007ee8: 90 10 00 1c mov %i4, %o0 rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 2007eec: 40 00 01 8a call 2008514 2007ef0: 90 10 00 1c mov %i4, %o0 pthread_mutex_unlock (&r_chain->mutex); 2007ef4: 40 00 04 55 call 2009048 2007ef8: 90 10 00 1b mov %i3, %o0 pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; 2007efc: b0 10 20 00 clr %i0 pthread_mutex_lock (&r_chain->mutex); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_unlock (&aio_request_queue.mutex); 2007f00: 40 00 04 52 call 2009048 2007f04: 90 17 61 a4 or %i5, 0x1a4, %o0 return AIO_CANCELED; 2007f08: 81 c7 e0 08 ret 2007f0c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 2007f10: b8 17 61 a4 or %i5, 0x1a4, %i4 r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); if (r_chain == NULL) { AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 2007f14: c4 07 20 54 ld [ %i4 + 0x54 ], %g2 2007f18: 82 07 20 58 add %i4, 0x58, %g1 2007f1c: 80 a0 80 01 cmp %g2, %g1 2007f20: 02 bf ff da be 2007e88 <== NEVER TAKEN 2007f24: 90 07 20 54 add %i4, 0x54, %o0 r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 2007f28: 92 10 00 18 mov %i0, %o1 2007f2c: 40 00 01 45 call 2008440 2007f30: 94 10 20 00 clr %o2 if (r_chain == NULL) { 2007f34: b6 92 20 00 orcc %o0, 0, %i3 2007f38: 22 bf ff d5 be,a 2007e8c 2007f3c: b0 10 20 02 mov 2, %i0 2007f40: 40 00 0b 0f call 200ab7c <_Chain_Extract> 2007f44: ba 06 e0 1c add %i3, 0x1c, %i5 } AIO_printf ("Request chain on [IQ]\n"); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 2007f48: 40 00 01 73 call 2008514 2007f4c: 90 10 00 1b mov %i3, %o0 pthread_mutex_destroy (&r_chain->mutex); 2007f50: 40 00 03 71 call 2008d14 2007f54: 90 10 00 1d mov %i5, %o0 pthread_cond_destroy (&r_chain->mutex); 2007f58: 40 00 02 92 call 20089a0 2007f5c: 90 10 00 1d mov %i5, %o0 free (r_chain); 2007f60: 7f ff ef b0 call 2003e20 2007f64: 90 10 00 1b mov %i3, %o0 pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; 2007f68: b0 10 20 00 clr %i0 rtems_aio_remove_fd (r_chain); pthread_mutex_destroy (&r_chain->mutex); pthread_cond_destroy (&r_chain->mutex); free (r_chain); pthread_mutex_unlock (&aio_request_queue.mutex); 2007f6c: 40 00 04 37 call 2009048 2007f70: 90 10 00 1c mov %i4, %o0 return AIO_CANCELED; 2007f74: 81 c7 e0 08 ret 2007f78: 81 e8 00 00 restore int result; pthread_mutex_lock (&aio_request_queue.mutex); if (fcntl (fildes, F_GETFD) < 0) { pthread_mutex_unlock(&aio_request_queue.mutex); 2007f7c: 40 00 04 33 call 2009048 2007f80: 90 17 61 a4 or %i5, 0x1a4, %o0 rtems_set_errno_and_return_minus_one (EBADF); 2007f84: 40 00 2b 31 call 2012c48 <__errno> 2007f88: b0 10 3f ff mov -1, %i0 2007f8c: 82 10 20 09 mov 9, %g1 2007f90: c2 22 00 00 st %g1, [ %o0 ] 2007f94: 81 c7 e0 08 ret 2007f98: 81 e8 00 00 restore =============================================================================== 02007fa4 : int aio_fsync( int op, struct aiocb *aiocbp ) { 2007fa4: 9d e3 bf a0 save %sp, -96, %sp rtems_aio_request *req; int mode; if (op != O_SYNC) 2007fa8: 03 00 00 08 sethi %hi(0x2000), %g1 2007fac: 80 a6 00 01 cmp %i0, %g1 2007fb0: 12 80 00 14 bne 2008000 2007fb4: ba 10 20 16 mov 0x16, %i5 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); mode = fcntl (aiocbp->aio_fildes, F_GETFL); 2007fb8: d0 06 40 00 ld [ %i1 ], %o0 2007fbc: 40 00 1b c3 call 200eec8 2007fc0: 92 10 20 03 mov 3, %o1 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 2007fc4: 90 0a 20 03 and %o0, 3, %o0 2007fc8: 90 02 3f ff add %o0, -1, %o0 2007fcc: 80 a2 20 01 cmp %o0, 1 2007fd0: 18 80 00 0c bgu 2008000 2007fd4: ba 10 20 09 mov 9, %i5 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); req = malloc (sizeof (rtems_aio_request)); 2007fd8: 7f ff f0 d3 call 2004324 2007fdc: 90 10 20 18 mov 0x18, %o0 if (req == NULL) 2007fe0: 80 a2 20 00 cmp %o0, 0 2007fe4: 02 80 00 06 be 2007ffc <== NEVER TAKEN 2007fe8: 82 10 20 03 mov 3, %g1 rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 2007fec: f2 22 20 14 st %i1, [ %o0 + 0x14 ] req->aiocbp->aio_lio_opcode = LIO_SYNC; 2007ff0: c2 26 60 30 st %g1, [ %i1 + 0x30 ] return rtems_aio_enqueue (req); 2007ff4: 40 00 01 78 call 20085d4 2007ff8: 91 e8 00 08 restore %g0, %o0, %o0 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 2007ffc: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED 2008000: 82 10 3f ff mov -1, %g1 2008004: fa 26 60 34 st %i5, [ %i1 + 0x34 ] 2008008: c2 26 60 38 st %g1, [ %i1 + 0x38 ] 200800c: 40 00 2b 0f call 2012c48 <__errno> 2008010: b0 10 3f ff mov -1, %i0 2008014: fa 22 00 00 st %i5, [ %o0 ] req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); } 2008018: 81 c7 e0 08 ret 200801c: 81 e8 00 00 restore =============================================================================== 020087b8 : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 20087b8: 9d e3 bf a0 save %sp, -96, %sp rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 20087bc: d0 06 00 00 ld [ %i0 ], %o0 20087c0: 92 10 20 03 mov 3, %o1 20087c4: 40 00 19 c1 call 200eec8 20087c8: ba 10 20 09 mov 9, %i5 if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 20087cc: 80 8a 20 01 btst 1, %o0 20087d0: 12 80 00 0b bne 20087fc 20087d4: 82 10 3f ff mov -1, %g1 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 20087d8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20087dc: 80 a0 60 00 cmp %g1, 0 20087e0: 12 80 00 06 bne 20087f8 20087e4: ba 10 20 16 mov 0x16, %i5 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 20087e8: c2 06 20 08 ld [ %i0 + 8 ], %g1 20087ec: 80 a0 60 00 cmp %g1, 0 20087f0: 16 80 00 0a bge 2008818 20087f4: 01 00 00 00 nop rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 20087f8: 82 10 3f ff mov -1, %g1 ! ffffffff 20087fc: fa 26 20 34 st %i5, [ %i0 + 0x34 ] 2008800: c2 26 20 38 st %g1, [ %i0 + 0x38 ] 2008804: 40 00 29 11 call 2012c48 <__errno> 2008808: b0 10 3f ff mov -1, %i0 200880c: fa 22 00 00 st %i5, [ %o0 ] req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_READ; return rtems_aio_enqueue (req); } 2008810: 81 c7 e0 08 ret 2008814: 81 e8 00 00 restore rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 2008818: 7f ff ee c3 call 2004324 200881c: 90 10 20 18 mov 0x18, %o0 if (req == NULL) 2008820: 80 a2 20 00 cmp %o0, 0 2008824: 02 80 00 06 be 200883c <== NEVER TAKEN 2008828: 82 10 20 01 mov 1, %g1 rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 200882c: f0 22 20 14 st %i0, [ %o0 + 0x14 ] req->aiocbp->aio_lio_opcode = LIO_READ; 2008830: c2 26 20 30 st %g1, [ %i0 + 0x30 ] return rtems_aio_enqueue (req); 2008834: 7f ff ff 68 call 20085d4 2008838: 91 e8 00 08 restore %g0, %o0, %o0 if (aiocbp->aio_offset < 0) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 200883c: 10 bf ff ef b 20087f8 <== NOT EXECUTED 2008840: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED =============================================================================== 0200884c : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 200884c: 9d e3 bf a0 save %sp, -96, %sp rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 2008850: d0 06 00 00 ld [ %i0 ], %o0 2008854: 40 00 19 9d call 200eec8 2008858: 92 10 20 03 mov 3, %o1 if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 200885c: 90 0a 20 03 and %o0, 3, %o0 2008860: 90 02 3f ff add %o0, -1, %o0 2008864: 80 a2 20 01 cmp %o0, 1 2008868: 18 80 00 0a bgu 2008890 200886c: ba 10 20 09 mov 9, %i5 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 2008870: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2008874: 80 a0 60 00 cmp %g1, 0 2008878: 12 80 00 06 bne 2008890 200887c: ba 10 20 16 mov 0x16, %i5 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 2008880: c2 06 20 08 ld [ %i0 + 8 ], %g1 2008884: 80 a0 60 00 cmp %g1, 0 2008888: 16 80 00 0a bge 20088b0 200888c: 01 00 00 00 nop rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 2008890: 82 10 3f ff mov -1, %g1 ! ffffffff 2008894: fa 26 20 34 st %i5, [ %i0 + 0x34 ] 2008898: c2 26 20 38 st %g1, [ %i0 + 0x38 ] 200889c: 40 00 28 eb call 2012c48 <__errno> 20088a0: b0 10 3f ff mov -1, %i0 20088a4: fa 22 00 00 st %i5, [ %o0 ] req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_WRITE; return rtems_aio_enqueue (req); } 20088a8: 81 c7 e0 08 ret 20088ac: 81 e8 00 00 restore rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); 20088b0: 7f ff ee 9d call 2004324 20088b4: 90 10 20 18 mov 0x18, %o0 if (req == NULL) 20088b8: 80 a2 20 00 cmp %o0, 0 20088bc: 02 80 00 06 be 20088d4 <== NEVER TAKEN 20088c0: 82 10 20 02 mov 2, %g1 rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; 20088c4: f0 22 20 14 st %i0, [ %o0 + 0x14 ] req->aiocbp->aio_lio_opcode = LIO_WRITE; 20088c8: c2 26 20 30 st %g1, [ %i0 + 0x30 ] return rtems_aio_enqueue (req); 20088cc: 7f ff ff 42 call 20085d4 20088d0: 91 e8 00 08 restore %g0, %o0, %o0 if (aiocbp->aio_offset < 0) rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); req = malloc (sizeof (rtems_aio_request)); if (req == NULL) rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 20088d4: 10 bf ff ef b 2008890 <== NOT EXECUTED 20088d8: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED =============================================================================== 02008e18 : rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 2008e18: 80 a2 ff f8 cmp %o3, -8 2008e1c: 02 80 00 23 be 2008ea8 2008e20: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 2008e24: c2 02 c0 00 ld [ %o3 ], %g1 2008e28: 80 a0 60 00 cmp %g1, 0 2008e2c: 22 80 00 1c be,a 2008e9c 2008e30: c4 02 e0 04 ld [ %o3 + 4 ], %g2 if (b->begin < a->begin) { 2008e34: c6 02 e0 18 ld [ %o3 + 0x18 ], %g3 2008e38: c4 02 a0 18 ld [ %o2 + 0x18 ], %g2 2008e3c: 80 a0 c0 02 cmp %g3, %g2 2008e40: 3a 80 00 07 bcc,a 2008e5c 2008e44: c8 02 a0 1c ld [ %o2 + 0x1c ], %g4 2008e48: 84 10 00 0a mov %o2, %g2 2008e4c: c2 02 80 00 ld [ %o2 ], %g1 2008e50: 94 10 00 0b mov %o3, %o2 2008e54: 96 10 00 02 mov %g2, %o3 a = b; b = t; } a->size += b->size; 2008e58: c8 02 a0 1c ld [ %o2 + 0x1c ], %g4 2008e5c: c6 02 e0 1c ld [ %o3 + 0x1c ], %g3 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 2008e60: c4 02 e0 04 ld [ %o3 + 4 ], %g2 2008e64: 86 01 00 03 add %g4, %g3, %g3 2008e68: c6 22 a0 1c st %g3, [ %o2 + 0x1c ] next->previous = previous; previous->next = next; 2008e6c: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 2008e70: c4 20 60 04 st %g2, [ %g1 + 4 ] ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 2008e74: c2 02 00 00 ld [ %o0 ], %g1 Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 2008e78: d0 22 e0 04 st %o0, [ %o3 + 4 ] before_node = after_node->next; after_node->next = the_node; 2008e7c: d6 22 00 00 st %o3, [ %o0 ] the_node->next = before_node; 2008e80: c2 22 c0 00 st %g1, [ %o3 ] rtems_chain_extract_unprotected(&b->chain_node); add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); 2008e84: 90 10 00 09 mov %o1, %o0 before_node->previous = the_node; 2008e88: d6 20 60 04 st %o3, [ %g1 + 4 ] 2008e8c: 92 02 e0 08 add %o3, 8, %o1 2008e90: 82 13 c0 00 mov %o7, %g1 2008e94: 40 00 07 25 call 200ab28 <_RBTree_Extract_unprotected> 2008e98: 9e 10 40 00 mov %g1, %o7 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 2008e9c: 80 a0 a0 00 cmp %g2, 0 2008ea0: 32 bf ff e6 bne,a 2008e38 <== NEVER TAKEN 2008ea4: c6 02 e0 18 ld [ %o3 + 0x18 ], %g3 <== NOT EXECUTED 2008ea8: 81 c3 e0 08 retl =============================================================================== 02007a0c : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 2007a0c: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 2007a10: 80 a6 60 00 cmp %i1, 0 2007a14: 02 80 00 0a be 2007a3c 2007a18: 80 a6 20 01 cmp %i0, 1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 2007a1c: 02 80 00 19 be 2007a80 2007a20: 80 a6 20 04 cmp %i0, 4 _TOD_Get(tp); return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 2007a24: 02 80 00 12 be 2007a6c <== NEVER TAKEN 2007a28: 80 a6 20 02 cmp %i0, 2 return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) { 2007a2c: 02 80 00 10 be 2007a6c 2007a30: 80 a6 20 03 cmp %i0, 3 return 0; } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME_ID ) 2007a34: 02 80 00 08 be 2007a54 2007a38: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSYS ); #endif rtems_set_errno_and_return_minus_one( EINVAL ); 2007a3c: 40 00 27 f1 call 2011a00 <__errno> 2007a40: b0 10 3f ff mov -1, %i0 ! ffffffff 2007a44: 82 10 20 16 mov 0x16, %g1 2007a48: c2 22 00 00 st %g1, [ %o0 ] return 0; } 2007a4c: 81 c7 e0 08 ret 2007a50: 81 e8 00 00 restore } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME_ID ) rtems_set_errno_and_return_minus_one( ENOSYS ); 2007a54: 40 00 27 eb call 2011a00 <__errno> 2007a58: b0 10 3f ff mov -1, %i0 2007a5c: 82 10 20 58 mov 0x58, %g1 2007a60: c2 22 00 00 st %g1, [ %o0 ] 2007a64: 81 c7 e0 08 ret 2007a68: 81 e8 00 00 restore _TOD_Get(tp); return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { _TOD_Get_uptime_as_timespec( tp ); 2007a6c: 90 10 00 19 mov %i1, %o0 2007a70: 40 00 08 a1 call 2009cf4 <_TOD_Get_uptime_as_timespec> 2007a74: b0 10 20 00 clr %i0 return 0; 2007a78: 81 c7 e0 08 ret 2007a7c: 81 e8 00 00 restore struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 2007a80: 40 00 08 8b call 2009cac <_TOD_Get_as_timestamp> 2007a84: 90 07 bf f8 add %fp, -8, %o0 _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 2007a88: f8 1f bf f8 ldd [ %fp + -8 ], %i4 static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 2007a8c: 94 10 20 00 clr %o2 2007a90: 90 10 00 1c mov %i4, %o0 2007a94: 92 10 00 1d mov %i5, %o1 2007a98: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2007a9c: 40 00 56 16 call 201d2f4 <__divdi3> 2007aa0: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 2007aa4: 94 10 20 00 clr %o2 static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 2007aa8: d2 26 40 00 st %o1, [ %i1 ] _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 2007aac: 90 10 00 1c mov %i4, %o0 2007ab0: 92 10 00 1d mov %i5, %o1 2007ab4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { _TOD_Get(tp); return 0; 2007ab8: b0 10 20 00 clr %i0 2007abc: 40 00 56 f9 call 201d6a0 <__moddi3> 2007ac0: 96 12 e2 00 or %o3, 0x200, %o3 2007ac4: d2 26 60 04 st %o1, [ %i1 + 4 ] 2007ac8: 81 c7 e0 08 ret 2007acc: 81 e8 00 00 restore =============================================================================== 0202d7a4 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 202d7a4: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 202d7a8: 80 a6 60 00 cmp %i1, 0 202d7ac: 02 80 00 08 be 202d7cc <== NEVER TAKEN 202d7b0: 80 a6 20 01 cmp %i0, 1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 202d7b4: 02 80 00 0c be 202d7e4 202d7b8: 80 a6 20 02 cmp %i0, 2 _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) 202d7bc: 02 80 00 4a be 202d8e4 202d7c0: 80 a6 20 03 cmp %i0, 3 rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME_ID ) 202d7c4: 02 80 00 48 be 202d8e4 202d7c8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 202d7cc: 40 00 6c 4f call 2048908 <__errno> 202d7d0: b0 10 3f ff mov -1, %i0 ! ffffffff 202d7d4: 82 10 20 16 mov 0x16, %g1 202d7d8: c2 22 00 00 st %g1, [ %o0 ] return 0; } 202d7dc: 81 c7 e0 08 ret 202d7e0: 81 e8 00 00 restore { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 202d7e4: c4 06 40 00 ld [ %i1 ], %g2 202d7e8: 03 08 76 b9 sethi %hi(0x21dae400), %g1 202d7ec: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff 202d7f0: 80 a0 80 01 cmp %g2, %g1 202d7f4: 08 bf ff f6 bleu 202d7cc 202d7f8: 03 00 81 d7 sethi %hi(0x2075c00), %g1 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 202d7fc: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 2075d90 <_Thread_Dispatch_disable_level> 202d800: 84 00 a0 01 inc %g2 202d804: c4 20 61 90 st %g2, [ %g1 + 0x190 ] return _Thread_Dispatch_disable_level; 202d808: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 const struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _Timestamp_Set( 202d80c: fa 06 40 00 ld [ %i1 ], %i5 202d810: ea 06 60 04 ld [ %i1 + 4 ], %l5 202d814: b9 3f 60 1f sra %i5, 0x1f, %i4 Timestamp64_Control *_time, Timestamp64_Control _seconds, Timestamp64_Control _nanoseconds ) { *_time = _seconds * 1000000000L + _nanoseconds; 202d818: 83 2f 20 03 sll %i4, 3, %g1 202d81c: b7 2f 60 03 sll %i5, 3, %i3 202d820: 85 37 60 1d srl %i5, 0x1d, %g2 202d824: b4 10 80 01 or %g2, %g1, %i2 202d828: 83 36 e0 1b srl %i3, 0x1b, %g1 202d82c: a5 2e a0 05 sll %i2, 5, %l2 202d830: a7 2e e0 05 sll %i3, 5, %l3 202d834: a4 10 40 12 or %g1, %l2, %l2 202d838: b6 a4 c0 1b subcc %l3, %i3, %i3 202d83c: 83 36 e0 1a srl %i3, 0x1a, %g1 202d840: b4 64 80 1a subx %l2, %i2, %i2 202d844: a3 2e e0 06 sll %i3, 6, %l1 202d848: a1 2e a0 06 sll %i2, 6, %l0 202d84c: 86 a4 40 1b subcc %l1, %i3, %g3 202d850: a0 10 40 10 or %g1, %l0, %l0 202d854: 84 64 00 1a subx %l0, %i2, %g2 202d858: 86 80 c0 1d addcc %g3, %i5, %g3 202d85c: 83 30 e0 1e srl %g3, 0x1e, %g1 202d860: 84 40 80 1c addx %g2, %i4, %g2 202d864: 97 28 e0 02 sll %g3, 2, %o3 202d868: 95 28 a0 02 sll %g2, 2, %o2 202d86c: 86 80 c0 0b addcc %g3, %o3, %g3 202d870: 94 10 40 0a or %g1, %o2, %o2 202d874: 83 30 e0 1e srl %g3, 0x1e, %g1 202d878: 84 40 80 0a addx %g2, %o2, %g2 202d87c: 9b 28 e0 02 sll %g3, 2, %o5 202d880: 99 28 a0 02 sll %g2, 2, %o4 202d884: 86 80 c0 0d addcc %g3, %o5, %g3 202d888: 98 10 40 0c or %g1, %o4, %o4 202d88c: b3 28 e0 02 sll %g3, 2, %i1 202d890: 84 40 80 0c addx %g2, %o4, %g2 202d894: 83 30 e0 1e srl %g3, 0x1e, %g1 202d898: b1 28 a0 02 sll %g2, 2, %i0 202d89c: 86 80 c0 19 addcc %g3, %i1, %g3 202d8a0: b0 10 40 18 or %g1, %i0, %i0 202d8a4: 84 40 80 18 addx %g2, %i0, %g2 202d8a8: 83 28 e0 09 sll %g3, 9, %g1 202d8ac: 89 28 a0 09 sll %g2, 9, %g4 &tod_as_timestamp, tod_as_timespec->tv_sec, tod_as_timespec->tv_nsec ); _TOD_Set_with_timestamp( &tod_as_timestamp ); 202d8b0: 90 07 bf f8 add %fp, -8, %o0 202d8b4: bb 30 e0 17 srl %g3, 0x17, %i5 const struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _Timestamp_Set( 202d8b8: a9 3d 60 1f sra %l5, 0x1f, %l4 202d8bc: 86 85 40 01 addcc %l5, %g1, %g3 202d8c0: 84 17 40 04 or %i5, %g4, %g2 202d8c4: 84 45 00 02 addx %l4, %g2, %g2 rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 202d8c8: b0 10 20 00 clr %i0 &tod_as_timestamp, tod_as_timespec->tv_sec, tod_as_timespec->tv_nsec ); _TOD_Set_with_timestamp( &tod_as_timestamp ); 202d8cc: 40 00 06 9d call 202f340 <_TOD_Set_with_timestamp> 202d8d0: c4 3f bf f8 std %g2, [ %fp + -8 ] if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); 202d8d4: 7f ff 8d 9a call 2010f3c <_Thread_Enable_dispatch> 202d8d8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 202d8dc: 81 c7 e0 08 ret 202d8e0: 81 e8 00 00 restore else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME_ID ) rtems_set_errno_and_return_minus_one( ENOSYS ); 202d8e4: 40 00 6c 09 call 2048908 <__errno> 202d8e8: b0 10 3f ff mov -1, %i0 202d8ec: 82 10 20 58 mov 0x58, %g1 202d8f0: c2 22 00 00 st %g1, [ %o0 ] 202d8f4: 81 c7 e0 08 ret 202d8f8: 81 e8 00 00 restore =============================================================================== 0201b0b4 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 201b0b4: 9d e3 bf 90 save %sp, -112, %sp POSIX_signals_Siginfo_node *psiginfo; /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 201b0b8: 7f ff ff 63 call 201ae44 201b0bc: 01 00 00 00 nop 201b0c0: 80 a2 00 18 cmp %o0, %i0 201b0c4: 12 80 00 ad bne 201b378 201b0c8: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); /* * Validate the signal passed. */ if ( !sig ) 201b0cc: 02 80 00 b1 be 201b390 201b0d0: 82 06 7f ff add %i1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 201b0d4: 80 a0 60 1f cmp %g1, 0x1f 201b0d8: 18 80 00 ae bgu 201b390 201b0dc: a1 2e 60 02 sll %i1, 2, %l0 rtems_set_errno_and_return_minus_one( EINVAL ); /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) 201b0e0: 31 00 80 7b sethi %hi(0x201ec00), %i0 201b0e4: a3 2e 60 04 sll %i1, 4, %l1 201b0e8: b0 16 22 40 or %i0, 0x240, %i0 201b0ec: 84 24 40 10 sub %l1, %l0, %g2 201b0f0: 84 06 00 02 add %i0, %g2, %g2 201b0f4: c4 00 a0 08 ld [ %g2 + 8 ], %g2 201b0f8: 80 a0 a0 01 cmp %g2, 1 201b0fc: 02 80 00 9d be 201b370 201b100: 80 a6 60 04 cmp %i1, 4 /* * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 201b104: 02 80 00 3f be 201b200 201b108: 80 a6 60 08 cmp %i1, 8 201b10c: 02 80 00 3d be 201b200 201b110: 80 a6 60 0b cmp %i1, 0xb 201b114: 02 80 00 3b be 201b200 201b118: ba 10 20 01 mov 1, %i5 /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 201b11c: f2 27 bf f4 st %i1, [ %fp + -12 ] siginfo->si_code = SI_USER; 201b120: fa 27 bf f8 st %i5, [ %fp + -8 ] if ( !value ) { 201b124: 80 a6 a0 00 cmp %i2, 0 201b128: 02 80 00 3c be 201b218 201b12c: bb 2f 40 01 sll %i5, %g1, %i5 siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 201b130: c2 06 80 00 ld [ %i2 ], %g1 201b134: c2 27 bf fc st %g1, [ %fp + -4 ] * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 201b138: 03 00 80 7a sethi %hi(0x201e800), %g1 201b13c: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 201e8b0 <_Thread_Dispatch_disable_level> 201b140: 84 00 a0 01 inc %g2 201b144: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] return _Thread_Dispatch_disable_level; 201b148: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 201b14c: 03 00 80 7b sethi %hi(0x201ec00), %g1 201b150: d0 00 61 ec ld [ %g1 + 0x1ec ], %o0 ! 201edec <_Per_CPU_Information+0xc> api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 201b154: c2 02 21 5c ld [ %o0 + 0x15c ], %g1 201b158: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 201b15c: 80 af 40 01 andncc %i5, %g1, %g0 201b160: 12 80 00 17 bne 201b1bc 201b164: 09 00 80 7b sethi %hi(0x201ec00), %g4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 201b168: c2 01 23 cc ld [ %g4 + 0x3cc ], %g1 ! 201efcc <_POSIX_signals_Wait_queue> 201b16c: 88 11 23 cc or %g4, 0x3cc, %g4 /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 201b170: 88 01 20 04 add %g4, 4, %g4 201b174: 80 a0 40 04 cmp %g1, %g4 201b178: 32 80 00 0d bne,a 201b1ac 201b17c: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 201b180: 10 80 00 28 b 201b220 201b184: 03 00 80 76 sethi %hi(0x201d800), %g1 /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 201b188: c4 00 e0 d0 ld [ %g3 + 0xd0 ], %g2 201b18c: 80 af 40 02 andncc %i5, %g2, %g0 201b190: 12 80 00 0b bne 201b1bc 201b194: 90 10 00 01 mov %g1, %o0 the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 201b198: c2 00 40 00 ld [ %g1 ], %g1 /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 201b19c: 80 a0 40 04 cmp %g1, %g4 201b1a0: 22 80 00 20 be,a 201b220 <== ALWAYS TAKEN 201b1a4: 03 00 80 76 sethi %hi(0x201d800), %g1 #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 201b1a8: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 201d830 <__mprec_tinytens+0x8><== NOT EXECUTED 201b1ac: 80 8f 40 02 btst %i5, %g2 201b1b0: 02 bf ff f6 be 201b188 201b1b4: c6 00 61 5c ld [ %g1 + 0x15c ], %g3 the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 201b1b8: 90 10 00 01 mov %g1, %o0 /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 201b1bc: 92 10 00 19 mov %i1, %o1 201b1c0: 40 00 00 8b call 201b3ec <_POSIX_signals_Unblock_thread> 201b1c4: 94 07 bf f4 add %fp, -12, %o2 201b1c8: 80 8a 20 ff btst 0xff, %o0 201b1cc: 12 80 00 09 bne 201b1f0 201b1d0: 01 00 00 00 nop /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 201b1d4: 40 00 00 7d call 201b3c8 <_POSIX_signals_Set_process_signals> 201b1d8: 90 10 00 1d mov %i5, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 201b1dc: a0 24 40 10 sub %l1, %l0, %l0 201b1e0: c2 06 00 10 ld [ %i0 + %l0 ], %g1 201b1e4: 80 a0 60 02 cmp %g1, 2 201b1e8: 02 80 00 4f be 201b324 201b1ec: 11 00 80 7b sethi %hi(0x201ec00), %o0 /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { _Thread_Enable_dispatch(); 201b1f0: 7f ff bd bc call 200a8e0 <_Thread_Enable_dispatch> 201b1f4: b0 10 20 00 clr %i0 201b1f8: 81 c7 e0 08 ret 201b1fc: 81 e8 00 00 restore * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) return pthread_kill( pthread_self(), sig ); 201b200: 40 00 01 0f call 201b63c 201b204: 01 00 00 00 nop 201b208: 40 00 00 d2 call 201b550 201b20c: 92 10 00 19 mov %i1, %o1 201b210: 81 c7 e0 08 ret 201b214: 91 e8 00 08 restore %g0, %o0, %o0 */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { siginfo->si_value.sival_int = 0; 201b218: 10 bf ff c8 b 201b138 201b21c: c0 27 bf fc clr [ %fp + -4 ] * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 201b220: f8 08 63 18 ldub [ %g1 + 0x318 ], %i4 201b224: 1b 00 80 7a sethi %hi(0x201e800), %o5 201b228: b8 07 20 01 inc %i4 201b22c: 9a 13 60 1c or %o5, 0x1c, %o5 * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 201b230: 90 10 20 00 clr %o0 */ #define _POSIX_signals_Is_interested( _api, _mask ) \ ( ~(_api)->signals_blocked & (_mask) ) int killinfo( 201b234: 98 03 60 08 add %o5, 8, %o4 */ RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal ( States_Control the_states ) { return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL); 201b238: 17 04 00 00 sethi %hi(0x10000000), %o3 for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { /* * This can occur when no one is interested and an API is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 201b23c: c2 03 40 00 ld [ %o5 ], %g1 201b240: 80 a0 60 00 cmp %g1, 0 201b244: 22 80 00 31 be,a 201b308 <== NEVER TAKEN 201b248: 9a 03 60 04 add %o5, 4, %o5 <== NOT EXECUTED continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 201b24c: c2 00 60 04 ld [ %g1 + 4 ], %g1 */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 201b250: f6 10 60 10 lduh [ %g1 + 0x10 ], %i3 object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 201b254: 80 a6 e0 00 cmp %i3, 0 201b258: 02 80 00 2b be 201b304 201b25c: f4 00 60 1c ld [ %g1 + 0x1c ], %i2 201b260: 84 10 20 01 mov 1, %g2 */ #define _POSIX_signals_Is_interested( _api, _mask ) \ ( ~(_api)->signals_blocked & (_mask) ) int killinfo( 201b264: 87 28 a0 02 sll %g2, 2, %g3 maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { the_thread = (Thread_Control *) object_table[ index ]; 201b268: c6 06 80 03 ld [ %i2 + %g3 ], %g3 if ( !the_thread ) 201b26c: 80 a0 e0 00 cmp %g3, 0 201b270: 22 80 00 22 be,a 201b2f8 201b274: 84 00 a0 01 inc %g2 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 201b278: c8 00 e0 14 ld [ %g3 + 0x14 ], %g4 201b27c: 80 a1 00 1c cmp %g4, %i4 201b280: 38 80 00 1e bgu,a 201b2f8 201b284: 84 00 a0 01 inc %g2 #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 201b288: de 00 e1 5c ld [ %g3 + 0x15c ], %o7 201b28c: de 03 e0 d0 ld [ %o7 + 0xd0 ], %o7 201b290: 80 af 40 0f andncc %i5, %o7, %g0 201b294: 22 80 00 19 be,a 201b2f8 201b298: 84 00 a0 01 inc %g2 * * NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1 * so we never have to worry about deferencing a NULL * interested thread. */ if ( the_thread->current_priority < interested_priority ) { 201b29c: 80 a1 00 1c cmp %g4, %i4 201b2a0: 2a 80 00 14 bcs,a 201b2f0 201b2a4: b8 10 00 04 mov %g4, %i4 * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 201b2a8: 80 a2 20 00 cmp %o0, 0 201b2ac: 22 80 00 13 be,a 201b2f8 <== NEVER TAKEN 201b2b0: 84 00 a0 01 inc %g2 <== NOT EXECUTED 201b2b4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 201b2b8: 80 a0 60 00 cmp %g1, 0 201b2bc: 22 80 00 0f be,a 201b2f8 <== NEVER TAKEN 201b2c0: 84 00 a0 01 inc %g2 <== NOT EXECUTED /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 201b2c4: de 00 e0 10 ld [ %g3 + 0x10 ], %o7 201b2c8: 80 a3 e0 00 cmp %o7, 0 201b2cc: 22 80 00 09 be,a 201b2f0 201b2d0: b8 10 00 04 mov %g4, %i4 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 201b2d4: 80 88 40 0b btst %g1, %o3 201b2d8: 32 80 00 08 bne,a 201b2f8 201b2dc: 84 00 a0 01 inc %g2 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 201b2e0: 80 8b c0 0b btst %o7, %o3 201b2e4: 22 80 00 05 be,a 201b2f8 201b2e8: 84 00 a0 01 inc %g2 */ if ( interested && !_States_Is_ready( interested->current_state ) ) { /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 201b2ec: b8 10 00 04 mov %g4, %i4 201b2f0: 90 10 00 03 mov %g3, %o0 #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 201b2f4: 84 00 a0 01 inc %g2 201b2f8: 80 a6 c0 02 cmp %i3, %g2 201b2fc: 1a bf ff db bcc 201b268 201b300: 87 28 a0 02 sll %g2, 2, %g3 201b304: 9a 03 60 04 add %o5, 4, %o5 * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 201b308: 80 a3 40 0c cmp %o5, %o4 201b30c: 32 bf ff cd bne,a 201b240 201b310: c2 03 40 00 ld [ %o5 ], %g1 } } } } if ( interested ) { 201b314: 80 a2 20 00 cmp %o0, 0 201b318: 12 bf ff aa bne 201b1c0 201b31c: 92 10 00 19 mov %i1, %o1 201b320: 30 bf ff ad b,a 201b1d4 */ _POSIX_signals_Set_process_signals( mask ); if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) 201b324: 7f ff b5 63 call 20088b0 <_Chain_Get> 201b328: 90 12 23 c0 or %o0, 0x3c0, %o0 _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 201b32c: 92 92 20 00 orcc %o0, 0, %o1 201b330: 02 80 00 1e be 201b3a8 201b334: c2 07 bf f4 ld [ %fp + -12 ], %g1 rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 201b338: 11 00 80 7c sethi %hi(0x201f000), %o0 if ( !psiginfo ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 201b33c: c2 22 60 08 st %g1, [ %o1 + 8 ] 201b340: c2 07 bf f8 ld [ %fp + -8 ], %g1 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 201b344: 90 12 20 38 or %o0, 0x38, %o0 if ( !psiginfo ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 201b348: c2 22 60 0c st %g1, [ %o1 + 0xc ] 201b34c: c2 07 bf fc ld [ %fp + -4 ], %g1 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 201b350: 90 02 00 10 add %o0, %l0, %o0 if ( !psiginfo ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 201b354: c2 22 60 10 st %g1, [ %o1 + 0x10 ] _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 201b358: 7f ff b5 4b call 2008884 <_Chain_Append> 201b35c: b0 10 20 00 clr %i0 /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { _Thread_Enable_dispatch(); 201b360: 7f ff bd 60 call 200a8e0 <_Thread_Enable_dispatch> 201b364: 01 00 00 00 nop 201b368: 81 c7 e0 08 ret 201b36c: 81 e8 00 00 restore } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 201b370: 81 c7 e0 08 ret 201b374: 91 e8 20 00 restore %g0, 0, %o0 /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) rtems_set_errno_and_return_minus_one( ESRCH ); 201b378: 7f ff d5 1f call 20107f4 <__errno> 201b37c: b0 10 3f ff mov -1, %i0 201b380: 82 10 20 03 mov 3, %g1 201b384: c2 22 00 00 st %g1, [ %o0 ] 201b388: 81 c7 e0 08 ret 201b38c: 81 e8 00 00 restore */ if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 201b390: 7f ff d5 19 call 20107f4 <__errno> 201b394: b0 10 3f ff mov -1, %i0 201b398: 82 10 20 16 mov 0x16, %g1 201b39c: c2 22 00 00 st %g1, [ %o0 ] 201b3a0: 81 c7 e0 08 ret 201b3a4: 81 e8 00 00 restore if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { _Thread_Enable_dispatch(); 201b3a8: 7f ff bd 4e call 200a8e0 <_Thread_Enable_dispatch> 201b3ac: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( EAGAIN ); 201b3b0: 7f ff d5 11 call 20107f4 <__errno> 201b3b4: 01 00 00 00 nop 201b3b8: 82 10 20 0b mov 0xb, %g1 ! b 201b3bc: c2 22 00 00 st %g1, [ %o0 ] 201b3c0: 81 c7 e0 08 ret 201b3c4: 81 e8 00 00 restore =============================================================================== 02007f70 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 2007f70: 9d e3 bf 88 save %sp, -120, %sp * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2007f74: 03 00 80 8c sethi %hi(0x2023000), %g1 2007f78: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20233a0 <_Thread_Dispatch_disable_level> size_t name_len; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); 2007f7c: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 2007f80: 84 00 a0 01 inc %g2 2007f84: c4 20 63 a0 st %g2, [ %g1 + 0x3a0 ] return _Thread_Dispatch_disable_level; 2007f88: c2 00 63 a0 ld [ %g1 + 0x3a0 ], %g1 2007f8c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2007f90: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2007f94: fa 27 a0 58 st %i5, [ %fp + 0x58 ] Objects_Locations location; size_t name_len; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 2007f98: a2 8e 62 00 andcc %i1, 0x200, %l1 2007f9c: 12 80 00 36 bne 2008074 2007fa0: a0 10 20 00 clr %l0 */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd * _POSIX_Message_queue_Allocate_fd( void ) { return (POSIX_Message_queue_Control_fd *) 2007fa4: 39 00 80 8e sethi %hi(0x2023800), %i4 2007fa8: 40 00 0c 19 call 200b00c <_Objects_Allocate> 2007fac: 90 17 20 9c or %i4, 0x9c, %o0 ! 202389c <_POSIX_Message_queue_Information_fds> attr = va_arg( arg, struct mq_attr * ); va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 2007fb0: ba 92 20 00 orcc %o0, 0, %i5 2007fb4: 02 80 00 39 be 2008098 <== NEVER TAKEN 2007fb8: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq_fd->oflag = oflag; 2007fbc: f2 27 60 14 st %i1, [ %i5 + 0x14 ] const char *name, Objects_Id *id, size_t *len ) { return _POSIX_Name_to_id( &_POSIX_Message_queue_Information, name, id, len ); 2007fc0: 35 00 80 8d sethi %hi(0x2023400), %i2 2007fc4: 92 10 00 18 mov %i0, %o1 2007fc8: 90 16 a3 10 or %i2, 0x310, %o0 2007fcc: 94 07 bf f0 add %fp, -16, %o2 2007fd0: 40 00 01 46 call 20084e8 <_POSIX_Name_to_id> 2007fd4: 96 07 bf fc add %fp, -4, %o3 * If the name to id translation worked, then the message queue exists * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "message queue does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 2007fd8: b6 92 20 00 orcc %o0, 0, %i3 2007fdc: 22 80 00 0f be,a 2008018 2007fe0: b2 0e 6a 00 and %i1, 0xa00, %i1 /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 2007fe4: 80 a6 e0 02 cmp %i3, 2 2007fe8: 02 80 00 3f be 20080e4 2007fec: 80 a4 60 00 cmp %l1, 0 RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd ( POSIX_Message_queue_Control_fd *the_mq_fd ) { _Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); 2007ff0: 90 17 20 9c or %i4, 0x9c, %o0 2007ff4: 40 00 0c f3 call 200b3c0 <_Objects_Free> 2007ff8: 92 10 00 1d mov %i5, %o1 _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 2007ffc: 40 00 11 6c call 200c5ac <_Thread_Enable_dispatch> 2008000: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 2008004: 40 00 29 d2 call 201274c <__errno> 2008008: 01 00 00 00 nop 200800c: f6 22 00 00 st %i3, [ %o0 ] 2008010: 81 c7 e0 08 ret 2008014: 81 e8 00 00 restore } else { /* name -> ID translation succeeded */ /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 2008018: 80 a6 6a 00 cmp %i1, 0xa00 200801c: 02 80 00 27 be 20080b8 2008020: d2 07 bf f0 ld [ %fp + -16 ], %o1 RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control *) 2008024: 94 07 bf f8 add %fp, -8, %o2 2008028: 40 00 0d 4c call 200b558 <_Objects_Get> 200802c: 90 16 a3 10 or %i2, 0x310, %o0 /* * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); the_mq->open_count += 1; 2008030: c4 02 20 18 ld [ %o0 + 0x18 ], %g2 Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 2008034: c2 17 60 0a lduh [ %i5 + 0xa ], %g1 2008038: 84 00 a0 01 inc %g2 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200803c: b8 17 20 9c or %i4, 0x9c, %i4 2008040: c4 22 20 18 st %g2, [ %o0 + 0x18 ] 2008044: c4 07 20 1c ld [ %i4 + 0x1c ], %g2 /* * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); 2008048: d0 27 bf f4 st %o0, [ %fp + -12 ] the_mq->open_count += 1; the_mq_fd->Queue = the_mq; 200804c: d0 27 60 10 st %o0, [ %i5 + 0x10 ] 2008050: 83 28 60 02 sll %g1, 2, %g1 2008054: fa 20 80 01 st %i5, [ %g2 + %g1 ] _Objects_Open_string( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 2008058: 40 00 11 55 call 200c5ac <_Thread_Enable_dispatch> 200805c: c0 27 60 0c clr [ %i5 + 0xc ] _Thread_Enable_dispatch(); 2008060: 40 00 11 53 call 200c5ac <_Thread_Enable_dispatch> 2008064: 01 00 00 00 nop return (mqd_t)the_mq_fd->Object.id; 2008068: f0 07 60 08 ld [ %i5 + 8 ], %i0 200806c: 81 c7 e0 08 ret 2008070: 81 e8 00 00 restore size_t name_len; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); 2008074: 82 07 a0 4c add %fp, 0x4c, %g1 mode = va_arg( arg, mode_t ); attr = va_arg( arg, struct mq_attr * ); 2008078: e0 07 a0 50 ld [ %fp + 0x50 ], %l0 size_t name_len; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); 200807c: c2 27 bf ec st %g1, [ %fp + -20 ] */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd * _POSIX_Message_queue_Allocate_fd( void ) { return (POSIX_Message_queue_Control_fd *) 2008080: 39 00 80 8e sethi %hi(0x2023800), %i4 2008084: 40 00 0b e2 call 200b00c <_Objects_Allocate> 2008088: 90 17 20 9c or %i4, 0x9c, %o0 ! 202389c <_POSIX_Message_queue_Information_fds> attr = va_arg( arg, struct mq_attr * ); va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 200808c: ba 92 20 00 orcc %o0, 0, %i5 2008090: 32 bf ff cc bne,a 2007fc0 2008094: f2 27 60 14 st %i1, [ %i5 + 0x14 ] _Thread_Enable_dispatch(); 2008098: 40 00 11 45 call 200c5ac <_Thread_Enable_dispatch> 200809c: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( ENFILE ); 20080a0: 40 00 29 ab call 201274c <__errno> 20080a4: 01 00 00 00 nop 20080a8: 82 10 20 17 mov 0x17, %g1 ! 17 20080ac: c2 22 00 00 st %g1, [ %o0 ] 20080b0: 81 c7 e0 08 ret 20080b4: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd ( POSIX_Message_queue_Control_fd *the_mq_fd ) { _Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); 20080b8: 90 17 20 9c or %i4, 0x9c, %o0 20080bc: 40 00 0c c1 call 200b3c0 <_Objects_Free> 20080c0: 92 10 00 1d mov %i5, %o1 /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 20080c4: 40 00 11 3a call 200c5ac <_Thread_Enable_dispatch> 20080c8: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 20080cc: 40 00 29 a0 call 201274c <__errno> 20080d0: 01 00 00 00 nop 20080d4: 82 10 20 11 mov 0x11, %g1 ! 11 20080d8: c2 22 00 00 st %g1, [ %o0 ] 20080dc: 81 c7 e0 08 ret 20080e0: 81 e8 00 00 restore if ( status ) { /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 20080e4: 02 bf ff c4 be 2007ff4 20080e8: 90 17 20 9c or %i4, 0x9c, %o0 /* * At this point, the message queue does not exist and everything has been * checked. We should go ahead and create a message queue. */ status = _POSIX_Message_queue_Create_support( 20080ec: d2 07 bf fc ld [ %fp + -4 ], %o1 20080f0: 90 10 00 18 mov %i0, %o0 20080f4: 94 10 20 01 mov 1, %o2 20080f8: 96 10 00 10 mov %l0, %o3 20080fc: 40 00 1c 13 call 200f148 <_POSIX_Message_queue_Create_support> 2008100: 98 07 bf f4 add %fp, -12, %o4 ); /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 2008104: 80 a2 3f ff cmp %o0, -1 2008108: 02 80 00 0d be 200813c 200810c: c6 07 bf f4 ld [ %fp + -12 ], %g3 Objects_Information *information, Objects_Control *the_object, const char *name ) { _Objects_Set_local_object( 2008110: c2 17 60 0a lduh [ %i5 + 0xa ], %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2008114: b8 17 20 9c or %i4, 0x9c, %i4 2008118: c4 07 20 1c ld [ %i4 + 0x1c ], %g2 _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); return (mqd_t) -1; } the_mq_fd->Queue = the_mq; 200811c: c6 27 60 10 st %g3, [ %i5 + 0x10 ] 2008120: 83 28 60 02 sll %g1, 2, %g1 2008124: fa 20 80 01 st %i5, [ %g2 + %g1 ] &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 2008128: 40 00 11 21 call 200c5ac <_Thread_Enable_dispatch> 200812c: c0 27 60 0c clr [ %i5 + 0xc ] return (mqd_t) the_mq_fd->Object.id; 2008130: f0 07 60 08 ld [ %i5 + 8 ], %i0 } 2008134: 81 c7 e0 08 ret 2008138: 81 e8 00 00 restore 200813c: 90 17 20 9c or %i4, 0x9c, %o0 2008140: 92 10 00 1d mov %i5, %o1 2008144: 40 00 0c 9f call 200b3c0 <_Objects_Free> 2008148: b0 10 3f ff mov -1, %i0 /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 200814c: 40 00 11 18 call 200c5ac <_Thread_Enable_dispatch> 2008150: 01 00 00 00 nop 2008154: 81 c7 e0 08 ret 2008158: 81 e8 00 00 restore =============================================================================== 0200c834 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 200c834: 82 10 00 08 mov %o0, %g1 if ( !attr || !attr->is_initialized ) 200c838: 80 a0 60 00 cmp %g1, 0 200c83c: 02 80 00 06 be 200c854 200c840: 90 10 20 16 mov 0x16, %o0 200c844: c4 00 40 00 ld [ %g1 ], %g2 200c848: 80 a0 a0 00 cmp %g2, 0 200c84c: 12 80 00 04 bne 200c85c 200c850: 80 a2 60 04 cmp %o1, 4 return 0; default: return ENOTSUP; } } 200c854: 81 c3 e0 08 retl 200c858: 01 00 00 00 nop ) { if ( !attr || !attr->is_initialized ) return EINVAL; switch ( policy ) { 200c85c: 18 80 00 09 bgu 200c880 200c860: 84 10 20 01 mov 1, %g2 ! 1 200c864: 85 28 80 09 sll %g2, %o1, %g2 200c868: 80 88 a0 17 btst 0x17, %g2 200c86c: 02 80 00 05 be 200c880 <== NEVER TAKEN 200c870: 01 00 00 00 nop case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 200c874: d2 20 60 14 st %o1, [ %g1 + 0x14 ] return 0; 200c878: 81 c3 e0 08 retl 200c87c: 90 10 20 00 clr %o0 default: return ENOTSUP; } } 200c880: 81 c3 e0 08 retl 200c884: 90 10 20 86 mov 0x86, %o0 =============================================================================== 02007fb4 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 2007fb4: 9d e3 bf 90 save %sp, -112, %sp const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 2007fb8: 80 a6 20 00 cmp %i0, 0 2007fbc: 02 80 00 04 be 2007fcc 2007fc0: 80 a6 a0 00 cmp %i2, 0 return EINVAL; if ( count == 0 ) 2007fc4: 12 80 00 04 bne 2007fd4 2007fc8: 80 a6 60 00 cmp %i1, 0 * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; } 2007fcc: 81 c7 e0 08 ret 2007fd0: 91 e8 20 16 restore %g0, 0x16, %o0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 2007fd4: 02 80 00 24 be 2008064 2007fd8: 90 07 bf f8 add %fp, -8, %o0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 2007fdc: c2 06 40 00 ld [ %i1 ], %g1 2007fe0: 80 a0 60 00 cmp %g1, 0 2007fe4: 02 bf ff fa be 2007fcc 2007fe8: 01 00 00 00 nop return EINVAL; switch ( the_attr->process_shared ) { 2007fec: c2 06 60 04 ld [ %i1 + 4 ], %g1 2007ff0: 80 a0 60 00 cmp %g1, 0 2007ff4: 12 bf ff f6 bne 2007fcc <== NEVER TAKEN 2007ff8: 03 00 80 7f sethi %hi(0x201fc00), %g1 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2007ffc: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 201ff00 <_Thread_Dispatch_disable_level> } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 2008000: c0 27 bf f0 clr [ %fp + -16 ] 2008004: 84 00 a0 01 inc %g2 the_attributes.maximum_count = count; 2008008: f4 27 bf f4 st %i2, [ %fp + -12 ] 200800c: c4 20 63 00 st %g2, [ %g1 + 0x300 ] return _Thread_Dispatch_disable_level; 2008010: c2 00 63 00 ld [ %g1 + 0x300 ], %g1 * This function allocates a barrier control block from * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void ) { return (POSIX_Barrier_Control *) 2008014: 39 00 80 80 sethi %hi(0x2020000), %i4 2008018: 40 00 08 ee call 200a3d0 <_Objects_Allocate> 200801c: 90 17 22 b0 or %i4, 0x2b0, %o0 ! 20202b0 <_POSIX_Barrier_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 2008020: ba 92 20 00 orcc %o0, 0, %i5 2008024: 02 80 00 14 be 2008074 2008028: 90 07 60 10 add %i5, 0x10, %o0 _Thread_Enable_dispatch(); return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 200802c: 40 00 06 36 call 2009904 <_CORE_barrier_Initialize> 2008030: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 2008034: c4 17 60 0a lduh [ %i5 + 0xa ], %g2 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2008038: b8 17 22 b0 or %i4, 0x2b0, %i4 200803c: c6 07 20 1c ld [ %i4 + 0x1c ], %g3 Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 2008040: c2 07 60 08 ld [ %i5 + 8 ], %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2008044: 85 28 a0 02 sll %g2, 2, %g2 2008048: fa 20 c0 02 st %i5, [ %g3 + %g2 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 200804c: c0 27 60 0c clr [ %i5 + 0xc ] ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 2008050: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2008054: 40 00 0e 10 call 200b894 <_Thread_Enable_dispatch> 2008058: b0 10 20 00 clr %i0 200805c: 81 c7 e0 08 ret 2008060: 81 e8 00 00 restore * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 2008064: 7f ff ff 9b call 2007ed0 2008068: b2 07 bf f8 add %fp, -8, %i1 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 200806c: 10 bf ff dd b 2007fe0 2008070: c2 06 40 00 ld [ %i1 ], %g1 _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 2008074: 40 00 0e 08 call 200b894 <_Thread_Enable_dispatch> 2008078: b0 10 20 0b mov 0xb, %i0 200807c: 81 c7 e0 08 ret 2008080: 81 e8 00 00 restore =============================================================================== 02007848 : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 2007848: 9d e3 bf a0 save %sp, -96, %sp /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 200784c: 80 a6 20 00 cmp %i0, 0 2007850: 02 80 00 14 be 20078a0 2007854: 03 00 80 7d sethi %hi(0x201f400), %g1 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2007858: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 201f700 <_Thread_Dispatch_disable_level> 200785c: 84 00 a0 01 inc %g2 2007860: c4 20 63 00 st %g2, [ %g1 + 0x300 ] return _Thread_Dispatch_disable_level; 2007864: c2 00 63 00 ld [ %g1 + 0x300 ], %g1 return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 2007868: 40 00 12 ef call 200c424 <_Workspace_Allocate> 200786c: 90 10 20 10 mov 0x10, %o0 if ( handler ) { 2007870: 80 a2 20 00 cmp %o0, 0 2007874: 02 80 00 09 be 2007898 <== NEVER TAKEN 2007878: 03 00 80 7f sethi %hi(0x201fc00), %g1 thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 200787c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 ! 201fc3c <_Per_CPU_Information+0xc> handler_stack = &thread_support->Cancellation_Handlers; handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); 2007880: 92 10 00 08 mov %o0, %o1 handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); if ( handler ) { thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; handler_stack = &thread_support->Cancellation_Handlers; 2007884: c2 00 61 5c ld [ %g1 + 0x15c ], %g1 handler->routine = routine; 2007888: f0 22 20 08 st %i0, [ %o0 + 8 ] handler->arg = arg; 200788c: f2 22 20 0c st %i1, [ %o0 + 0xc ] _Chain_Append( handler_stack, &handler->Node ); 2007890: 40 00 06 6b call 200923c <_Chain_Append> 2007894: 90 00 60 e4 add %g1, 0xe4, %o0 } _Thread_Enable_dispatch(); 2007898: 40 00 0e 54 call 200b1e8 <_Thread_Enable_dispatch> 200789c: 81 e8 00 00 restore 20078a0: 81 c7 e0 08 ret 20078a4: 81 e8 00 00 restore =============================================================================== 020087e0 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 20087e0: 9d e3 bf a0 save %sp, -96, %sp POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 20087e4: 80 a6 60 00 cmp %i1, 0 20087e8: 22 80 00 28 be,a 2008888 20087ec: 33 00 80 7b sethi %hi(0x201ec00), %i1 else the_attr = &_POSIX_Condition_variables_Default_attributes; /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 20087f0: c4 06 60 04 ld [ %i1 + 4 ], %g2 ! 201ec04 20087f4: 80 a0 a0 01 cmp %g2, 1 20087f8: 02 80 00 06 be 2008810 <== NEVER TAKEN 20087fc: 82 10 20 16 mov 0x16, %g1 return EINVAL; if ( !the_attr->is_initialized ) 2008800: c4 06 40 00 ld [ %i1 ], %g2 2008804: 80 a0 a0 00 cmp %g2, 0 2008808: 32 80 00 04 bne,a 2008818 200880c: 03 00 80 84 sethi %hi(0x2021000), %g1 *cond = the_cond->Object.id; _Thread_Enable_dispatch(); return 0; } 2008810: 81 c7 e0 08 ret 2008814: 91 e8 00 01 restore %g0, %g1, %o0 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2008818: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 200881c: 84 00 a0 01 inc %g2 2008820: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] return _Thread_Dispatch_disable_level; 2008824: c2 00 60 f0 ld [ %g1 + 0xf0 ], %g1 */ RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) 2008828: 39 00 80 85 sethi %hi(0x2021400), %i4 200882c: 40 00 0a 9e call 200b2a4 <_Objects_Allocate> 2008830: 90 17 21 38 or %i4, 0x138, %o0 ! 2021538 <_POSIX_Condition_variables_Information> _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 2008834: ba 92 20 00 orcc %o0, 0, %i5 2008838: 02 80 00 16 be 2008890 200883c: 90 07 60 18 add %i5, 0x18, %o0 _Thread_Enable_dispatch(); return ENOMEM; } the_cond->process_shared = the_attr->process_shared; 2008840: c2 06 60 04 ld [ %i1 + 4 ], %g1 the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; _Thread_queue_Initialize( 2008844: 92 10 20 00 clr %o1 2008848: 15 04 00 02 sethi %hi(0x10000800), %o2 200884c: 96 10 20 74 mov 0x74, %o3 if ( !the_cond ) { _Thread_Enable_dispatch(); return ENOMEM; } the_cond->process_shared = the_attr->process_shared; 2008850: c2 27 60 10 st %g1, [ %i5 + 0x10 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; _Thread_queue_Initialize( 2008854: 40 00 11 f3 call 200d020 <_Thread_queue_Initialize> 2008858: c0 27 60 14 clr [ %i5 + 0x14 ] Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 200885c: c4 17 60 0a lduh [ %i5 + 0xa ], %g2 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2008860: b8 17 21 38 or %i4, 0x138, %i4 2008864: c6 07 20 1c ld [ %i4 + 0x1c ], %g3 Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 2008868: c2 07 60 08 ld [ %i5 + 8 ], %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200886c: 85 28 a0 02 sll %g2, 2, %g2 2008870: fa 20 c0 02 st %i5, [ %g3 + %g2 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 2008874: c0 27 60 0c clr [ %i5 + 0xc ] 0 ); *cond = the_cond->Object.id; _Thread_Enable_dispatch(); 2008878: 40 00 0f bc call 200c768 <_Thread_Enable_dispatch> 200887c: c2 26 00 00 st %g1, [ %i0 ] return 0; 2008880: 10 bf ff e4 b 2008810 2008884: 82 10 20 00 clr %g1 { POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; else the_attr = &_POSIX_Condition_variables_Default_attributes; 2008888: 10 bf ff da b 20087f0 200888c: b2 16 62 24 or %i1, 0x224, %i1 _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { _Thread_Enable_dispatch(); 2008890: 40 00 0f b6 call 200c768 <_Thread_Enable_dispatch> 2008894: 01 00 00 00 nop return ENOMEM; 2008898: 10 bf ff de b 2008810 200889c: 82 10 20 0c mov 0xc, %g1 ! c =============================================================================== 02008644 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 2008644: 82 10 00 08 mov %o0, %g1 if ( !attr || attr->is_initialized == false ) 2008648: 80 a0 60 00 cmp %g1, 0 200864c: 02 80 00 06 be 2008664 2008650: 90 10 20 16 mov 0x16, %o0 2008654: c4 00 40 00 ld [ %g1 ], %g2 2008658: 80 a0 a0 00 cmp %g2, 0 200865c: 32 80 00 04 bne,a 200866c <== ALWAYS TAKEN 2008660: c0 20 40 00 clr [ %g1 ] return EINVAL; attr->is_initialized = false; return 0; } 2008664: 81 c3 e0 08 retl 2008668: 01 00 00 00 nop 200866c: 81 c3 e0 08 retl 2008670: 90 10 20 00 clr %o0 ! 0 =============================================================================== 02007cf4 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 2007cf4: 9d e3 bf 58 save %sp, -168, %sp int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) 2007cf8: 80 a6 a0 00 cmp %i2, 0 2007cfc: 02 80 00 0a be 2007d24 2007d00: ba 10 20 0e mov 0xe, %i5 return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 2007d04: 80 a6 60 00 cmp %i1, 0 2007d08: 22 80 00 63 be,a 2007e94 2007d0c: 33 00 80 84 sethi %hi(0x2021000), %i1 if ( !the_attr->is_initialized ) 2007d10: c2 06 40 00 ld [ %i1 ], %g1 2007d14: 80 a0 60 00 cmp %g1, 0 2007d18: 32 80 00 05 bne,a 2007d2c 2007d1c: c2 06 60 04 ld [ %i1 + 4 ], %g1 schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; break; default: return EINVAL; 2007d20: ba 10 20 16 mov 0x16, %i5 */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 2007d24: 81 c7 e0 08 ret 2007d28: 91 e8 00 1d restore %g0, %i5, %o0 * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 2007d2c: 80 a0 60 00 cmp %g1, 0 2007d30: 02 80 00 07 be 2007d4c 2007d34: 03 00 80 8a sethi %hi(0x2022800), %g1 2007d38: c4 06 60 08 ld [ %i1 + 8 ], %g2 2007d3c: c2 00 60 ec ld [ %g1 + 0xec ], %g1 2007d40: 80 a0 80 01 cmp %g2, %g1 2007d44: 0a bf ff f8 bcs 2007d24 2007d48: ba 10 20 16 mov 0x16, %i5 * If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 2007d4c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 2007d50: 80 a0 60 01 cmp %g1, 1 2007d54: 02 80 00 52 be 2007e9c 2007d58: 80 a0 60 02 cmp %g1, 2 2007d5c: 32 bf ff f2 bne,a 2007d24 2007d60: ba 10 20 16 mov 0x16, %i5 schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; 2007d64: da 06 60 18 ld [ %i1 + 0x18 ], %o5 2007d68: de 06 60 1c ld [ %i1 + 0x1c ], %o7 2007d6c: fa 06 60 20 ld [ %i1 + 0x20 ], %i5 2007d70: c8 06 60 24 ld [ %i1 + 0x24 ], %g4 2007d74: c6 06 60 28 ld [ %i1 + 0x28 ], %g3 2007d78: c4 06 60 2c ld [ %i1 + 0x2c ], %g2 2007d7c: c2 06 60 30 ld [ %i1 + 0x30 ], %g1 schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 2007d80: f8 06 60 14 ld [ %i1 + 0x14 ], %i4 schedparam = the_attr->schedparam; 2007d84: da 27 bf e4 st %o5, [ %fp + -28 ] 2007d88: de 27 bf e8 st %o7, [ %fp + -24 ] 2007d8c: fa 27 bf ec st %i5, [ %fp + -20 ] 2007d90: c8 27 bf f0 st %g4, [ %fp + -16 ] 2007d94: c6 27 bf f4 st %g3, [ %fp + -12 ] 2007d98: c4 27 bf f8 st %g2, [ %fp + -8 ] 2007d9c: c2 27 bf fc st %g1, [ %fp + -4 ] /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 2007da0: c2 06 60 0c ld [ %i1 + 0xc ], %g1 2007da4: 80 a0 60 00 cmp %g1, 0 2007da8: 12 bf ff df bne 2007d24 2007dac: ba 10 20 86 mov 0x86, %i5 return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 2007db0: 40 00 1a 94 call 200e800 <_POSIX_Priority_Is_valid> 2007db4: d0 07 bf e4 ld [ %fp + -28 ], %o0 2007db8: 80 8a 20 ff btst 0xff, %o0 2007dbc: 02 bf ff da be 2007d24 <== NEVER TAKEN 2007dc0: ba 10 20 16 mov 0x16, %i5 RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 2007dc4: 03 00 80 8a sethi %hi(0x2022800), %g1 return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 2007dc8: e0 07 bf e4 ld [ %fp + -28 ], %l0 2007dcc: e8 08 60 e8 ldub [ %g1 + 0xe8 ], %l4 /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 2007dd0: 90 10 00 1c mov %i4, %o0 2007dd4: 92 07 bf e4 add %fp, -28, %o1 2007dd8: 94 07 bf dc add %fp, -36, %o2 2007ddc: 40 00 1a 96 call 200e834 <_POSIX_Thread_Translate_sched_param> 2007de0: 96 07 bf e0 add %fp, -32, %o3 schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 2007de4: ba 92 20 00 orcc %o0, 0, %i5 2007de8: 12 bf ff cf bne 2007d24 2007dec: 25 00 80 8d sethi %hi(0x2023400), %l2 #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 2007df0: d0 04 a3 00 ld [ %l2 + 0x300 ], %o0 ! 2023700 <_RTEMS_Allocator_Mutex> 2007df4: 40 00 06 9a call 200985c <_API_Mutex_Lock> 2007df8: 27 00 80 8e sethi %hi(0x2023800), %l3 * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 2007dfc: 40 00 09 73 call 200a3c8 <_Objects_Allocate> 2007e00: 90 14 e0 a0 or %l3, 0xa0, %o0 ! 20238a0 <_POSIX_Threads_Information> * Allocate the thread control block. * * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 2007e04: a2 92 20 00 orcc %o0, 0, %l1 2007e08: 02 80 00 1f be 2007e84 2007e0c: 05 00 80 8a sethi %hi(0x2022800), %g2 /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 2007e10: c2 06 60 08 ld [ %i1 + 8 ], %g1 static inline size_t _POSIX_Threads_Ensure_minimum_stack ( size_t size ) { if ( size >= PTHREAD_MINIMUM_STACK_SIZE ) 2007e14: d6 00 a0 ec ld [ %g2 + 0xec ], %o3 /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 2007e18: c0 27 bf d4 clr [ %fp + -44 ] 2007e1c: 97 2a e0 01 sll %o3, 1, %o3 2007e20: 80 a2 c0 01 cmp %o3, %g1 2007e24: 1a 80 00 03 bcc 2007e30 2007e28: d4 06 60 04 ld [ %i1 + 4 ], %o2 2007e2c: 96 10 00 01 mov %g1, %o3 2007e30: c2 07 bf dc ld [ %fp + -36 ], %g1 2007e34: 9a 0d 20 ff and %l4, 0xff, %o5 2007e38: c2 23 a0 60 st %g1, [ %sp + 0x60 ] 2007e3c: 82 10 20 01 mov 1, %g1 2007e40: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2007e44: c2 07 bf e0 ld [ %fp + -32 ], %g1 2007e48: c0 23 a0 68 clr [ %sp + 0x68 ] 2007e4c: c2 23 a0 64 st %g1, [ %sp + 0x64 ] 2007e50: 82 07 bf d4 add %fp, -44, %g1 2007e54: 90 14 e0 a0 or %l3, 0xa0, %o0 2007e58: c2 23 a0 6c st %g1, [ %sp + 0x6c ] 2007e5c: 92 10 00 11 mov %l1, %o1 2007e60: 98 10 20 01 mov 1, %o4 2007e64: 40 00 0e c3 call 200b970 <_Thread_Initialize> 2007e68: 9a 23 40 10 sub %o5, %l0, %o5 budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 2007e6c: 80 8a 20 ff btst 0xff, %o0 2007e70: 12 80 00 1e bne 2007ee8 2007e74: 11 00 80 8e sethi %hi(0x2023800), %o0 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 2007e78: 92 10 00 11 mov %l1, %o1 2007e7c: 40 00 0a 40 call 200a77c <_Objects_Free> 2007e80: 90 12 20 a0 or %o0, 0xa0, %o0 _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 2007e84: d0 04 a3 00 ld [ %l2 + 0x300 ], %o0 2007e88: 40 00 06 8a call 20098b0 <_API_Mutex_Unlock> 2007e8c: ba 10 20 0b mov 0xb, %i5 2007e90: 30 bf ff a5 b,a 2007d24 int rc; if ( !start_routine ) return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 2007e94: 10 bf ff 9f b 2007d10 2007e98: b2 16 63 9c or %i1, 0x39c, %i1 * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2007e9c: 03 00 80 8e sethi %hi(0x2023800), %g1 2007ea0: c2 00 63 ac ld [ %g1 + 0x3ac ], %g1 ! 2023bac <_Per_CPU_Information+0xc> 2007ea4: c2 00 61 5c ld [ %g1 + 0x15c ], %g1 schedpolicy = api->schedpolicy; schedparam = api->schedparam; 2007ea8: d8 00 60 88 ld [ %g1 + 0x88 ], %o4 2007eac: da 00 60 8c ld [ %g1 + 0x8c ], %o5 2007eb0: de 00 60 90 ld [ %g1 + 0x90 ], %o7 2007eb4: fa 00 60 94 ld [ %g1 + 0x94 ], %i5 2007eb8: c8 00 60 98 ld [ %g1 + 0x98 ], %g4 2007ebc: c6 00 60 9c ld [ %g1 + 0x9c ], %g3 2007ec0: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2 * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; schedpolicy = api->schedpolicy; 2007ec4: f8 00 60 84 ld [ %g1 + 0x84 ], %i4 schedparam = api->schedparam; 2007ec8: d8 27 bf e4 st %o4, [ %fp + -28 ] 2007ecc: da 27 bf e8 st %o5, [ %fp + -24 ] 2007ed0: de 27 bf ec st %o7, [ %fp + -20 ] 2007ed4: fa 27 bf f0 st %i5, [ %fp + -16 ] 2007ed8: c8 27 bf f4 st %g4, [ %fp + -12 ] 2007edc: c6 27 bf f8 st %g3, [ %fp + -8 ] break; 2007ee0: 10 bf ff b0 b 2007da0 2007ee4: c4 27 bf fc st %g2, [ %fp + -4 ] } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2007ee8: e0 04 61 5c ld [ %l1 + 0x15c ], %l0 api->Attributes = *the_attr; 2007eec: 92 10 00 19 mov %i1, %o1 2007ef0: 94 10 20 40 mov 0x40, %o2 2007ef4: 40 00 27 8e call 2011d2c 2007ef8: 90 10 00 10 mov %l0, %o0 api->detachstate = the_attr->detachstate; 2007efc: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2007f00: 92 07 bf e4 add %fp, -28, %o1 2007f04: 94 10 20 1c mov 0x1c, %o2 * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; 2007f08: c2 24 20 40 st %g1, [ %l0 + 0x40 ] api->schedpolicy = schedpolicy; 2007f0c: f8 24 20 84 st %i4, [ %l0 + 0x84 ] api->schedparam = schedparam; 2007f10: 40 00 27 87 call 2011d2c 2007f14: 90 04 20 88 add %l0, 0x88, %o0 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 2007f18: 90 10 00 11 mov %l1, %o0 2007f1c: 92 10 20 01 mov 1, %o1 2007f20: 94 10 00 1a mov %i2, %o2 2007f24: 96 10 00 1b mov %i3, %o3 2007f28: 40 00 11 07 call 200c344 <_Thread_Start> 2007f2c: 98 10 20 00 clr %o4 _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 2007f30: 80 a7 20 04 cmp %i4, 4 2007f34: 02 80 00 07 be 2007f50 2007f38: 01 00 00 00 nop } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 2007f3c: c2 04 60 08 ld [ %l1 + 8 ], %g1 _RTEMS_Unlock_allocator(); 2007f40: d0 04 a3 00 ld [ %l2 + 0x300 ], %o0 2007f44: 40 00 06 5b call 20098b0 <_API_Mutex_Unlock> 2007f48: c2 26 00 00 st %g1, [ %i0 ] 2007f4c: 30 bf ff 76 b,a 2007d24 return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 2007f50: 40 00 11 25 call 200c3e4 <_Timespec_To_ticks> 2007f54: 90 04 20 90 add %l0, 0x90, %o0 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2007f58: 92 04 20 a8 add %l0, 0xa8, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2007f5c: d0 24 20 b4 st %o0, [ %l0 + 0xb4 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2007f60: 11 00 80 8d sethi %hi(0x2023400), %o0 2007f64: 40 00 12 0d call 200c798 <_Watchdog_Insert> 2007f68: 90 12 23 18 or %o0, 0x318, %o0 ! 2023718 <_Watchdog_Ticks_chain> } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 2007f6c: 10 bf ff f5 b 2007f40 2007f70: c2 04 60 08 ld [ %l1 + 8 ], %g1 =============================================================================== 0201b550 : int pthread_kill( pthread_t thread, int sig ) { 201b550: 9d e3 bf 98 save %sp, -104, %sp POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 201b554: 80 a6 60 00 cmp %i1, 0 201b558: 02 80 00 2d be 201b60c 201b55c: ba 06 7f ff add %i1, -1, %i5 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 201b560: 80 a7 60 1f cmp %i5, 0x1f 201b564: 18 80 00 2a bgu 201b60c 201b568: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); the_thread = _Thread_Get( thread, &location ); 201b56c: 7f ff bc ea call 200a914 <_Thread_Get> 201b570: 92 07 bf fc add %fp, -4, %o1 switch ( location ) { 201b574: c2 07 bf fc ld [ %fp + -4 ], %g1 201b578: 80 a0 60 00 cmp %g1, 0 201b57c: 12 80 00 2a bne 201b624 <== NEVER TAKEN 201b580: b8 10 00 08 mov %o0, %i4 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 201b584: 83 2e 60 02 sll %i1, 2, %g1 201b588: 85 2e 60 04 sll %i1, 4, %g2 201b58c: 84 20 80 01 sub %g2, %g1, %g2 201b590: 03 00 80 7b sethi %hi(0x201ec00), %g1 201b594: 82 10 62 40 or %g1, 0x240, %g1 ! 201ee40 <_POSIX_signals_Vectors> 201b598: 82 00 40 02 add %g1, %g2, %g1 201b59c: c4 00 60 08 ld [ %g1 + 8 ], %g2 201b5a0: 80 a0 a0 01 cmp %g2, 1 201b5a4: 02 80 00 14 be 201b5f4 201b5a8: c2 02 21 5c ld [ %o0 + 0x15c ], %g1 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 201b5ac: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2 201b5b0: b6 10 20 01 mov 1, %i3 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 201b5b4: 92 10 00 19 mov %i1, %o1 201b5b8: bb 2e c0 1d sll %i3, %i5, %i5 201b5bc: 94 10 20 00 clr %o2 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 201b5c0: ba 10 80 1d or %g2, %i5, %i5 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 201b5c4: 7f ff ff 8a call 201b3ec <_POSIX_signals_Unblock_thread> 201b5c8: fa 20 60 d4 st %i5, [ %g1 + 0xd4 ] if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 201b5cc: 03 00 80 7b sethi %hi(0x201ec00), %g1 201b5d0: 82 10 61 e0 or %g1, 0x1e0, %g1 ! 201ede0 <_Per_CPU_Information> 201b5d4: c4 00 60 08 ld [ %g1 + 8 ], %g2 201b5d8: 80 a0 a0 00 cmp %g2, 0 201b5dc: 02 80 00 06 be 201b5f4 201b5e0: 01 00 00 00 nop 201b5e4: c4 00 60 0c ld [ %g1 + 0xc ], %g2 201b5e8: 80 a7 00 02 cmp %i4, %g2 201b5ec: 02 80 00 06 be 201b604 201b5f0: 01 00 00 00 nop api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { _Thread_Enable_dispatch(); 201b5f4: 7f ff bc bb call 200a8e0 <_Thread_Enable_dispatch> 201b5f8: b0 10 20 00 clr %i0 ! 0 201b5fc: 81 c7 e0 08 ret 201b600: 81 e8 00 00 restore api->signals_pending |= signo_to_mask( sig ); (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 201b604: f6 28 60 18 stb %i3, [ %g1 + 0x18 ] 201b608: 30 bf ff fb b,a 201b5f4 if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 201b60c: 7f ff d4 7a call 20107f4 <__errno> 201b610: b0 10 3f ff mov -1, %i0 201b614: 82 10 20 16 mov 0x16, %g1 201b618: c2 22 00 00 st %g1, [ %o0 ] 201b61c: 81 c7 e0 08 ret 201b620: 81 e8 00 00 restore #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 201b624: 7f ff d4 74 call 20107f4 <__errno> <== NOT EXECUTED 201b628: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201b62c: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 201b630: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 201b634: 81 c7 e0 08 ret <== NOT EXECUTED 201b638: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02009d3c : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 2009d3c: 9d e3 bf 98 save %sp, -104, %sp * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 2009d40: 90 10 00 19 mov %i1, %o0 2009d44: 40 00 00 38 call 2009e24 <_POSIX_Absolute_timeout_to_ticks> 2009d48: 92 07 bf fc add %fp, -4, %o1 if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 2009d4c: d4 07 bf fc ld [ %fp + -4 ], %o2 * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 2009d50: ba 10 00 08 mov %o0, %i5 if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 2009d54: 80 a7 60 03 cmp %i5, 3 2009d58: 02 80 00 0c be 2009d88 2009d5c: 90 10 00 18 mov %i0, %o0 do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 2009d60: 7f ff ff bd call 2009c54 <_POSIX_Mutex_Lock_support> 2009d64: 92 10 20 00 clr %o1 * This service only gives us the option to block. We used a polling * attempt to lock if the abstime was not in the future. If we did * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { 2009d68: 80 a2 20 10 cmp %o0, 0x10 2009d6c: 12 80 00 0a bne 2009d94 2009d70: b0 10 00 08 mov %o0, %i0 if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 2009d74: 80 a7 60 00 cmp %i5, 0 2009d78: 12 80 00 09 bne 2009d9c <== ALWAYS TAKEN 2009d7c: ba 07 7f ff add %i5, -1, %i5 return EINVAL; 2009d80: 81 c7 e0 08 ret <== NOT EXECUTED 2009d84: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 2009d88: 7f ff ff b3 call 2009c54 <_POSIX_Mutex_Lock_support> 2009d8c: 92 10 20 01 mov 1, %o1 2009d90: b0 10 00 08 mov %o0, %i0 status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return lock_status; } 2009d94: 81 c7 e0 08 ret 2009d98: 81 e8 00 00 restore * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 2009d9c: 80 a7 60 01 cmp %i5, 1 2009da0: 18 bf ff fd bgu 2009d94 <== NEVER TAKEN 2009da4: 01 00 00 00 nop status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 2009da8: 81 c7 e0 08 ret 2009dac: 91 e8 20 74 restore %g0, 0x74, %o0 =============================================================================== 02007574 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_gettype( const pthread_mutexattr_t *attr, int *type ) { 2007574: 82 10 00 08 mov %o0, %g1 if ( !attr ) 2007578: 80 a0 60 00 cmp %g1, 0 200757c: 02 80 00 06 be 2007594 2007580: 90 10 20 16 mov 0x16, %o0 return EINVAL; if ( !attr->is_initialized ) 2007584: c4 00 40 00 ld [ %g1 ], %g2 2007588: 80 a0 a0 00 cmp %g2, 0 200758c: 12 80 00 04 bne 200759c 2007590: 80 a2 60 00 cmp %o1, 0 if ( !type ) return EINVAL; *type = attr->type; return 0; } 2007594: 81 c3 e0 08 retl 2007598: 01 00 00 00 nop return EINVAL; if ( !attr->is_initialized ) return EINVAL; if ( !type ) 200759c: 02 bf ff fe be 2007594 <== NEVER TAKEN 20075a0: 01 00 00 00 nop return EINVAL; *type = attr->type; 20075a4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 return 0; 20075a8: 90 10 20 00 clr %o0 } 20075ac: 81 c3 e0 08 retl 20075b0: c2 22 40 00 st %g1, [ %o1 ] =============================================================================== 02009904 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 2009904: 82 10 00 08 mov %o0, %g1 if ( !attr || !attr->is_initialized ) 2009908: 80 a0 60 00 cmp %g1, 0 200990c: 02 80 00 06 be 2009924 2009910: 90 10 20 16 mov 0x16, %o0 2009914: c4 00 40 00 ld [ %g1 ], %g2 2009918: 80 a0 a0 00 cmp %g2, 0 200991c: 12 80 00 04 bne 200992c 2009920: 80 a2 60 01 cmp %o1, 1 return 0; default: return EINVAL; } } 2009924: 81 c3 e0 08 retl 2009928: 01 00 00 00 nop ) { if ( !attr || !attr->is_initialized ) return EINVAL; switch ( pshared ) { 200992c: 18 bf ff fe bgu 2009924 <== NEVER TAKEN 2009930: 01 00 00 00 nop case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 2009934: d2 20 60 04 st %o1, [ %g1 + 4 ] return 0; default: return EINVAL; } } 2009938: 81 c3 e0 08 retl 200993c: 90 10 20 00 clr %o0 =============================================================================== 02007608 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 2007608: 82 10 00 08 mov %o0, %g1 if ( !attr || !attr->is_initialized ) 200760c: 80 a0 60 00 cmp %g1, 0 2007610: 02 80 00 06 be 2007628 2007614: 90 10 20 16 mov 0x16, %o0 2007618: c4 00 40 00 ld [ %g1 ], %g2 200761c: 80 a0 a0 00 cmp %g2, 0 2007620: 12 80 00 04 bne 2007630 <== ALWAYS TAKEN 2007624: 80 a2 60 03 cmp %o1, 3 return 0; default: return EINVAL; } } 2007628: 81 c3 e0 08 retl 200762c: 01 00 00 00 nop ) { if ( !attr || !attr->is_initialized ) return EINVAL; switch ( type ) { 2007630: 18 bf ff fe bgu 2007628 2007634: 01 00 00 00 nop case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 2007638: d2 20 60 10 st %o1, [ %g1 + 0x10 ] return 0; default: return EINVAL; } } 200763c: 81 c3 e0 08 retl 2007640: 90 10 20 00 clr %o0 =============================================================================== 02008430 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 2008430: 9d e3 bf 98 save %sp, -104, %sp if ( !once_control || !init_routine ) 2008434: 80 a6 60 00 cmp %i1, 0 2008438: 12 80 00 05 bne 200844c 200843c: 80 a6 20 00 cmp %i0, 0 return EINVAL; 2008440: 82 10 20 16 mov 0x16, %g1 (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 2008444: 81 c7 e0 08 ret 2008448: 91 e8 00 01 restore %g0, %g1, %o0 int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) 200844c: 22 bf ff fe be,a 2008444 2008450: 82 10 20 16 mov 0x16, %g1 return EINVAL; if ( !once_control->init_executed ) { 2008454: c4 06 20 04 ld [ %i0 + 4 ], %g2 2008458: 80 a0 a0 00 cmp %g2, 0 200845c: 12 bf ff fa bne 2008444 2008460: 82 10 20 00 clr %g1 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 2008464: 90 10 21 00 mov 0x100, %o0 2008468: 92 10 21 00 mov 0x100, %o1 200846c: 40 00 03 17 call 20090c8 2008470: 94 07 bf fc add %fp, -4, %o2 if ( !once_control->init_executed ) { 2008474: c2 06 20 04 ld [ %i0 + 4 ], %g1 2008478: 80 a0 60 00 cmp %g1, 0 200847c: 02 80 00 09 be 20084a0 <== ALWAYS TAKEN 2008480: 82 10 20 01 mov 1, %g1 once_control->is_initialized = true; once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 2008484: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED 2008488: 92 10 21 00 mov 0x100, %o1 200848c: 40 00 03 0f call 20090c8 2008490: 94 07 bf fc add %fp, -4, %o2 } return 0; 2008494: 82 10 20 00 clr %g1 } 2008498: 81 c7 e0 08 ret 200849c: 91 e8 00 01 restore %g0, %g1, %o0 if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); if ( !once_control->init_executed ) { once_control->is_initialized = true; 20084a0: c2 26 00 00 st %g1, [ %i0 ] once_control->init_executed = true; (*init_routine)(); 20084a4: 9f c6 40 00 call %i1 20084a8: c2 26 20 04 st %g1, [ %i0 + 4 ] } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 20084ac: 10 bf ff f7 b 2008488 20084b0: d0 07 bf fc ld [ %fp + -4 ], %o0 =============================================================================== 02008394 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 2008394: 9d e3 bf 90 save %sp, -112, %sp const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 2008398: 80 a6 20 00 cmp %i0, 0 200839c: 02 80 00 08 be 20083bc 20083a0: 80 a6 60 00 cmp %i1, 0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 20083a4: 02 80 00 24 be 2008434 20083a8: 90 07 bf f8 add %fp, -8, %o0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 20083ac: c2 06 40 00 ld [ %i1 ], %g1 20083b0: 80 a0 60 00 cmp %g1, 0 20083b4: 32 80 00 04 bne,a 20083c4 <== ALWAYS TAKEN 20083b8: c2 06 60 04 ld [ %i1 + 4 ], %g1 *rwlock = the_rwlock->Object.id; _Thread_Enable_dispatch(); return 0; } 20083bc: 81 c7 e0 08 ret 20083c0: 91 e8 20 16 restore %g0, 0x16, %o0 * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) return EINVAL; switch ( the_attr->process_shared ) { 20083c4: 80 a0 60 00 cmp %g1, 0 20083c8: 12 bf ff fd bne 20083bc <== NEVER TAKEN 20083cc: 03 00 80 8c sethi %hi(0x2023000), %g1 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 20083d0: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20233a0 <_Thread_Dispatch_disable_level> */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 20083d4: c0 27 bf f4 clr [ %fp + -12 ] 20083d8: 84 00 a0 01 inc %g2 20083dc: c4 20 63 a0 st %g2, [ %g1 + 0x3a0 ] return _Thread_Dispatch_disable_level; 20083e0: c2 00 63 a0 ld [ %g1 + 0x3a0 ], %g1 * This function allocates a RWLock control block from * the inactive chain of free RWLock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void ) { return (POSIX_RWLock_Control *) 20083e4: 39 00 80 8d sethi %hi(0x2023400), %i4 20083e8: 40 00 0b 09 call 200b00c <_Objects_Allocate> 20083ec: 90 17 21 d0 or %i4, 0x1d0, %o0 ! 20235d0 <_POSIX_RWLock_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 20083f0: ba 92 20 00 orcc %o0, 0, %i5 20083f4: 02 80 00 14 be 2008444 20083f8: 90 07 60 10 add %i5, 0x10, %o0 _Thread_Enable_dispatch(); return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 20083fc: 40 00 09 54 call 200a94c <_CORE_RWLock_Initialize> 2008400: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 2008404: c4 17 60 0a lduh [ %i5 + 0xa ], %g2 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2008408: b8 17 21 d0 or %i4, 0x1d0, %i4 200840c: c6 07 20 1c ld [ %i4 + 0x1c ], %g3 Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 2008410: c2 07 60 08 ld [ %i5 + 8 ], %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2008414: 85 28 a0 02 sll %g2, 2, %g2 2008418: fa 20 c0 02 st %i5, [ %g3 + %g2 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 200841c: c0 27 60 0c clr [ %i5 + 0xc ] &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 2008420: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2008424: 40 00 10 62 call 200c5ac <_Thread_Enable_dispatch> 2008428: b0 10 20 00 clr %i0 200842c: 81 c7 e0 08 ret 2008430: 81 e8 00 00 restore * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 2008434: 40 00 01 b7 call 2008b10 2008438: b2 07 bf f8 add %fp, -8, %i1 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 200843c: 10 bf ff dd b 20083b0 2008440: c2 06 40 00 ld [ %i1 ], %g1 _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { _Thread_Enable_dispatch(); 2008444: 40 00 10 5a call 200c5ac <_Thread_Enable_dispatch> 2008448: b0 10 20 0b mov 0xb, %i0 200844c: 81 c7 e0 08 ret 2008450: 81 e8 00 00 restore =============================================================================== 02008c7c : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 2008c7c: 9d e3 bf 98 save %sp, -104, %sp Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 2008c80: 80 a6 20 00 cmp %i0, 0 2008c84: 02 80 00 25 be 2008d18 2008c88: 92 07 bf fc add %fp, -4, %o1 * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 2008c8c: 40 00 1b 29 call 200f930 <_POSIX_Absolute_timeout_to_ticks> 2008c90: 90 10 00 19 mov %i1, %o0 2008c94: d2 06 00 00 ld [ %i0 ], %o1 2008c98: ba 10 00 08 mov %o0, %i5 2008c9c: 94 07 bf f8 add %fp, -8, %o2 2008ca0: 11 00 80 86 sethi %hi(0x2021800), %o0 2008ca4: 40 00 0b ac call 200bb54 <_Objects_Get> 2008ca8: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 2021ab0 <_POSIX_RWLock_Information> if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2008cac: c2 07 bf f8 ld [ %fp + -8 ], %g1 2008cb0: 80 a0 60 00 cmp %g1, 0 2008cb4: 32 80 00 1a bne,a 2008d1c 2008cb8: b0 10 20 16 mov 0x16, %i0 case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 2008cbc: d2 06 00 00 ld [ %i0 ], %o1 2008cc0: d6 07 bf fc ld [ %fp + -4 ], %o3 * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 2008cc4: 82 1f 60 03 xor %i5, 3, %g1 the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 2008cc8: 90 02 20 10 add %o0, 0x10, %o0 2008ccc: 80 a0 00 01 cmp %g0, %g1 2008cd0: 98 10 20 00 clr %o4 2008cd4: b8 60 3f ff subx %g0, -1, %i4 2008cd8: 40 00 07 f6 call 200acb0 <_CORE_RWLock_Obtain_for_reading> 2008cdc: 94 10 00 1c mov %i4, %o2 do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 2008ce0: 40 00 0f 7b call 200cacc <_Thread_Enable_dispatch> 2008ce4: 01 00 00 00 nop if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 2008ce8: 03 00 80 87 sethi %hi(0x2021c00), %g1 2008cec: c2 00 61 fc ld [ %g1 + 0x1fc ], %g1 ! 2021dfc <_Per_CPU_Information+0xc> ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait ) { 2008cf0: 80 a7 20 00 cmp %i4, 0 2008cf4: 12 80 00 05 bne 2008d08 2008cf8: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 2008cfc: 80 a2 20 02 cmp %o0, 2 2008d00: 02 80 00 09 be 2008d24 2008d04: 80 a7 60 00 cmp %i5, 0 status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 2008d08: 40 00 00 3f call 2008e04 <_POSIX_RWLock_Translate_core_RWLock_return_code> 2008d0c: 01 00 00 00 nop 2008d10: 81 c7 e0 08 ret 2008d14: 91 e8 00 08 restore %g0, %o0, %o0 #endif case OBJECTS_ERROR: break; } return EINVAL; 2008d18: b0 10 20 16 mov 0x16, %i0 } 2008d1c: 81 c7 e0 08 ret 2008d20: 81 e8 00 00 restore ); _Thread_Enable_dispatch(); if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 2008d24: 22 bf ff fe be,a 2008d1c <== NEVER TAKEN 2008d28: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 2008d2c: ba 07 7f ff add %i5, -1, %i5 2008d30: 80 a7 60 01 cmp %i5, 1 2008d34: 18 bf ff f5 bgu 2008d08 <== NEVER TAKEN 2008d38: b0 10 20 74 mov 0x74, %i0 2008d3c: 30 bf ff f8 b,a 2008d1c =============================================================================== 02008d40 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 2008d40: 9d e3 bf 98 save %sp, -104, %sp Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 2008d44: 80 a6 20 00 cmp %i0, 0 2008d48: 02 80 00 25 be 2008ddc 2008d4c: 92 07 bf fc add %fp, -4, %o1 * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 2008d50: 40 00 1a f8 call 200f930 <_POSIX_Absolute_timeout_to_ticks> 2008d54: 90 10 00 19 mov %i1, %o0 2008d58: d2 06 00 00 ld [ %i0 ], %o1 2008d5c: ba 10 00 08 mov %o0, %i5 2008d60: 94 07 bf f8 add %fp, -8, %o2 2008d64: 11 00 80 86 sethi %hi(0x2021800), %o0 2008d68: 40 00 0b 7b call 200bb54 <_Objects_Get> 2008d6c: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 2021ab0 <_POSIX_RWLock_Information> if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2008d70: c2 07 bf f8 ld [ %fp + -8 ], %g1 2008d74: 80 a0 60 00 cmp %g1, 0 2008d78: 32 80 00 1a bne,a 2008de0 2008d7c: b0 10 20 16 mov 0x16, %i0 case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 2008d80: d2 06 00 00 ld [ %i0 ], %o1 2008d84: d6 07 bf fc ld [ %fp + -4 ], %o3 * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 2008d88: 82 1f 60 03 xor %i5, 3, %g1 the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 2008d8c: 90 02 20 10 add %o0, 0x10, %o0 2008d90: 80 a0 00 01 cmp %g0, %g1 2008d94: 98 10 20 00 clr %o4 2008d98: b8 60 3f ff subx %g0, -1, %i4 2008d9c: 40 00 07 fa call 200ad84 <_CORE_RWLock_Obtain_for_writing> 2008da0: 94 10 00 1c mov %i4, %o2 do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 2008da4: 40 00 0f 4a call 200cacc <_Thread_Enable_dispatch> 2008da8: 01 00 00 00 nop if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 2008dac: 03 00 80 87 sethi %hi(0x2021c00), %g1 2008db0: c2 00 61 fc ld [ %g1 + 0x1fc ], %g1 ! 2021dfc <_Per_CPU_Information+0xc> ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 2008db4: 80 a7 20 00 cmp %i4, 0 2008db8: 12 80 00 05 bne 2008dcc 2008dbc: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 2008dc0: 80 a2 20 02 cmp %o0, 2 2008dc4: 02 80 00 09 be 2008de8 2008dc8: 80 a7 60 00 cmp %i5, 0 if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 2008dcc: 40 00 00 0e call 2008e04 <_POSIX_RWLock_Translate_core_RWLock_return_code> 2008dd0: 01 00 00 00 nop 2008dd4: 81 c7 e0 08 ret 2008dd8: 91 e8 00 08 restore %g0, %o0, %o0 #endif case OBJECTS_ERROR: break; } return EINVAL; 2008ddc: b0 10 20 16 mov 0x16, %i0 } 2008de0: 81 c7 e0 08 ret 2008de4: 81 e8 00 00 restore ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 2008de8: 22 bf ff fe be,a 2008de0 <== NEVER TAKEN 2008dec: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 2008df0: ba 07 7f ff add %i5, -1, %i5 2008df4: 80 a7 60 01 cmp %i5, 1 2008df8: 18 bf ff f5 bgu 2008dcc <== NEVER TAKEN 2008dfc: b0 10 20 74 mov 0x74, %i0 2008e00: 30 bf ff f8 b,a 2008de0 =============================================================================== 0200961c : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 200961c: 82 10 00 08 mov %o0, %g1 if ( !attr ) 2009620: 80 a0 60 00 cmp %g1, 0 2009624: 02 80 00 06 be 200963c 2009628: 90 10 20 16 mov 0x16, %o0 return EINVAL; if ( !attr->is_initialized ) 200962c: c4 00 40 00 ld [ %g1 ], %g2 2009630: 80 a0 a0 00 cmp %g2, 0 2009634: 12 80 00 04 bne 2009644 2009638: 80 a2 60 01 cmp %o1, 1 return 0; default: return EINVAL; } } 200963c: 81 c3 e0 08 retl 2009640: 01 00 00 00 nop return EINVAL; if ( !attr->is_initialized ) return EINVAL; switch ( pshared ) { 2009644: 18 bf ff fe bgu 200963c <== NEVER TAKEN 2009648: 01 00 00 00 nop case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 200964c: d2 20 60 04 st %o1, [ %g1 + 4 ] return 0; default: return EINVAL; } } 2009650: 81 c3 e0 08 retl 2009654: 90 10 20 00 clr %o0 =============================================================================== 0200a6ec : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 200a6ec: 9d e3 bf 90 save %sp, -112, %sp int rc; /* * Check all the parameters */ if ( !param ) 200a6f0: 80 a6 a0 00 cmp %i2, 0 200a6f4: 02 80 00 0a be 200a71c 200a6f8: ba 10 20 16 mov 0x16, %i5 return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 200a6fc: 90 10 00 19 mov %i1, %o0 200a700: 92 10 00 1a mov %i2, %o1 200a704: 94 07 bf f4 add %fp, -12, %o2 200a708: 40 00 18 fd call 2010afc <_POSIX_Thread_Translate_sched_param> 200a70c: 96 07 bf f8 add %fp, -8, %o3 policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 200a710: ba 92 20 00 orcc %o0, 0, %i5 200a714: 02 80 00 05 be 200a728 200a718: 90 10 00 18 mov %i0, %o0 case OBJECTS_ERROR: break; } return ESRCH; } 200a71c: b0 10 00 1d mov %i5, %i0 200a720: 81 c7 e0 08 ret 200a724: 81 e8 00 00 restore return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _Thread_Get( thread, &location ); 200a728: 40 00 0c d1 call 200da6c <_Thread_Get> 200a72c: 92 07 bf fc add %fp, -4, %o1 switch ( location ) { 200a730: c2 07 bf fc ld [ %fp + -4 ], %g1 200a734: 80 a0 60 00 cmp %g1, 0 200a738: 12 80 00 2b bne 200a7e4 200a73c: b6 10 00 08 mov %o0, %i3 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200a740: f8 02 21 5c ld [ %o0 + 0x15c ], %i4 if ( api->schedpolicy == SCHED_SPORADIC ) 200a744: c2 07 20 84 ld [ %i4 + 0x84 ], %g1 200a748: 80 a0 60 04 cmp %g1, 4 200a74c: 02 80 00 35 be 200a820 200a750: 01 00 00 00 nop (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 200a754: c2 06 80 00 ld [ %i2 ], %g1 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 200a758: 80 a6 60 00 cmp %i1, 0 if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 200a75c: c2 27 20 88 st %g1, [ %i4 + 0x88 ] 200a760: c4 06 a0 04 ld [ %i2 + 4 ], %g2 200a764: c4 27 20 8c st %g2, [ %i4 + 0x8c ] 200a768: c4 06 a0 08 ld [ %i2 + 8 ], %g2 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; 200a76c: f2 27 20 84 st %i1, [ %i4 + 0x84 ] api->schedparam = *param; 200a770: c4 27 20 90 st %g2, [ %i4 + 0x90 ] 200a774: c4 06 a0 0c ld [ %i2 + 0xc ], %g2 200a778: c4 27 20 94 st %g2, [ %i4 + 0x94 ] 200a77c: c4 06 a0 10 ld [ %i2 + 0x10 ], %g2 200a780: c4 27 20 98 st %g2, [ %i4 + 0x98 ] 200a784: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2 200a788: c4 27 20 9c st %g2, [ %i4 + 0x9c ] 200a78c: c4 06 a0 18 ld [ %i2 + 0x18 ], %g2 200a790: c4 27 20 a0 st %g2, [ %i4 + 0xa0 ] the_thread->budget_algorithm = budget_algorithm; 200a794: c4 07 bf f4 ld [ %fp + -12 ], %g2 200a798: c4 26 e0 78 st %g2, [ %i3 + 0x78 ] the_thread->budget_callout = budget_callout; 200a79c: c4 07 bf f8 ld [ %fp + -8 ], %g2 switch ( api->schedpolicy ) { 200a7a0: 06 80 00 0e bl 200a7d8 <== NEVER TAKEN 200a7a4: c4 26 e0 7c st %g2, [ %i3 + 0x7c ] 200a7a8: 80 a6 60 02 cmp %i1, 2 200a7ac: 04 80 00 11 ble 200a7f0 200a7b0: 07 00 80 8c sethi %hi(0x2023000), %g3 200a7b4: 80 a6 60 04 cmp %i1, 4 200a7b8: 12 80 00 08 bne 200a7d8 <== NEVER TAKEN 200a7bc: 01 00 00 00 nop true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 200a7c0: c2 27 20 a4 st %g1, [ %i4 + 0xa4 ] _Watchdog_Remove( &api->Sporadic_timer ); 200a7c4: 40 00 11 13 call 200ec10 <_Watchdog_Remove> 200a7c8: 90 07 20 a8 add %i4, 0xa8, %o0 _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 200a7cc: 90 10 20 00 clr %o0 200a7d0: 7f ff ff 7b call 200a5bc <_POSIX_Threads_Sporadic_budget_TSR> 200a7d4: 92 10 00 1b mov %i3, %o1 break; } _Thread_Enable_dispatch(); 200a7d8: 40 00 0c 98 call 200da38 <_Thread_Enable_dispatch> 200a7dc: b0 10 00 1d mov %i5, %i0 200a7e0: 30 bf ff d0 b,a 200a720 #endif case OBJECTS_ERROR: break; } return ESRCH; 200a7e4: ba 10 20 03 mov 3, %i5 } 200a7e8: 81 c7 e0 08 ret 200a7ec: 91 e8 00 1d restore %g0, %i5, %o0 200a7f0: d2 08 e0 68 ldub [ %g3 + 0x68 ], %o1 switch ( api->schedpolicy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 200a7f4: 05 00 80 8f sethi %hi(0x2023c00), %g2 200a7f8: c4 00 a1 c0 ld [ %g2 + 0x1c0 ], %g2 ! 2023dc0 <_Thread_Ticks_per_timeslice> 200a7fc: 92 22 40 01 sub %o1, %g1, %o1 the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 200a800: 90 10 00 1b mov %i3, %o0 200a804: 94 10 20 01 mov 1, %o2 switch ( api->schedpolicy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 200a808: c4 26 e0 74 st %g2, [ %i3 + 0x74 ] the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 200a80c: 40 00 0b 4a call 200d534 <_Thread_Change_priority> 200a810: d2 26 e0 18 st %o1, [ %i3 + 0x18 ] _Watchdog_Remove( &api->Sporadic_timer ); _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); break; } _Thread_Enable_dispatch(); 200a814: 40 00 0c 89 call 200da38 <_Thread_Enable_dispatch> 200a818: b0 10 00 1d mov %i5, %i0 200a81c: 30 bf ff c1 b,a 200a720 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 200a820: 40 00 10 fc call 200ec10 <_Watchdog_Remove> 200a824: 90 07 20 a8 add %i4, 0xa8, %o0 api->schedpolicy = policy; api->schedparam = *param; 200a828: 10 bf ff cc b 200a758 200a82c: c2 06 80 00 ld [ %i2 ], %g1 =============================================================================== 0200808c : /* * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 200808c: 9d e3 bf a0 save %sp, -96, %sp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 2008090: 3b 00 80 7f sethi %hi(0x201fc00), %i5 2008094: ba 17 60 30 or %i5, 0x30, %i5 ! 201fc30 <_Per_CPU_Information> 2008098: c2 07 60 08 ld [ %i5 + 8 ], %g1 200809c: 80 a0 60 00 cmp %g1, 0 20080a0: 12 80 00 17 bne 20080fc <== NEVER TAKEN 20080a4: 03 00 80 7d sethi %hi(0x201f400), %g1 return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 20080a8: c4 07 60 0c ld [ %i5 + 0xc ], %g2 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 20080ac: c6 00 63 00 ld [ %g1 + 0x300 ], %g3 20080b0: c4 00 a1 5c ld [ %g2 + 0x15c ], %g2 20080b4: 86 00 e0 01 inc %g3 20080b8: c6 20 63 00 st %g3, [ %g1 + 0x300 ] return _Thread_Dispatch_disable_level; 20080bc: c2 00 63 00 ld [ %g1 + 0x300 ], %g1 _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 20080c0: c2 00 a0 d8 ld [ %g2 + 0xd8 ], %g1 20080c4: 80 a0 60 00 cmp %g1, 0 20080c8: 12 80 00 0b bne 20080f4 <== NEVER TAKEN 20080cc: 01 00 00 00 nop 20080d0: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1 20080d4: 80 a0 60 00 cmp %g1, 0 20080d8: 02 80 00 07 be 20080f4 20080dc: 01 00 00 00 nop thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 20080e0: 40 00 0c 42 call 200b1e8 <_Thread_Enable_dispatch> 20080e4: b2 10 3f ff mov -1, %i1 ! ffffffff if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 20080e8: f0 07 60 0c ld [ %i5 + 0xc ], %i0 20080ec: 40 00 18 9a call 200e354 <_POSIX_Thread_Exit> 20080f0: 81 e8 00 00 restore _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 20080f4: 40 00 0c 3d call 200b1e8 <_Thread_Enable_dispatch> 20080f8: 81 e8 00 00 restore 20080fc: 81 c7 e0 08 ret <== NOT EXECUTED 2008100: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 020085d4 : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 20085d4: 9d e3 bf 78 save %sp, -136, %sp struct sched_param param; /* The queue should be initialized */ AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED); result = pthread_mutex_lock (&aio_request_queue.mutex); 20085d8: 39 00 80 83 sethi %hi(0x2020c00), %i4 20085dc: 40 00 02 7b call 2008fc8 20085e0: 90 17 21 a4 or %i4, 0x1a4, %o0 ! 2020da4 if (result != 0) { 20085e4: b6 92 20 00 orcc %o0, 0, %i3 20085e8: 12 80 00 31 bne 20086ac <== NEVER TAKEN 20085ec: 90 10 00 18 mov %i0, %o0 return result; } /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined, we can use aio_reqprio to lower the priority of the request */ pthread_getschedparam (pthread_self(), &policy, ¶m); 20085f0: 40 00 04 b5 call 20098c4 20085f4: b2 17 21 a4 or %i4, 0x1a4, %i1 20085f8: 92 07 bf e0 add %fp, -32, %o1 20085fc: 40 00 03 a7 call 2009498 2008600: 94 07 bf e4 add %fp, -28, %o2 req->caller_thread = pthread_self (); 2008604: 40 00 04 b0 call 20098c4 2008608: 01 00 00 00 nop req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 200860c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 req->policy = policy; 2008610: c6 07 bf e0 ld [ %fp + -32 ], %g3 /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined, we can use aio_reqprio to lower the priority of the request */ pthread_getschedparam (pthread_self(), &policy, ¶m); req->caller_thread = pthread_self (); req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 2008614: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 req->policy = policy; 2008618: c6 26 20 08 st %g3, [ %i0 + 8 ] /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined, we can use aio_reqprio to lower the priority of the request */ pthread_getschedparam (pthread_self(), &policy, ¶m); req->caller_thread = pthread_self (); req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 200861c: c6 07 bf e4 ld [ %fp + -28 ], %g3 /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined, we can use aio_reqprio to lower the priority of the request */ pthread_getschedparam (pthread_self(), &policy, ¶m); req->caller_thread = pthread_self (); 2008620: d0 26 20 10 st %o0, [ %i0 + 0x10 ] req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 2008624: 84 20 c0 02 sub %g3, %g2, %g2 2008628: c4 26 20 0c st %g2, [ %i0 + 0xc ] req->policy = policy; req->aiocbp->error_code = EINPROGRESS; req->aiocbp->return_value = 0; if ((aio_request_queue.idle_threads == 0) && 200862c: c4 06 60 68 ld [ %i1 + 0x68 ], %g2 pthread_getschedparam (pthread_self(), &policy, ¶m); req->caller_thread = pthread_self (); req->priority = param.sched_priority - req->aiocbp->aio_reqprio; req->policy = policy; req->aiocbp->error_code = EINPROGRESS; 2008630: 86 10 20 77 mov 0x77, %g3 req->aiocbp->return_value = 0; 2008634: c0 20 60 38 clr [ %g1 + 0x38 ] pthread_getschedparam (pthread_self(), &policy, ¶m); req->caller_thread = pthread_self (); req->priority = param.sched_priority - req->aiocbp->aio_reqprio; req->policy = policy; req->aiocbp->error_code = EINPROGRESS; 2008638: c6 20 60 34 st %g3, [ %g1 + 0x34 ] req->aiocbp->return_value = 0; if ((aio_request_queue.idle_threads == 0) && 200863c: 80 a0 a0 00 cmp %g2, 0 2008640: 12 80 00 06 bne 2008658 <== NEVER TAKEN 2008644: d2 00 40 00 ld [ %g1 ], %o1 2008648: c4 06 60 64 ld [ %i1 + 0x64 ], %g2 200864c: 80 a0 a0 04 cmp %g2, 4 2008650: 24 80 00 1b ble,a 20086bc 2008654: 90 06 60 48 add %i1, 0x48, %o0 else { /* the maximum number of threads has been already created even though some of them might be idle. The request belongs to one of the active fd chain */ r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 2008658: 94 10 20 00 clr %o2 200865c: 11 00 80 83 sethi %hi(0x2020c00), %o0 2008660: 7f ff ff 78 call 2008440 2008664: 90 12 21 ec or %o0, 0x1ec, %o0 ! 2020dec req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 2008668: b4 92 20 00 orcc %o0, 0, %i2 200866c: 22 80 00 31 be,a 2008730 2008670: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 { pthread_mutex_lock (&r_chain->mutex); 2008674: b2 06 a0 1c add %i2, 0x1c, %i1 2008678: 40 00 02 54 call 2008fc8 200867c: 90 10 00 19 mov %i1, %o0 rtems_aio_insert_prio (&r_chain->perfd, req); 2008680: 90 06 a0 08 add %i2, 8, %o0 2008684: 7f ff ff 12 call 20082cc 2008688: 92 10 00 18 mov %i0, %o1 pthread_cond_signal (&r_chain->cond); 200868c: 40 00 01 2b call 2008b38 2008690: 90 06 a0 20 add %i2, 0x20, %o0 pthread_mutex_unlock (&r_chain->mutex); 2008694: 40 00 02 6d call 2009048 2008698: 90 10 00 19 mov %i1, %o0 if (aio_request_queue.idle_threads > 0) pthread_cond_signal (&aio_request_queue.new_req); } } pthread_mutex_unlock (&aio_request_queue.mutex); 200869c: 40 00 02 6b call 2009048 20086a0: 90 17 21 a4 or %i4, 0x1a4, %o0 return 0; } 20086a4: 81 c7 e0 08 ret 20086a8: 91 e8 00 1b restore %g0, %i3, %o0 /* The queue should be initialized */ AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED); result = pthread_mutex_lock (&aio_request_queue.mutex); if (result != 0) { free (req); 20086ac: 7f ff ed dd call 2003e20 <== NOT EXECUTED 20086b0: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED } } pthread_mutex_unlock (&aio_request_queue.mutex); return 0; } 20086b4: 81 c7 e0 08 ret <== NOT EXECUTED 20086b8: 81 e8 00 00 restore <== NOT EXECUTED if ((aio_request_queue.idle_threads == 0) && aio_request_queue.active_threads < AIO_MAX_THREADS) /* we still have empty places on the active_threads chain */ { chain = &aio_request_queue.work_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 20086bc: 7f ff ff 61 call 2008440 20086c0: 94 10 20 01 mov 1, %o2 if (r_chain->new_fd == 1) { 20086c4: c2 02 20 18 ld [ %o0 + 0x18 ], %g1 20086c8: 80 a0 60 01 cmp %g1, 1 20086cc: 12 bf ff ea bne 2008674 20086d0: b4 10 00 08 mov %o0, %i2 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 20086d4: 90 02 20 08 add %o0, 8, %o0 20086d8: 40 00 09 42 call 200abe0 <_Chain_Insert> 20086dc: 92 10 00 18 mov %i0, %o1 rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL); 20086e0: 92 10 20 00 clr %o1 chain = &aio_request_queue.work_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); if (r_chain->new_fd == 1) { rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 20086e4: c0 26 a0 18 clr [ %i2 + 0x18 ] pthread_mutex_init (&r_chain->mutex, NULL); 20086e8: 40 00 01 de call 2008e60 20086ec: 90 06 a0 1c add %i2, 0x1c, %o0 pthread_cond_init (&r_chain->cond, NULL); 20086f0: 92 10 20 00 clr %o1 20086f4: 40 00 00 e1 call 2008a78 20086f8: 90 06 a0 20 add %i2, 0x20, %o0 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 20086fc: 90 07 bf dc add %fp, -36, %o0 2008700: 92 06 60 08 add %i1, 8, %o1 2008704: 96 10 00 1a mov %i2, %o3 2008708: 15 00 80 20 sethi %hi(0x2008000), %o2 200870c: 40 00 02 c3 call 2009218 2008710: 94 12 a0 20 or %o2, 0x20, %o2 ! 2008020 rtems_aio_handle, (void *) r_chain); if (result != 0) { 2008714: 82 92 20 00 orcc %o0, 0, %g1 2008718: 12 80 00 25 bne 20087ac <== NEVER TAKEN 200871c: 90 10 00 19 mov %i1, %o0 pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads; 2008720: c2 06 60 64 ld [ %i1 + 0x64 ], %g1 2008724: 82 00 60 01 inc %g1 2008728: 10 bf ff dd b 200869c 200872c: c2 26 60 64 st %g1, [ %i1 + 0x64 ] } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 2008730: 11 00 80 83 sethi %hi(0x2020c00), %o0 2008734: d2 00 40 00 ld [ %g1 ], %o1 2008738: 90 12 21 f8 or %o0, 0x1f8, %o0 200873c: 7f ff ff 41 call 2008440 2008740: 94 10 20 01 mov 1, %o2 if (r_chain->new_fd == 1) { 2008744: c2 02 20 18 ld [ %o0 + 0x18 ], %g1 } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 2008748: b4 10 00 08 mov %o0, %i2 200874c: 92 10 00 18 mov %i0, %o1 if (r_chain->new_fd == 1) { 2008750: 80 a0 60 01 cmp %g1, 1 2008754: 02 80 00 0b be 2008780 2008758: 90 02 20 08 add %o0, 8, %o0 r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL); pthread_cond_init (&r_chain->cond, NULL); } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 200875c: 7f ff fe dc call 20082cc 2008760: 01 00 00 00 nop if (aio_request_queue.idle_threads > 0) 2008764: c2 06 60 68 ld [ %i1 + 0x68 ], %g1 2008768: 80 a0 60 00 cmp %g1, 0 200876c: 04 bf ff cc ble 200869c <== ALWAYS TAKEN 2008770: 01 00 00 00 nop pthread_cond_signal (&aio_request_queue.new_req); 2008774: 40 00 00 f1 call 2008b38 <== NOT EXECUTED 2008778: 90 06 60 04 add %i1, 4, %o0 <== NOT EXECUTED 200877c: 30 bf ff c8 b,a 200869c <== NOT EXECUTED 2008780: 40 00 09 18 call 200abe0 <_Chain_Insert> 2008784: 01 00 00 00 nop /* If this is a new fd chain we signal the idle threads that might be waiting for requests */ AIO_printf (" New chain on waiting queue \n "); rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL); 2008788: 90 06 a0 1c add %i2, 0x1c, %o0 if (r_chain->new_fd == 1) { /* If this is a new fd chain we signal the idle threads that might be waiting for requests */ AIO_printf (" New chain on waiting queue \n "); rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 200878c: c0 26 a0 18 clr [ %i2 + 0x18 ] pthread_mutex_init (&r_chain->mutex, NULL); 2008790: 40 00 01 b4 call 2008e60 2008794: 92 10 20 00 clr %o1 pthread_cond_init (&r_chain->cond, NULL); 2008798: 90 06 a0 20 add %i2, 0x20, %o0 200879c: 40 00 00 b7 call 2008a78 20087a0: 92 10 20 00 clr %o1 } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); if (aio_request_queue.idle_threads > 0) 20087a4: 10 bf ff f1 b 2008768 20087a8: c2 06 60 68 ld [ %i1 + 0x68 ], %g1 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, rtems_aio_handle, (void *) r_chain); if (result != 0) { pthread_mutex_unlock (&aio_request_queue.mutex); 20087ac: 40 00 02 27 call 2009048 <== NOT EXECUTED 20087b0: b6 10 00 01 mov %g1, %i3 <== NOT EXECUTED 20087b4: 30 bf ff bc b,a 20086a4 <== NOT EXECUTED =============================================================================== 02008020 : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 2008020: 9d e3 bf 78 save %sp, -136, %sp struct timespec timeout; AIO_printf ("Chain is empty [WQ], wait for work\n"); pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_lock (&aio_request_queue.mutex); 2008024: 35 00 80 83 sethi %hi(0x2020c00), %i2 2008028: b6 06 20 1c add %i0, 0x1c, %i3 200802c: b4 16 a1 a4 or %i2, 0x1a4, %i2 if (rtems_chain_is_empty (chain)) { clock_gettime (CLOCK_REALTIME, &timeout); timeout.tv_sec += 3; timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond, 2008030: a0 10 00 1a mov %i2, %l0 2008034: a2 10 00 1a mov %i2, %l1 pthread_cond_destroy (&r_chain->cond); free (r_chain); /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { 2008038: a4 06 a0 58 add %i2, 0x58, %l2 rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 200803c: b2 06 a0 4c add %i2, 0x4c, %i1 /* acquire the mutex of the current fd chain. we don't need to lock the queue mutex since we can add requests to idle fd chains or even active ones if the working request has been extracted from the chain */ result = pthread_mutex_lock (&r_chain->mutex); 2008040: 40 00 03 e2 call 2008fc8 2008044: 90 10 00 1b mov %i3, %o0 if (result != 0) 2008048: 80 a2 20 00 cmp %o0, 0 200804c: 12 80 00 2b bne 20080f8 <== NEVER TAKEN 2008050: 01 00 00 00 nop 2008054: fa 06 20 08 ld [ %i0 + 8 ], %i5 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 2008058: 82 06 20 0c add %i0, 0xc, %g1 /* If the locked chain is not empty, take the first request extract it, unlock the chain and process the request, in this way the user can supply more requests to this fd chain */ if (!rtems_chain_is_empty (chain)) { 200805c: 80 a7 40 01 cmp %i5, %g1 2008060: 02 80 00 41 be 2008164 2008064: 01 00 00 00 nop node = rtems_chain_first (chain); req = (rtems_aio_request *) node; /* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING discussion in rtems_aio_enqueue () */ pthread_getschedparam (pthread_self(), &policy, ¶m); 2008068: 40 00 06 17 call 20098c4 200806c: 01 00 00 00 nop 2008070: 92 07 bf d8 add %fp, -40, %o1 2008074: 40 00 05 09 call 2009498 2008078: 94 07 bf e4 add %fp, -28, %o2 param.sched_priority = req->priority; 200807c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 pthread_setschedparam (pthread_self(), req->policy, ¶m); 2008080: 40 00 06 11 call 20098c4 2008084: c2 27 bf e4 st %g1, [ %fp + -28 ] 2008088: d2 07 60 08 ld [ %i5 + 8 ], %o1 200808c: 40 00 06 12 call 20098d4 2008090: 94 07 bf e4 add %fp, -28, %o2 2008094: 40 00 0a ba call 200ab7c <_Chain_Extract> 2008098: 90 10 00 1d mov %i5, %o0 rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 200809c: 40 00 03 eb call 2009048 20080a0: 90 10 00 1b mov %i3, %o0 switch (req->aiocbp->aio_lio_opcode) { 20080a4: f8 07 60 14 ld [ %i5 + 0x14 ], %i4 20080a8: c2 07 20 30 ld [ %i4 + 0x30 ], %g1 20080ac: 80 a0 60 02 cmp %g1, 2 20080b0: 22 80 00 25 be,a 2008144 20080b4: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 20080b8: 80 a0 60 03 cmp %g1, 3 20080bc: 02 80 00 1e be 2008134 <== NEVER TAKEN 20080c0: 01 00 00 00 nop 20080c4: 80 a0 60 01 cmp %g1, 1 20080c8: 22 80 00 0e be,a 2008100 <== ALWAYS TAKEN 20080cc: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 default: result = -1; } if (result == -1) { req->aiocbp->return_value = -1; 20080d0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED req->aiocbp->error_code = errno; 20080d4: 40 00 2a dd call 2012c48 <__errno> <== NOT EXECUTED 20080d8: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED 20080dc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED /* acquire the mutex of the current fd chain. we don't need to lock the queue mutex since we can add requests to idle fd chains or even active ones if the working request has been extracted from the chain */ result = pthread_mutex_lock (&r_chain->mutex); 20080e0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 20080e4: 40 00 03 b9 call 2008fc8 <== NOT EXECUTED 20080e8: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED if (result != 0) 20080ec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20080f0: 22 bf ff da be,a 2008058 <== NOT EXECUTED 20080f4: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== NOT EXECUTED } } AIO_printf ("Thread finished\n"); return NULL; } 20080f8: 81 c7 e0 08 ret 20080fc: 91 e8 20 00 restore %g0, 0, %o0 pthread_mutex_unlock (&r_chain->mutex); switch (req->aiocbp->aio_lio_opcode) { case LIO_READ: AIO_printf ("read\n"); result = pread (req->aiocbp->aio_fildes, 2008100: d0 07 00 00 ld [ %i4 ], %o0 2008104: d2 07 20 10 ld [ %i4 + 0x10 ], %o1 2008108: d4 07 20 14 ld [ %i4 + 0x14 ], %o2 200810c: 96 10 00 02 mov %g2, %o3 2008110: 40 00 2d ca call 2013838 2008114: 98 10 00 03 mov %g3, %o4 break; default: result = -1; } if (result == -1) { 2008118: 80 a2 3f ff cmp %o0, -1 200811c: 22 bf ff ed be,a 20080d0 <== NEVER TAKEN 2008120: f8 07 60 14 ld [ %i5 + 0x14 ], %i4 <== NOT EXECUTED req->aiocbp->return_value = -1; req->aiocbp->error_code = errno; } else { req->aiocbp->return_value = result; 2008124: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 2008128: d0 20 60 38 st %o0, [ %g1 + 0x38 ] req->aiocbp->error_code = 0; 200812c: 10 bf ff c5 b 2008040 2008130: c0 20 60 34 clr [ %g1 + 0x34 ] req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_SYNC: AIO_printf ("sync\n"); result = fsync (req->aiocbp->aio_fildes); 2008134: 40 00 1c 0c call 200f164 <== NOT EXECUTED 2008138: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED break; 200813c: 10 bf ff f8 b 200811c <== NOT EXECUTED 2008140: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: AIO_printf ("write\n"); result = pwrite (req->aiocbp->aio_fildes, 2008144: d0 07 00 00 ld [ %i4 ], %o0 2008148: d2 07 20 10 ld [ %i4 + 0x10 ], %o1 200814c: d4 07 20 14 ld [ %i4 + 0x14 ], %o2 2008150: 96 10 00 02 mov %g2, %o3 2008154: 40 00 2d f7 call 2013930 2008158: 98 10 00 03 mov %g3, %o4 (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 200815c: 10 bf ff f0 b 200811c 2008160: 80 a2 3f ff cmp %o0, -1 struct timespec timeout; AIO_printf ("Chain is empty [WQ], wait for work\n"); pthread_mutex_unlock (&r_chain->mutex); 2008164: 40 00 03 b9 call 2009048 2008168: 90 10 00 1b mov %i3, %o0 pthread_mutex_lock (&aio_request_queue.mutex); 200816c: 40 00 03 97 call 2008fc8 2008170: 90 10 00 1a mov %i2, %o0 if (rtems_chain_is_empty (chain)) 2008174: c2 06 20 08 ld [ %i0 + 8 ], %g1 2008178: 80 a7 40 01 cmp %i5, %g1 200817c: 02 80 00 05 be 2008190 <== ALWAYS TAKEN 2008180: 92 07 bf dc add %fp, -36, %o1 } } /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex); 2008184: 40 00 03 b1 call 2009048 2008188: 90 10 00 1a mov %i2, %o0 200818c: 30 bf ff ad b,a 2008040 pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_lock (&aio_request_queue.mutex); if (rtems_chain_is_empty (chain)) { clock_gettime (CLOCK_REALTIME, &timeout); 2008190: 40 00 01 d3 call 20088dc 2008194: 90 10 20 01 mov 1, %o0 timeout.tv_sec += 3; 2008198: c2 07 bf dc ld [ %fp + -36 ], %g1 timeout.tv_nsec = 0; 200819c: c0 27 bf e0 clr [ %fp + -32 ] pthread_mutex_lock (&aio_request_queue.mutex); if (rtems_chain_is_empty (chain)) { clock_gettime (CLOCK_REALTIME, &timeout); timeout.tv_sec += 3; 20081a0: 82 00 60 03 add %g1, 3, %g1 timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond, 20081a4: ba 06 20 20 add %i0, 0x20, %i5 pthread_mutex_lock (&aio_request_queue.mutex); if (rtems_chain_is_empty (chain)) { clock_gettime (CLOCK_REALTIME, &timeout); timeout.tv_sec += 3; 20081a8: c2 27 bf dc st %g1, [ %fp + -36 ] timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond, 20081ac: 90 10 00 1d mov %i5, %o0 20081b0: 92 10 00 10 mov %l0, %o1 20081b4: 40 00 02 7d call 2008ba8 20081b8: 94 07 bf dc add %fp, -36, %o2 &aio_request_queue.mutex, &timeout); /* If no requests were added to the chain we delete the fd chain from the queue and start working with idle fd chains */ if (result == ETIMEDOUT) { 20081bc: 80 a2 20 74 cmp %o0, 0x74 20081c0: 12 bf ff f1 bne 2008184 <== NEVER TAKEN 20081c4: 01 00 00 00 nop 20081c8: 40 00 0a 6d call 200ab7c <_Chain_Extract> 20081cc: 90 10 00 18 mov %i0, %o0 rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 20081d0: 40 00 02 d1 call 2008d14 20081d4: 90 10 00 1b mov %i3, %o0 pthread_cond_destroy (&r_chain->cond); 20081d8: 40 00 01 f2 call 20089a0 20081dc: 90 10 00 1d mov %i5, %o0 free (r_chain); 20081e0: 7f ff ef 10 call 2003e20 20081e4: 90 10 00 18 mov %i0, %o0 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 20081e8: f0 06 a0 54 ld [ %i2 + 0x54 ], %i0 /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { 20081ec: 80 a6 00 12 cmp %i0, %l2 20081f0: 22 80 00 1d be,a 2008264 20081f4: c4 06 a0 68 ld [ %i2 + 0x68 ], %g2 } } /* Otherwise move this chain to the working chain and start the loop all over again */ AIO_printf ("Work on idle\n"); --aio_request_queue.idle_threads; 20081f8: c4 04 60 68 ld [ %l1 + 0x68 ], %g2 ++aio_request_queue.active_threads; 20081fc: c2 04 60 64 ld [ %l1 + 0x64 ], %g1 } } /* Otherwise move this chain to the working chain and start the loop all over again */ AIO_printf ("Work on idle\n"); --aio_request_queue.idle_threads; 2008200: 84 00 bf ff add %g2, -1, %g2 ++aio_request_queue.active_threads; 2008204: 82 00 60 01 inc %g1 } } /* Otherwise move this chain to the working chain and start the loop all over again */ AIO_printf ("Work on idle\n"); --aio_request_queue.idle_threads; 2008208: c4 24 60 68 st %g2, [ %l1 + 0x68 ] ++aio_request_queue.active_threads; 200820c: c2 24 60 64 st %g1, [ %l1 + 0x64 ] 2008210: 40 00 0a 5b call 200ab7c <_Chain_Extract> 2008214: 90 10 00 18 mov %i0, %o0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 2008218: c2 04 60 48 ld [ %l1 + 0x48 ], %g1 rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 200821c: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 2008220: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 2008224: 80 a0 c0 02 cmp %g3, %g2 2008228: 14 80 00 08 bg 2008248 <== ALWAYS TAKEN 200822c: 80 a0 40 19 cmp %g1, %i1 RTEMS_INLINE_ROUTINE void rtems_chain_insert( rtems_chain_node *after_node, rtems_chain_node *the_node ) { _Chain_Insert( after_node, the_node ); 2008230: 10 80 00 09 b 2008254 <== NOT EXECUTED 2008234: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED 2008238: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 200823c: 80 a0 80 03 cmp %g2, %g3 2008240: 16 80 00 04 bge 2008250 2008244: 80 a0 40 19 cmp %g1, %i1 2008248: 32 bf ff fc bne,a 2008238 <== ALWAYS TAKEN 200824c: c2 00 40 00 ld [ %g1 ], %g1 2008250: d0 00 60 04 ld [ %g1 + 4 ], %o0 2008254: 92 10 00 18 mov %i0, %o1 2008258: 40 00 0a 62 call 200abe0 <_Chain_Insert> 200825c: b6 06 20 1c add %i0, 0x1c, %i3 2008260: 30 bf ff c9 b,a 2008184 signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; --aio_request_queue.active_threads; 2008264: c2 06 a0 64 ld [ %i2 + 0x64 ], %g1 /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; 2008268: 84 00 a0 01 inc %g2 --aio_request_queue.active_threads; 200826c: 82 00 7f ff add %g1, -1, %g1 clock_gettime (CLOCK_REALTIME, &timeout); 2008270: 92 07 bf dc add %fp, -36, %o1 /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; 2008274: c4 26 a0 68 st %g2, [ %i2 + 0x68 ] --aio_request_queue.active_threads; 2008278: c2 26 a0 64 st %g1, [ %i2 + 0x64 ] clock_gettime (CLOCK_REALTIME, &timeout); 200827c: 40 00 01 98 call 20088dc 2008280: 90 10 20 01 mov 1, %o0 timeout.tv_sec += 3; 2008284: c2 07 bf dc ld [ %fp + -36 ], %g1 timeout.tv_nsec = 0; 2008288: c0 27 bf e0 clr [ %fp + -32 ] AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; --aio_request_queue.active_threads; clock_gettime (CLOCK_REALTIME, &timeout); timeout.tv_sec += 3; 200828c: 82 00 60 03 add %g1, 3, %g1 timeout.tv_nsec = 0; result = pthread_cond_timedwait (&aio_request_queue.new_req, 2008290: 90 06 a0 04 add %i2, 4, %o0 AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; --aio_request_queue.active_threads; clock_gettime (CLOCK_REALTIME, &timeout); timeout.tv_sec += 3; 2008294: c2 27 bf dc st %g1, [ %fp + -36 ] timeout.tv_nsec = 0; result = pthread_cond_timedwait (&aio_request_queue.new_req, 2008298: 92 10 00 1a mov %i2, %o1 200829c: 40 00 02 43 call 2008ba8 20082a0: 94 07 bf dc add %fp, -36, %o2 &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 20082a4: 80 a2 20 74 cmp %o0, 0x74 20082a8: 22 80 00 04 be,a 20082b8 <== ALWAYS TAKEN 20082ac: c2 06 a0 68 ld [ %i2 + 0x68 ], %g1 20082b0: 10 bf ff d2 b 20081f8 <== NOT EXECUTED 20082b4: f0 06 a0 54 ld [ %i2 + 0x54 ], %i0 <== NOT EXECUTED AIO_printf ("Etimeout\n"); --aio_request_queue.idle_threads; pthread_mutex_unlock (&aio_request_queue.mutex); 20082b8: 90 10 00 1a mov %i2, %o0 /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { AIO_printf ("Etimeout\n"); --aio_request_queue.idle_threads; 20082bc: 82 00 7f ff add %g1, -1, %g1 pthread_mutex_unlock (&aio_request_queue.mutex); 20082c0: 40 00 03 62 call 2009048 20082c4: c2 26 a0 68 st %g1, [ %i2 + 0x68 ] 20082c8: 30 bf ff 8c b,a 20080f8 =============================================================================== 02008338 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 2008338: 9d e3 bf a0 save %sp, -96, %sp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 200833c: 3b 00 80 83 sethi %hi(0x2020c00), %i5 2008340: 40 00 03 9b call 20091ac 2008344: 90 17 61 ac or %i5, 0x1ac, %o0 ! 2020dac if (result != 0) 2008348: b0 92 20 00 orcc %o0, 0, %i0 200834c: 12 80 00 23 bne 20083d8 <== NEVER TAKEN 2008350: 90 17 61 ac or %i5, 0x1ac, %o0 return result; result = 2008354: 40 00 03 a2 call 20091dc 2008358: 92 10 20 00 clr %o1 pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 200835c: 80 a2 20 00 cmp %o0, 0 2008360: 12 80 00 20 bne 20083e0 <== NEVER TAKEN 2008364: 39 00 80 83 sethi %hi(0x2020c00), %i4 pthread_attr_destroy (&aio_request_queue.attr); result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 2008368: 92 10 20 00 clr %o1 200836c: 40 00 02 bd call 2008e60 2008370: 90 17 21 a4 or %i4, 0x1a4, %o0 if (result != 0) 2008374: 80 a2 20 00 cmp %o0, 0 2008378: 12 80 00 23 bne 2008404 <== NEVER TAKEN 200837c: 92 10 20 00 clr %o1 pthread_attr_destroy (&aio_request_queue.attr); result = pthread_cond_init (&aio_request_queue.new_req, NULL); 2008380: 11 00 80 83 sethi %hi(0x2020c00), %o0 2008384: 40 00 01 bd call 2008a78 2008388: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 2020da8 if (result != 0) { 200838c: b0 92 20 00 orcc %o0, 0, %i0 2008390: 12 80 00 26 bne 2008428 <== NEVER TAKEN 2008394: 01 00 00 00 nop ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 2008398: 82 17 21 a4 or %i4, 0x1a4, %g1 head->previous = NULL; tail->previous = head; 200839c: 84 00 60 54 add %g1, 0x54, %g2 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 20083a0: ba 00 60 4c add %g1, 0x4c, %i5 head->previous = NULL; tail->previous = head; 20083a4: 88 00 60 48 add %g1, 0x48, %g4 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 20083a8: 86 00 60 58 add %g1, 0x58, %g3 head->previous = NULL; tail->previous = head; 20083ac: c4 20 60 5c st %g2, [ %g1 + 0x5c ] ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 20083b0: fa 20 60 48 st %i5, [ %g1 + 0x48 ] head->previous = NULL; 20083b4: c0 20 60 4c clr [ %g1 + 0x4c ] tail->previous = head; 20083b8: c8 20 60 50 st %g4, [ %g1 + 0x50 ] ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 20083bc: c6 20 60 54 st %g3, [ %g1 + 0x54 ] head->previous = NULL; 20083c0: c0 20 60 58 clr [ %g1 + 0x58 ] } rtems_chain_initialize_empty (&aio_request_queue.work_req); rtems_chain_initialize_empty (&aio_request_queue.idle_req); aio_request_queue.active_threads = 0; 20083c4: c0 20 60 64 clr [ %g1 + 0x64 ] aio_request_queue.idle_threads = 0; 20083c8: c0 20 60 68 clr [ %g1 + 0x68 ] aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 20083cc: 05 00 00 2c sethi %hi(0xb000), %g2 20083d0: 84 10 a0 0b or %g2, 0xb, %g2 ! b00b 20083d4: c4 20 60 60 st %g2, [ %g1 + 0x60 ] return result; } 20083d8: 81 c7 e0 08 ret 20083dc: 81 e8 00 00 restore result = pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) pthread_attr_destroy (&aio_request_queue.attr); 20083e0: 40 00 03 67 call 200917c <== NOT EXECUTED 20083e4: 90 17 61 ac or %i5, 0x1ac, %o0 <== NOT EXECUTED result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 20083e8: 39 00 80 83 sethi %hi(0x2020c00), %i4 <== NOT EXECUTED 20083ec: 92 10 20 00 clr %o1 <== NOT EXECUTED 20083f0: 40 00 02 9c call 2008e60 <== NOT EXECUTED 20083f4: 90 17 21 a4 or %i4, 0x1a4, %o0 <== NOT EXECUTED if (result != 0) 20083f8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20083fc: 02 bf ff e1 be 2008380 <== NOT EXECUTED 2008400: 92 10 20 00 clr %o1 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 2008404: 40 00 03 5e call 200917c <== NOT EXECUTED 2008408: 90 17 61 ac or %i5, 0x1ac, %o0 <== NOT EXECUTED result = pthread_cond_init (&aio_request_queue.new_req, NULL); 200840c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008410: 11 00 80 83 sethi %hi(0x2020c00), %o0 <== NOT EXECUTED 2008414: 40 00 01 99 call 2008a78 <== NOT EXECUTED 2008418: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 2020da8 <== NOT EXECUTED if (result != 0) { 200841c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 2008420: 22 bf ff df be,a 200839c <== NOT EXECUTED 2008424: 82 17 21 a4 or %i4, 0x1a4, %g1 <== NOT EXECUTED pthread_mutex_destroy (&aio_request_queue.mutex); 2008428: 40 00 02 3b call 2008d14 <== NOT EXECUTED 200842c: 90 17 21 a4 or %i4, 0x1a4, %o0 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 2008430: 40 00 03 53 call 200917c <== NOT EXECUTED 2008434: 90 17 61 ac or %i5, 0x1ac, %o0 <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 2008438: 10 bf ff d9 b 200839c <== NOT EXECUTED 200843c: 82 17 21 a4 or %i4, 0x1a4, %g1 <== NOT EXECUTED =============================================================================== 020082cc : 20082cc: c2 02 00 00 ld [ %o0 ], %g1 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 20082d0: 88 02 20 04 add %o0, 4, %g4 rtems_chain_node *node; AIO_printf ("FD exists \n"); node = rtems_chain_first (chain); if (rtems_chain_is_empty (chain)) { 20082d4: 80 a0 40 04 cmp %g1, %g4 20082d8: 02 80 00 15 be 200832c <== NEVER TAKEN 20082dc: 9a 10 00 09 mov %o1, %o5 rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && 20082e0: c6 02 60 14 ld [ %o1 + 0x14 ], %g3 if (rtems_chain_is_empty (chain)) { AIO_printf ("First in chain \n"); rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 20082e4: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 while (req->aiocbp->aio_reqprio > prio && 20082e8: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3 20082ec: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2 20082f0: 80 a0 80 03 cmp %g2, %g3 20082f4: 26 80 00 07 bl,a 2008310 <== NEVER TAKEN 20082f8: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED 20082fc: 10 80 00 0b b 2008328 2008300: d0 00 60 04 ld [ %g1 + 4 ], %o0 2008304: 22 80 00 09 be,a 2008328 <== NOT EXECUTED 2008308: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next( Chain_Node *the_node ) { return the_node->next; 200830c: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED !rtems_chain_is_tail (chain, node)) { node = rtems_chain_next (node); prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 2008310: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && 2008314: c4 00 a0 18 ld [ %g2 + 0x18 ], %g2 <== NOT EXECUTED 2008318: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 200831c: 06 bf ff fa bl 2008304 <== NOT EXECUTED 2008320: 80 a1 00 01 cmp %g4, %g1 <== NOT EXECUTED 2008324: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED 2008328: 92 10 00 0d mov %o5, %o1 200832c: 82 13 c0 00 mov %o7, %g1 2008330: 40 00 0a 2c call 200abe0 <_Chain_Insert> 2008334: 9e 10 40 00 mov %g1, %o7 =============================================================================== 02008514 : * Output parameters: * NONE */ void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain) { 2008514: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 2008518: fa 06 20 08 ld [ %i0 + 8 ], %i5 RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( const Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Immutable_tail( the_chain )); 200851c: b0 06 20 0c add %i0, 0xc, %i0 rtems_chain_control *chain; rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 2008520: 80 a7 40 18 cmp %i5, %i0 2008524: 02 80 00 0e be 200855c <== NEVER TAKEN 2008528: b6 10 20 8c mov 0x8c, %i3 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 200852c: 40 00 09 94 call 200ab7c <_Chain_Extract> 2008530: 90 10 00 1d mov %i5, %o0 { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; node = rtems_chain_next (node); req->aiocbp->error_code = ECANCELED; 2008534: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next( Chain_Node *the_node ) { return the_node->next; 2008538: f8 07 40 00 ld [ %i5 ], %i4 req->aiocbp->return_value = -1; 200853c: 84 10 3f ff mov -1, %g2 free (req); 2008540: 90 10 00 1d mov %i5, %o0 while (!rtems_chain_is_tail (chain, node)) { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; node = rtems_chain_next (node); req->aiocbp->error_code = ECANCELED; 2008544: f6 20 60 34 st %i3, [ %g1 + 0x34 ] req->aiocbp->return_value = -1; free (req); 2008548: 7f ff ee 36 call 2003e20 200854c: c4 20 60 38 st %g2, [ %g1 + 0x38 ] rtems_chain_control *chain; rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 2008550: 80 a7 00 18 cmp %i4, %i0 2008554: 12 bf ff f6 bne 200852c 2008558: ba 10 00 1c mov %i4, %i5 200855c: 81 c7 e0 08 ret 2008560: 81 e8 00 00 restore =============================================================================== 02008564 : * AIO_NOTCANCELED - if request was not canceled * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { 2008564: 9d e3 bf a0 save %sp, -96, %sp */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 2008568: fa 06 00 00 ld [ %i0 ], %i5 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 200856c: 84 06 20 04 add %i0, 4, %g2 if (rtems_chain_is_empty (chain)) 2008570: 80 a7 40 02 cmp %i5, %g2 2008574: 12 80 00 06 bne 200858c 2008578: b0 10 20 02 mov 2, %i0 200857c: 30 80 00 12 b,a 20085c4 rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 2008580: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED 2008584: 02 80 00 12 be 20085cc <== NOT EXECUTED 2008588: 01 00 00 00 nop <== NOT EXECUTED 200858c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 2008590: 80 a0 40 19 cmp %g1, %i1 2008594: 32 bf ff fb bne,a 2008580 <== NEVER TAKEN 2008598: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED 200859c: 40 00 09 78 call 200ab7c <_Chain_Extract> 20085a0: 90 10 00 1d mov %i5, %o0 if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 20085a4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 current->aiocbp->return_value = -1; 20085a8: 84 10 3f ff mov -1, %g2 20085ac: c4 20 60 38 st %g2, [ %g1 + 0x38 ] if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 20085b0: 84 10 20 8c mov 0x8c, %g2 current->aiocbp->return_value = -1; free (current); 20085b4: 90 10 00 1d mov %i5, %o0 if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 20085b8: c4 20 60 34 st %g2, [ %g1 + 0x34 ] current->aiocbp->return_value = -1; free (current); 20085bc: 7f ff ee 19 call 2003e20 20085c0: b0 10 20 00 clr %i0 } return AIO_CANCELED; } 20085c4: 81 c7 e0 08 ret 20085c8: 81 e8 00 00 restore node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 20085cc: 81 c7 e0 08 ret <== NOT EXECUTED 20085d0: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED =============================================================================== 020089c8 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 20089c8: 9d e3 bf 98 save %sp, -104, %sp */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 20089cc: 40 00 01 aa call 2009074 <_Chain_Get> 20089d0: 90 10 00 18 mov %i0, %o0 while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 20089d4: 92 10 20 00 clr %o1 20089d8: ba 10 00 08 mov %o0, %i5 20089dc: 94 10 00 1a mov %i2, %o2 20089e0: 90 10 00 19 mov %i1, %o0 rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 20089e4: 80 a7 60 00 cmp %i5, 0 20089e8: 12 80 00 0a bne 2008a10 20089ec: 96 07 bf fc add %fp, -4, %o3 ) { rtems_event_set out; sc = rtems_event_receive( 20089f0: 7f ff fc e9 call 2007d94 20089f4: 01 00 00 00 nop ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 20089f8: 80 a2 20 00 cmp %o0, 0 20089fc: 02 bf ff f4 be 20089cc <== NEVER TAKEN 2008a00: 01 00 00 00 nop timeout, &out ); } *node_ptr = node; 2008a04: fa 26 c0 00 st %i5, [ %i3 ] return sc; } 2008a08: 81 c7 e0 08 ret 2008a0c: 91 e8 00 08 restore %g0, %o0, %o0 rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 2008a10: 90 10 20 00 clr %o0 timeout, &out ); } *node_ptr = node; 2008a14: fa 26 c0 00 st %i5, [ %i3 ] return sc; } 2008a18: 81 c7 e0 08 ret 2008a1c: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 02009950 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 2009950: 9d e3 bf a0 save %sp, -96, %sp rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) 2009954: 03 00 80 8c sethi %hi(0x2023000), %g1 2009958: c4 00 63 88 ld [ %g1 + 0x388 ], %g2 ! 2023388 <_Per_CPU_Information+0x8> rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 200995c: ba 10 00 18 mov %i0, %i5 rtems_device_major_number major_limit = _IO_Number_of_drivers; 2009960: 03 00 80 8d sethi %hi(0x2023400), %g1 rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 2009964: 86 10 00 19 mov %i1, %g3 rtems_device_major_number major_limit = _IO_Number_of_drivers; 2009968: c8 00 63 c4 ld [ %g1 + 0x3c4 ], %g4 if ( rtems_interrupt_is_in_progress() ) 200996c: 80 a0 a0 00 cmp %g2, 0 2009970: 12 80 00 20 bne 20099f0 2009974: b0 10 20 12 mov 0x12, %i0 return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 2009978: 80 a6 a0 00 cmp %i2, 0 200997c: 02 80 00 22 be 2009a04 2009980: 80 a6 60 00 cmp %i1, 0 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; if ( driver_table == NULL ) 2009984: 02 80 00 20 be 2009a04 2009988: c8 26 80 00 st %g4, [ %i2 ] static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 200998c: c4 06 40 00 ld [ %i1 ], %g2 2009990: 80 a0 a0 00 cmp %g2, 0 2009994: 22 80 00 19 be,a 20099f8 2009998: c4 06 60 04 ld [ %i1 + 4 ], %g2 return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 200999c: 80 a1 00 1d cmp %g4, %i5 20099a0: 08 80 00 14 bleu 20099f0 20099a4: b0 10 20 0a mov 0xa, %i0 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 20099a8: 05 00 80 8b sethi %hi(0x2022c00), %g2 20099ac: c8 00 a2 50 ld [ %g2 + 0x250 ], %g4 ! 2022e50 <_Thread_Dispatch_disable_level> 20099b0: 88 01 20 01 inc %g4 20099b4: c8 20 a2 50 st %g4, [ %g2 + 0x250 ] return _Thread_Dispatch_disable_level; 20099b8: c4 00 a2 50 ld [ %g2 + 0x250 ], %g2 return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 20099bc: 80 a7 60 00 cmp %i5, 0 20099c0: 02 80 00 13 be 2009a0c 20099c4: 39 00 80 8d sethi %hi(0x2023400), %i4 _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 20099c8: c8 07 23 c8 ld [ %i4 + 0x3c8 ], %g4 ! 20237c8 <_IO_Driver_address_table> 20099cc: 85 2f 60 03 sll %i5, 3, %g2 20099d0: b7 2f 60 05 sll %i5, 5, %i3 20099d4: 82 26 c0 02 sub %i3, %g2, %g1 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 20099d8: f2 01 00 01 ld [ %g4 + %g1 ], %i1 20099dc: 80 a6 60 00 cmp %i1, 0 20099e0: 02 80 00 3a be 2009ac8 20099e4: 82 01 00 01 add %g4, %g1, %g1 major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); 20099e8: 40 00 08 6a call 200bb90 <_Thread_Enable_dispatch> 20099ec: b0 10 20 0c mov 0xc, %i0 return RTEMS_RESOURCE_IN_USE; 20099f0: 81 c7 e0 08 ret 20099f4: 81 e8 00 00 restore static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 20099f8: 80 a0 a0 00 cmp %g2, 0 20099fc: 12 bf ff e9 bne 20099a0 2009a00: 80 a1 00 1d cmp %g4, %i5 if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 2009a04: 81 c7 e0 08 ret 2009a08: 91 e8 20 09 restore %g0, 9, %o0 static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 2009a0c: c8 00 63 c4 ld [ %g1 + 0x3c4 ], %g4 rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 2009a10: 80 a1 20 00 cmp %g4, 0 2009a14: 02 80 00 33 be 2009ae0 <== NEVER TAKEN 2009a18: c2 07 23 c8 ld [ %i4 + 0x3c8 ], %g1 2009a1c: 30 80 00 04 b,a 2009a2c 2009a20: 80 a7 40 04 cmp %i5, %g4 2009a24: 02 80 00 24 be 2009ab4 2009a28: 82 00 60 18 add %g1, 0x18, %g1 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 2009a2c: c4 00 40 00 ld [ %g1 ], %g2 2009a30: 80 a0 a0 00 cmp %g2, 0 2009a34: 32 bf ff fb bne,a 2009a20 2009a38: ba 07 60 01 inc %i5 2009a3c: c4 00 60 04 ld [ %g1 + 4 ], %g2 2009a40: 80 a0 a0 00 cmp %g2, 0 2009a44: 32 bf ff f7 bne,a 2009a20 2009a48: ba 07 60 01 inc %i5 if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 2009a4c: fa 26 80 00 st %i5, [ %i2 ] 2009a50: 85 2f 60 03 sll %i5, 3, %g2 if ( m != n ) 2009a54: 80 a1 00 1d cmp %g4, %i5 2009a58: 02 80 00 18 be 2009ab8 <== NEVER TAKEN 2009a5c: b7 2f 60 05 sll %i5, 5, %i3 } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 2009a60: c8 00 c0 00 ld [ %g3 ], %g4 2009a64: c2 07 23 c8 ld [ %i4 + 0x3c8 ], %g1 2009a68: 84 26 c0 02 sub %i3, %g2, %g2 2009a6c: c8 20 40 02 st %g4, [ %g1 + %g2 ] 2009a70: c8 00 e0 04 ld [ %g3 + 4 ], %g4 2009a74: 82 00 40 02 add %g1, %g2, %g1 2009a78: c8 20 60 04 st %g4, [ %g1 + 4 ] 2009a7c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 2009a80: b2 10 20 00 clr %i1 } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 2009a84: c4 20 60 08 st %g2, [ %g1 + 8 ] 2009a88: c4 00 e0 0c ld [ %g3 + 0xc ], %g2 _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 2009a8c: b4 10 20 00 clr %i2 } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 2009a90: c4 20 60 0c st %g2, [ %g1 + 0xc ] 2009a94: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2 _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 2009a98: b0 10 00 1d mov %i5, %i0 } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 2009a9c: c4 20 60 10 st %g2, [ %g1 + 0x10 ] 2009aa0: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 _Thread_Enable_dispatch(); 2009aa4: 40 00 08 3b call 200bb90 <_Thread_Enable_dispatch> 2009aa8: c4 20 60 14 st %g2, [ %g1 + 0x14 ] return rtems_io_initialize( major, 0, NULL ); 2009aac: 40 00 22 81 call 20124b0 2009ab0: 81 e8 00 00 restore if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 2009ab4: fa 26 80 00 st %i5, [ %i2 ] if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 2009ab8: 40 00 08 36 call 200bb90 <_Thread_Enable_dispatch> 2009abc: b0 10 20 05 mov 5, %i0 return sc; 2009ac0: 81 c7 e0 08 ret 2009ac4: 81 e8 00 00 restore static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 2009ac8: c2 00 60 04 ld [ %g1 + 4 ], %g1 2009acc: 80 a0 60 00 cmp %g1, 0 2009ad0: 12 bf ff c6 bne 20099e8 2009ad4: 01 00 00 00 nop if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } *registered_major = major; 2009ad8: 10 bf ff e2 b 2009a60 2009adc: fa 26 80 00 st %i5, [ %i2 ] if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 2009ae0: 10 bf ff f6 b 2009ab8 <== NOT EXECUTED 2009ae4: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED =============================================================================== 0200ab54 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 200ab54: 9d e3 bf a0 save %sp, -96, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 200ab58: 80 a6 20 00 cmp %i0, 0 200ab5c: 02 80 00 20 be 200abdc <== NEVER TAKEN 200ab60: 37 00 80 84 sethi %hi(0x2021000), %i3 200ab64: b6 16 e2 88 or %i3, 0x288, %i3 ! 2021288 <_Objects_Information_table+0x4> #endif #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) 200ab68: b4 06 e0 0c add %i3, 0xc, %i2 #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 200ab6c: c2 06 c0 00 ld [ %i3 ], %g1 200ab70: f8 00 60 04 ld [ %g1 + 4 ], %i4 if ( !information ) 200ab74: 80 a7 20 00 cmp %i4, 0 200ab78: 22 80 00 16 be,a 200abd0 200ab7c: b6 06 e0 04 add %i3, 4, %i3 continue; for ( i=1 ; i <= information->maximum ; i++ ) { 200ab80: c2 17 20 10 lduh [ %i4 + 0x10 ], %g1 200ab84: 86 90 60 00 orcc %g1, 0, %g3 200ab88: 22 80 00 12 be,a 200abd0 200ab8c: b6 06 e0 04 add %i3, 4, %i3 200ab90: ba 10 20 01 mov 1, %i5 the_thread = (Thread_Control *)information->local_table[ i ]; 200ab94: c4 07 20 1c ld [ %i4 + 0x1c ], %g2 200ab98: 83 2f 60 02 sll %i5, 2, %g1 200ab9c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 if ( !the_thread ) 200aba0: 90 90 60 00 orcc %g1, 0, %o0 200aba4: 02 80 00 05 be 200abb8 200aba8: ba 07 60 01 inc %i5 continue; (*routine)(the_thread); 200abac: 9f c6 00 00 call %i0 200abb0: 01 00 00 00 nop 200abb4: c6 17 20 10 lduh [ %i4 + 0x10 ], %g3 information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 200abb8: 83 28 e0 10 sll %g3, 0x10, %g1 200abbc: 83 30 60 10 srl %g1, 0x10, %g1 200abc0: 80 a0 40 1d cmp %g1, %i5 200abc4: 3a bf ff f5 bcc,a 200ab98 200abc8: c4 07 20 1c ld [ %i4 + 0x1c ], %g2 200abcc: b6 06 e0 04 add %i3, 4, %i3 Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 200abd0: 80 a6 c0 1a cmp %i3, %i2 200abd4: 32 bf ff e7 bne,a 200ab70 200abd8: c2 06 c0 00 ld [ %i3 ], %g1 200abdc: 81 c7 e0 08 ret 200abe0: 81 e8 00 00 restore =============================================================================== 02009778 : rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) { 2009778: 9d e3 bf a0 save %sp, -96, %sp int i; /* * Validate parameters and look up information structure. */ if ( !info ) 200977c: 80 a6 a0 00 cmp %i2, 0 2009780: 02 80 00 21 be 2009804 2009784: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 2009788: 93 2e 60 10 sll %i1, 0x10, %o1 200978c: 90 10 00 18 mov %i0, %o0 2009790: 40 00 07 a7 call 200b62c <_Objects_Get_information> 2009794: 93 32 60 10 srl %o1, 0x10, %o1 if ( !obj_info ) 2009798: 80 a2 20 00 cmp %o0, 0 200979c: 02 80 00 1a be 2009804 20097a0: 82 10 20 0a mov 0xa, %g1 * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; 20097a4: c8 12 20 10 lduh [ %o0 + 0x10 ], %g4 return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 20097a8: c6 02 20 08 ld [ %o0 + 8 ], %g3 info->maximum_id = obj_info->maximum_id; 20097ac: c4 02 20 0c ld [ %o0 + 0xc ], %g2 info->auto_extend = obj_info->auto_extend; 20097b0: c2 0a 20 12 ldub [ %o0 + 0x12 ], %g1 return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 20097b4: c6 26 80 00 st %g3, [ %i2 ] info->maximum_id = obj_info->maximum_id; 20097b8: c4 26 a0 04 st %g2, [ %i2 + 4 ] info->auto_extend = obj_info->auto_extend; 20097bc: c2 2e a0 0c stb %g1, [ %i2 + 0xc ] info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 20097c0: 80 a1 20 00 cmp %g4, 0 20097c4: 02 80 00 12 be 200980c <== NEVER TAKEN 20097c8: c8 26 a0 08 st %g4, [ %i2 + 8 ] 20097cc: fa 02 20 1c ld [ %o0 + 0x1c ], %i5 20097d0: 86 10 20 01 mov 1, %g3 20097d4: 82 10 20 01 mov 1, %g1 20097d8: 84 10 20 00 clr %g2 if ( !obj_info->local_table[i] ) 20097dc: 87 28 e0 02 sll %g3, 2, %g3 20097e0: c6 07 40 03 ld [ %i5 + %g3 ], %g3 info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 20097e4: 82 00 60 01 inc %g1 if ( !obj_info->local_table[i] ) unallocated++; 20097e8: 80 a0 00 03 cmp %g0, %g3 20097ec: 84 60 bf ff subx %g2, -1, %g2 info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 20097f0: 80 a1 00 01 cmp %g4, %g1 20097f4: 1a bf ff fa bcc 20097dc 20097f8: 86 10 00 01 mov %g1, %g3 if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 20097fc: c4 26 a0 10 st %g2, [ %i2 + 0x10 ] return RTEMS_SUCCESSFUL; 2009800: 82 10 20 00 clr %g1 } 2009804: 81 c7 e0 08 ret 2009808: 91 e8 00 01 restore %g0, %g1, %o0 info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 200980c: 84 10 20 00 clr %g2 <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; 2009810: 82 10 20 00 clr %g1 <== NOT EXECUTED for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 2009814: 10 bf ff fc b 2009804 <== NOT EXECUTED 2009818: c4 26 a0 10 st %g2, [ %i2 + 0x10 ] <== NOT EXECUTED =============================================================================== 02009238 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 2009238: 9d e3 bf a0 save %sp, -96, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 200923c: 80 a6 20 00 cmp %i0, 0 2009240: 12 80 00 04 bne 2009250 2009244: 82 10 20 03 mov 3, %g1 ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 2009248: 81 c7 e0 08 ret 200924c: 91 e8 00 01 restore %g0, %g1, %o0 register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) 2009250: 80 a6 60 00 cmp %i1, 0 2009254: 02 bf ff fd be 2009248 2009258: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; if ( !id ) 200925c: 80 a7 60 00 cmp %i5, 0 2009260: 02 bf ff fa be 2009248 <== NEVER TAKEN 2009264: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 2009268: 02 bf ff f8 be 2009248 200926c: 82 10 20 08 mov 8, %g1 2009270: 80 a6 a0 00 cmp %i2, 0 2009274: 02 bf ff f5 be 2009248 2009278: 80 a6 80 1b cmp %i2, %i3 200927c: 0a bf ff f3 bcs 2009248 2009280: 80 8e e0 07 btst 7, %i3 2009284: 12 bf ff f1 bne 2009248 2009288: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 200928c: 12 bf ff ef bne 2009248 2009290: 82 10 20 09 mov 9, %g1 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2009294: 03 00 80 8c sethi %hi(0x2023000), %g1 2009298: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20233a0 <_Thread_Dispatch_disable_level> 200929c: 84 00 a0 01 inc %g2 20092a0: c4 20 63 a0 st %g2, [ %g1 + 0x3a0 ] return _Thread_Dispatch_disable_level; 20092a4: c2 00 63 a0 ld [ %g1 + 0x3a0 ], %g1 * This function allocates a partition control block from * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 20092a8: 23 00 80 8c sethi %hi(0x2023000), %l1 20092ac: 40 00 07 58 call 200b00c <_Objects_Allocate> 20092b0: 90 14 61 9c or %l1, 0x19c, %o0 ! 202319c <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 20092b4: a0 92 20 00 orcc %o0, 0, %l0 20092b8: 02 80 00 1a be 2009320 20092bc: 92 10 00 1b mov %i3, %o1 #endif the_partition->starting_address = starting_address; the_partition->length = length; the_partition->buffer_size = buffer_size; the_partition->attribute_set = attribute_set; 20092c0: f8 24 20 1c st %i4, [ %l0 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 20092c4: f2 24 20 10 st %i1, [ %l0 + 0x10 ] the_partition->length = length; 20092c8: f4 24 20 14 st %i2, [ %l0 + 0x14 ] the_partition->buffer_size = buffer_size; 20092cc: f6 24 20 18 st %i3, [ %l0 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 20092d0: c0 24 20 20 clr [ %l0 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, length / buffer_size, buffer_size ); 20092d4: 40 00 48 b0 call 201b594 <.udiv> 20092d8: 90 10 00 1a mov %i2, %o0 the_partition->length = length; the_partition->buffer_size = buffer_size; the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; _Chain_Initialize( &the_partition->Memory, starting_address, 20092dc: 92 10 00 19 mov %i1, %o1 length / buffer_size, buffer_size ); 20092e0: 94 10 00 08 mov %o0, %o2 the_partition->length = length; the_partition->buffer_size = buffer_size; the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; _Chain_Initialize( &the_partition->Memory, starting_address, 20092e4: 96 10 00 1b mov %i3, %o3 20092e8: b8 04 20 24 add %l0, 0x24, %i4 20092ec: 40 00 04 8d call 200a520 <_Chain_Initialize> 20092f0: 90 10 00 1c mov %i4, %o0 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 20092f4: c4 14 20 0a lduh [ %l0 + 0xa ], %g2 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 20092f8: a2 14 61 9c or %l1, 0x19c, %l1 20092fc: c6 04 60 1c ld [ %l1 + 0x1c ], %g3 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 2009300: c2 04 20 08 ld [ %l0 + 8 ], %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2009304: 85 28 a0 02 sll %g2, 2, %g2 2009308: e0 20 c0 02 st %l0, [ %g3 + %g2 ] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 200930c: f0 24 20 0c st %i0, [ %l0 + 0xc ] name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2009310: 40 00 0c a7 call 200c5ac <_Thread_Enable_dispatch> 2009314: c2 27 40 00 st %g1, [ %i5 ] return RTEMS_SUCCESSFUL; 2009318: 10 bf ff cc b 2009248 200931c: 82 10 20 00 clr %g1 _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { _Thread_Enable_dispatch(); 2009320: 40 00 0c a3 call 200c5ac <_Thread_Enable_dispatch> 2009324: 01 00 00 00 nop return RTEMS_TOO_MANY; 2009328: 10 bf ff c8 b 2009248 200932c: 82 10 20 05 mov 5, %g1 ! 5 =============================================================================== 0201593c : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 201593c: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 2015940: 11 00 80 f2 sethi %hi(0x203c800), %o0 2015944: 92 10 00 18 mov %i0, %o1 2015948: 90 12 23 24 or %o0, 0x324, %o0 201594c: 40 00 15 13 call 201ad98 <_Objects_Get> 2015950: 94 07 bf fc add %fp, -4, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 2015954: c2 07 bf fc ld [ %fp + -4 ], %g1 2015958: 80 a0 60 00 cmp %g1, 0 201595c: 12 80 00 19 bne 20159c0 2015960: ba 10 00 08 mov %o0, %i5 ) { void *starting; void *ending; starting = the_partition->starting_address; 2015964: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 2015968: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 201596c: 82 02 00 01 add %o0, %g1, %g1 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 2015970: 80 a6 40 01 cmp %i1, %g1 2015974: 18 80 00 15 bgu 20159c8 <== NEVER TAKEN 2015978: 80 a6 40 08 cmp %i1, %o0 201597c: 0a 80 00 13 bcs 20159c8 2015980: 01 00 00 00 nop offset = (uint32_t) _Addresses_Subtract( the_buffer, the_partition->starting_address ); return ((offset % the_partition->buffer_size) == 0); 2015984: d2 07 60 18 ld [ %i5 + 0x18 ], %o1 2015988: 40 00 5b 17 call 202c5e4 <.urem> 201598c: 90 26 40 08 sub %i1, %o0, %o0 starting = the_partition->starting_address; ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 2015990: 80 a2 20 00 cmp %o0, 0 2015994: 12 80 00 0d bne 20159c8 2015998: 90 07 60 24 add %i5, 0x24, %o0 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 201599c: 40 00 0c fa call 2018d84 <_Chain_Append> 20159a0: 92 10 00 19 mov %i1, %o1 case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 20159a4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 20159a8: b0 10 20 00 clr %i0 switch ( location ) { case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 20159ac: 82 00 7f ff add %g1, -1, %g1 _Thread_Enable_dispatch(); 20159b0: 40 00 19 04 call 201bdc0 <_Thread_Enable_dispatch> 20159b4: c2 27 60 20 st %g1, [ %i5 + 0x20 ] 20159b8: 81 c7 e0 08 ret 20159bc: 81 e8 00 00 restore case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 20159c0: 81 c7 e0 08 ret 20159c4: 91 e8 20 04 restore %g0, 4, %o0 _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 20159c8: 40 00 18 fe call 201bdc0 <_Thread_Enable_dispatch> 20159cc: b0 10 20 09 mov 9, %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 20159d0: 81 c7 e0 08 ret 20159d4: 81 e8 00 00 restore =============================================================================== 02045634 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 2045634: 9d e3 bf 98 save %sp, -104, %sp 2045638: 11 00 81 da sethi %hi(0x2076800), %o0 204563c: 92 10 00 18 mov %i0, %o1 2045640: 90 12 21 30 or %o0, 0x130, %o0 2045644: 7f ff 2a 54 call 200ff94 <_Objects_Get> 2045648: 94 07 bf fc add %fp, -4, %o2 rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 204564c: c2 07 bf fc ld [ %fp + -4 ], %g1 2045650: 80 a0 60 00 cmp %g1, 0 2045654: 12 80 00 0d bne 2045688 2045658: ba 10 00 08 mov %o0, %i5 case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 204565c: c4 02 20 40 ld [ %o0 + 0x40 ], %g2 2045660: 39 00 81 d8 sethi %hi(0x2076000), %i4 2045664: b8 17 22 c0 or %i4, 0x2c0, %i4 ! 20762c0 <_Per_CPU_Information> 2045668: c2 07 20 0c ld [ %i4 + 0xc ], %g1 204566c: 80 a0 80 01 cmp %g2, %g1 2045670: 02 80 00 08 be 2045690 2045674: 80 a6 60 00 cmp %i1, 0 _Thread_Enable_dispatch(); 2045678: 7f ff 2e 31 call 2010f3c <_Thread_Enable_dispatch> 204567c: b0 10 20 17 mov 0x17, %i0 2045680: 81 c7 e0 08 ret 2045684: 81 e8 00 00 restore case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2045688: 81 c7 e0 08 ret 204568c: 91 e8 20 04 restore %g0, 4, %o0 if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 2045690: 12 80 00 0e bne 20456c8 2045694: 01 00 00 00 nop switch ( the_period->state ) { 2045698: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 204569c: 80 a0 60 04 cmp %g1, 4 20456a0: 18 80 00 06 bgu 20456b8 <== NEVER TAKEN 20456a4: b0 10 20 00 clr %i0 20456a8: 83 28 60 02 sll %g1, 2, %g1 20456ac: 05 00 81 bf sethi %hi(0x206fc00), %g2 20456b0: 84 10 a0 c4 or %g2, 0xc4, %g2 ! 206fcc4 20456b4: f0 00 80 01 ld [ %g2 + %g1 ], %i0 id, NULL ); _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 20456b8: 7f ff 2e 21 call 2010f3c <_Thread_Enable_dispatch> 20456bc: 01 00 00 00 nop 20456c0: 81 c7 e0 08 ret 20456c4: 81 e8 00 00 restore } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 20456c8: 7f fe fa d4 call 2004218 20456cc: 01 00 00 00 nop 20456d0: b4 10 00 08 mov %o0, %i2 if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 20456d4: f6 07 60 38 ld [ %i5 + 0x38 ], %i3 20456d8: 80 a6 e0 00 cmp %i3, 0 20456dc: 02 80 00 1c be 204574c 20456e0: 80 a6 e0 02 cmp %i3, 2 _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 20456e4: 02 80 00 2e be 204579c 20456e8: 80 a6 e0 04 cmp %i3, 4 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 20456ec: 12 bf ff e5 bne 2045680 <== NEVER TAKEN 20456f0: b0 10 20 04 mov 4, %i0 /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 20456f4: 7f ff ff 60 call 2045474 <_Rate_monotonic_Update_statistics> 20456f8: 90 10 00 1d mov %i5, %o0 _ISR_Enable( level ); 20456fc: 7f fe fa cb call 2004228 2045700: 90 10 00 1a mov %i2, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 2045704: 82 10 20 02 mov 2, %g1 2045708: 92 07 60 10 add %i5, 0x10, %o1 204570c: c2 27 60 38 st %g1, [ %i5 + 0x38 ] the_period->next_length = length; 2045710: f2 27 60 3c st %i1, [ %i5 + 0x3c ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2045714: f2 27 60 1c st %i1, [ %i5 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2045718: 11 00 81 d7 sethi %hi(0x2075c00), %o0 204571c: 7f ff 31 8a call 2011d44 <_Watchdog_Insert> 2045720: 90 12 22 38 or %o0, 0x238, %o0 ! 2075e38 <_Watchdog_Ticks_chain> 2045724: d0 07 60 40 ld [ %i5 + 0x40 ], %o0 2045728: d2 07 60 3c ld [ %i5 + 0x3c ], %o1 204572c: 03 00 81 c6 sethi %hi(0x2071800), %g1 2045730: c2 00 62 5c ld [ %g1 + 0x25c ], %g1 ! 2071a5c <_Scheduler+0x34> 2045734: 9f c0 40 00 call %g1 2045738: b0 10 20 06 mov 6, %i0 _Watchdog_Insert_ticks( &the_period->Timer, length ); _Scheduler_Release_job(the_period->owner, the_period->next_length); _Thread_Enable_dispatch(); 204573c: 7f ff 2e 00 call 2010f3c <_Thread_Enable_dispatch> 2045740: 01 00 00 00 nop 2045744: 81 c7 e0 08 ret 2045748: 81 e8 00 00 restore return( return_value ); } _ISR_Disable( level ); if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { _ISR_Enable( level ); 204574c: 7f fe fa b7 call 2004228 2045750: 01 00 00 00 nop the_period->next_length = length; /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 2045754: 90 10 00 1d mov %i5, %o0 2045758: 7f ff ff 96 call 20455b0 <_Rate_monotonic_Initiate_statistics> 204575c: f2 27 60 3c st %i1, [ %i5 + 0x3c ] the_period->state = RATE_MONOTONIC_ACTIVE; 2045760: 82 10 20 02 mov 2, %g1 2045764: c2 27 60 38 st %g1, [ %i5 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2045768: 03 00 81 16 sethi %hi(0x2045800), %g1 204576c: 82 10 60 10 or %g1, 0x10, %g1 ! 2045810 <_Rate_monotonic_Timeout> the_watchdog->id = id; 2045770: f0 27 60 30 st %i0, [ %i5 + 0x30 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2045774: 92 07 60 10 add %i5, 0x10, %o1 2045778: 11 00 81 d7 sethi %hi(0x2075c00), %o0 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 204577c: c0 27 60 18 clr [ %i5 + 0x18 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2045780: 90 12 22 38 or %o0, 0x238, %o0 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2045784: c0 27 60 34 clr [ %i5 + 0x34 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2045788: c2 27 60 2c st %g1, [ %i5 + 0x2c ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 204578c: f2 27 60 1c st %i1, [ %i5 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2045790: 7f ff 31 6d call 2011d44 <_Watchdog_Insert> 2045794: b0 10 20 00 clr %i0 2045798: 30 bf ff c8 b,a 20456b8 if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 204579c: 7f ff ff 36 call 2045474 <_Rate_monotonic_Update_statistics> 20457a0: 90 10 00 1d mov %i5, %o0 /* * This tells the _Rate_monotonic_Timeout that this task is * in the process of blocking on the period and that we * may be changing the length of the next period. */ the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; 20457a4: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 20457a8: f2 27 60 3c st %i1, [ %i5 + 0x3c ] /* * This tells the _Rate_monotonic_Timeout that this task is * in the process of blocking on the period and that we * may be changing the length of the next period. */ the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; 20457ac: c2 27 60 38 st %g1, [ %i5 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 20457b0: 7f fe fa 9e call 2004228 20457b4: 90 10 00 1a mov %i2, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 20457b8: c2 07 20 0c ld [ %i4 + 0xc ], %g1 20457bc: c4 07 60 08 ld [ %i5 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 20457c0: 90 10 00 01 mov %g1, %o0 20457c4: 13 00 00 10 sethi %hi(0x4000), %o1 20457c8: 7f ff 30 3d call 20118bc <_Thread_Set_state> 20457cc: c4 20 60 20 st %g2, [ %g1 + 0x20 ] /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 20457d0: 7f fe fa 92 call 2004218 20457d4: 01 00 00 00 nop local_state = the_period->state; 20457d8: f4 07 60 38 ld [ %i5 + 0x38 ], %i2 the_period->state = RATE_MONOTONIC_ACTIVE; 20457dc: f6 27 60 38 st %i3, [ %i5 + 0x38 ] _ISR_Enable( level ); 20457e0: 7f fe fa 92 call 2004228 20457e4: 01 00 00 00 nop /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) 20457e8: 80 a6 a0 03 cmp %i2, 3 20457ec: 22 80 00 06 be,a 2045804 20457f0: d0 07 20 0c ld [ %i4 + 0xc ], %o0 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); _Thread_Enable_dispatch(); 20457f4: 7f ff 2d d2 call 2010f3c <_Thread_Enable_dispatch> 20457f8: b0 10 20 00 clr %i0 20457fc: 81 c7 e0 08 ret 2045800: 81 e8 00 00 restore /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2045804: 7f ff 2c db call 2010b70 <_Thread_Clear_state> 2045808: 13 00 00 10 sethi %hi(0x4000), %o1 204580c: 30 bf ff fa b,a 20457f4 =============================================================================== 0202e7c0 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 202e7c0: 9d e3 bf 38 save %sp, -200, %sp rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 202e7c4: 80 a6 60 00 cmp %i1, 0 202e7c8: 02 80 00 48 be 202e8e8 <== NEVER TAKEN 202e7cc: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 202e7d0: 13 00 81 ab sethi %hi(0x206ac00), %o1 202e7d4: 9f c6 40 00 call %i1 202e7d8: 92 12 61 00 or %o1, 0x100, %o1 ! 206ad00 <_TOD_Days_per_month+0x68> #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 202e7dc: 90 10 00 18 mov %i0, %o0 202e7e0: 13 00 81 ab sethi %hi(0x206ac00), %o1 202e7e4: 9f c6 40 00 call %i1 202e7e8: 92 12 61 20 or %o1, 0x120, %o1 ! 206ad20 <_TOD_Days_per_month+0x88> (*print)( context, "--- Wall times are in seconds ---\n" ); 202e7ec: 90 10 00 18 mov %i0, %o0 202e7f0: 13 00 81 ab sethi %hi(0x206ac00), %o1 202e7f4: 9f c6 40 00 call %i1 202e7f8: 92 12 61 48 or %o1, 0x148, %o1 ! 206ad48 <_TOD_Days_per_month+0xb0> Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 202e7fc: 90 10 00 18 mov %i0, %o0 202e800: 13 00 81 ab sethi %hi(0x206ac00), %o1 202e804: 9f c6 40 00 call %i1 202e808: 92 12 61 70 or %o1, 0x170, %o1 ! 206ad70 <_TOD_Days_per_month+0xd8> #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 202e80c: 90 10 00 18 mov %i0, %o0 202e810: 13 00 81 ab sethi %hi(0x206ac00), %o1 202e814: 9f c6 40 00 call %i1 202e818: 92 12 61 c0 or %o1, 0x1c0, %o1 ! 206adc0 <_TOD_Days_per_month+0x128> /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 202e81c: 39 00 81 da sethi %hi(0x2076800), %i4 202e820: b8 17 21 30 or %i4, 0x130, %i4 ! 2076930 <_Rate_monotonic_Information> 202e824: fa 07 20 08 ld [ %i4 + 8 ], %i5 202e828: c2 07 20 0c ld [ %i4 + 0xc ], %g1 202e82c: 80 a7 40 01 cmp %i5, %g1 202e830: 18 80 00 2e bgu 202e8e8 <== NEVER TAKEN 202e834: 35 00 81 ab sethi %hi(0x206ac00), %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 ); (*print)( context, 202e838: 27 00 81 ab sethi %hi(0x206ac00), %l3 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); (*print)( context, 202e83c: 25 00 81 ab sethi %hi(0x206ac00), %l2 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 202e840: 37 00 81 b0 sethi %hi(0x206c000), %i3 rtems_object_get_name( the_status.owner, sizeof(name), name ); /* * Print part of report line that is not dependent on granularity */ (*print)( context, 202e844: b4 16 a2 10 or %i2, 0x210, %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 ); (*print)( context, 202e848: a6 14 e2 28 or %l3, 0x228, %l3 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); (*print)( context, 202e84c: a4 14 a2 48 or %l2, 0x248, %l2 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 202e850: 10 80 00 06 b 202e868 202e854: b6 16 e2 e8 or %i3, 0x2e8, %i3 * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 202e858: ba 07 60 01 inc %i5 /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 202e85c: 80 a0 40 1d cmp %g1, %i5 202e860: 0a 80 00 22 bcs 202e8e8 202e864: 01 00 00 00 nop id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 202e868: 90 10 00 1d mov %i5, %o0 202e86c: 40 00 5a 20 call 20450ec 202e870: 92 07 bf c8 add %fp, -56, %o1 if ( status != RTEMS_SUCCESSFUL ) 202e874: 80 a2 20 00 cmp %o0, 0 202e878: 32 bf ff f8 bne,a 202e858 202e87c: c2 07 20 0c ld [ %i4 + 0xc ], %g1 #if defined(RTEMS_DEBUG) status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; #else (void) rtems_rate_monotonic_get_status( id, &the_status ); 202e880: 92 07 bf b0 add %fp, -80, %o1 202e884: 40 00 5a 8c call 20452b4 202e888: 90 10 00 1d mov %i5, %o0 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 202e88c: d0 07 bf b0 ld [ %fp + -80 ], %o0 202e890: 94 07 bf a0 add %fp, -96, %o2 202e894: 7f ff 7d 03 call 200dca0 202e898: 92 10 20 05 mov 5, %o1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 202e89c: d8 1f bf c8 ldd [ %fp + -56 ], %o4 202e8a0: 92 10 00 1a mov %i2, %o1 202e8a4: 94 10 00 1d mov %i5, %o2 202e8a8: 90 10 00 18 mov %i0, %o0 202e8ac: 9f c6 40 00 call %i1 202e8b0: 96 07 bf a0 add %fp, -96, %o3 ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 202e8b4: c2 07 bf c8 ld [ %fp + -56 ], %g1 struct timespec cpu_average; 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 ); 202e8b8: 94 07 bf a8 add %fp, -88, %o2 202e8bc: 90 07 bf e0 add %fp, -32, %o0 ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 202e8c0: 80 a0 60 00 cmp %g1, 0 202e8c4: 12 80 00 0b bne 202e8f0 202e8c8: 92 10 00 1b mov %i3, %o1 (*print)( context, "\n" ); 202e8cc: 9f c6 40 00 call %i1 202e8d0: 90 10 00 18 mov %i0, %o0 /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 202e8d4: c2 07 20 0c ld [ %i4 + 0xc ], %g1 id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 202e8d8: ba 07 60 01 inc %i5 /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 202e8dc: 80 a0 40 1d cmp %g1, %i5 202e8e0: 1a bf ff e3 bcc 202e86c <== ALWAYS TAKEN 202e8e4: 90 10 00 1d mov %i5, %o0 202e8e8: 81 c7 e0 08 ret 202e8ec: 81 e8 00 00 restore struct timespec cpu_average; 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 ); 202e8f0: 40 00 05 68 call 202fe90 <_Timespec_Divide_by_integer> 202e8f4: 92 10 00 01 mov %g1, %o1 (*print)( context, 202e8f8: d0 07 bf d4 ld [ %fp + -44 ], %o0 202e8fc: 40 00 cc ea call 2061ca4 <.div> 202e900: 92 10 23 e8 mov 0x3e8, %o1 202e904: aa 10 00 08 mov %o0, %l5 202e908: d0 07 bf dc ld [ %fp + -36 ], %o0 202e90c: 40 00 cc e6 call 2061ca4 <.div> 202e910: 92 10 23 e8 mov 0x3e8, %o1 202e914: c2 07 bf a8 ld [ %fp + -88 ], %g1 202e918: a2 10 00 08 mov %o0, %l1 202e91c: d0 07 bf ac ld [ %fp + -84 ], %o0 202e920: e0 07 bf d0 ld [ %fp + -48 ], %l0 202e924: e8 07 bf d8 ld [ %fp + -40 ], %l4 202e928: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 202e92c: 40 00 cc de call 2061ca4 <.div> 202e930: 92 10 23 e8 mov 0x3e8, %o1 202e934: 96 10 00 15 mov %l5, %o3 202e938: 98 10 00 14 mov %l4, %o4 202e93c: 9a 10 00 11 mov %l1, %o5 202e940: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 202e944: 92 10 00 13 mov %l3, %o1 202e948: 94 10 00 10 mov %l0, %o2 202e94c: 9f c6 40 00 call %i1 202e950: 90 10 00 18 mov %i0, %o0 struct timespec wall_average; 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); 202e954: d2 07 bf c8 ld [ %fp + -56 ], %o1 202e958: 94 07 bf a8 add %fp, -88, %o2 202e95c: 40 00 05 4d call 202fe90 <_Timespec_Divide_by_integer> 202e960: 90 07 bf f8 add %fp, -8, %o0 (*print)( context, 202e964: d0 07 bf ec ld [ %fp + -20 ], %o0 202e968: 40 00 cc cf call 2061ca4 <.div> 202e96c: 92 10 23 e8 mov 0x3e8, %o1 202e970: a8 10 00 08 mov %o0, %l4 202e974: d0 07 bf f4 ld [ %fp + -12 ], %o0 202e978: 40 00 cc cb call 2061ca4 <.div> 202e97c: 92 10 23 e8 mov 0x3e8, %o1 202e980: c2 07 bf a8 ld [ %fp + -88 ], %g1 202e984: a0 10 00 08 mov %o0, %l0 202e988: d0 07 bf ac ld [ %fp + -84 ], %o0 202e98c: ea 07 bf e8 ld [ %fp + -24 ], %l5 202e990: e2 07 bf f0 ld [ %fp + -16 ], %l1 202e994: 92 10 23 e8 mov 0x3e8, %o1 202e998: 40 00 cc c3 call 2061ca4 <.div> 202e99c: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 202e9a0: 92 10 00 12 mov %l2, %o1 202e9a4: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 202e9a8: 94 10 00 15 mov %l5, %o2 202e9ac: 90 10 00 18 mov %i0, %o0 202e9b0: 96 10 00 14 mov %l4, %o3 202e9b4: 98 10 00 11 mov %l1, %o4 202e9b8: 9f c6 40 00 call %i1 202e9bc: 9a 10 00 10 mov %l0, %o5 /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 202e9c0: 10 bf ff a6 b 202e858 202e9c4: c2 07 20 0c ld [ %i4 + 0xc ], %g1 =============================================================================== 0202e9e0 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 202e9e0: 9d e3 bf a0 save %sp, -96, %sp * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 202e9e4: 03 00 81 d7 sethi %hi(0x2075c00), %g1 202e9e8: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 2075d90 <_Thread_Dispatch_disable_level> 202e9ec: 84 00 a0 01 inc %g2 202e9f0: c4 20 61 90 st %g2, [ %g1 + 0x190 ] return _Thread_Dispatch_disable_level; 202e9f4: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 202e9f8: 39 00 81 da sethi %hi(0x2076800), %i4 202e9fc: b8 17 21 30 or %i4, 0x130, %i4 ! 2076930 <_Rate_monotonic_Information> 202ea00: fa 07 20 08 ld [ %i4 + 8 ], %i5 202ea04: c2 07 20 0c ld [ %i4 + 0xc ], %g1 202ea08: 80 a7 40 01 cmp %i5, %g1 202ea0c: 18 80 00 09 bgu 202ea30 <== NEVER TAKEN 202ea10: 01 00 00 00 nop id <= _Rate_monotonic_Information.maximum_id ; id++ ) { (void) rtems_rate_monotonic_reset_statistics( id ); 202ea14: 40 00 00 09 call 202ea38 202ea18: 90 10 00 1d mov %i5, %o0 /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 202ea1c: c2 07 20 0c ld [ %i4 + 0xc ], %g1 id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 202ea20: ba 07 60 01 inc %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. */ for ( id=_Rate_monotonic_Information.minimum_id ; 202ea24: 80 a0 40 1d cmp %g1, %i5 202ea28: 1a bf ff fb bcc 202ea14 202ea2c: 01 00 00 00 nop } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 202ea30: 7f ff 89 43 call 2010f3c <_Thread_Enable_dispatch> 202ea34: 81 e8 00 00 restore =============================================================================== 02008fe0 : return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { 2008fe0: 9d e3 bf a0 save %sp, -96, %sp void *ptr = NULL; rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; 2008fe4: fa 06 20 30 ld [ %i0 + 0x30 ], %i5 #include static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 2008fe8: 90 10 00 19 mov %i1, %o0 2008fec: 40 00 47 3b call 201acd8 <.urem> 2008ff0: 92 10 00 1d mov %i5, %o1 if (excess > 0) { 2008ff4: 80 a2 20 00 cmp %o0, 0 2008ff8: 02 80 00 26 be 2009090 <== ALWAYS TAKEN 2008ffc: b6 10 00 19 mov %i1, %i3 value += alignment - excess; 2009000: ba 06 40 1d add %i1, %i5, %i5 <== NOT EXECUTED 2009004: b6 27 40 08 sub %i5, %o0, %i3 <== NOT EXECUTED 2009008: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED 200900c: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { 2009010: 80 88 60 ff btst 0xff, %g1 2009014: 02 80 00 1d be 2009088 <== NEVER TAKEN 2009018: 80 a6 60 00 cmp %i1, 0 200901c: 02 80 00 1b be 2009088 2009020: 82 06 20 04 add %i0, 4, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 2009024: fa 06 00 00 ld [ %i0 ], %i5 { rtems_chain_node *current = rtems_chain_first(free_chain); const rtems_chain_node *tail = rtems_chain_tail(free_chain); rtems_rbheap_chunk *big_enough = NULL; while (current != tail && big_enough == NULL) { 2009028: 80 a7 40 01 cmp %i5, %g1 200902c: 02 80 00 17 be 2009088 2009030: 01 00 00 00 nop rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current; if (free_chunk->size >= size) { 2009034: f8 07 60 1c ld [ %i5 + 0x1c ], %i4 2009038: 80 a6 c0 1c cmp %i3, %i4 200903c: 38 80 00 10 bgu,a 200907c 2009040: fa 07 40 00 ld [ %i5 ], %i5 uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size); if (free_chunk != NULL) { 2009044: 80 a7 60 00 cmp %i5, 0 2009048: 02 80 00 10 be 2009088 <== NEVER TAKEN 200904c: 80 a7 00 1b cmp %i4, %i3 uintptr_t free_size = free_chunk->size; if (free_size > aligned_size) { 2009050: 18 80 00 12 bgu 2009098 2009054: 01 00 00 00 nop ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 2009058: c4 07 40 00 ld [ %i5 ], %g2 previous = the_node->previous; 200905c: c2 07 60 04 ld [ %i5 + 4 ], %g1 ptr = (void *) new_chunk->begin; } } else { rtems_chain_extract_unprotected(&free_chunk->chain_node); rtems_chain_set_off_chain(&free_chunk->chain_node); ptr = (void *) free_chunk->begin; 2009060: f0 07 60 18 ld [ %i5 + 0x18 ], %i0 next->previous = previous; 2009064: c2 20 a0 04 st %g1, [ %g2 + 4 ] previous->next = next; 2009068: c4 20 40 00 st %g2, [ %g1 ] */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 200906c: c0 27 60 04 clr [ %i5 + 4 ] 2009070: c0 27 40 00 clr [ %i5 ] } } } return ptr; } 2009074: 81 c7 e0 08 ret 2009078: 81 e8 00 00 restore { rtems_chain_node *current = rtems_chain_first(free_chain); const rtems_chain_node *tail = rtems_chain_tail(free_chain); rtems_rbheap_chunk *big_enough = NULL; while (current != tail && big_enough == NULL) { 200907c: 80 a0 40 1d cmp %g1, %i5 2009080: 32 bf ff ee bne,a 2009038 <== NEVER TAKEN 2009084: f8 07 60 1c ld [ %i5 + 0x1c ], %i4 <== NOT EXECUTED return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; 2009088: 81 c7 e0 08 ret 200908c: 91 e8 20 00 restore %g0, 0, %o0 static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; if (excess > 0) { 2009090: 10 bf ff e0 b 2009010 2009094: 82 10 20 01 mov 1, %g1 if (free_chunk != NULL) { uintptr_t free_size = free_chunk->size; if (free_size > aligned_size) { rtems_rbheap_chunk *new_chunk = get_chunk(control); 2009098: 7f ff ff 46 call 2008db0 200909c: 90 10 00 18 mov %i0, %o0 if (new_chunk != NULL) { 20090a0: b4 92 20 00 orcc %o0, 0, %i2 20090a4: 02 bf ff f9 be 2009088 <== NEVER TAKEN 20090a8: b8 27 00 1b sub %i4, %i3, %i4 uintptr_t new_free_size = free_size - aligned_size; free_chunk->size = new_free_size; new_chunk->begin = free_chunk->begin + new_free_size; 20090ac: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 rtems_rbheap_chunk *new_chunk = get_chunk(control); if (new_chunk != NULL) { uintptr_t new_free_size = free_size - aligned_size; free_chunk->size = new_free_size; 20090b0: f8 27 60 1c st %i4, [ %i5 + 0x1c ] new_chunk->begin = free_chunk->begin + new_free_size; new_chunk->size = aligned_size; 20090b4: f6 26 a0 1c st %i3, [ %i2 + 0x1c ] if (new_chunk != NULL) { uintptr_t new_free_size = free_size - aligned_size; free_chunk->size = new_free_size; new_chunk->begin = free_chunk->begin + new_free_size; 20090b8: b8 07 00 01 add %i4, %g1, %i4 20090bc: c0 26 a0 04 clr [ %i2 + 4 ] 20090c0: f8 26 a0 18 st %i4, [ %i2 + 0x18 ] 20090c4: c0 26 80 00 clr [ %i2 ] static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 20090c8: 90 06 20 18 add %i0, 0x18, %o0 20090cc: 40 00 07 0f call 200ad08 <_RBTree_Insert_unprotected> 20090d0: 92 06 a0 08 add %i2, 8, %o1 free_chunk->size = new_free_size; new_chunk->begin = free_chunk->begin + new_free_size; new_chunk->size = aligned_size; rtems_chain_set_off_chain(&new_chunk->chain_node); insert_into_tree(chunk_tree, new_chunk); ptr = (void *) new_chunk->begin; 20090d4: f0 06 a0 18 ld [ %i2 + 0x18 ], %i0 20090d8: 81 c7 e0 08 ret 20090dc: 81 e8 00 00 restore =============================================================================== 02009224 : /* Do nothing */ } void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control) { 2009224: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk)); 2009228: 7f ff ec 86 call 2004440 <== NOT EXECUTED 200922c: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED if (chunk != NULL) { 2009230: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2009234: 02 80 00 07 be 2009250 <== NOT EXECUTED 2009238: 84 06 20 0c add %i0, 0xc, %g2 <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 200923c: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED after_node->next = the_node; 2009240: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 2009244: c4 22 20 04 st %g2, [ %o0 + 4 ] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 2009248: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED before_node->previous = the_node; 200924c: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED 2009250: 81 c7 e0 08 ret <== NOT EXECUTED 2009254: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 020090e0 : _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { 20090e0: 9d e3 bf 80 save %sp, -128, %sp 20090e4: b4 10 00 18 mov %i0, %i2 rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { 20090e8: 80 a6 60 00 cmp %i1, 0 20090ec: 02 80 00 2a be 2009194 20090f0: b0 10 20 00 clr %i0 RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; 20090f4: fa 06 a0 1c ld [ %i2 + 0x1c ], %i5 #define NULL_PAGE rtems_rbheap_chunk_of_node(NULL) static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key) { rtems_rbheap_chunk chunk = { .begin = key }; 20090f8: c0 27 bf fc clr [ %fp + -4 ] 20090fc: c0 27 bf e0 clr [ %fp + -32 ] 2009100: c0 27 bf e4 clr [ %fp + -28 ] 2009104: c0 27 bf e8 clr [ %fp + -24 ] 2009108: c0 27 bf ec clr [ %fp + -20 ] 200910c: c0 27 bf f0 clr [ %fp + -16 ] 2009110: c0 27 bf f4 clr [ %fp + -12 ] 2009114: f2 27 bf f8 st %i1, [ %fp + -8 ] RBTree_Node* found = NULL; int compare_result; while (iter_node) { 2009118: 80 a7 60 00 cmp %i5, 0 200911c: 02 80 00 3e be 2009214 <== NEVER TAKEN 2009120: b8 06 a0 18 add %i2, 0x18, %i4 2009124: b6 10 20 00 clr %i3 compare_result = the_rbtree->compare_function(the_node, iter_node); 2009128: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 200912c: 92 10 00 1d mov %i5, %o1 2009130: 9f c0 40 00 call %g1 2009134: 90 07 bf e8 add %fp, -24, %o0 RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater( int compare_result ) { return compare_result > 0; 2009138: 83 3a 20 1f sra %o0, 0x1f, %g1 RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); if ( _RBTree_Is_equal( compare_result ) ) { 200913c: 80 a2 20 00 cmp %o0, 0 RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater( int compare_result ) { return compare_result > 0; 2009140: 82 20 40 08 sub %g1, %o0, %g1 2009144: 83 30 60 1f srl %g1, 0x1f, %g1 break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 2009148: 83 28 60 02 sll %g1, 2, %g1 RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); if ( _RBTree_Is_equal( compare_result ) ) { 200914c: 12 80 00 06 bne 2009164 2009150: 82 07 40 01 add %i5, %g1, %g1 found = iter_node; if ( the_rbtree->is_unique ) 2009154: c4 0f 20 14 ldub [ %i4 + 0x14 ], %g2 2009158: 80 a0 a0 00 cmp %g2, 0 200915c: 12 80 00 10 bne 200919c <== ALWAYS TAKEN 2009160: b6 10 00 1d mov %i5, %i3 break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 2009164: fa 00 60 04 ld [ %g1 + 4 ], %i5 ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { 2009168: 80 a7 60 00 cmp %i5, 0 200916c: 32 bf ff f0 bne,a 200912c 2009170: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 return rtems_rbheap_chunk_of_node( 2009174: ba 06 ff f8 add %i3, -8, %i5 if (ptr != NULL) { rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { 2009178: 80 a7 7f f8 cmp %i5, -8 200917c: 02 80 00 06 be 2009194 2009180: b0 10 20 04 mov 4, %i0 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 2009184: c2 06 ff f8 ld [ %i3 + -8 ], %g1 2009188: 80 a0 60 00 cmp %g1, 0 200918c: 02 80 00 06 be 20091a4 2009190: b0 10 20 0e mov 0xe, %i0 sc = RTEMS_INVALID_ID; } } return sc; } 2009194: 81 c7 e0 08 ret 2009198: 81 e8 00 00 restore static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key) { rtems_rbheap_chunk chunk = { .begin = key }; return rtems_rbheap_chunk_of_node( 200919c: 10 bf ff f7 b 2009178 20091a0: ba 06 ff f8 add %i3, -8, %i5 20091a4: c2 06 ff fc ld [ %i3 + -4 ], %g1 20091a8: 80 a0 60 00 cmp %g1, 0 20091ac: 12 bf ff fa bne 2009194 <== NEVER TAKEN 20091b0: 92 10 20 00 clr %o1 static rtems_rbheap_chunk *get_next( const rtems_rbheap_chunk *chunk, RBTree_Direction dir ) { return rtems_rbheap_chunk_of_node( 20091b4: 40 00 07 a4 call 200b044 <_RBTree_Next_unprotected> 20091b8: 90 10 00 1b mov %i3, %o0 20091bc: 92 10 20 01 mov 1, %o1 20091c0: b2 10 00 08 mov %o0, %i1 20091c4: 40 00 07 a0 call 200b044 <_RBTree_Next_unprotected> 20091c8: 90 10 00 1b mov %i3, %o0 if (chunk != NULL_PAGE) { if (!rtems_rbheap_is_chunk_free(chunk)) { rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT); rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT); check_and_merge(free_chain, chunk_tree, chunk, succ); 20091cc: 92 10 00 1c mov %i4, %o1 static rtems_rbheap_chunk *get_next( const rtems_rbheap_chunk *chunk, RBTree_Direction dir ) { return rtems_rbheap_chunk_of_node( 20091d0: 96 02 3f f8 add %o0, -8, %o3 if (chunk != NULL_PAGE) { if (!rtems_rbheap_is_chunk_free(chunk)) { rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT); rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT); check_and_merge(free_chain, chunk_tree, chunk, succ); 20091d4: 94 10 00 1d mov %i5, %o2 20091d8: 7f ff ff 10 call 2008e18 20091dc: 90 10 00 1a mov %i2, %o0 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 20091e0: c2 06 80 00 ld [ %i2 ], %g1 Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 20091e4: f4 26 ff fc st %i2, [ %i3 + -4 ] before_node = after_node->next; after_node->next = the_node; 20091e8: fa 26 80 00 st %i5, [ %i2 ] the_node->next = before_node; 20091ec: c2 26 ff f8 st %g1, [ %i3 + -8 ] before_node->previous = the_node; 20091f0: fa 20 60 04 st %i5, [ %g1 + 4 ] add_to_chain(free_chain, chunk); check_and_merge(free_chain, chunk_tree, chunk, pred); 20091f4: 90 10 00 1a mov %i2, %o0 20091f8: 92 10 00 1c mov %i4, %o1 20091fc: 94 10 00 1d mov %i5, %o2 2009200: 96 06 7f f8 add %i1, -8, %o3 2009204: 7f ff ff 05 call 2008e18 2009208: b0 10 20 00 clr %i0 200920c: 81 c7 e0 08 ret 2009210: 81 e8 00 00 restore sc = RTEMS_INVALID_ID; } } return sc; } 2009214: 81 c7 e0 08 ret <== NOT EXECUTED 2009218: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED =============================================================================== 02008eb0 : uintptr_t area_size, uintptr_t alignment, rtems_rbheap_extend_descriptors extend_descriptors, void *handler_arg ) { 2008eb0: 9d e3 bf a0 save %sp, -96, %sp rtems_status_code sc = RTEMS_SUCCESSFUL; if (alignment > 0) { 2008eb4: 80 a6 e0 00 cmp %i3, 0 2008eb8: 12 80 00 04 bne 2008ec8 2008ebc: 82 10 20 0a mov 0xa, %g1 } else { sc = RTEMS_INVALID_NUMBER; } return sc; } 2008ec0: 81 c7 e0 08 ret 2008ec4: 91 e8 00 01 restore %g0, %g1, %o0 #include static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 2008ec8: 90 10 00 19 mov %i1, %o0 2008ecc: 92 10 00 1b mov %i3, %o1 2008ed0: 40 00 47 82 call 201acd8 <.urem> 2008ed4: b4 06 40 1a add %i1, %i2, %i2 if (excess > 0) { 2008ed8: 80 a2 20 00 cmp %o0, 0 2008edc: 32 80 00 09 bne,a 2008f00 2008ee0: a0 06 40 1b add %i1, %i3, %l0 2008ee4: 82 10 20 01 mov 1, %g1 uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; uintptr_t aligned_begin = align_up(alignment, begin); uintptr_t aligned_end = align_down(alignment, end); if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) { 2008ee8: 80 88 60 ff btst 0xff, %g1 2008eec: 12 80 00 0b bne 2008f18 <== ALWAYS TAKEN 2008ef0: a0 10 00 19 mov %i1, %l0 insert_into_tree(chunk_tree, first); } else { sc = RTEMS_NO_MEMORY; } } else { sc = RTEMS_INVALID_ADDRESS; 2008ef4: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED } else { sc = RTEMS_INVALID_NUMBER; } return sc; } 2008ef8: 81 c7 e0 08 ret 2008efc: 91 e8 00 01 restore %g0, %g1, %o0 static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; if (excess > 0) { value += alignment - excess; 2008f00: a0 24 00 08 sub %l0, %o0, %l0 2008f04: 80 a4 00 19 cmp %l0, %i1 2008f08: 82 60 3f ff subx %g0, -1, %g1 uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; uintptr_t aligned_begin = align_up(alignment, begin); uintptr_t aligned_end = align_down(alignment, end); if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) { 2008f0c: 80 88 60 ff btst 0xff, %g1 2008f10: 02 bf ff fa be 2008ef8 2008f14: 82 10 20 09 mov 9, %g1 2008f18: 80 a6 40 1a cmp %i1, %i2 2008f1c: 1a bf ff f7 bcc 2008ef8 2008f20: 82 10 20 09 mov 9, %g1 return value; } static uintptr_t align_down(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 2008f24: 90 10 00 1a mov %i2, %o0 2008f28: 40 00 47 6c call 201acd8 <.urem> 2008f2c: 92 10 00 1b mov %i3, %o1 return value - excess; 2008f30: b4 26 80 08 sub %i2, %o0, %i2 uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; uintptr_t aligned_begin = align_up(alignment, begin); uintptr_t aligned_end = align_down(alignment, end); if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) { 2008f34: 80 a4 00 1a cmp %l0, %i2 2008f38: 1a bf ff e2 bcc 2008ec0 2008f3c: 82 10 20 09 mov 9, %g1 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 2008f40: 82 06 20 04 add %i0, 4, %g1 head->next = tail; 2008f44: c2 26 00 00 st %g1, [ %i0 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 2008f48: 82 06 20 0c add %i0, 0xc, %g1 head->next = tail; head->previous = NULL; tail->previous = head; 2008f4c: c2 26 20 14 st %g1, [ %i0 + 0x14 ] the_rbtree->permanent_null = NULL; the_rbtree->root = NULL; the_rbtree->first[0] = NULL; the_rbtree->first[1] = NULL; the_rbtree->compare_function = compare_function; the_rbtree->is_unique = is_unique; 2008f50: 82 10 20 01 mov 1, %g1 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 2008f54: 84 06 20 10 add %i0, 0x10, %g2 2008f58: c2 2e 20 2c stb %g1, [ %i0 + 0x2c ] { the_rbtree->permanent_null = NULL; the_rbtree->root = NULL; the_rbtree->first[0] = NULL; the_rbtree->first[1] = NULL; the_rbtree->compare_function = compare_function; 2008f5c: 03 00 80 23 sethi %hi(0x2008c00), %g1 2008f60: 82 10 61 a0 or %g1, 0x1a0, %g1 ! 2008da0 head->next = tail; head->previous = NULL; 2008f64: c0 26 20 04 clr [ %i0 + 4 ] 2008f68: c2 26 20 28 st %g1, [ %i0 + 0x28 ] tail->previous = head; 2008f6c: f0 26 20 08 st %i0, [ %i0 + 8 ] { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; head->previous = NULL; 2008f70: c0 26 20 10 clr [ %i0 + 0x10 ] ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 2008f74: c4 26 20 0c st %g2, [ %i0 + 0xc ] RBTree_Control *the_rbtree, RBTree_Compare_function compare_function, bool is_unique ) { the_rbtree->permanent_null = NULL; 2008f78: c0 26 20 18 clr [ %i0 + 0x18 ] the_rbtree->root = NULL; 2008f7c: c0 26 20 1c clr [ %i0 + 0x1c ] the_rbtree->first[0] = NULL; 2008f80: c0 26 20 20 clr [ %i0 + 0x20 ] the_rbtree->first[1] = NULL; 2008f84: c0 26 20 24 clr [ %i0 + 0x24 ] rtems_rbheap_chunk *first = NULL; rtems_chain_initialize_empty(free_chain); rtems_chain_initialize_empty(&control->spare_descriptor_chain); rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true); control->alignment = alignment; 2008f88: f6 26 20 30 st %i3, [ %i0 + 0x30 ] control->handler_arg = handler_arg; 2008f8c: fa 26 20 38 st %i5, [ %i0 + 0x38 ] control->extend_descriptors = extend_descriptors; 2008f90: f8 26 20 34 st %i4, [ %i0 + 0x34 ] first = get_chunk(control); 2008f94: 7f ff ff 87 call 2008db0 2008f98: 90 10 00 18 mov %i0, %o0 first->begin = aligned_begin; first->size = aligned_end - aligned_begin; add_to_chain(free_chain, first); insert_into_tree(chunk_tree, first); } else { sc = RTEMS_NO_MEMORY; 2008f9c: 82 10 20 1a mov 0x1a, %g1 control->alignment = alignment; control->handler_arg = handler_arg; control->extend_descriptors = extend_descriptors; first = get_chunk(control); if (first != NULL) { 2008fa0: 80 a2 20 00 cmp %o0, 0 2008fa4: 02 bf ff c7 be 2008ec0 2008fa8: 92 10 00 08 mov %o0, %o1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 2008fac: c2 06 00 00 ld [ %i0 ], %g1 first->begin = aligned_begin; first->size = aligned_end - aligned_begin; 2008fb0: b4 26 80 10 sub %i2, %l0, %i2 control->handler_arg = handler_arg; control->extend_descriptors = extend_descriptors; first = get_chunk(control); if (first != NULL) { first->begin = aligned_begin; 2008fb4: e0 22 20 18 st %l0, [ %o0 + 0x18 ] first->size = aligned_end - aligned_begin; 2008fb8: f4 22 20 1c st %i2, [ %o0 + 0x1c ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 2008fbc: f0 22 20 04 st %i0, [ %o0 + 4 ] before_node = after_node->next; after_node->next = the_node; 2008fc0: d0 26 00 00 st %o0, [ %i0 ] the_node->next = before_node; 2008fc4: c2 22 00 00 st %g1, [ %o0 ] before_node->previous = the_node; 2008fc8: d0 20 60 04 st %o0, [ %g1 + 4 ] static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 2008fcc: 92 02 60 08 add %o1, 8, %o1 2008fd0: 40 00 07 4e call 200ad08 <_RBTree_Insert_unprotected> 2008fd4: 90 06 20 18 add %i0, 0x18, %o0 uintptr_t alignment, rtems_rbheap_extend_descriptors extend_descriptors, void *handler_arg ) { rtems_status_code sc = RTEMS_SUCCESSFUL; 2008fd8: 10 bf ff ba b 2008ec0 2008fdc: 82 10 20 00 clr %g1 =============================================================================== 02016ef4 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 2016ef4: 9d e3 bf 98 save %sp, -104, %sp register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 2016ef8: 80 a6 60 00 cmp %i1, 0 2016efc: 12 80 00 04 bne 2016f0c 2016f00: 82 10 20 0a mov 0xa, %g1 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2016f04: 81 c7 e0 08 ret 2016f08: 91 e8 00 01 restore %g0, %g1, %o0 ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 2016f0c: 90 10 00 18 mov %i0, %o0 2016f10: 40 00 13 b9 call 201bdf4 <_Thread_Get> 2016f14: 92 07 bf fc add %fp, -4, %o1 switch ( location ) { 2016f18: c2 07 bf fc ld [ %fp + -4 ], %g1 2016f1c: 80 a0 60 00 cmp %g1, 0 2016f20: 12 80 00 20 bne 2016fa0 2016f24: b8 10 00 08 mov %o0, %i4 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 2016f28: fa 02 21 58 ld [ %o0 + 0x158 ], %i5 asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 2016f2c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 2016f30: 80 a0 60 00 cmp %g1, 0 2016f34: 02 80 00 1e be 2016fac 2016f38: 01 00 00 00 nop if ( asr->is_enabled ) { 2016f3c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1 2016f40: 80 a0 60 00 cmp %g1, 0 2016f44: 02 80 00 1e be 2016fbc 2016f48: 01 00 00 00 nop rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 2016f4c: 7f ff e2 31 call 200f810 2016f50: 01 00 00 00 nop *signal_set |= signals; 2016f54: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 2016f58: b2 10 40 19 or %g1, %i1, %i1 2016f5c: f2 27 60 14 st %i1, [ %i5 + 0x14 ] _ISR_Enable( _level ); 2016f60: 7f ff e2 30 call 200f820 2016f64: 01 00 00 00 nop _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2016f68: 03 00 80 f4 sethi %hi(0x203d000), %g1 2016f6c: 82 10 62 60 or %g1, 0x260, %g1 ! 203d260 <_Per_CPU_Information> 2016f70: c4 00 60 08 ld [ %g1 + 8 ], %g2 2016f74: 80 a0 a0 00 cmp %g2, 0 2016f78: 02 80 00 06 be 2016f90 2016f7c: 01 00 00 00 nop 2016f80: c4 00 60 0c ld [ %g1 + 0xc ], %g2 2016f84: 80 a7 00 02 cmp %i4, %g2 2016f88: 02 80 00 15 be 2016fdc <== ALWAYS TAKEN 2016f8c: 84 10 20 01 mov 1, %g2 _Thread_Dispatch_necessary = true; } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 2016f90: 40 00 13 8c call 201bdc0 <_Thread_Enable_dispatch> 2016f94: 01 00 00 00 nop return RTEMS_SUCCESSFUL; 2016f98: 10 bf ff db b 2016f04 2016f9c: 82 10 20 00 clr %g1 ! 0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 2016fa0: 82 10 20 04 mov 4, %g1 } 2016fa4: 81 c7 e0 08 ret 2016fa8: 91 e8 00 01 restore %g0, %g1, %o0 _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2016fac: 40 00 13 85 call 201bdc0 <_Thread_Enable_dispatch> 2016fb0: 01 00 00 00 nop return RTEMS_NOT_DEFINED; 2016fb4: 10 bf ff d4 b 2016f04 2016fb8: 82 10 20 0b mov 0xb, %g1 ! b rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 2016fbc: 7f ff e2 15 call 200f810 2016fc0: 01 00 00 00 nop *signal_set |= signals; 2016fc4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 2016fc8: b2 10 40 19 or %g1, %i1, %i1 2016fcc: f2 27 60 18 st %i1, [ %i5 + 0x18 ] _ISR_Enable( _level ); 2016fd0: 7f ff e2 14 call 200f820 2016fd4: 01 00 00 00 nop 2016fd8: 30 bf ff ee b,a 2016f90 if ( ! _ASR_Is_null_handler( asr->handler ) ) { if ( asr->is_enabled ) { _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 2016fdc: c4 28 60 18 stb %g2, [ %g1 + 0x18 ] 2016fe0: 30 bf ff ec b,a 2016f90 =============================================================================== 020101e4 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 20101e4: 9d e3 bf a0 save %sp, -96, %sp ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 20101e8: 80 a6 a0 00 cmp %i2, 0 20101ec: 02 80 00 3b be 20102d8 20101f0: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 20101f4: 21 00 80 7b sethi %hi(0x201ec00), %l0 20101f8: a0 14 21 e0 or %l0, 0x1e0, %l0 ! 201ede0 <_Per_CPU_Information> 20101fc: fa 04 20 0c ld [ %l0 + 0xc ], %i5 api = executing->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 2010200: c4 0f 60 70 ldub [ %i5 + 0x70 ], %g2 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 2010204: c2 07 60 78 ld [ %i5 + 0x78 ], %g1 executing = _Thread_Executing; api = executing->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 2010208: 80 a0 00 02 cmp %g0, %g2 if ( !previous_mode_set ) return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 201020c: f8 07 61 58 ld [ %i5 + 0x158 ], %i4 asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 2010210: b6 60 3f ff subx %g0, -1, %i3 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 2010214: 80 a0 60 00 cmp %g1, 0 2010218: 12 80 00 40 bne 2010318 201021c: b7 2e e0 08 sll %i3, 8, %i3 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 2010220: c2 0f 20 08 ldub [ %i4 + 8 ], %g1 2010224: 80 a0 00 01 cmp %g0, %g1 old_mode |= _ISR_Get_level(); 2010228: 7f ff ee c3 call 200bd34 <_CPU_ISR_Get_level> 201022c: a2 60 3f ff subx %g0, -1, %l1 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 2010230: a3 2c 60 0a sll %l1, 0xa, %l1 2010234: 90 14 40 08 or %l1, %o0, %o0 old_mode |= _ISR_Get_level(); 2010238: b6 12 00 1b or %o0, %i3, %i3 *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 201023c: 80 8e 61 00 btst 0x100, %i1 2010240: 02 80 00 06 be 2010258 2010244: f6 26 80 00 st %i3, [ %i2 ] */ RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt ( Modes_Control mode_set ) { return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT; 2010248: 83 36 20 08 srl %i0, 8, %g1 201024c: 82 18 60 01 xor %g1, 1, %g1 2010250: 82 08 60 01 and %g1, 1, %g1 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 2010254: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ] if ( mask & RTEMS_TIMESLICE_MASK ) { 2010258: 80 8e 62 00 btst 0x200, %i1 201025c: 12 80 00 21 bne 20102e0 2010260: 80 8e 22 00 btst 0x200, %i0 } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 2010264: 80 8e 60 0f btst 0xf, %i1 2010268: 12 80 00 27 bne 2010304 201026c: 01 00 00 00 nop * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { 2010270: 80 8e 64 00 btst 0x400, %i1 2010274: 02 80 00 14 be 20102c4 2010278: 86 10 20 00 clr %g3 is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 201027c: c2 0f 20 08 ldub [ %i4 + 8 ], %g1 */ is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; 2010280: b1 36 20 0a srl %i0, 0xa, %i0 2010284: b0 1e 20 01 xor %i0, 1, %i0 2010288: b0 0e 20 01 and %i0, 1, %i0 if ( is_asr_enabled != asr->is_enabled ) { 201028c: 80 a6 00 01 cmp %i0, %g1 2010290: 22 80 00 0e be,a 20102c8 2010294: 03 00 80 7a sethi %hi(0x201e800), %g1 ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 2010298: 7f ff c9 33 call 2002764 201029c: f0 2f 20 08 stb %i0, [ %i4 + 8 ] _signals = information->signals_pending; 20102a0: c4 07 20 18 ld [ %i4 + 0x18 ], %g2 information->signals_pending = information->signals_posted; 20102a4: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 information->signals_posted = _signals; 20102a8: c4 27 20 14 st %g2, [ %i4 + 0x14 ] rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); _signals = information->signals_pending; information->signals_pending = information->signals_posted; 20102ac: c2 27 20 18 st %g1, [ %i4 + 0x18 ] information->signals_posted = _signals; _ISR_Enable( _level ); 20102b0: 7f ff c9 31 call 2002774 20102b4: 01 00 00 00 nop asr->is_enabled = is_asr_enabled; _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 20102b8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 20102bc: 80 a0 00 01 cmp %g0, %g1 20102c0: 86 40 20 00 addx %g0, 0, %g3 needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 20102c4: 03 00 80 7a sethi %hi(0x201e800), %g1 20102c8: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 201e9f0 <_System_state_Current> 20102cc: 80 a0 a0 03 cmp %g2, 3 20102d0: 02 80 00 1f be 201034c 20102d4: 82 10 20 00 clr %g1 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; } 20102d8: 81 c7 e0 08 ret 20102dc: 91 e8 00 01 restore %g0, %g1, %o0 */ if ( mask & RTEMS_PREEMPT_MASK ) executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { 20102e0: 22 bf ff e1 be,a 2010264 20102e4: c0 27 60 78 clr [ %i5 + 0x78 ] executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 20102e8: 03 00 80 7a sethi %hi(0x201e800), %g1 20102ec: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 201e810 <_Thread_Ticks_per_timeslice> } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 20102f0: 80 8e 60 0f btst 0xf, %i1 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 20102f4: c2 27 60 74 st %g1, [ %i5 + 0x74 ] if ( mask & RTEMS_PREEMPT_MASK ) executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 20102f8: 82 10 20 01 mov 1, %g1 } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 20102fc: 02 bf ff dd be 2010270 2010300: c2 27 60 78 st %g1, [ %i5 + 0x78 ] */ RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level ( Modes_Control mode_set ) { return ( mode_set & RTEMS_INTERRUPT_MASK ); 2010304: 90 0e 20 0f and %i0, 0xf, %o0 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 2010308: 7f ff c9 1b call 2002774 201030c: 91 2a 20 08 sll %o0, 8, %o0 * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { 2010310: 10 bf ff d9 b 2010274 2010314: 80 8e 64 00 btst 0x400, %i1 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 2010318: c2 0f 20 08 ldub [ %i4 + 8 ], %g1 old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 201031c: b6 16 e2 00 or %i3, 0x200, %i3 old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 2010320: 80 a0 00 01 cmp %g0, %g1 old_mode |= _ISR_Get_level(); 2010324: 7f ff ee 84 call 200bd34 <_CPU_ISR_Get_level> 2010328: a2 60 3f ff subx %g0, -1, %l1 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 201032c: a3 2c 60 0a sll %l1, 0xa, %l1 2010330: 90 14 40 08 or %l1, %o0, %o0 old_mode |= _ISR_Get_level(); 2010334: b6 12 00 1b or %o0, %i3, %i3 *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 2010338: 80 8e 61 00 btst 0x100, %i1 201033c: 02 bf ff c7 be 2010258 2010340: f6 26 80 00 st %i3, [ %i2 ] */ RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt ( Modes_Control mode_set ) { return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT; 2010344: 10 bf ff c2 b 201024c 2010348: 83 36 20 08 srl %i0, 8, %g1 { Thread_Control *executing; executing = _Thread_Executing; if ( are_signals_pending || 201034c: 80 88 e0 ff btst 0xff, %g3 2010350: 12 80 00 0a bne 2010378 2010354: c4 04 20 0c ld [ %l0 + 0xc ], %g2 2010358: c6 04 20 10 ld [ %l0 + 0x10 ], %g3 201035c: 80 a0 80 03 cmp %g2, %g3 2010360: 02 bf ff de be 20102d8 2010364: 01 00 00 00 nop (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 2010368: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2 201036c: 80 a0 a0 00 cmp %g2, 0 2010370: 02 bf ff da be 20102d8 <== NEVER TAKEN 2010374: 01 00 00 00 nop _Thread_Dispatch_necessary = true; 2010378: 82 10 20 01 mov 1, %g1 ! 1 201037c: c2 2c 20 18 stb %g1, [ %l0 + 0x18 ] } } if ( _System_state_Is_up( _System_state_Get() ) ) { if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 2010380: 7f ff e8 fd call 200a774 <_Thread_Dispatch> 2010384: 01 00 00 00 nop } return RTEMS_SUCCESSFUL; 2010388: 82 10 20 00 clr %g1 ! 0 } 201038c: 81 c7 e0 08 ret 2010390: 91 e8 00 01 restore %g0, %g1, %o0 =============================================================================== 0200c84c : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 200c84c: 9d e3 bf 98 save %sp, -104, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 200c850: 80 a6 60 00 cmp %i1, 0 200c854: 02 80 00 08 be 200c874 200c858: 80 a6 a0 00 cmp %i2, 0 RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 200c85c: 03 00 80 88 sethi %hi(0x2022000), %g1 200c860: c4 08 63 88 ldub [ %g1 + 0x388 ], %g2 ! 2022388 */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 200c864: 80 a6 40 02 cmp %i1, %g2 200c868: 18 80 00 1e bgu 200c8e0 200c86c: 82 10 20 13 mov 0x13, %g1 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 200c870: 80 a6 a0 00 cmp %i2, 0 200c874: 02 80 00 1b be 200c8e0 200c878: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 200c87c: 90 10 00 18 mov %i0, %o0 200c880: 40 00 0a 2c call 200f130 <_Thread_Get> 200c884: 92 07 bf fc add %fp, -4, %o1 switch ( location ) { 200c888: c2 07 bf fc ld [ %fp + -4 ], %g1 200c88c: 80 a0 60 00 cmp %g1, 0 200c890: 12 80 00 16 bne 200c8e8 200c894: 82 10 20 04 mov 4, %g1 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 200c898: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 200c89c: 80 a6 60 00 cmp %i1, 0 200c8a0: 02 80 00 0d be 200c8d4 200c8a4: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200c8a8: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 200c8ac: 80 a0 60 00 cmp %g1, 0 200c8b0: 02 80 00 06 be 200c8c8 200c8b4: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 200c8b8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200c8bc: 80 a6 40 01 cmp %i1, %g1 200c8c0: 1a 80 00 05 bcc 200c8d4 <== ALWAYS TAKEN 200c8c4: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 200c8c8: 92 10 00 19 mov %i1, %o1 200c8cc: 40 00 08 cb call 200ebf8 <_Thread_Change_priority> 200c8d0: 94 10 20 00 clr %o2 } _Thread_Enable_dispatch(); 200c8d4: 40 00 0a 0a call 200f0fc <_Thread_Enable_dispatch> 200c8d8: 01 00 00 00 nop return RTEMS_SUCCESSFUL; 200c8dc: 82 10 20 00 clr %g1 ! 0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200c8e0: 81 c7 e0 08 ret 200c8e4: 91 e8 00 01 restore %g0, %g1, %o0 200c8e8: 81 c7 e0 08 ret 200c8ec: 91 e8 00 01 restore %g0, %g1, %o0 =============================================================================== 0202eee0 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 202eee0: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 202eee4: 80 a6 60 00 cmp %i1, 0 202eee8: 02 80 00 1e be 202ef60 202eeec: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 202eef0: 90 10 00 18 mov %i0, %o0 202eef4: 7f ff 88 1f call 2010f70 <_Thread_Get> 202eef8: 92 07 bf fc add %fp, -4, %o1 switch (location) { 202eefc: c2 07 bf fc ld [ %fp + -4 ], %g1 202ef00: 80 a0 60 00 cmp %g1, 0 202ef04: 12 80 00 19 bne 202ef68 202ef08: 82 10 20 04 mov 4, %g1 case OBJECTS_LOCAL: tvp = the_thread->task_variables; 202ef0c: c2 02 21 64 ld [ %o0 + 0x164 ], %g1 while (tvp) { 202ef10: 80 a0 60 00 cmp %g1, 0 202ef14: 02 80 00 10 be 202ef54 202ef18: 01 00 00 00 nop if (tvp->ptr == ptr) { 202ef1c: c4 00 60 04 ld [ %g1 + 4 ], %g2 202ef20: 80 a0 80 19 cmp %g2, %i1 202ef24: 32 80 00 09 bne,a 202ef48 202ef28: d2 00 40 00 ld [ %g1 ], %o1 if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 202ef2c: 10 80 00 18 b 202ef8c 202ef30: c4 00 40 00 ld [ %g1 ], %g2 switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 202ef34: 80 a0 80 19 cmp %g2, %i1 202ef38: 22 80 00 0e be,a 202ef70 202ef3c: c4 02 40 00 ld [ %o1 ], %g2 202ef40: 82 10 00 09 mov %o1, %g1 _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 202ef44: d2 00 40 00 ld [ %g1 ], %o1 the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 202ef48: 80 a2 60 00 cmp %o1, 0 202ef4c: 32 bf ff fa bne,a 202ef34 <== ALWAYS TAKEN 202ef50: c4 02 60 04 ld [ %o1 + 4 ], %g2 return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 202ef54: 7f ff 87 fa call 2010f3c <_Thread_Enable_dispatch> 202ef58: 01 00 00 00 nop return RTEMS_INVALID_ADDRESS; 202ef5c: 82 10 20 09 mov 9, %g1 ! 9 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 202ef60: 81 c7 e0 08 ret 202ef64: 91 e8 00 01 restore %g0, %g1, %o0 202ef68: 81 c7 e0 08 ret 202ef6c: 91 e8 00 01 restore %g0, %g1, %o0 case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 202ef70: c4 20 40 00 st %g2, [ %g1 ] else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 202ef74: 40 00 00 2e call 202f02c <_RTEMS_Tasks_Invoke_task_variable_dtor> 202ef78: 01 00 00 00 nop _Thread_Enable_dispatch(); 202ef7c: 7f ff 87 f0 call 2010f3c <_Thread_Enable_dispatch> 202ef80: 01 00 00 00 nop return RTEMS_SUCCESSFUL; 202ef84: 10 bf ff f7 b 202ef60 202ef88: 82 10 20 00 clr %g1 ! 0 while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 202ef8c: 92 10 00 01 mov %g1, %o1 202ef90: 10 bf ff f9 b 202ef74 202ef94: c4 22 21 64 st %g2, [ %o0 + 0x164 ] =============================================================================== 0202ef98 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 202ef98: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 202ef9c: 80 a6 60 00 cmp %i1, 0 202efa0: 02 80 00 1b be 202f00c 202efa4: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; if ( !result ) 202efa8: 80 a6 a0 00 cmp %i2, 0 202efac: 02 80 00 18 be 202f00c 202efb0: 90 10 00 18 mov %i0, %o0 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 202efb4: 7f ff 87 ef call 2010f70 <_Thread_Get> 202efb8: 92 07 bf fc add %fp, -4, %o1 switch (location) { 202efbc: c2 07 bf fc ld [ %fp + -4 ], %g1 202efc0: 80 a0 60 00 cmp %g1, 0 202efc4: 12 80 00 14 bne 202f014 202efc8: 82 10 20 04 mov 4, %g1 case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 202efcc: c2 02 21 64 ld [ %o0 + 0x164 ], %g1 while (tvp) { 202efd0: 80 a0 60 00 cmp %g1, 0 202efd4: 32 80 00 07 bne,a 202eff0 202efd8: c4 00 60 04 ld [ %g1 + 4 ], %g2 202efdc: 30 80 00 10 b,a 202f01c 202efe0: 80 a0 60 00 cmp %g1, 0 202efe4: 02 80 00 0e be 202f01c <== NEVER TAKEN 202efe8: 01 00 00 00 nop if (tvp->ptr == ptr) { 202efec: c4 00 60 04 ld [ %g1 + 4 ], %g2 202eff0: 80 a0 80 19 cmp %g2, %i1 202eff4: 32 bf ff fb bne,a 202efe0 202eff8: c2 00 40 00 ld [ %g1 ], %g1 /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 202effc: c2 00 60 0c ld [ %g1 + 0xc ], %g1 _Thread_Enable_dispatch(); 202f000: 7f ff 87 cf call 2010f3c <_Thread_Enable_dispatch> 202f004: c2 26 80 00 st %g1, [ %i2 ] return RTEMS_SUCCESSFUL; 202f008: 82 10 20 00 clr %g1 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 202f00c: 81 c7 e0 08 ret 202f010: 91 e8 00 01 restore %g0, %g1, %o0 202f014: 81 c7 e0 08 ret 202f018: 91 e8 00 01 restore %g0, %g1, %o0 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 202f01c: 7f ff 87 c8 call 2010f3c <_Thread_Enable_dispatch> 202f020: 01 00 00 00 nop return RTEMS_INVALID_ADDRESS; 202f024: 10 bf ff fa b 202f00c 202f028: 82 10 20 09 mov 9, %g1 ! 9 =============================================================================== 02017994 : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 2017994: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2017998: 11 00 80 f5 sethi %hi(0x203d400), %o0 201799c: 92 10 00 18 mov %i0, %o1 20179a0: 90 12 22 a4 or %o0, 0x2a4, %o0 20179a4: 40 00 0c fd call 201ad98 <_Objects_Get> 20179a8: 94 07 bf fc add %fp, -4, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20179ac: c2 07 bf fc ld [ %fp + -4 ], %g1 20179b0: 80 a0 60 00 cmp %g1, 0 20179b4: 12 80 00 0c bne 20179e4 20179b8: 01 00 00 00 nop case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 20179bc: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 20179c0: 80 a0 60 04 cmp %g1, 4 20179c4: 02 80 00 04 be 20179d4 <== NEVER TAKEN 20179c8: 01 00 00 00 nop (void) _Watchdog_Remove( &the_timer->Ticker ); 20179cc: 40 00 15 78 call 201cfac <_Watchdog_Remove> 20179d0: 90 02 20 10 add %o0, 0x10, %o0 _Thread_Enable_dispatch(); 20179d4: 40 00 10 fb call 201bdc0 <_Thread_Enable_dispatch> 20179d8: b0 10 20 00 clr %i0 20179dc: 81 c7 e0 08 ret 20179e0: 81 e8 00 00 restore case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 20179e4: 81 c7 e0 08 ret 20179e8: 91 e8 20 04 restore %g0, 4, %o0 =============================================================================== 02017ef0 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 2017ef0: 9d e3 bf 98 save %sp, -104, %sp Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 2017ef4: 03 00 80 f5 sethi %hi(0x203d400), %g1 2017ef8: fa 00 62 e4 ld [ %g1 + 0x2e4 ], %i5 ! 203d6e4 <_Timer_server> if ( !timer_server ) 2017efc: 80 a7 60 00 cmp %i5, 0 2017f00: 02 80 00 08 be 2017f20 2017f04: 82 10 20 0e mov 0xe, %g1 return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) 2017f08: 39 00 80 f3 sethi %hi(0x203cc00), %i4 2017f0c: 82 17 20 78 or %i4, 0x78, %g1 ! 203cc78 <_TOD> 2017f10: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2 2017f14: 80 a0 a0 00 cmp %g2, 0 2017f18: 12 80 00 04 bne 2017f28 <== ALWAYS TAKEN 2017f1c: 82 10 20 0b mov 0xb, %g1 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2017f20: 81 c7 e0 08 ret 2017f24: 91 e8 00 01 restore %g0, %g1, %o0 return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 2017f28: 80 a6 a0 00 cmp %i2, 0 2017f2c: 02 bf ff fd be 2017f20 2017f30: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 2017f34: 7f ff f3 24 call 2014bc4 <_TOD_Validate> 2017f38: 90 10 00 19 mov %i1, %o0 2017f3c: 80 8a 20 ff btst 0xff, %o0 2017f40: 12 80 00 04 bne 2017f50 2017f44: 82 10 20 14 mov 0x14, %g1 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2017f48: 81 c7 e0 08 ret 2017f4c: 91 e8 00 01 restore %g0, %g1, %o0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 2017f50: 7f ff f2 e3 call 2014adc <_TOD_To_seconds> 2017f54: 90 10 00 19 mov %i1, %o0 2017f58: b2 10 00 08 mov %o0, %i1 2017f5c: d0 1f 20 78 ldd [ %i4 + 0x78 ], %o0 2017f60: 94 10 20 00 clr %o2 2017f64: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2017f68: 40 00 52 7d call 202c95c <__divdi3> 2017f6c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 if ( seconds <= _TOD_Seconds_since_epoch() ) 2017f70: 80 a6 40 09 cmp %i1, %o1 2017f74: 08 bf ff f5 bleu 2017f48 2017f78: 82 10 20 14 mov 0x14, %g1 2017f7c: 92 10 00 18 mov %i0, %o1 2017f80: 11 00 80 f5 sethi %hi(0x203d400), %o0 2017f84: 94 07 bf fc add %fp, -4, %o2 2017f88: 40 00 0b 84 call 201ad98 <_Objects_Get> 2017f8c: 90 12 22 a4 or %o0, 0x2a4, %o0 return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2017f90: c2 07 bf fc ld [ %fp + -4 ], %g1 2017f94: 80 a0 60 00 cmp %g1, 0 2017f98: 12 80 00 19 bne 2017ffc 2017f9c: a0 10 00 08 mov %o0, %l0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2017fa0: 40 00 14 03 call 201cfac <_Watchdog_Remove> 2017fa4: 90 02 20 10 add %o0, 0x10, %o0 2017fa8: d0 1f 20 78 ldd [ %i4 + 0x78 ], %o0 the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 2017fac: 82 10 20 03 mov 3, %g1 2017fb0: 94 10 20 00 clr %o2 2017fb4: c2 24 20 38 st %g1, [ %l0 + 0x38 ] 2017fb8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2017fbc: c0 24 20 18 clr [ %l0 + 0x18 ] 2017fc0: 96 12 e2 00 or %o3, 0x200, %o3 the_watchdog->routine = routine; 2017fc4: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 2017fc8: f0 24 20 30 st %i0, [ %l0 + 0x30 ] 2017fcc: 40 00 52 64 call 202c95c <__divdi3> 2017fd0: f6 24 20 34 st %i3, [ %l0 + 0x34 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); (*timer_server->schedule_operation)( timer_server, the_timer ); 2017fd4: c2 07 60 04 ld [ %i5 + 4 ], %g1 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 2017fd8: b2 26 40 09 sub %i1, %o1, %i1 (*timer_server->schedule_operation)( timer_server, the_timer ); 2017fdc: 90 10 00 1d mov %i5, %o0 2017fe0: 92 10 00 10 mov %l0, %o1 2017fe4: 9f c0 40 00 call %g1 2017fe8: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Thread_Enable_dispatch(); 2017fec: 40 00 0f 75 call 201bdc0 <_Thread_Enable_dispatch> 2017ff0: 01 00 00 00 nop return RTEMS_SUCCESSFUL; 2017ff4: 10 bf ff cb b 2017f20 2017ff8: 82 10 20 00 clr %g1 ! 0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 2017ffc: 10 bf ff c9 b 2017f20 2018000: 82 10 20 04 mov 4, %g1 =============================================================================== 020084c4 : #include int sched_get_priority_max( int policy ) { 20084c4: 9d e3 bf a0 save %sp, -96, %sp switch ( policy ) { 20084c8: 80 a6 20 04 cmp %i0, 4 20084cc: 08 80 00 08 bleu 20084ec 20084d0: 82 10 20 01 mov 1, %g1 case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 20084d4: 40 00 23 cf call 2011410 <__errno> 20084d8: b0 10 3f ff mov -1, %i0 20084dc: 82 10 20 16 mov 0x16, %g1 20084e0: c2 22 00 00 st %g1, [ %o0 ] 20084e4: 81 c7 e0 08 ret 20084e8: 81 e8 00 00 restore int sched_get_priority_max( int policy ) { switch ( policy ) { 20084ec: b1 28 40 18 sll %g1, %i0, %i0 20084f0: 80 8e 20 17 btst 0x17, %i0 20084f4: 02 bf ff f8 be 20084d4 <== NEVER TAKEN 20084f8: 03 00 80 8a sethi %hi(0x2022800), %g1 default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 20084fc: f0 08 60 e8 ldub [ %g1 + 0xe8 ], %i0 ! 20228e8 } 2008500: 81 c7 e0 08 ret 2008504: 91 ee 3f ff restore %i0, -1, %o0 =============================================================================== 02008508 : #include int sched_get_priority_min( int policy ) { 2008508: 9d e3 bf a0 save %sp, -96, %sp switch ( policy ) { 200850c: 80 a6 20 04 cmp %i0, 4 2008510: 08 80 00 08 bleu 2008530 2008514: 82 10 00 18 mov %i0, %g1 case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 2008518: 40 00 23 be call 2011410 <__errno> 200851c: b0 10 3f ff mov -1, %i0 2008520: 82 10 20 16 mov 0x16, %g1 2008524: c2 22 00 00 st %g1, [ %o0 ] } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 2008528: 81 c7 e0 08 ret 200852c: 81 e8 00 00 restore int sched_get_priority_min( int policy ) { switch ( policy ) { 2008530: 84 10 20 01 mov 1, %g2 2008534: 83 28 80 01 sll %g2, %g1, %g1 2008538: 80 88 60 17 btst 0x17, %g1 200853c: 02 bf ff f7 be 2008518 <== NEVER TAKEN 2008540: b0 10 20 01 mov 1, %i0 default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 2008544: 81 c7 e0 08 ret 2008548: 81 e8 00 00 restore =============================================================================== 0200854c : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 200854c: 9d e3 bf a0 save %sp, -96, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 2008550: 80 a6 20 00 cmp %i0, 0 2008554: 12 80 00 0a bne 200857c <== ALWAYS TAKEN 2008558: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); if ( !interval ) 200855c: 02 80 00 13 be 20085a8 2008560: 03 00 80 8d sethi %hi(0x2023400), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 2008564: d0 00 61 d0 ld [ %g1 + 0x1d0 ], %o0 ! 20235d0 <_Thread_Ticks_per_timeslice> 2008568: 92 10 00 19 mov %i1, %o1 200856c: 40 00 0f 89 call 200c390 <_Timespec_From_ticks> 2008570: b0 10 20 00 clr %i0 return 0; } 2008574: 81 c7 e0 08 ret 2008578: 81 e8 00 00 restore { /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 200857c: 7f ff ee 7c call 2003f6c 2008580: 01 00 00 00 nop 2008584: 80 a2 00 18 cmp %o0, %i0 2008588: 02 bf ff f5 be 200855c 200858c: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 2008590: 40 00 23 a0 call 2011410 <__errno> 2008594: b0 10 3f ff mov -1, %i0 2008598: 82 10 20 03 mov 3, %g1 200859c: c2 22 00 00 st %g1, [ %o0 ] 20085a0: 81 c7 e0 08 ret 20085a4: 81 e8 00 00 restore if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 20085a8: 40 00 23 9a call 2011410 <__errno> 20085ac: b0 10 3f ff mov -1, %i0 20085b0: 82 10 20 16 mov 0x16, %g1 20085b4: c2 22 00 00 st %g1, [ %o0 ] 20085b8: 81 c7 e0 08 ret 20085bc: 81 e8 00 00 restore =============================================================================== 02008b38 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 2008b38: 9d e3 bf 88 save %sp, -120, %sp * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2008b3c: 03 00 80 8c sethi %hi(0x2023000), %g1 2008b40: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20233a0 <_Thread_Dispatch_disable_level> size_t name_len; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); 2008b44: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 2008b48: 84 00 a0 01 inc %g2 2008b4c: c4 20 63 a0 st %g2, [ %g1 + 0x3a0 ] return _Thread_Dispatch_disable_level; 2008b50: c2 00 63 a0 ld [ %g1 + 0x3a0 ], %g1 2008b54: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2008b58: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2008b5c: fa 27 a0 58 st %i5, [ %fp + 0x58 ] Objects_Locations location; size_t name_len; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 2008b60: b4 8e 62 00 andcc %i1, 0x200, %i2 2008b64: 12 80 00 27 bne 2008c00 2008b68: b6 10 20 00 clr %i3 const char *name, Objects_Id *id, size_t *len ) { return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len ); 2008b6c: 39 00 80 8d sethi %hi(0x2023400), %i4 2008b70: 92 10 00 18 mov %i0, %o1 2008b74: 90 17 22 90 or %i4, 0x290, %o0 2008b78: 94 07 bf f0 add %fp, -16, %o2 2008b7c: 7f ff fe 5b call 20084e8 <_POSIX_Name_to_id> 2008b80: 96 07 bf fc add %fp, -4, %o3 * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 2008b84: ba 92 20 00 orcc %o0, 0, %i5 2008b88: 22 80 00 0e be,a 2008bc0 2008b8c: b2 0e 6a 00 and %i1, 0xa00, %i1 /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 2008b90: 80 a7 60 02 cmp %i5, 2 2008b94: 12 80 00 04 bne 2008ba4 2008b98: 80 a6 a0 00 cmp %i2, 0 2008b9c: 12 80 00 1d bne 2008c10 2008ba0: d2 07 bf fc ld [ %fp + -4 ], %o1 _Thread_Enable_dispatch(); 2008ba4: 40 00 0e 82 call 200c5ac <_Thread_Enable_dispatch> 2008ba8: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 2008bac: 40 00 26 e8 call 201274c <__errno> 2008bb0: 01 00 00 00 nop 2008bb4: fa 22 00 00 st %i5, [ %o0 ] 2008bb8: 81 c7 e0 08 ret 2008bbc: 81 e8 00 00 restore /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 2008bc0: 80 a6 6a 00 cmp %i1, 0xa00 2008bc4: 02 80 00 1f be 2008c40 2008bc8: d2 07 bf f0 ld [ %fp + -16 ], %o1 RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get ( sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) 2008bcc: 94 07 bf f8 add %fp, -8, %o2 2008bd0: 40 00 0a 62 call 200b558 <_Objects_Get> 2008bd4: 90 17 22 90 or %i4, 0x290, %o0 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location ); the_semaphore->open_count += 1; 2008bd8: c2 02 20 18 ld [ %o0 + 0x18 ], %g1 if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location ); 2008bdc: d0 27 bf f4 st %o0, [ %fp + -12 ] the_semaphore->open_count += 1; 2008be0: 82 00 60 01 inc %g1 _Thread_Enable_dispatch(); 2008be4: 40 00 0e 72 call 200c5ac <_Thread_Enable_dispatch> 2008be8: c2 22 20 18 st %g1, [ %o0 + 0x18 ] _Thread_Enable_dispatch(); 2008bec: 40 00 0e 70 call 200c5ac <_Thread_Enable_dispatch> 2008bf0: 01 00 00 00 nop return_id: #if defined(RTEMS_USE_16_BIT_OBJECT) the_semaphore->Semaphore_id = the_semaphore->Object.id; return &the_semaphore->Semaphore_id; #else return (sem_t *)&the_semaphore->Object.id; 2008bf4: f0 07 bf f4 ld [ %fp + -12 ], %i0 2008bf8: 81 c7 e0 08 ret 2008bfc: 91 ee 20 08 restore %i0, 8, %o0 size_t name_len; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); 2008c00: 82 07 a0 4c add %fp, 0x4c, %g1 mode = va_arg( arg, mode_t ); value = va_arg( arg, unsigned int ); 2008c04: f6 07 a0 50 ld [ %fp + 0x50 ], %i3 size_t name_len; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); 2008c08: 10 bf ff d9 b 2008b6c 2008c0c: c2 27 bf ec st %g1, [ %fp + -20 ] /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 2008c10: 94 10 20 00 clr %o2 2008c14: 96 10 00 1b mov %i3, %o3 2008c18: 98 07 bf f4 add %fp, -12, %o4 2008c1c: 40 00 1b 29 call 200f8c0 <_POSIX_Semaphore_Create_support> 2008c20: 90 10 00 18 mov %i0, %o0 /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 2008c24: 40 00 0e 62 call 200c5ac <_Thread_Enable_dispatch> 2008c28: ba 10 00 08 mov %o0, %i5 if ( status == -1 ) 2008c2c: 80 a7 7f ff cmp %i5, -1 2008c30: 32 bf ff f2 bne,a 2008bf8 <== ALWAYS TAKEN 2008c34: f0 07 bf f4 ld [ %fp + -12 ], %i0 the_semaphore->Semaphore_id = the_semaphore->Object.id; return &the_semaphore->Semaphore_id; #else return (sem_t *)&the_semaphore->Object.id; #endif } 2008c38: 81 c7 e0 08 ret <== NOT EXECUTED 2008c3c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); 2008c40: 40 00 0e 5b call 200c5ac <_Thread_Enable_dispatch> 2008c44: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 2008c48: 40 00 26 c1 call 201274c <__errno> 2008c4c: 01 00 00 00 nop 2008c50: 82 10 20 11 mov 0x11, %g1 ! 11 2008c54: c2 22 00 00 st %g1, [ %o0 ] 2008c58: 81 c7 e0 08 ret 2008c5c: 81 e8 00 00 restore =============================================================================== 0200af68 : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 200af68: 9d e3 bf 98 save %sp, -104, %sp * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 200af6c: 90 10 00 19 mov %i1, %o0 200af70: 40 00 17 1a call 2010bd8 <_POSIX_Absolute_timeout_to_ticks> 200af74: 92 07 bf fc add %fp, -4, %o1 if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 200af78: d4 07 bf fc ld [ %fp + -4 ], %o2 * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) 200af7c: 80 a2 20 03 cmp %o0, 3 200af80: 02 80 00 06 be 200af98 <== ALWAYS TAKEN 200af84: 90 10 00 18 mov %i0, %o0 do_wait = false; lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 200af88: 40 00 1a 14 call 20117d8 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 200af8c: 92 10 20 00 clr %o1 <== NOT EXECUTED 200af90: 81 c7 e0 08 ret <== NOT EXECUTED 200af94: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 200af98: 40 00 1a 10 call 20117d8 <_POSIX_Semaphore_Wait_support> 200af9c: 92 10 20 01 mov 1, %o1 lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) rtems_set_errno_and_return_minus_one( ETIMEDOUT ); } return lock_status; } 200afa0: 81 c7 e0 08 ret 200afa4: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 02008460 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 2008460: 9d e3 bf a0 save %sp, -96, %sp ISR_Level level; if ( oact ) 2008464: 80 a6 a0 00 cmp %i2, 0 2008468: 02 80 00 0d be 200849c 200846c: 87 2e 20 02 sll %i0, 2, %g3 *oact = _POSIX_signals_Vectors[ sig ]; 2008470: 05 00 80 89 sethi %hi(0x2022400), %g2 2008474: 83 2e 20 04 sll %i0, 4, %g1 2008478: 84 10 a1 50 or %g2, 0x150, %g2 200847c: 82 20 40 03 sub %g1, %g3, %g1 2008480: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2008484: 82 00 80 01 add %g2, %g1, %g1 2008488: c6 26 80 00 st %g3, [ %i2 ] 200848c: c4 00 60 04 ld [ %g1 + 4 ], %g2 2008490: c4 26 a0 04 st %g2, [ %i2 + 4 ] 2008494: c2 00 60 08 ld [ %g1 + 8 ], %g1 2008498: c2 26 a0 08 st %g1, [ %i2 + 8 ] if ( !sig ) 200849c: 80 a6 20 00 cmp %i0, 0 20084a0: 02 80 00 33 be 200856c 20084a4: 01 00 00 00 nop static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 20084a8: 82 06 3f ff add %i0, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 20084ac: 80 a0 60 1f cmp %g1, 0x1f 20084b0: 18 80 00 2f bgu 200856c 20084b4: 80 a6 20 09 cmp %i0, 9 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 20084b8: 02 80 00 2d be 200856c 20084bc: 80 a6 60 00 cmp %i1, 0 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 20084c0: 02 80 00 1a be 2008528 <== NEVER TAKEN 20084c4: 82 10 20 00 clr %g1 /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 20084c8: 7f ff e9 93 call 2002b14 20084cc: 01 00 00 00 nop 20084d0: ba 10 00 08 mov %o0, %i5 if ( act->sa_handler == SIG_DFL ) { 20084d4: c2 06 60 08 ld [ %i1 + 8 ], %g1 20084d8: 80 a0 60 00 cmp %g1, 0 20084dc: 02 80 00 15 be 2008530 20084e0: 83 2e 20 02 sll %i0, 2, %g1 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; } else { _POSIX_signals_Clear_process_signals( sig ); 20084e4: 40 00 18 69 call 200e688 <_POSIX_signals_Clear_process_signals> 20084e8: 90 10 00 18 mov %i0, %o0 _POSIX_signals_Vectors[ sig ] = *act; 20084ec: c4 06 40 00 ld [ %i1 ], %g2 20084f0: 87 2e 20 02 sll %i0, 2, %g3 20084f4: 03 00 80 89 sethi %hi(0x2022400), %g1 20084f8: b1 2e 20 04 sll %i0, 4, %i0 20084fc: 82 10 61 50 or %g1, 0x150, %g1 2008500: b0 26 00 03 sub %i0, %g3, %i0 2008504: c4 20 40 18 st %g2, [ %g1 + %i0 ] 2008508: c4 06 60 04 ld [ %i1 + 4 ], %g2 200850c: b0 00 40 18 add %g1, %i0, %i0 2008510: c4 26 20 04 st %g2, [ %i0 + 4 ] 2008514: c2 06 60 08 ld [ %i1 + 8 ], %g1 2008518: c2 26 20 08 st %g1, [ %i0 + 8 ] } _ISR_Enable( level ); 200851c: 7f ff e9 82 call 2002b24 2008520: 90 10 00 1d mov %i5, %o0 * now (signals not posted when SIG_IGN). * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; 2008524: 82 10 20 00 clr %g1 } 2008528: 81 c7 e0 08 ret 200852c: 91 e8 00 01 restore %g0, %g1, %o0 * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); if ( act->sa_handler == SIG_DFL ) { _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 2008530: b1 2e 20 04 sll %i0, 4, %i0 2008534: b0 26 00 01 sub %i0, %g1, %i0 2008538: 03 00 80 7f sethi %hi(0x201fc00), %g1 200853c: 82 10 63 94 or %g1, 0x394, %g1 ! 201ff94 <_POSIX_signals_Default_vectors> 2008540: c8 00 40 18 ld [ %g1 + %i0 ], %g4 2008544: 82 00 40 18 add %g1, %i0, %g1 2008548: c6 00 60 04 ld [ %g1 + 4 ], %g3 200854c: c4 00 60 08 ld [ %g1 + 8 ], %g2 2008550: 03 00 80 89 sethi %hi(0x2022400), %g1 2008554: 82 10 61 50 or %g1, 0x150, %g1 ! 2022550 <_POSIX_signals_Vectors> 2008558: c8 20 40 18 st %g4, [ %g1 + %i0 ] 200855c: b0 00 40 18 add %g1, %i0, %i0 2008560: c6 26 20 04 st %g3, [ %i0 + 4 ] 2008564: 10 bf ff ee b 200851c 2008568: c4 26 20 08 st %g2, [ %i0 + 8 ] * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) rtems_set_errno_and_return_minus_one( EINVAL ); 200856c: 40 00 25 25 call 2011a00 <__errno> 2008570: 01 00 00 00 nop 2008574: 84 10 20 16 mov 0x16, %g2 ! 16 2008578: 82 10 3f ff mov -1, %g1 200857c: 10 bf ff eb b 2008528 2008580: c4 22 00 00 st %g2, [ %o0 ] =============================================================================== 020089f4 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 20089f4: 9d e3 bf 90 save %sp, -112, %sp ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 20089f8: ba 96 20 00 orcc %i0, 0, %i5 20089fc: 02 80 00 84 be 2008c0c 2008a00: 80 a6 a0 00 cmp %i2, 0 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 2008a04: 02 80 00 5c be 2008b74 2008a08: 80 a6 60 00 cmp %i1, 0 if ( !_Timespec_Is_valid( timeout ) ) 2008a0c: 40 00 0f cc call 200c93c <_Timespec_Is_valid> 2008a10: 90 10 00 1a mov %i2, %o0 2008a14: 80 8a 20 ff btst 0xff, %o0 2008a18: 02 80 00 7d be 2008c0c 2008a1c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 2008a20: 40 00 0f da call 200c988 <_Timespec_To_ticks> 2008a24: 90 10 00 1a mov %i2, %o0 if ( !interval ) 2008a28: b0 92 20 00 orcc %o0, 0, %i0 2008a2c: 02 80 00 78 be 2008c0c <== NEVER TAKEN 2008a30: 80 a6 60 00 cmp %i1, 0 /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 2008a34: 02 80 00 53 be 2008b80 <== NEVER TAKEN 2008a38: 35 00 80 8a sethi %hi(0x2022800), %i2 the_thread = _Thread_Executing; 2008a3c: 35 00 80 8a sethi %hi(0x2022800), %i2 2008a40: b4 16 a2 10 or %i2, 0x210, %i2 ! 2022a10 <_Per_CPU_Information> 2008a44: f8 06 a0 0c ld [ %i2 + 0xc ], %i4 * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 2008a48: 7f ff e9 0e call 2002e80 2008a4c: f6 07 21 5c ld [ %i4 + 0x15c ], %i3 2008a50: a0 10 00 08 mov %o0, %l0 if ( *set & api->signals_pending ) { 2008a54: c2 07 40 00 ld [ %i5 ], %g1 2008a58: c4 06 e0 d4 ld [ %i3 + 0xd4 ], %g2 2008a5c: 80 88 40 02 btst %g1, %g2 2008a60: 12 80 00 53 bne 2008bac 2008a64: 01 00 00 00 nop return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 2008a68: 05 00 80 8b sethi %hi(0x2022c00), %g2 2008a6c: c4 00 a0 64 ld [ %g2 + 0x64 ], %g2 ! 2022c64 <_POSIX_signals_Pending> 2008a70: 80 88 40 02 btst %g1, %g2 2008a74: 12 80 00 2f bne 2008b30 2008a78: 03 00 80 89 sethi %hi(0x2022400), %g1 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2008a7c: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 20224e0 <_Thread_Dispatch_disable_level> the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 2008a80: 86 10 3f ff mov -1, %g3 2008a84: c6 26 40 00 st %g3, [ %i1 ] 2008a88: 84 00 a0 01 inc %g2 2008a8c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] return _Thread_Dispatch_disable_level; 2008a90: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; 2008a94: 82 10 20 04 mov 4, %g1 2008a98: c2 27 20 34 st %g1, [ %i4 + 0x34 ] the_thread->Wait.option = *set; 2008a9c: c2 07 40 00 ld [ %i5 ], %g1 the_thread->Wait.return_argument = the_info; 2008aa0: f2 27 20 28 st %i1, [ %i4 + 0x28 ] the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; the_thread->Wait.option = *set; 2008aa4: c2 27 20 30 st %g1, [ %i4 + 0x30 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 2008aa8: a2 10 20 01 mov 1, %l1 } the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 2008aac: 21 00 80 8a sethi %hi(0x2022800), %l0 2008ab0: a0 14 23 fc or %l0, 0x3fc, %l0 ! 2022bfc <_POSIX_signals_Wait_queue> 2008ab4: e0 27 20 44 st %l0, [ %i4 + 0x44 ] 2008ab8: e2 24 20 30 st %l1, [ %l0 + 0x30 ] the_thread->Wait.return_code = EINTR; the_thread->Wait.option = *set; the_thread->Wait.return_argument = the_info; _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 2008abc: 7f ff e8 f5 call 2002e90 2008ac0: 01 00 00 00 nop _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 2008ac4: 90 10 00 10 mov %l0, %o0 2008ac8: 92 10 00 18 mov %i0, %o1 2008acc: 15 00 80 31 sethi %hi(0x200c400), %o2 2008ad0: 40 00 0e 29 call 200c374 <_Thread_queue_Enqueue_with_handler> 2008ad4: 94 12 a3 54 or %o2, 0x354, %o2 ! 200c754 <_Thread_queue_Timeout> _Thread_Enable_dispatch(); 2008ad8: 40 00 0c d8 call 200be38 <_Thread_Enable_dispatch> 2008adc: 01 00 00 00 nop /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); 2008ae0: d2 06 40 00 ld [ %i1 ], %o1 2008ae4: 90 10 00 1b mov %i3, %o0 2008ae8: 94 10 00 19 mov %i1, %o2 2008aec: 96 10 20 00 clr %o3 2008af0: 40 00 19 23 call 200ef7c <_POSIX_signals_Clear_signals> 2008af4: 98 10 20 00 clr %o4 /* Set errno only if return code is not EINTR or * if EINTR was caused by a signal being caught, which * was not in our set. */ if ( (_Thread_Executing->Wait.return_code != EINTR) 2008af8: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 2008afc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 2008b00: 80 a0 60 04 cmp %g1, 4 2008b04: 12 80 00 3b bne 2008bf0 2008b08: 01 00 00 00 nop || !(*set & signo_to_mask( the_info->si_signo )) ) { 2008b0c: f0 06 40 00 ld [ %i1 ], %i0 2008b10: c2 07 40 00 ld [ %i5 ], %g1 2008b14: 84 06 3f ff add %i0, -1, %g2 2008b18: a3 2c 40 02 sll %l1, %g2, %l1 2008b1c: 80 8c 40 01 btst %l1, %g1 2008b20: 02 80 00 34 be 2008bf0 2008b24: 01 00 00 00 nop errno = _Thread_Executing->Wait.return_code; return -1; } return the_info->si_signo; } 2008b28: 81 c7 e0 08 ret 2008b2c: 81 e8 00 00 restore } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 2008b30: 7f ff ff 99 call 2008994 <_POSIX_signals_Get_lowest> 2008b34: 90 10 00 02 mov %g2, %o0 _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 2008b38: 94 10 00 19 mov %i1, %o2 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 2008b3c: b0 10 00 08 mov %o0, %i0 _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 2008b40: 96 10 20 01 mov 1, %o3 2008b44: 90 10 00 1b mov %i3, %o0 2008b48: 92 10 00 18 mov %i0, %o1 2008b4c: 40 00 19 0c call 200ef7c <_POSIX_signals_Clear_signals> 2008b50: 98 10 20 00 clr %o4 _ISR_Enable( level ); 2008b54: 7f ff e8 cf call 2002e90 2008b58: 90 10 00 10 mov %l0, %o0 the_info->si_signo = signo; the_info->si_code = SI_USER; 2008b5c: 82 10 20 01 mov 1, %g1 if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); _ISR_Enable( level ); the_info->si_signo = signo; 2008b60: f0 26 40 00 st %i0, [ %i1 ] the_info->si_code = SI_USER; 2008b64: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->si_value.sival_int = 0; 2008b68: c0 26 60 08 clr [ %i1 + 8 ] 2008b6c: 81 c7 e0 08 ret 2008b70: 81 e8 00 00 restore /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 2008b74: 12 bf ff b2 bne 2008a3c 2008b78: b0 10 20 00 clr %i0 the_thread = _Thread_Executing; 2008b7c: 35 00 80 8a sethi %hi(0x2022800), %i2 2008b80: b4 16 a2 10 or %i2, 0x210, %i2 ! 2022a10 <_Per_CPU_Information> 2008b84: f8 06 a0 0c ld [ %i2 + 0xc ], %i4 /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 2008b88: b2 07 bf f4 add %fp, -12, %i1 * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 2008b8c: 7f ff e8 bd call 2002e80 2008b90: f6 07 21 5c ld [ %i4 + 0x15c ], %i3 2008b94: a0 10 00 08 mov %o0, %l0 if ( *set & api->signals_pending ) { 2008b98: c2 07 40 00 ld [ %i5 ], %g1 2008b9c: c4 06 e0 d4 ld [ %i3 + 0xd4 ], %g2 2008ba0: 80 88 40 02 btst %g1, %g2 2008ba4: 22 bf ff b2 be,a 2008a6c 2008ba8: 05 00 80 8b sethi %hi(0x2022c00), %g2 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 2008bac: 7f ff ff 7a call 2008994 <_POSIX_signals_Get_lowest> 2008bb0: 90 10 00 02 mov %g2, %o0 _POSIX_signals_Clear_signals( 2008bb4: 94 10 00 19 mov %i1, %o2 /* API signals pending? */ _ISR_Disable( level ); if ( *set & api->signals_pending ) { /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 2008bb8: 92 10 00 08 mov %o0, %o1 2008bbc: d0 26 40 00 st %o0, [ %i1 ] _POSIX_signals_Clear_signals( 2008bc0: 96 10 20 00 clr %o3 2008bc4: 90 10 00 1b mov %i3, %o0 2008bc8: 40 00 18 ed call 200ef7c <_POSIX_signals_Clear_signals> 2008bcc: 98 10 20 00 clr %o4 the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 2008bd0: 7f ff e8 b0 call 2002e90 2008bd4: 90 10 00 10 mov %l0, %o0 the_info->si_code = SI_USER; 2008bd8: 82 10 20 01 mov 1, %g1 the_info->si_value.sival_int = 0; 2008bdc: c0 26 60 08 clr [ %i1 + 8 ] false, false ); _ISR_Enable( level ); the_info->si_code = SI_USER; 2008be0: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->si_value.sival_int = 0; return the_info->si_signo; 2008be4: f0 06 40 00 ld [ %i1 ], %i0 2008be8: 81 c7 e0 08 ret 2008bec: 81 e8 00 00 restore * was not in our set. */ if ( (_Thread_Executing->Wait.return_code != EINTR) || !(*set & signo_to_mask( the_info->si_signo )) ) { errno = _Thread_Executing->Wait.return_code; 2008bf0: 40 00 25 64 call 2012180 <__errno> 2008bf4: b0 10 3f ff mov -1, %i0 2008bf8: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 2008bfc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 2008c00: c2 22 00 00 st %g1, [ %o0 ] return -1; } return the_info->si_signo; } 2008c04: 81 c7 e0 08 ret 2008c08: 81 e8 00 00 restore rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 2008c0c: 40 00 25 5d call 2012180 <__errno> 2008c10: b0 10 3f ff mov -1, %i0 2008c14: 82 10 20 16 mov 0x16, %g1 2008c18: c2 22 00 00 st %g1, [ %o0 ] 2008c1c: 81 c7 e0 08 ret 2008c20: 81 e8 00 00 restore =============================================================================== 0200a82c : int sigwait( const sigset_t *set, int *sig ) { 200a82c: 9d e3 bf a0 save %sp, -96, %sp int status; status = sigtimedwait( set, NULL, NULL ); 200a830: 92 10 20 00 clr %o1 200a834: 90 10 00 18 mov %i0, %o0 200a838: 7f ff ff 6d call 200a5ec 200a83c: 94 10 20 00 clr %o2 if ( status != -1 ) { 200a840: 80 a2 3f ff cmp %o0, -1 200a844: 02 80 00 07 be 200a860 200a848: 80 a6 60 00 cmp %i1, 0 if ( sig ) 200a84c: 02 80 00 0a be 200a874 <== NEVER TAKEN 200a850: 01 00 00 00 nop *sig = status; 200a854: d0 26 40 00 st %o0, [ %i1 ] return 0; 200a858: 81 c7 e0 08 ret 200a85c: 91 e8 20 00 restore %g0, 0, %o0 } return errno; 200a860: 40 00 24 7f call 2013a5c <__errno> 200a864: 01 00 00 00 nop 200a868: f0 02 00 00 ld [ %o0 ], %i0 200a86c: 81 c7 e0 08 ret 200a870: 81 e8 00 00 restore } 200a874: 81 c7 e0 08 ret <== NOT EXECUTED 200a878: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 020076a8 : */ long sysconf( int name ) { 20076a8: 9d e3 bf a0 save %sp, -96, %sp if ( name == _SC_CLK_TCK ) 20076ac: 80 a6 20 02 cmp %i0, 2 20076b0: 02 80 00 12 be 20076f8 20076b4: 82 10 00 18 mov %i0, %g1 return (TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick()); if ( name == _SC_OPEN_MAX ) 20076b8: 80 a6 20 04 cmp %i0, 4 20076bc: 02 80 00 16 be 2007714 20076c0: 80 a0 60 33 cmp %g1, 0x33 return rtems_libio_number_iops; if ( name == _SC_GETPW_R_SIZE_MAX ) 20076c4: 02 80 00 0b be 20076f0 20076c8: b0 10 24 00 mov 0x400, %i0 return 1024; if ( name == _SC_PAGESIZE ) 20076cc: 80 a0 60 08 cmp %g1, 8 20076d0: 02 80 00 08 be 20076f0 20076d4: 31 00 00 04 sethi %hi(0x1000), %i0 return PAGE_SIZE; if ( name == _SC_SYMLOOP_MAX ) 20076d8: 80 a0 60 4f cmp %g1, 0x4f 20076dc: 02 80 00 05 be 20076f0 <== NEVER TAKEN 20076e0: b0 10 20 20 mov 0x20, %i0 return RTEMS_FILESYSTEM_SYMLOOP_MAX; #if defined(__sparc__) if ( name == 515 ) /* Solaris _SC_STACK_PROT */ 20076e4: 80 a0 62 03 cmp %g1, 0x203 20076e8: 12 80 00 0f bne 2007724 <== ALWAYS TAKEN 20076ec: b0 10 20 00 clr %i0 return 0; #endif rtems_set_errno_and_return_minus_one( EINVAL ); } 20076f0: 81 c7 e0 08 ret 20076f4: 81 e8 00 00 restore int name ) { if ( name == _SC_CLK_TCK ) return (TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick()); 20076f8: 03 00 80 77 sethi %hi(0x201dc00), %g1 long sysconf( int name ) { if ( name == _SC_CLK_TCK ) return (TOD_MICROSECONDS_PER_SECOND / 20076fc: d2 00 62 bc ld [ %g1 + 0x2bc ], %o1 ! 201debc 2007700: 11 00 03 d0 sethi %hi(0xf4000), %o0 2007704: 40 00 48 a5 call 2019998 <.udiv> 2007708: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 200770c: 81 c7 e0 08 ret 2007710: 91 e8 00 08 restore %g0, %o0, %o0 rtems_configuration_get_microseconds_per_tick()); if ( name == _SC_OPEN_MAX ) return rtems_libio_number_iops; 2007714: 03 00 80 78 sethi %hi(0x201e000), %g1 2007718: f0 00 60 04 ld [ %g1 + 4 ], %i0 ! 201e004 200771c: 81 c7 e0 08 ret 2007720: 81 e8 00 00 restore #if defined(__sparc__) if ( name == 515 ) /* Solaris _SC_STACK_PROT */ return 0; #endif rtems_set_errno_and_return_minus_one( EINVAL ); 2007724: 40 00 25 1f call 2010ba0 <__errno> 2007728: b0 10 3f ff mov -1, %i0 200772c: 82 10 20 16 mov 0x16, %g1 2007730: c2 22 00 00 st %g1, [ %o0 ] } 2007734: 81 c7 e0 08 ret 2007738: 81 e8 00 00 restore =============================================================================== 02008c60 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 2008c60: 9d e3 bf a0 save %sp, -96, %sp POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 2008c64: 80 a6 20 01 cmp %i0, 1 2008c68: 12 80 00 3e bne 2008d60 2008c6c: 80 a6 a0 00 cmp %i2, 0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 2008c70: 02 80 00 3c be 2008d60 2008c74: 80 a6 60 00 cmp %i1, 0 /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 2008c78: 02 80 00 0e be 2008cb0 2008c7c: 03 00 80 8c sethi %hi(0x2023000), %g1 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 2008c80: c2 06 40 00 ld [ %i1 ], %g1 2008c84: 82 00 7f ff add %g1, -1, %g1 2008c88: 80 a0 60 01 cmp %g1, 1 2008c8c: 18 80 00 35 bgu 2008d60 <== NEVER TAKEN 2008c90: 01 00 00 00 nop ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 2008c94: c2 06 60 04 ld [ %i1 + 4 ], %g1 2008c98: 80 a0 60 00 cmp %g1, 0 2008c9c: 02 80 00 31 be 2008d60 <== NEVER TAKEN 2008ca0: 82 00 7f ff add %g1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 2008ca4: 80 a0 60 1f cmp %g1, 0x1f 2008ca8: 18 80 00 2e bgu 2008d60 <== NEVER TAKEN 2008cac: 03 00 80 8c sethi %hi(0x2023000), %g1 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 2008cb0: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20233a0 <_Thread_Dispatch_disable_level> 2008cb4: 84 00 a0 01 inc %g2 2008cb8: c4 20 63 a0 st %g2, [ %g1 + 0x3a0 ] return _Thread_Dispatch_disable_level; 2008cbc: c2 00 63 a0 ld [ %g1 + 0x3a0 ], %g1 * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void ) { return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information ); 2008cc0: 3b 00 80 8d sethi %hi(0x2023400), %i5 2008cc4: 40 00 08 d2 call 200b00c <_Objects_Allocate> 2008cc8: 90 17 62 d0 or %i5, 0x2d0, %o0 ! 20236d0 <_POSIX_Timer_Information> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 2008ccc: 80 a2 20 00 cmp %o0, 0 2008cd0: 02 80 00 2a be 2008d78 2008cd4: 82 10 20 02 mov 2, %g1 rtems_set_errno_and_return_minus_one( EAGAIN ); } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 2008cd8: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ] ptimer->thread_id = _Thread_Executing->Object.id; 2008cdc: 03 00 80 8e sethi %hi(0x2023800), %g1 2008ce0: c2 00 61 1c ld [ %g1 + 0x11c ], %g1 ! 202391c <_Per_CPU_Information+0xc> if ( evp != NULL ) { 2008ce4: 80 a6 60 00 cmp %i1, 0 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; ptimer->thread_id = _Thread_Executing->Object.id; 2008ce8: c2 00 60 08 ld [ %g1 + 8 ], %g1 if ( evp != NULL ) { 2008cec: 02 80 00 08 be 2008d0c 2008cf0: c2 22 20 38 st %g1, [ %o0 + 0x38 ] ptimer->inf.sigev_notify = evp->sigev_notify; 2008cf4: c6 06 40 00 ld [ %i1 ], %g3 ptimer->inf.sigev_signo = evp->sigev_signo; 2008cf8: c4 06 60 04 ld [ %i1 + 4 ], %g2 ptimer->inf.sigev_value = evp->sigev_value; 2008cfc: c2 06 60 08 ld [ %i1 + 8 ], %g1 ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; ptimer->thread_id = _Thread_Executing->Object.id; if ( evp != NULL ) { ptimer->inf.sigev_notify = evp->sigev_notify; 2008d00: c6 22 20 40 st %g3, [ %o0 + 0x40 ] ptimer->inf.sigev_signo = evp->sigev_signo; 2008d04: c4 22 20 44 st %g2, [ %o0 + 0x44 ] ptimer->inf.sigev_value = evp->sigev_value; 2008d08: c2 22 20 48 st %g1, [ %o0 + 0x48 ] Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 2008d0c: c4 12 20 0a lduh [ %o0 + 0xa ], %g2 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2008d10: ba 17 62 d0 or %i5, 0x2d0, %i5 2008d14: c6 07 60 1c ld [ %i5 + 0x1c ], %g3 } ptimer->overrun = 0; 2008d18: c0 22 20 68 clr [ %o0 + 0x68 ] ptimer->timer_data.it_value.tv_sec = 0; 2008d1c: c0 22 20 5c clr [ %o0 + 0x5c ] ptimer->timer_data.it_value.tv_nsec = 0; 2008d20: c0 22 20 60 clr [ %o0 + 0x60 ] ptimer->timer_data.it_interval.tv_sec = 0; 2008d24: c0 22 20 54 clr [ %o0 + 0x54 ] ptimer->timer_data.it_interval.tv_nsec = 0; 2008d28: c0 22 20 58 clr [ %o0 + 0x58 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2008d2c: c0 22 20 18 clr [ %o0 + 0x18 ] the_watchdog->routine = routine; 2008d30: c0 22 20 2c clr [ %o0 + 0x2c ] the_watchdog->id = id; 2008d34: c0 22 20 30 clr [ %o0 + 0x30 ] the_watchdog->user_data = user_data; 2008d38: c0 22 20 34 clr [ %o0 + 0x34 ] Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 2008d3c: c2 02 20 08 ld [ %o0 + 8 ], %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2008d40: 85 28 a0 02 sll %g2, 2, %g2 2008d44: d0 20 c0 02 st %o0, [ %g3 + %g2 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 2008d48: c0 22 20 0c clr [ %o0 + 0xc ] _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 2008d4c: c2 26 80 00 st %g1, [ %i2 ] _Thread_Enable_dispatch(); 2008d50: 40 00 0e 17 call 200c5ac <_Thread_Enable_dispatch> 2008d54: b0 10 20 00 clr %i0 return 0; } 2008d58: 81 c7 e0 08 ret 2008d5c: 81 e8 00 00 restore if ( !evp->sigev_signo ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 2008d60: 40 00 26 7b call 201274c <__errno> 2008d64: b0 10 3f ff mov -1, %i0 2008d68: 82 10 20 16 mov 0x16, %g1 2008d6c: c2 22 00 00 st %g1, [ %o0 ] 2008d70: 81 c7 e0 08 ret 2008d74: 81 e8 00 00 restore /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { _Thread_Enable_dispatch(); 2008d78: 40 00 0e 0d call 200c5ac <_Thread_Enable_dispatch> 2008d7c: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( EAGAIN ); 2008d80: 40 00 26 73 call 201274c <__errno> 2008d84: 01 00 00 00 nop 2008d88: 82 10 20 0b mov 0xb, %g1 ! b 2008d8c: c2 22 00 00 st %g1, [ %o0 ] 2008d90: 81 c7 e0 08 ret 2008d94: 81 e8 00 00 restore =============================================================================== 0200789c : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 200789c: 9d e3 bf 78 save %sp, -136, %sp Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 20078a0: 80 a6 a0 00 cmp %i2, 0 20078a4: 02 80 00 82 be 2007aac <== NEVER TAKEN 20078a8: 01 00 00 00 nop /* * First, it verifies if the structure "value" is correct * if the number of nanoseconds is not correct return EINVAL */ if ( !_Timespec_Is_valid( &(value->it_value) ) ) { 20078ac: 40 00 10 50 call 200b9ec <_Timespec_Is_valid> 20078b0: 90 06 a0 08 add %i2, 8, %o0 20078b4: 80 8a 20 ff btst 0xff, %o0 20078b8: 02 80 00 7d be 2007aac 20078bc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 20078c0: 40 00 10 4b call 200b9ec <_Timespec_Is_valid> 20078c4: 90 10 00 1a mov %i2, %o0 20078c8: 80 8a 20 ff btst 0xff, %o0 20078cc: 02 80 00 78 be 2007aac <== NEVER TAKEN 20078d0: 80 8e 7f fb btst -5, %i1 rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 20078d4: 12 80 00 76 bne 2007aac 20078d8: 80 a6 60 04 cmp %i1, 4 rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 20078dc: c8 06 80 00 ld [ %i2 ], %g4 20078e0: c6 06 a0 04 ld [ %i2 + 4 ], %g3 20078e4: c4 06 a0 08 ld [ %i2 + 8 ], %g2 20078e8: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 20078ec: c8 27 bf f0 st %g4, [ %fp + -16 ] 20078f0: c6 27 bf f4 st %g3, [ %fp + -12 ] 20078f4: c4 27 bf f8 st %g2, [ %fp + -8 ] /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 20078f8: 02 80 00 4a be 2007a20 20078fc: c2 27 bf fc st %g1, [ %fp + -4 ] RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get ( timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) 2007900: 92 10 00 18 mov %i0, %o1 2007904: 11 00 80 7d sethi %hi(0x201f400), %o0 2007908: 94 07 bf dc add %fp, -36, %o2 200790c: 40 00 09 99 call 2009f70 <_Objects_Get> 2007910: 90 12 22 d0 or %o0, 0x2d0, %o0 * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 2007914: c2 07 bf dc ld [ %fp + -36 ], %g1 2007918: 80 a0 60 00 cmp %g1, 0 200791c: 12 80 00 64 bne 2007aac <== NEVER TAKEN 2007920: b2 10 00 08 mov %o0, %i1 case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 2007924: c2 07 bf f8 ld [ %fp + -8 ], %g1 2007928: 80 a0 60 00 cmp %g1, 0 200792c: 12 80 00 05 bne 2007940 2007930: c2 07 bf fc ld [ %fp + -4 ], %g1 2007934: 80 a0 60 00 cmp %g1, 0 2007938: 02 80 00 63 be 2007ac4 200793c: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 2007940: 40 00 10 64 call 200bad0 <_Timespec_To_ticks> 2007944: 90 10 00 1a mov %i2, %o0 2007948: d0 26 60 64 st %o0, [ %i1 + 0x64 ] initial_period = _Timespec_To_ticks( &normalize.it_value ); 200794c: 40 00 10 61 call 200bad0 <_Timespec_To_ticks> 2007950: 90 07 bf f8 add %fp, -8, %o0 activated = _POSIX_Timer_Insert_helper( 2007954: d4 06 60 08 ld [ %i1 + 8 ], %o2 return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); initial_period = _Timespec_To_ticks( &normalize.it_value ); 2007958: 92 10 00 08 mov %o0, %o1 activated = _POSIX_Timer_Insert_helper( 200795c: 98 10 00 19 mov %i1, %o4 2007960: 90 06 60 10 add %i1, 0x10, %o0 2007964: 17 00 80 1e sethi %hi(0x2007800), %o3 2007968: 40 00 1a 27 call 200e204 <_POSIX_Timer_Insert_helper> 200796c: 96 12 e3 30 or %o3, 0x330, %o3 ! 2007b30 <_POSIX_Timer_TSR> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 2007970: 80 8a 20 ff btst 0xff, %o0 2007974: 02 80 00 27 be 2007a10 2007978: 80 a6 e0 00 cmp %i3, 0 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 200797c: 02 80 00 0b be 20079a8 2007980: c2 07 bf f0 ld [ %fp + -16 ], %g1 *ovalue = ptimer->timer_data; 2007984: c2 06 60 54 ld [ %i1 + 0x54 ], %g1 2007988: c2 26 c0 00 st %g1, [ %i3 ] 200798c: c2 06 60 58 ld [ %i1 + 0x58 ], %g1 2007990: c2 26 e0 04 st %g1, [ %i3 + 4 ] 2007994: c2 06 60 5c ld [ %i1 + 0x5c ], %g1 2007998: c2 26 e0 08 st %g1, [ %i3 + 8 ] 200799c: c2 06 60 60 ld [ %i1 + 0x60 ], %g1 20079a0: c2 26 e0 0c st %g1, [ %i3 + 0xc ] ptimer->timer_data = normalize; 20079a4: c2 07 bf f0 ld [ %fp + -16 ], %g1 struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 20079a8: 90 07 bf e0 add %fp, -32, %o0 20079ac: c2 26 60 54 st %g1, [ %i1 + 0x54 ] 20079b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20079b4: c2 26 60 58 st %g1, [ %i1 + 0x58 ] 20079b8: c2 07 bf f8 ld [ %fp + -8 ], %g1 20079bc: c2 26 60 5c st %g1, [ %i1 + 0x5c ] 20079c0: c2 07 bf fc ld [ %fp + -4 ], %g1 20079c4: c2 26 60 60 st %g1, [ %i1 + 0x60 ] /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 20079c8: 82 10 20 03 mov 3, %g1 20079cc: 40 00 06 a0 call 200944c <_TOD_Get_as_timestamp> 20079d0: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 20079d4: f8 1f bf e0 ldd [ %fp + -32 ], %i4 static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 20079d8: 94 10 20 00 clr %o2 20079dc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 20079e0: 90 10 00 1c mov %i4, %o0 20079e4: 96 12 e2 00 or %o3, 0x200, %o3 20079e8: 40 00 4b 89 call 201a80c <__divdi3> 20079ec: 92 10 00 1d mov %i5, %o1 _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 20079f0: 94 10 20 00 clr %o2 static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 20079f4: d2 26 60 6c st %o1, [ %i1 + 0x6c ] _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 20079f8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 20079fc: 90 10 00 1c mov %i4, %o0 2007a00: 96 12 e2 00 or %o3, 0x200, %o3 2007a04: 40 00 4c 6d call 201abb8 <__moddi3> 2007a08: 92 10 00 1d mov %i5, %o1 2007a0c: d2 26 60 70 st %o1, [ %i1 + 0x70 ] _TOD_Get( &ptimer->time ); _Thread_Enable_dispatch(); 2007a10: 40 00 0d 36 call 200aee8 <_Thread_Enable_dispatch> 2007a14: b0 10 20 00 clr %i0 2007a18: 81 c7 e0 08 ret 2007a1c: 81 e8 00 00 restore struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 2007a20: 40 00 06 8b call 200944c <_TOD_Get_as_timestamp> 2007a24: 90 07 bf e0 add %fp, -32, %o0 _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 2007a28: f8 1f bf e0 ldd [ %fp + -32 ], %i4 static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 2007a2c: 94 10 20 00 clr %o2 2007a30: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2007a34: 90 10 00 1c mov %i4, %o0 2007a38: 96 12 e2 00 or %o3, 0x200, %o3 2007a3c: 40 00 4b 74 call 201a80c <__divdi3> 2007a40: 92 10 00 1d mov %i5, %o1 _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 2007a44: 94 10 20 00 clr %o2 static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 2007a48: d2 27 bf e8 st %o1, [ %fp + -24 ] _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 2007a4c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3 2007a50: 90 10 00 1c mov %i4, %o0 2007a54: 96 12 e2 00 or %o3, 0x200, %o3 2007a58: 40 00 4c 58 call 201abb8 <__moddi3> 2007a5c: 92 10 00 1d mov %i5, %o1 /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { struct timespec now; _TOD_Get( &now ); /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 2007a60: 90 07 bf f8 add %fp, -8, %o0 2007a64: d2 27 bf ec st %o1, [ %fp + -20 ] 2007a68: 40 00 0f f4 call 200ba38 <_Timespec_Less_than> 2007a6c: 92 07 bf e8 add %fp, -24, %o1 2007a70: 80 8a 20 ff btst 0xff, %o0 2007a74: 12 80 00 0e bne 2007aac 2007a78: 92 07 bf f8 add %fp, -8, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 2007a7c: 90 07 bf e8 add %fp, -24, %o0 2007a80: 40 00 10 00 call 200ba80 <_Timespec_Subtract> 2007a84: 94 10 00 09 mov %o1, %o2 2007a88: 92 10 00 18 mov %i0, %o1 2007a8c: 11 00 80 7d sethi %hi(0x201f400), %o0 2007a90: 94 07 bf dc add %fp, -36, %o2 2007a94: 40 00 09 37 call 2009f70 <_Objects_Get> 2007a98: 90 12 22 d0 or %o0, 0x2d0, %o0 * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 2007a9c: c2 07 bf dc ld [ %fp + -36 ], %g1 2007aa0: 80 a0 60 00 cmp %g1, 0 2007aa4: 02 bf ff a0 be 2007924 2007aa8: b2 10 00 08 mov %o0, %i1 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 2007aac: 40 00 25 be call 20111a4 <__errno> 2007ab0: b0 10 3f ff mov -1, %i0 2007ab4: 82 10 20 16 mov 0x16, %g1 2007ab8: c2 22 00 00 st %g1, [ %o0 ] } 2007abc: 81 c7 e0 08 ret 2007ac0: 81 e8 00 00 restore case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 2007ac4: 40 00 11 3f call 200bfc0 <_Watchdog_Remove> 2007ac8: 90 02 20 10 add %o0, 0x10, %o0 /* The old data of the timer are returned */ if ( ovalue ) 2007acc: 80 a6 e0 00 cmp %i3, 0 2007ad0: 02 80 00 0b be 2007afc 2007ad4: c2 07 bf f0 ld [ %fp + -16 ], %g1 *ovalue = ptimer->timer_data; 2007ad8: c2 06 60 54 ld [ %i1 + 0x54 ], %g1 2007adc: c2 26 c0 00 st %g1, [ %i3 ] 2007ae0: c2 06 60 58 ld [ %i1 + 0x58 ], %g1 2007ae4: c2 26 e0 04 st %g1, [ %i3 + 4 ] 2007ae8: c2 06 60 5c ld [ %i1 + 0x5c ], %g1 2007aec: c2 26 e0 08 st %g1, [ %i3 + 8 ] 2007af0: c2 06 60 60 ld [ %i1 + 0x60 ], %g1 2007af4: c2 26 e0 0c st %g1, [ %i3 + 0xc ] /* The new data are set */ ptimer->timer_data = normalize; 2007af8: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; /* Returns with success */ _Thread_Enable_dispatch(); return 0; 2007afc: b0 10 20 00 clr %i0 (void) _Watchdog_Remove( &ptimer->Timer ); /* The old data of the timer are returned */ if ( ovalue ) *ovalue = ptimer->timer_data; /* The new data are set */ ptimer->timer_data = normalize; 2007b00: c2 26 60 54 st %g1, [ %i1 + 0x54 ] 2007b04: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007b08: c2 26 60 58 st %g1, [ %i1 + 0x58 ] 2007b0c: c2 07 bf f8 ld [ %fp + -8 ], %g1 2007b10: c2 26 60 5c st %g1, [ %i1 + 0x5c ] 2007b14: c2 07 bf fc ld [ %fp + -4 ], %g1 2007b18: c2 26 60 60 st %g1, [ %i1 + 0x60 ] /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 2007b1c: 82 10 20 04 mov 4, %g1 /* Returns with success */ _Thread_Enable_dispatch(); 2007b20: 40 00 0c f2 call 200aee8 <_Thread_Enable_dispatch> 2007b24: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] 2007b28: 81 c7 e0 08 ret 2007b2c: 81 e8 00 00 restore =============================================================================== 02007ad8 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 2007ad8: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 2007adc: 3b 00 80 83 sethi %hi(0x2020c00), %i5 2007ae0: ba 17 62 a8 or %i5, 0x2a8, %i5 ! 2020ea8 <_POSIX_signals_Ualarm_timer> 2007ae4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 2007ae8: 80 a0 60 00 cmp %g1, 0 2007aec: 02 80 00 24 be 2007b7c 2007af0: b8 10 00 18 mov %i0, %i4 _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 2007af4: 40 00 10 f1 call 200beb8 <_Watchdog_Remove> 2007af8: 90 10 00 1d mov %i5, %o0 if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 2007afc: 90 02 3f fe add %o0, -2, %o0 2007b00: 80 a2 20 01 cmp %o0, 1 2007b04: 08 80 00 26 bleu 2007b9c <== ALWAYS TAKEN 2007b08: b0 10 20 00 clr %i0 /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 2007b0c: 80 a7 20 00 cmp %i4, 0 2007b10: 02 80 00 19 be 2007b74 2007b14: 37 00 03 d0 sethi %hi(0xf4000), %i3 Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 2007b18: 90 10 00 1c mov %i4, %o0 2007b1c: 40 00 4e dd call 201b690 <.udiv> 2007b20: 92 16 e2 40 or %i3, 0x240, %o1 tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 2007b24: 92 16 e2 40 or %i3, 0x240, %o1 * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 2007b28: d0 27 bf f8 st %o0, [ %fp + -8 ] tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 2007b2c: 40 00 4f 85 call 201b940 <.urem> 2007b30: 90 10 00 1c mov %i4, %o0 2007b34: 87 2a 20 07 sll %o0, 7, %g3 2007b38: 82 10 00 08 mov %o0, %g1 2007b3c: 85 2a 20 02 sll %o0, 2, %g2 2007b40: 84 20 c0 02 sub %g3, %g2, %g2 2007b44: 82 00 80 01 add %g2, %g1, %g1 2007b48: 83 28 60 03 sll %g1, 3, %g1 ticks = _Timespec_To_ticks( &tp ); 2007b4c: 90 07 bf f8 add %fp, -8, %o0 2007b50: 40 00 0f 6e call 200b908 <_Timespec_To_ticks> 2007b54: c2 27 bf fc st %g1, [ %fp + -4 ] if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 2007b58: 40 00 0f 6c call 200b908 <_Timespec_To_ticks> 2007b5c: 90 07 bf f8 add %fp, -8, %o0 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2007b60: 92 10 00 1d mov %i5, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2007b64: d0 27 60 0c st %o0, [ %i5 + 0xc ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2007b68: 11 00 80 81 sethi %hi(0x2020400), %o0 2007b6c: 40 00 10 74 call 200bd3c <_Watchdog_Insert> 2007b70: 90 12 22 48 or %o0, 0x248, %o0 ! 2020648 <_Watchdog_Ticks_chain> } return remaining; } 2007b74: 81 c7 e0 08 ret 2007b78: 81 e8 00 00 restore Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2007b7c: 03 00 80 1e sethi %hi(0x2007800), %g1 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2007b80: c0 27 60 08 clr [ %i5 + 8 ] the_watchdog->routine = routine; 2007b84: 82 10 62 a8 or %g1, 0x2a8, %g1 the_watchdog->id = id; 2007b88: c0 27 60 20 clr [ %i5 + 0x20 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2007b8c: c2 27 60 1c st %g1, [ %i5 + 0x1c ] the_watchdog->id = id; the_watchdog->user_data = user_data; 2007b90: c0 27 60 24 clr [ %i5 + 0x24 ] useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 2007b94: 10 bf ff de b 2007b0c 2007b98: b0 10 20 00 clr %i0 * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 2007b9c: c4 07 60 0c ld [ %i5 + 0xc ], %g2 2007ba0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 2007ba4: d0 07 60 14 ld [ %i5 + 0x14 ], %o0 /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 2007ba8: 92 07 bf f8 add %fp, -8, %o1 * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 2007bac: 90 02 00 02 add %o0, %g2, %o0 /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 2007bb0: 40 00 0f 41 call 200b8b4 <_Timespec_From_ticks> 2007bb4: 90 22 00 01 sub %o0, %g1, %o0 remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 2007bb8: c2 07 bf f8 ld [ %fp + -8 ], %g1 remaining += tp.tv_nsec / 1000; 2007bbc: d0 07 bf fc ld [ %fp + -4 ], %o0 ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 2007bc0: 85 28 60 03 sll %g1, 3, %g2 2007bc4: 87 28 60 08 sll %g1, 8, %g3 2007bc8: 84 20 c0 02 sub %g3, %g2, %g2 remaining += tp.tv_nsec / 1000; 2007bcc: 92 10 23 e8 mov 0x3e8, %o1 ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 2007bd0: b1 28 a0 06 sll %g2, 6, %i0 2007bd4: b0 26 00 02 sub %i0, %g2, %i0 remaining += tp.tv_nsec / 1000; 2007bd8: 40 00 4e b0 call 201b698 <.div> 2007bdc: b0 06 00 01 add %i0, %g1, %i0 ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 2007be0: b1 2e 20 06 sll %i0, 6, %i0 remaining += tp.tv_nsec / 1000; 2007be4: 10 bf ff ca b 2007b0c 2007be8: b0 02 00 18 add %o0, %i0, %i0