=============================================================================== 00116fcc <_CORE_message_queue_Broadcast>: Objects_Id id __attribute__((unused)), CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)), #endif uint32_t *count ) { 116fcc: 55 push %ebp 116fcd: 89 e5 mov %esp,%ebp 116fcf: 57 push %edi 116fd0: 56 push %esi 116fd1: 53 push %ebx 116fd2: 83 ec 1c sub $0x1c,%esp 116fd5: 8b 55 08 mov 0x8(%ebp),%edx Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; 116fd8: b8 01 00 00 00 mov $0x1,%eax { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 116fdd: 8b 4d 10 mov 0x10(%ebp),%ecx 116fe0: 3b 4a 4c cmp 0x4c(%edx),%ecx 116fe3: 77 44 ja 117029 <_CORE_message_queue_Broadcast+0x5d><== NEVER TAKEN * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 116fe5: 31 db xor %ebx,%ebx 116fe7: 83 7a 48 00 cmpl $0x0,0x48(%edx) 116feb: 74 1f je 11700c <_CORE_message_queue_Broadcast+0x40> *count = 0; 116fed: 8b 45 1c mov 0x1c(%ebp),%eax 116ff0: c7 00 00 00 00 00 movl $0x0,(%eax) 116ff6: eb 2f jmp 117027 <_CORE_message_queue_Broadcast+0x5b> */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 116ff8: 43 inc %ebx const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 116ff9: 8b 78 2c mov 0x2c(%eax),%edi 116ffc: 8b 75 0c mov 0xc(%ebp),%esi 116fff: 8b 4d 10 mov 0x10(%ebp),%ecx 117002: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 117004: 8b 40 28 mov 0x28(%eax),%eax 117007: 8b 4d 10 mov 0x10(%ebp),%ecx 11700a: 89 08 mov %ecx,(%eax) /* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = 11700c: 83 ec 0c sub $0xc,%esp 11700f: 52 push %edx 117010: 89 55 e4 mov %edx,-0x1c(%ebp) 117013: e8 9c 25 00 00 call 1195b4 <_Thread_queue_Dequeue> 117018: 83 c4 10 add $0x10,%esp 11701b: 85 c0 test %eax,%eax 11701d: 8b 55 e4 mov -0x1c(%ebp),%edx 117020: 75 d6 jne 116ff8 <_CORE_message_queue_Broadcast+0x2c> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 117022: 8b 45 1c mov 0x1c(%ebp),%eax 117025: 89 18 mov %ebx,(%eax) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 117027: 31 c0 xor %eax,%eax } 117029: 8d 65 f4 lea -0xc(%ebp),%esp 11702c: 5b pop %ebx 11702d: 5e pop %esi 11702e: 5f pop %edi 11702f: 5d pop %ebp 117030: c3 ret =============================================================================== 0010e600 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 10e600: 55 push %ebp 10e601: 89 e5 mov %esp,%ebp 10e603: 57 push %edi 10e604: 56 push %esi 10e605: 53 push %ebx 10e606: 83 ec 1c sub $0x1c,%esp 10e609: 8b 5d 08 mov 0x8(%ebp),%ebx 10e60c: 8b 75 10 mov 0x10(%ebp),%esi 10e60f: 8b 55 14 mov 0x14(%ebp),%edx size_t message_buffering_required = 0; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 10e612: 89 73 44 mov %esi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 10e615: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 10e61c: 89 53 4c mov %edx,0x4c(%ebx) /* * Check if allocated_message_size is aligned to uintptr-size boundary. * If not, it will increase allocated_message_size to multiplicity of pointer * size. */ if (allocated_message_size & (sizeof(uintptr_t) - 1)) { 10e61f: f6 c2 03 test $0x3,%dl 10e622: 74 0e je 10e632 <_CORE_message_queue_Initialize+0x32> allocated_message_size += sizeof(uintptr_t); 10e624: 8d 42 04 lea 0x4(%edx),%eax allocated_message_size &= ~(sizeof(uintptr_t) - 1); 10e627: 83 e0 fc and $0xfffffffc,%eax /* * Check for an overflow. It can occur while increasing allocated_message_size * to multiplicity of uintptr_t above. */ if (allocated_message_size < maximum_message_size) 10e62a: 39 d0 cmp %edx,%eax 10e62c: 73 06 jae 10e634 <_CORE_message_queue_Initialize+0x34> return false; 10e62e: 31 c0 xor %eax,%eax 10e630: eb 64 jmp 10e696 <_CORE_message_queue_Initialize+0x96> /* * Check if allocated_message_size is aligned to uintptr-size boundary. * If not, it will increase allocated_message_size to multiplicity of pointer * size. */ if (allocated_message_size & (sizeof(uintptr_t) - 1)) { 10e632: 89 d0 mov %edx,%eax /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ if ( !size_t_mult32_with_overflow( 10e634: 8d 78 10 lea 0x10(%eax),%edi size_t a, size_t b, size_t *c ) { long long x = (long long)a*b; 10e637: 89 f0 mov %esi,%eax 10e639: f7 e7 mul %edi 10e63b: 89 45 e0 mov %eax,-0x20(%ebp) 10e63e: 89 55 e4 mov %edx,-0x1c(%ebp) if ( x > SIZE_MAX ) 10e641: 85 d2 test %edx,%edx 10e643: 7f e9 jg 10e62e <_CORE_message_queue_Initialize+0x2e> /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 10e645: 83 ec 0c sub $0xc,%esp 10e648: 50 push %eax 10e649: e8 52 e4 ff ff call 10caa0 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 10e64e: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 10e651: 83 c4 10 add $0x10,%esp 10e654: 85 c0 test %eax,%eax 10e656: 74 d6 je 10e62e <_CORE_message_queue_Initialize+0x2e><== NEVER TAKEN /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 10e658: 57 push %edi 10e659: 56 push %esi 10e65a: 50 push %eax 10e65b: 8d 43 60 lea 0x60(%ebx),%eax 10e65e: 50 push %eax 10e65f: e8 f4 bf ff ff call 10a658 <_Chain_Initialize> Chain_Node *tail = _Chain_Tail( the_chain ); 10e664: 8d 43 50 lea 0x50(%ebx),%eax 10e667: 8d 53 54 lea 0x54(%ebx),%edx 10e66a: 89 53 50 mov %edx,0x50(%ebx) head->next = tail; head->previous = NULL; 10e66d: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10e674: 89 43 58 mov %eax,0x58(%ebx) allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 10e677: 6a 06 push $0x6 10e679: 68 80 00 00 00 push $0x80 */ RTEMS_INLINE_ROUTINE bool _CORE_message_queue_Is_priority( CORE_message_queue_Attributes *the_attribute ) { return 10e67e: 8b 45 0c mov 0xc(%ebp),%eax 10e681: 83 38 01 cmpl $0x1,(%eax) 10e684: 0f 94 c0 sete %al 10e687: 0f b6 c0 movzbl %al,%eax 10e68a: 50 push %eax 10e68b: 53 push %ebx 10e68c: e8 53 dd ff ff call 10c3e4 <_Thread_queue_Initialize> 10e691: 83 c4 20 add $0x20,%esp THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 10e694: b0 01 mov $0x1,%al } 10e696: 8d 65 f4 lea -0xc(%ebp),%esp 10e699: 5b pop %ebx 10e69a: 5e pop %esi 10e69b: 5f pop %edi 10e69c: 5d pop %ebp 10e69d: c3 ret =============================================================================== 0010a958 <_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 ) { 10a958: 55 push %ebp 10a959: 89 e5 mov %esp,%ebp 10a95b: 53 push %ebx 10a95c: 83 ec 10 sub $0x10,%esp 10a95f: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10a962: 53 push %ebx 10a963: e8 74 17 00 00 call 10c0dc <_Thread_queue_Dequeue> 10a968: 83 c4 10 add $0x10,%esp { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10a96b: 31 d2 xor %edx,%edx if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10a96d: 85 c0 test %eax,%eax 10a96f: 75 15 jne 10a986 <_CORE_semaphore_Surrender+0x2e> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10a971: 9c pushf 10a972: fa cli 10a973: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10a974: 8b 43 48 mov 0x48(%ebx),%eax the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10a977: b2 04 mov $0x4,%dl (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10a979: 3b 43 40 cmp 0x40(%ebx),%eax 10a97c: 73 06 jae 10a984 <_CORE_semaphore_Surrender+0x2c><== NEVER TAKEN the_semaphore->count += 1; 10a97e: 40 inc %eax 10a97f: 89 43 48 mov %eax,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10a982: 30 d2 xor %dl,%dl _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 10a984: 51 push %ecx 10a985: 9d popf } return status; } 10a986: 89 d0 mov %edx,%eax 10a988: 8b 5d fc mov -0x4(%ebp),%ebx 10a98b: c9 leave 10a98c: c3 ret =============================================================================== 00109a10 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109a10: 55 push %ebp 109a11: 89 e5 mov %esp,%ebp 109a13: 57 push %edi 109a14: 56 push %esi 109a15: 53 push %ebx 109a16: 83 ec 1c sub $0x1c,%esp 109a19: 8b 5d 08 mov 0x8(%ebp),%ebx 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 ]; 109a1c: 8b b3 e0 00 00 00 mov 0xe0(%ebx),%esi option_set = (rtems_option) the_thread->Wait.option; 109a22: 8b 43 30 mov 0x30(%ebx),%eax 109a25: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109a28: 9c pushf 109a29: fa cli 109a2a: 58 pop %eax pending_events = api->pending_events; 109a2b: 8b 16 mov (%esi),%edx 109a2d: 89 55 e4 mov %edx,-0x1c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109a30: 8b 4b 24 mov 0x24(%ebx),%ecx seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 109a33: 21 ca and %ecx,%edx 109a35: 75 05 jne 109a3c <_Event_Surrender+0x2c> 109a37: e9 ab 00 00 00 jmp 109ae7 <_Event_Surrender+0xd7> /* * 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() && 109a3c: 83 3d 64 c5 12 00 00 cmpl $0x0,0x12c564 109a43: 74 47 je 109a8c <_Event_Surrender+0x7c> 109a45: 3b 1d 68 c5 12 00 cmp 0x12c568,%ebx 109a4b: 75 3f jne 109a8c <_Event_Surrender+0x7c> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109a4d: 8b 3d a4 c5 12 00 mov 0x12c5a4,%edi /* * 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 ) && 109a53: 83 ff 02 cmp $0x2,%edi 109a56: 74 09 je 109a61 <_Event_Surrender+0x51> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109a58: 8b 3d a4 c5 12 00 mov 0x12c5a4,%edi * 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) || 109a5e: 4f dec %edi 109a5f: 75 2b jne 109a8c <_Event_Surrender+0x7c> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109a61: 39 ca cmp %ecx,%edx 109a63: 74 06 je 109a6b <_Event_Surrender+0x5b> 109a65: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109a69: 74 7c je 109ae7 <_Event_Surrender+0xd7> <== NEVER TAKEN 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) ); 109a6b: 89 d1 mov %edx,%ecx 109a6d: f7 d1 not %ecx 109a6f: 23 4d e4 and -0x1c(%ebp),%ecx 109a72: 89 0e mov %ecx,(%esi) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 109a74: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109a7b: 8b 4b 28 mov 0x28(%ebx),%ecx 109a7e: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109a80: c7 05 a4 c5 12 00 03 movl $0x3,0x12c5a4 109a87: 00 00 00 109a8a: eb 5b jmp 109ae7 <_Event_Surrender+0xd7> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109a8c: f6 43 11 01 testb $0x1,0x11(%ebx) 109a90: 74 55 je 109ae7 <_Event_Surrender+0xd7> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109a92: 39 ca cmp %ecx,%edx 109a94: 74 06 je 109a9c <_Event_Surrender+0x8c> 109a96: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109a9a: 74 4b je 109ae7 <_Event_Surrender+0xd7> <== NEVER TAKEN 109a9c: 89 d1 mov %edx,%ecx 109a9e: f7 d1 not %ecx 109aa0: 23 4d e4 and -0x1c(%ebp),%ecx 109aa3: 89 0e mov %ecx,(%esi) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 109aa5: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109aac: 8b 4b 28 mov 0x28(%ebx),%ecx 109aaf: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109ab1: 50 push %eax 109ab2: 9d popf 109ab3: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109ab4: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109ab8: 74 06 je 109ac0 <_Event_Surrender+0xb0> _ISR_Enable( level ); 109aba: 50 push %eax 109abb: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109abc: 51 push %ecx 109abd: 51 push %ecx 109abe: eb 17 jmp 109ad7 <_Event_Surrender+0xc7> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109ac0: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109ac7: 50 push %eax 109ac8: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109ac9: 83 ec 0c sub $0xc,%esp 109acc: 8d 43 48 lea 0x48(%ebx),%eax 109acf: 50 push %eax 109ad0: e8 9f 2e 00 00 call 10c974 <_Watchdog_Remove> 109ad5: 58 pop %eax 109ad6: 5a pop %edx 109ad7: 68 f8 ff 03 10 push $0x1003fff8 109adc: 53 push %ebx 109add: e8 8a 1f 00 00 call 10ba6c <_Thread_Clear_state> 109ae2: 83 c4 10 add $0x10,%esp 109ae5: eb 02 jmp 109ae9 <_Event_Surrender+0xd9> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109ae7: 50 push %eax 109ae8: 9d popf } 109ae9: 8d 65 f4 lea -0xc(%ebp),%esp 109aec: 5b pop %ebx 109aed: 5e pop %esi 109aee: 5f pop %edi 109aef: 5d pop %ebp 109af0: c3 ret =============================================================================== 00109af4 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109af4: 55 push %ebp 109af5: 89 e5 mov %esp,%ebp 109af7: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109afa: 8d 45 f4 lea -0xc(%ebp),%eax 109afd: 50 push %eax 109afe: ff 75 08 pushl 0x8(%ebp) 109b01: e8 b6 22 00 00 call 10bdbc <_Thread_Get> switch ( location ) { 109b06: 83 c4 10 add $0x10,%esp 109b09: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 109b0d: 75 4e jne 109b5d <_Event_Timeout+0x69> <== NEVER TAKEN * * 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 ); 109b0f: 9c pushf 109b10: fa cli 109b11: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 109b12: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 109b19: 3b 05 68 c5 12 00 cmp 0x12c568,%eax 109b1f: 75 13 jne 109b34 <_Event_Timeout+0x40> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 109b21: 8b 0d a4 c5 12 00 mov 0x12c5a4,%ecx 109b27: 49 dec %ecx 109b28: 75 0a jne 109b34 <_Event_Timeout+0x40> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 109b2a: c7 05 a4 c5 12 00 02 movl $0x2,0x12c5a4 109b31: 00 00 00 } the_thread->Wait.return_code = RTEMS_TIMEOUT; 109b34: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 109b3b: 52 push %edx 109b3c: 9d popf 109b3d: 52 push %edx 109b3e: 52 push %edx 109b3f: 68 f8 ff 03 10 push $0x1003fff8 109b44: 50 push %eax 109b45: e8 22 1f 00 00 call 10ba6c <_Thread_Clear_state> * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 109b4a: a1 6c c3 12 00 mov 0x12c36c,%eax 109b4f: 48 dec %eax 109b50: a3 6c c3 12 00 mov %eax,0x12c36c return _Thread_Dispatch_disable_level; 109b55: a1 6c c3 12 00 mov 0x12c36c,%eax 109b5a: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 109b5d: c9 leave 109b5e: c3 ret =============================================================================== 0010ead3 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 10ead3: 55 push %ebp 10ead4: 89 e5 mov %esp,%ebp 10ead6: 57 push %edi 10ead7: 56 push %esi 10ead8: 53 push %ebx 10ead9: 83 ec 4c sub $0x4c,%esp 10eadc: 8b 5d 08 mov 0x8(%ebp),%ebx 10eadf: 8b 45 10 mov 0x10(%ebp),%eax Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 10eae2: 8b 4b 20 mov 0x20(%ebx),%ecx 10eae5: 89 4d b8 mov %ecx,-0x48(%ebp) 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; 10eae8: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) Heap_Block *extend_last_block = NULL; 10eaef: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) uintptr_t const page_size = heap->page_size; 10eaf6: 8b 73 10 mov 0x10(%ebx),%esi 10eaf9: 89 75 bc mov %esi,-0x44(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10eafc: 8b 53 14 mov 0x14(%ebx),%edx uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size; 10eaff: 8b 4b 30 mov 0x30(%ebx),%ecx 10eb02: 89 4d b4 mov %ecx,-0x4c(%ebp) uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 10eb05: 8b 75 0c mov 0xc(%ebp),%esi 10eb08: 01 c6 add %eax,%esi 10eb0a: 89 75 d4 mov %esi,-0x2c(%ebp) 10eb0d: 73 07 jae 10eb16 <_Heap_Extend+0x43> return false; 10eb0f: 31 c0 xor %eax,%eax 10eb11: e9 cb 01 00 00 jmp 10ece1 <_Heap_Extend+0x20e> } extend_area_ok = _Heap_Get_first_and_last_block( 10eb16: 51 push %ecx 10eb17: 51 push %ecx 10eb18: 8d 4d e4 lea -0x1c(%ebp),%ecx 10eb1b: 51 push %ecx 10eb1c: 8d 4d e0 lea -0x20(%ebp),%ecx 10eb1f: 51 push %ecx 10eb20: 52 push %edx 10eb21: ff 75 bc pushl -0x44(%ebp) 10eb24: 50 push %eax 10eb25: ff 75 0c pushl 0xc(%ebp) 10eb28: e8 a9 c0 ff ff call 10abd6 <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 10eb2d: 83 c4 20 add $0x20,%esp 10eb30: 84 c0 test %al,%al 10eb32: 74 db je 10eb0f <_Heap_Extend+0x3c> 10eb34: 8b 4d b8 mov -0x48(%ebp),%ecx 10eb37: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 10eb3e: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 10eb45: 31 ff xor %edi,%edi 10eb47: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 10eb4e: 8b 73 18 mov 0x18(%ebx),%esi 10eb51: 89 75 c0 mov %esi,-0x40(%ebp) 10eb54: eb 03 jmp 10eb59 <_Heap_Extend+0x86> 10eb56: 89 4d c0 mov %ecx,-0x40(%ebp) uintptr_t const sub_area_end = start_block->prev_size; 10eb59: 8b 01 mov (%ecx),%eax 10eb5b: 89 45 d0 mov %eax,-0x30(%ebp) RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10eb5e: 89 c6 mov %eax,%esi 10eb60: 83 ee 08 sub $0x8,%esi 10eb63: 31 d2 xor %edx,%edx 10eb65: f7 75 bc divl -0x44(%ebp) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 10eb68: 29 d6 sub %edx,%esi Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 10eb6a: 8b 55 c0 mov -0x40(%ebp),%edx 10eb6d: 39 55 d4 cmp %edx,-0x2c(%ebp) 10eb70: 76 08 jbe 10eb7a <_Heap_Extend+0xa7> 10eb72: 8b 45 d0 mov -0x30(%ebp),%eax 10eb75: 39 45 0c cmp %eax,0xc(%ebp) 10eb78: 72 95 jb 10eb0f <_Heap_Extend+0x3c> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10eb7a: 8b 55 c0 mov -0x40(%ebp),%edx 10eb7d: 39 55 d4 cmp %edx,-0x2c(%ebp) 10eb80: 74 0a je 10eb8c <_Heap_Extend+0xb9> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10eb82: 8b 45 d0 mov -0x30(%ebp),%eax 10eb85: 39 45 d4 cmp %eax,-0x2c(%ebp) 10eb88: 72 07 jb 10eb91 <_Heap_Extend+0xbe> 10eb8a: eb 08 jmp 10eb94 <_Heap_Extend+0xc1> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10eb8c: 89 4d cc mov %ecx,-0x34(%ebp) 10eb8f: eb 03 jmp 10eb94 <_Heap_Extend+0xc1> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10eb91: 89 4d c4 mov %ecx,-0x3c(%ebp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 10eb94: 8b 55 0c mov 0xc(%ebp),%edx 10eb97: 39 55 d0 cmp %edx,-0x30(%ebp) 10eb9a: 75 09 jne 10eba5 <_Heap_Extend+0xd2> start_block->prev_size = extend_area_end; 10eb9c: 8b 45 d4 mov -0x2c(%ebp),%eax 10eb9f: 89 01 mov %eax,(%ecx) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area( uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) 10eba1: 89 f7 mov %esi,%edi 10eba3: eb 05 jmp 10ebaa <_Heap_Extend+0xd7> merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 10eba5: 73 03 jae 10ebaa <_Heap_Extend+0xd7> 10eba7: 89 75 c8 mov %esi,-0x38(%ebp) - 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; 10ebaa: 8b 4e 04 mov 0x4(%esi),%ecx 10ebad: 83 e1 fe and $0xfffffffe,%ecx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10ebb0: 01 f1 add %esi,%ecx link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 10ebb2: 3b 4d b8 cmp -0x48(%ebp),%ecx 10ebb5: 75 9f jne 10eb56 <_Heap_Extend+0x83> if ( extend_area_begin < heap->area_begin ) { 10ebb7: 8b 4d 0c mov 0xc(%ebp),%ecx 10ebba: 3b 4b 18 cmp 0x18(%ebx),%ecx 10ebbd: 73 05 jae 10ebc4 <_Heap_Extend+0xf1> heap->area_begin = extend_area_begin; 10ebbf: 89 4b 18 mov %ecx,0x18(%ebx) 10ebc2: eb 0b jmp 10ebcf <_Heap_Extend+0xfc> } else if ( heap->area_end < extend_area_end ) { 10ebc4: 8b 75 d4 mov -0x2c(%ebp),%esi 10ebc7: 39 73 1c cmp %esi,0x1c(%ebx) 10ebca: 73 03 jae 10ebcf <_Heap_Extend+0xfc> heap->area_end = extend_area_end; 10ebcc: 89 73 1c mov %esi,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 10ebcf: 8b 45 e4 mov -0x1c(%ebp),%eax 10ebd2: 8b 55 e0 mov -0x20(%ebp),%edx heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = 10ebd5: 89 c1 mov %eax,%ecx 10ebd7: 29 d1 sub %edx,%ecx (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 10ebd9: 8b 75 d4 mov -0x2c(%ebp),%esi 10ebdc: 89 32 mov %esi,(%edx) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 10ebde: 89 ce mov %ecx,%esi 10ebe0: 83 ce 01 or $0x1,%esi 10ebe3: 89 72 04 mov %esi,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 10ebe6: 89 08 mov %ecx,(%eax) extend_last_block->size_and_flag = 0; 10ebe8: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 10ebef: 39 53 20 cmp %edx,0x20(%ebx) 10ebf2: 76 05 jbe 10ebf9 <_Heap_Extend+0x126> heap->first_block = extend_first_block; 10ebf4: 89 53 20 mov %edx,0x20(%ebx) 10ebf7: eb 08 jmp 10ec01 <_Heap_Extend+0x12e> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 10ebf9: 39 43 24 cmp %eax,0x24(%ebx) 10ebfc: 73 03 jae 10ec01 <_Heap_Extend+0x12e> heap->last_block = extend_last_block; 10ebfe: 89 43 24 mov %eax,0x24(%ebx) } if ( merge_below_block != NULL ) { 10ec01: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10ec05: 74 35 je 10ec3c <_Heap_Extend+0x169> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 10ec07: 8b 73 10 mov 0x10(%ebx),%esi uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 10ec0a: 8b 4d 0c mov 0xc(%ebp),%ecx 10ec0d: 83 c1 08 add $0x8,%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 10ec10: 89 c8 mov %ecx,%eax 10ec12: 31 d2 xor %edx,%edx 10ec14: f7 f6 div %esi if ( remainder != 0 ) { 10ec16: 85 d2 test %edx,%edx 10ec18: 74 04 je 10ec1e <_Heap_Extend+0x14b> return value - remainder + alignment; 10ec1a: 01 f1 add %esi,%ecx 10ec1c: 29 d1 sub %edx,%ecx uintptr_t const new_first_block_begin = 10ec1e: 8d 51 f8 lea -0x8(%ecx),%edx 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; 10ec21: 8b 75 cc mov -0x34(%ebp),%esi 10ec24: 8b 06 mov (%esi),%eax 10ec26: 89 41 f8 mov %eax,-0x8(%ecx) 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 = 10ec29: 89 f0 mov %esi,%eax 10ec2b: 29 d0 sub %edx,%eax 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; 10ec2d: 83 c8 01 or $0x1,%eax 10ec30: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 10ec33: 89 d8 mov %ebx,%eax 10ec35: e8 7e fe ff ff call 10eab8 <_Heap_Free_block> 10ec3a: eb 11 jmp 10ec4d <_Heap_Extend+0x17a> 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 ) { 10ec3c: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10ec40: 74 0b je 10ec4d <_Heap_Extend+0x17a> { 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; 10ec42: 8b 55 c4 mov -0x3c(%ebp),%edx 10ec45: 29 c2 sub %eax,%edx 10ec47: 83 ca 01 or $0x1,%edx 10ec4a: 89 50 04 mov %edx,0x4(%eax) link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 10ec4d: 85 ff test %edi,%edi 10ec4f: 74 33 je 10ec84 <_Heap_Extend+0x1b1> ) { 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( extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE, 10ec51: 8b 4d d4 mov -0x2c(%ebp),%ecx 10ec54: 83 e9 08 sub $0x8,%ecx 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( 10ec57: 29 f9 sub %edi,%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10ec59: 89 c8 mov %ecx,%eax 10ec5b: 31 d2 xor %edx,%edx 10ec5d: f7 73 10 divl 0x10(%ebx) 10ec60: 29 d1 sub %edx,%ecx ); 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) 10ec62: 8b 47 04 mov 0x4(%edi),%eax 10ec65: 29 c8 sub %ecx,%eax | HEAP_PREV_BLOCK_USED; 10ec67: 83 c8 01 or $0x1,%eax 10ec6a: 89 44 39 04 mov %eax,0x4(%ecx,%edi,1) 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; 10ec6e: 8b 47 04 mov 0x4(%edi),%eax 10ec71: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 10ec74: 09 c8 or %ecx,%eax 10ec76: 89 47 04 mov %eax,0x4(%edi) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 10ec79: 89 fa mov %edi,%edx 10ec7b: 89 d8 mov %ebx,%eax 10ec7d: e8 36 fe ff ff call 10eab8 <_Heap_Free_block> 10ec82: eb 20 jmp 10eca4 <_Heap_Extend+0x1d1> ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 10ec84: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10ec88: 74 1a je 10eca4 <_Heap_Extend+0x1d1> _Heap_Link_above( 10ec8a: 8b 4d e4 mov -0x1c(%ebp),%ecx 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; 10ec8d: 8b 75 c8 mov -0x38(%ebp),%esi 10ec90: 8b 46 04 mov 0x4(%esi),%eax 10ec93: 83 e0 01 and $0x1,%eax ) { 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 ); 10ec96: 8b 55 e0 mov -0x20(%ebp),%edx 10ec99: 29 f2 sub %esi,%edx block->size_and_flag = size | flag; 10ec9b: 09 d0 or %edx,%eax 10ec9d: 89 46 04 mov %eax,0x4(%esi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 10eca0: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 10eca4: 85 ff test %edi,%edi 10eca6: 75 10 jne 10ecb8 <_Heap_Extend+0x1e5> 10eca8: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10ecac: 75 0a jne 10ecb8 <_Heap_Extend+0x1e5> _Heap_Free_block( heap, extend_first_block ); 10ecae: 8b 55 e0 mov -0x20(%ebp),%edx 10ecb1: 89 d8 mov %ebx,%eax 10ecb3: e8 00 fe ff ff call 10eab8 <_Heap_Free_block> */ 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 10ecb8: 8b 53 24 mov 0x24(%ebx),%edx 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; 10ecbb: 8b 42 04 mov 0x4(%edx),%eax 10ecbe: 83 e0 01 and $0x1,%eax * 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( 10ecc1: 8b 4b 20 mov 0x20(%ebx),%ecx 10ecc4: 29 d1 sub %edx,%ecx uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; block->size_and_flag = size | flag; 10ecc6: 09 c8 or %ecx,%eax 10ecc8: 89 42 04 mov %eax,0x4(%edx) } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 10eccb: 8b 43 30 mov 0x30(%ebx),%eax 10ecce: 2b 45 b4 sub -0x4c(%ebp),%eax /* Statistics */ stats->size += extended_size; 10ecd1: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) 10ecd4: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10ecd8: 74 05 je 10ecdf <_Heap_Extend+0x20c> <== NEVER TAKEN *extended_size_ptr = extended_size; 10ecda: 8b 4d 14 mov 0x14(%ebp),%ecx 10ecdd: 89 01 mov %eax,(%ecx) return true; 10ecdf: b0 01 mov $0x1,%al } 10ece1: 8d 65 f4 lea -0xc(%ebp),%esp 10ece4: 5b pop %ebx 10ece5: 5e pop %esi 10ece6: 5f pop %edi 10ece7: 5d pop %ebp 10ece8: c3 ret =============================================================================== 0010ea68 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 10ea68: 55 push %ebp 10ea69: 89 e5 mov %esp,%ebp 10ea6b: 57 push %edi 10ea6c: 56 push %esi 10ea6d: 53 push %ebx 10ea6e: 83 ec 14 sub $0x14,%esp 10ea71: 8b 4d 08 mov 0x8(%ebp),%ecx 10ea74: 8b 45 0c mov 0xc(%ebp),%eax /* * 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 ) { 10ea77: 85 c0 test %eax,%eax 10ea79: 0f 84 46 01 00 00 je 10ebc5 <_Heap_Free+0x15d> 10ea7f: 8d 58 f8 lea -0x8(%eax),%ebx 10ea82: 31 d2 xor %edx,%edx 10ea84: f7 71 10 divl 0x10(%ecx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 10ea87: 29 d3 sub %edx,%ebx 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 10ea89: 8b 41 20 mov 0x20(%ecx),%eax 10ea8c: 89 45 e8 mov %eax,-0x18(%ebp) && (uintptr_t) block <= (uintptr_t) heap->last_block; 10ea8f: 31 d2 xor %edx,%edx 10ea91: 39 c3 cmp %eax,%ebx 10ea93: 72 08 jb 10ea9d <_Heap_Free+0x35> 10ea95: 31 d2 xor %edx,%edx 10ea97: 39 59 24 cmp %ebx,0x24(%ecx) 10ea9a: 0f 93 c2 setae %dl alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10ea9d: 31 c0 xor %eax,%eax } alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { 10ea9f: 85 d2 test %edx,%edx 10eaa1: 0f 84 20 01 00 00 je 10ebc7 <_Heap_Free+0x15f> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10eaa7: 8b 43 04 mov 0x4(%ebx),%eax 10eaaa: 89 45 ec mov %eax,-0x14(%ebp) - 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; 10eaad: 89 c7 mov %eax,%edi 10eaaf: 83 e7 fe and $0xfffffffe,%edi RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10eab2: 8d 14 1f lea (%edi,%ebx,1),%edx 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; 10eab5: 31 f6 xor %esi,%esi 10eab7: 3b 55 e8 cmp -0x18(%ebp),%edx 10eaba: 72 0a jb 10eac6 <_Heap_Free+0x5e> <== NEVER TAKEN 10eabc: 31 c0 xor %eax,%eax 10eabe: 39 51 24 cmp %edx,0x24(%ecx) 10eac1: 0f 93 c0 setae %al 10eac4: 89 c6 mov %eax,%esi alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10eac6: 31 c0 xor %eax,%eax _Heap_Protection_block_check( heap, block ); block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10eac8: 85 f6 test %esi,%esi 10eaca: 0f 84 f7 00 00 00 je 10ebc7 <_Heap_Free+0x15f> <== NEVER TAKEN --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10ead0: 8b 72 04 mov 0x4(%edx),%esi return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 10ead3: f7 c6 01 00 00 00 test $0x1,%esi 10ead9: 0f 84 e8 00 00 00 je 10ebc7 <_Heap_Free+0x15f> <== NEVER TAKEN - 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; 10eadf: 83 e6 fe and $0xfffffffe,%esi 10eae2: 89 75 f0 mov %esi,-0x10(%ebp) 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 10eae5: 8b 41 24 mov 0x24(%ecx),%eax 10eae8: 89 45 e0 mov %eax,-0x20(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 10eaeb: 39 c2 cmp %eax,%edx 10eaed: 74 0c je 10eafb <_Heap_Free+0x93> 10eaef: 8b 74 32 04 mov 0x4(%edx,%esi,1),%esi 10eaf3: 83 f6 01 xor $0x1,%esi 10eaf6: 83 e6 01 and $0x1,%esi 10eaf9: eb 02 jmp 10eafd <_Heap_Free+0x95> 10eafb: 31 f6 xor %esi,%esi 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 10eafd: 89 f0 mov %esi,%eax 10eaff: 88 45 e7 mov %al,-0x19(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { 10eb02: f6 45 ec 01 testb $0x1,-0x14(%ebp) 10eb06: 75 5e jne 10eb66 <_Heap_Free+0xfe> uintptr_t const prev_size = block->prev_size; 10eb08: 8b 33 mov (%ebx),%esi RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10eb0a: 29 f3 sub %esi,%ebx 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; 10eb0c: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) 10eb13: 3b 5d e8 cmp -0x18(%ebp),%ebx 10eb16: 72 0b jb 10eb23 <_Heap_Free+0xbb> <== NEVER TAKEN 10eb18: 31 c0 xor %eax,%eax 10eb1a: 39 5d e0 cmp %ebx,-0x20(%ebp) 10eb1d: 0f 93 c0 setae %al 10eb20: 89 45 ec mov %eax,-0x14(%ebp) alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10eb23: 31 c0 xor %eax,%eax if ( !_Heap_Is_prev_used( block ) ) { uintptr_t const prev_size = block->prev_size; Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size ); if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) { 10eb25: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) 10eb29: 0f 84 98 00 00 00 je 10ebc7 <_Heap_Free+0x15f> <== NEVER TAKEN 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) ) { 10eb2f: f6 43 04 01 testb $0x1,0x4(%ebx) 10eb33: 0f 84 8e 00 00 00 je 10ebc7 <_Heap_Free+0x15f> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 10eb39: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10eb3d: 8d 34 37 lea (%edi,%esi,1),%esi 10eb40: 74 14 je 10eb56 <_Heap_Free+0xee> uintptr_t const size = block_size + prev_size + next_block_size; 10eb42: 03 75 f0 add -0x10(%ebp),%esi return _Heap_Free_list_tail(heap)->prev; } RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; 10eb45: 8b 42 08 mov 0x8(%edx),%eax Heap_Block *prev = block->prev; 10eb48: 8b 52 0c mov 0xc(%edx),%edx prev->next = next; 10eb4b: 89 42 08 mov %eax,0x8(%edx) next->prev = prev; 10eb4e: 89 50 0c mov %edx,0xc(%eax) _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 10eb51: ff 49 38 decl 0x38(%ecx) 10eb54: eb 2d jmp 10eb83 <_Heap_Free+0x11b> 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; 10eb56: 89 f0 mov %esi,%eax 10eb58: 83 c8 01 or $0x1,%eax 10eb5b: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10eb5e: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 10eb62: 89 32 mov %esi,(%edx) 10eb64: eb 56 jmp 10ebbc <_Heap_Free+0x154> } } else if ( next_is_free ) { /* coalesce next */ 10eb66: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10eb6a: 74 24 je 10eb90 <_Heap_Free+0x128> uintptr_t const size = block_size + next_block_size; 10eb6c: 8b 75 f0 mov -0x10(%ebp),%esi 10eb6f: 01 fe add %edi,%esi RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace( Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *next = old_block->next; 10eb71: 8b 42 08 mov 0x8(%edx),%eax Heap_Block *prev = old_block->prev; 10eb74: 8b 52 0c mov 0xc(%edx),%edx new_block->next = next; 10eb77: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = prev; 10eb7a: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 10eb7d: 89 58 0c mov %ebx,0xc(%eax) prev->next = new_block; 10eb80: 89 5a 08 mov %ebx,0x8(%edx) _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10eb83: 89 f0 mov %esi,%eax 10eb85: 83 c8 01 or $0x1,%eax 10eb88: 89 43 04 mov %eax,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 10eb8b: 89 34 1e mov %esi,(%esi,%ebx,1) 10eb8e: eb 2c jmp 10ebbc <_Heap_Free+0x154> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 10eb90: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 10eb93: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 10eb96: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 10eb99: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 10eb9c: 89 58 0c mov %ebx,0xc(%eax) } 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; 10eb9f: 89 f8 mov %edi,%eax 10eba1: 83 c8 01 or $0x1,%eax 10eba4: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10eba7: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 10ebab: 89 3a mov %edi,(%edx) /* Statistics */ ++stats->free_blocks; 10ebad: 8b 41 38 mov 0x38(%ecx),%eax 10ebb0: 40 inc %eax 10ebb1: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 10ebb4: 39 41 3c cmp %eax,0x3c(%ecx) 10ebb7: 73 03 jae 10ebbc <_Heap_Free+0x154> stats->max_free_blocks = stats->free_blocks; 10ebb9: 89 41 3c mov %eax,0x3c(%ecx) } } /* Statistics */ --stats->used_blocks; 10ebbc: ff 49 40 decl 0x40(%ecx) ++stats->frees; 10ebbf: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 10ebc2: 01 79 30 add %edi,0x30(%ecx) * 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 ) { return true; 10ebc5: b0 01 mov $0x1,%al --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10ebc7: 83 c4 14 add $0x14,%esp 10ebca: 5b pop %ebx 10ebcb: 5e pop %esi 10ebcc: 5f pop %edi 10ebcd: 5d pop %ebp 10ebce: c3 ret =============================================================================== 0010c4dc <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) { 10c4dc: 55 push %ebp 10c4dd: 89 e5 mov %esp,%ebp 10c4df: 57 push %edi 10c4e0: 56 push %esi 10c4e1: 53 push %ebx 10c4e2: 83 ec 1c sub $0x1c,%esp 10c4e5: 8b 5d 08 mov 0x8(%ebp),%ebx Heap_Block *allocated_blocks = NULL; Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 10c4e8: 31 f6 xor %esi,%esi 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; 10c4ea: 31 c9 xor %ecx,%ecx Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 10c4ec: eb 2d jmp 10c51b <_Heap_Greedy_allocate+0x3f> * @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 ); 10c4ee: 6a 00 push $0x0 10c4f0: 6a 00 push $0x0 10c4f2: 8b 45 0c mov 0xc(%ebp),%eax 10c4f5: ff 34 b0 pushl (%eax,%esi,4) 10c4f8: 53 push %ebx 10c4f9: 89 4d e4 mov %ecx,-0x1c(%ebp) 10c4fc: e8 9b 5f 00 00 call 11249c <_Heap_Allocate_aligned_with_boundary> void *next = _Heap_Allocate( heap, block_sizes [i] ); if ( next != NULL ) { 10c501: 83 c4 10 add $0x10,%esp 10c504: 85 c0 test %eax,%eax 10c506: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c509: 74 0f je 10c51a <_Heap_Greedy_allocate+0x3e><== NEVER TAKEN RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10c50b: 8d 78 f8 lea -0x8(%eax),%edi 10c50e: 31 d2 xor %edx,%edx 10c510: f7 73 10 divl 0x10(%ebx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 10c513: 29 d7 sub %edx,%edi Heap_Block *next_block = _Heap_Block_of_alloc_area( (uintptr_t) next, heap->page_size ); next_block->next = allocated_blocks; 10c515: 89 4f 08 mov %ecx,0x8(%edi) 10c518: 89 f9 mov %edi,%ecx Heap_Block *allocated_blocks = NULL; Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 10c51a: 46 inc %esi 10c51b: 3b 75 10 cmp 0x10(%ebp),%esi 10c51e: 75 ce jne 10c4ee <_Heap_Greedy_allocate+0x12> 10c520: 31 f6 xor %esi,%esi 10c522: eb 23 jmp 10c547 <_Heap_Greedy_allocate+0x6b> } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10c524: 8b 47 04 mov 0x4(%edi),%eax 10c527: 83 e0 fe and $0xfffffffe,%eax allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { _Heap_Block_allocate( 10c52a: 83 e8 08 sub $0x8,%eax 10c52d: 50 push %eax RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10c52e: 8d 47 08 lea 0x8(%edi),%eax 10c531: 50 push %eax 10c532: 57 push %edi 10c533: 53 push %ebx 10c534: 89 4d e4 mov %ecx,-0x1c(%ebp) 10c537: e8 8e 02 00 00 call 10c7ca <_Heap_Block_allocate> current, _Heap_Alloc_area_of_block( current ), _Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE ); current->next = blocks; 10c53c: 89 77 08 mov %esi,0x8(%edi) 10c53f: 89 fe mov %edi,%esi 10c541: 83 c4 10 add $0x10,%esp 10c544: 8b 4d e4 mov -0x1c(%ebp),%ecx return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10c547: 8b 7b 08 mov 0x8(%ebx),%edi next_block->next = allocated_blocks; allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 10c54a: 39 df cmp %ebx,%edi 10c54c: 75 d6 jne 10c524 <_Heap_Greedy_allocate+0x48> 10c54e: eb 14 jmp 10c564 <_Heap_Greedy_allocate+0x88> blocks = current; } while ( allocated_blocks != NULL ) { current = allocated_blocks; allocated_blocks = allocated_blocks->next; 10c550: 8b 79 08 mov 0x8(%ecx),%edi _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 10c553: 50 push %eax 10c554: 50 push %eax RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10c555: 83 c1 08 add $0x8,%ecx 10c558: 51 push %ecx 10c559: 53 push %ebx 10c55a: e8 95 60 00 00 call 1125f4 <_Heap_Free> 10c55f: 83 c4 10 add $0x10,%esp blocks = current; } while ( allocated_blocks != NULL ) { current = allocated_blocks; allocated_blocks = allocated_blocks->next; 10c562: 89 f9 mov %edi,%ecx current->next = blocks; blocks = current; } while ( allocated_blocks != NULL ) { 10c564: 85 c9 test %ecx,%ecx 10c566: 75 e8 jne 10c550 <_Heap_Greedy_allocate+0x74> allocated_blocks = allocated_blocks->next; _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); } return blocks; } 10c568: 89 f0 mov %esi,%eax 10c56a: 8d 65 f4 lea -0xc(%ebp),%esp 10c56d: 5b pop %ebx 10c56e: 5e pop %esi 10c56f: 5f pop %edi 10c570: 5d pop %ebp 10c571: c3 ret =============================================================================== 00111dc4 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) { 111dc4: 55 push %ebp 111dc5: 89 e5 mov %esp,%ebp 111dc7: 56 push %esi 111dc8: 53 push %ebx 111dc9: 8b 45 08 mov 0x8(%ebp),%eax Heap_Block *current = heap->first_block; 111dcc: 8b 50 20 mov 0x20(%eax),%edx Heap_Block *end = heap->last_block; 111dcf: 8b 58 24 mov 0x24(%eax),%ebx bool stop = false; 111dd2: 31 c0 xor %eax,%eax while ( !stop && current != end ) { 111dd4: eb 1f jmp 111df5 <_Heap_Iterate+0x31> 111dd6: 8b 42 04 mov 0x4(%edx),%eax 111dd9: 83 e0 fe and $0xfffffffe,%eax RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 111ddc: 8d 34 02 lea (%edx,%eax,1),%esi 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 ); 111ddf: ff 75 10 pushl 0x10(%ebp) 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; 111de2: 8b 4e 04 mov 0x4(%esi),%ecx 111de5: 83 e1 01 and $0x1,%ecx 111de8: 51 push %ecx 111de9: 50 push %eax 111dea: 52 push %edx 111deb: 8b 55 0c mov 0xc(%ebp),%edx 111dee: ff d2 call *%edx 111df0: 89 f2 mov %esi,%edx 111df2: 83 c4 10 add $0x10,%esp { Heap_Block *current = heap->first_block; Heap_Block *end = heap->last_block; bool stop = false; while ( !stop && current != end ) { 111df5: 39 da cmp %ebx,%edx 111df7: 74 04 je 111dfd <_Heap_Iterate+0x39> 111df9: fe c8 dec %al 111dfb: 75 d9 jne 111dd6 <_Heap_Iterate+0x12> <== ALWAYS TAKEN stop = (*visitor)( current, size, used, visitor_arg ); current = next; } } 111dfd: 8d 65 f8 lea -0x8(%ebp),%esp 111e00: 5b pop %ebx 111e01: 5e pop %esi 111e02: 5d pop %ebp 111e03: c3 ret =============================================================================== 0010ecc8 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 10ecc8: 55 push %ebp 10ecc9: 89 e5 mov %esp,%ebp 10eccb: 57 push %edi 10eccc: 56 push %esi 10eccd: 53 push %ebx 10ecce: 8b 5d 08 mov 0x8(%ebp),%ebx 10ecd1: 8b 75 0c mov 0xc(%ebp),%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10ecd4: 8d 4e f8 lea -0x8(%esi),%ecx 10ecd7: 89 f0 mov %esi,%eax 10ecd9: 31 d2 xor %edx,%edx 10ecdb: f7 73 10 divl 0x10(%ebx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 10ecde: 29 d1 sub %edx,%ecx 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 10ece0: 8b 53 20 mov 0x20(%ebx),%edx && (uintptr_t) block <= (uintptr_t) heap->last_block; 10ece3: 31 ff xor %edi,%edi 10ece5: 39 d1 cmp %edx,%ecx 10ece7: 72 0a jb 10ecf3 <_Heap_Size_of_alloc_area+0x2b> 10ece9: 31 c0 xor %eax,%eax 10eceb: 39 4b 24 cmp %ecx,0x24(%ebx) 10ecee: 0f 93 c0 setae %al 10ecf1: 89 c7 mov %eax,%edi Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); Heap_Block *next_block = NULL; uintptr_t block_size = 0; if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10ecf3: 31 c0 xor %eax,%eax uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr; Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); Heap_Block *next_block = NULL; uintptr_t block_size = 0; if ( !_Heap_Is_block_in_heap( heap, block ) ) { 10ecf5: 85 ff test %edi,%edi 10ecf7: 74 30 je 10ed29 <_Heap_Size_of_alloc_area+0x61> - 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; 10ecf9: 8b 41 04 mov 0x4(%ecx),%eax 10ecfc: 83 e0 fe and $0xfffffffe,%eax RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10ecff: 01 c1 add %eax,%ecx 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; 10ed01: 31 ff xor %edi,%edi 10ed03: 39 d1 cmp %edx,%ecx 10ed05: 72 0a jb 10ed11 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN 10ed07: 31 c0 xor %eax,%eax 10ed09: 39 4b 24 cmp %ecx,0x24(%ebx) 10ed0c: 0f 93 c0 setae %al 10ed0f: 89 c7 mov %eax,%edi return false; 10ed11: 31 c0 xor %eax,%eax } block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( 10ed13: 85 ff test %edi,%edi 10ed15: 74 12 je 10ed29 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 10ed17: f6 41 04 01 testb $0x1,0x4(%ecx) 10ed1b: 74 0c je 10ed29 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 10ed1d: 29 f1 sub %esi,%ecx 10ed1f: 8d 51 04 lea 0x4(%ecx),%edx 10ed22: 8b 45 10 mov 0x10(%ebp),%eax 10ed25: 89 10 mov %edx,(%eax) return true; 10ed27: b0 01 mov $0x1,%al } 10ed29: 5b pop %ebx 10ed2a: 5e pop %esi 10ed2b: 5f pop %edi 10ed2c: 5d pop %ebp 10ed2d: c3 ret =============================================================================== 0010b586 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10b586: 55 push %ebp 10b587: 89 e5 mov %esp,%ebp 10b589: 57 push %edi 10b58a: 56 push %esi 10b58b: 53 push %ebx 10b58c: 83 ec 3c sub $0x3c,%esp 10b58f: 8b 7d 0c mov 0xc(%ebp),%edi uintptr_t const page_size = heap->page_size; 10b592: 8b 4d 08 mov 0x8(%ebp),%ecx 10b595: 8b 49 10 mov 0x10(%ecx),%ecx 10b598: 89 4d e0 mov %ecx,-0x20(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10b59b: 8b 4d 08 mov 0x8(%ebp),%ecx 10b59e: 8b 49 14 mov 0x14(%ecx),%ecx 10b5a1: 89 4d d8 mov %ecx,-0x28(%ebp) Heap_Block *const first_block = heap->first_block; 10b5a4: 8b 4d 08 mov 0x8(%ebp),%ecx 10b5a7: 8b 71 20 mov 0x20(%ecx),%esi Heap_Block *const last_block = heap->last_block; 10b5aa: 8b 49 24 mov 0x24(%ecx),%ecx 10b5ad: 89 4d d4 mov %ecx,-0x2c(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10b5b0: bb 48 b5 10 00 mov $0x10b548,%ebx 10b5b5: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10b5b9: 74 05 je 10b5c0 <_Heap_Walk+0x3a> 10b5bb: bb 4d b5 10 00 mov $0x10b54d,%ebx if ( !_System_state_Is_up( _System_state_Get() ) ) { 10b5c0: 83 3d 30 e5 12 00 03 cmpl $0x3,0x12e530 10b5c7: 74 07 je 10b5d0 <_Heap_Walk+0x4a> return true; 10b5c9: b0 01 mov $0x1,%al 10b5cb: e9 ec 02 00 00 jmp 10b8bc <_Heap_Walk+0x336> 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)( 10b5d0: 50 push %eax 10b5d1: 8b 4d 08 mov 0x8(%ebp),%ecx 10b5d4: ff 71 0c pushl 0xc(%ecx) 10b5d7: ff 71 08 pushl 0x8(%ecx) 10b5da: ff 75 d4 pushl -0x2c(%ebp) 10b5dd: 56 push %esi 10b5de: ff 71 1c pushl 0x1c(%ecx) 10b5e1: ff 71 18 pushl 0x18(%ecx) 10b5e4: ff 75 d8 pushl -0x28(%ebp) 10b5e7: ff 75 e0 pushl -0x20(%ebp) 10b5ea: 68 00 f7 11 00 push $0x11f700 10b5ef: 6a 00 push $0x0 10b5f1: 57 push %edi 10b5f2: ff d3 call *%ebx heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 10b5f4: 83 c4 30 add $0x30,%esp 10b5f7: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 10b5fb: 75 0b jne 10b608 <_Heap_Walk+0x82> (*printer)( source, true, "page size is zero\n" ); 10b5fd: 50 push %eax 10b5fe: 68 91 f7 11 00 push $0x11f791 10b603: e9 d5 00 00 00 jmp 10b6dd <_Heap_Walk+0x157> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10b608: f6 45 e0 03 testb $0x3,-0x20(%ebp) 10b60c: 74 0d je 10b61b <_Heap_Walk+0x95> (*printer)( 10b60e: ff 75 e0 pushl -0x20(%ebp) 10b611: 68 a4 f7 11 00 push $0x11f7a4 10b616: e9 c2 00 00 00 jmp 10b6dd <_Heap_Walk+0x157> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10b61b: 8b 45 d8 mov -0x28(%ebp),%eax 10b61e: 31 d2 xor %edx,%edx 10b620: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10b623: 85 d2 test %edx,%edx 10b625: 74 0d je 10b634 <_Heap_Walk+0xae> (*printer)( 10b627: ff 75 d8 pushl -0x28(%ebp) 10b62a: 68 c2 f7 11 00 push $0x11f7c2 10b62f: e9 a9 00 00 00 jmp 10b6dd <_Heap_Walk+0x157> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10b634: 8d 46 08 lea 0x8(%esi),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10b637: 31 d2 xor %edx,%edx 10b639: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10b63c: 85 d2 test %edx,%edx 10b63e: 74 0b je 10b64b <_Heap_Walk+0xc5> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10b640: 56 push %esi 10b641: 68 e6 f7 11 00 push $0x11f7e6 10b646: e9 92 00 00 00 jmp 10b6dd <_Heap_Walk+0x157> ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10b64b: f6 46 04 01 testb $0x1,0x4(%esi) 10b64f: 75 0b jne 10b65c <_Heap_Walk+0xd6> (*printer)( 10b651: 50 push %eax 10b652: 68 17 f8 11 00 push $0x11f817 10b657: e9 81 00 00 00 jmp 10b6dd <_Heap_Walk+0x157> - 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; 10b65c: 8b 4d d4 mov -0x2c(%ebp),%ecx 10b65f: 8b 41 04 mov 0x4(%ecx),%eax 10b662: 83 e0 fe and $0xfffffffe,%eax RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10b665: 01 c8 add %ecx,%eax 10b667: 89 45 d0 mov %eax,-0x30(%ebp) ); return false; } if ( _Heap_Is_free( last_block ) ) { 10b66a: f6 40 04 01 testb $0x1,0x4(%eax) 10b66e: 75 08 jne 10b678 <_Heap_Walk+0xf2> (*printer)( 10b670: 50 push %eax 10b671: 68 45 f8 11 00 push $0x11f845 10b676: eb 65 jmp 10b6dd <_Heap_Walk+0x157> ); return false; } if ( 10b678: 39 75 d0 cmp %esi,-0x30(%ebp) 10b67b: 74 08 je 10b685 <_Heap_Walk+0xff> _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10b67d: 56 push %esi 10b67e: 68 5a f8 11 00 push $0x11f85a 10b683: eb 58 jmp 10b6dd <_Heap_Walk+0x157> int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10b685: 8b 4d 08 mov 0x8(%ebp),%ecx 10b688: 8b 49 10 mov 0x10(%ecx),%ecx 10b68b: 89 4d e4 mov %ecx,-0x1c(%ebp) return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10b68e: 8b 45 08 mov 0x8(%ebp),%eax 10b691: 8b 48 08 mov 0x8(%eax),%ecx const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); 10b694: 89 c6 mov %eax,%esi 10b696: eb 6d jmp 10b705 <_Heap_Walk+0x17f> 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; 10b698: 31 c0 xor %eax,%eax 10b69a: 8b 55 08 mov 0x8(%ebp),%edx 10b69d: 39 4a 20 cmp %ecx,0x20(%edx) 10b6a0: 77 08 ja 10b6aa <_Heap_Walk+0x124> 10b6a2: 31 c0 xor %eax,%eax 10b6a4: 39 4a 24 cmp %ecx,0x24(%edx) 10b6a7: 0f 93 c0 setae %al 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 ) { if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { 10b6aa: 85 c0 test %eax,%eax 10b6ac: 75 08 jne 10b6b6 <_Heap_Walk+0x130> (*printer)( 10b6ae: 51 push %ecx 10b6af: 68 89 f8 11 00 push $0x11f889 10b6b4: eb 27 jmp 10b6dd <_Heap_Walk+0x157> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10b6b6: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10b6b9: 31 d2 xor %edx,%edx 10b6bb: f7 75 e4 divl -0x1c(%ebp) ); return false; } if ( 10b6be: 85 d2 test %edx,%edx 10b6c0: 74 08 je 10b6ca <_Heap_Walk+0x144> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10b6c2: 51 push %ecx 10b6c3: 68 a9 f8 11 00 push $0x11f8a9 10b6c8: eb 13 jmp 10b6dd <_Heap_Walk+0x157> - 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; 10b6ca: 8b 41 04 mov 0x4(%ecx),%eax 10b6cd: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10b6d0: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10b6d5: 74 13 je 10b6ea <_Heap_Walk+0x164> (*printer)( 10b6d7: 51 push %ecx 10b6d8: 68 d9 f8 11 00 push $0x11f8d9 10b6dd: 6a 01 push $0x1 10b6df: 57 push %edi 10b6e0: ff d3 call *%ebx 10b6e2: 83 c4 10 add $0x10,%esp 10b6e5: e9 c3 01 00 00 jmp 10b8ad <_Heap_Walk+0x327> ); return false; } if ( free_block->prev != prev_block ) { 10b6ea: 8b 41 0c mov 0xc(%ecx),%eax 10b6ed: 39 f0 cmp %esi,%eax 10b6ef: 74 0f je 10b700 <_Heap_Walk+0x17a> (*printer)( 10b6f1: 83 ec 0c sub $0xc,%esp 10b6f4: 50 push %eax 10b6f5: 51 push %ecx 10b6f6: 68 f5 f8 11 00 push $0x11f8f5 10b6fb: e9 42 01 00 00 jmp 10b842 <_Heap_Walk+0x2bc> return false; } prev_block = free_block; free_block = free_block->next; 10b700: 89 ce mov %ecx,%esi 10b702: 8b 49 08 mov 0x8(%ecx),%ecx 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 ) { 10b705: 3b 4d 08 cmp 0x8(%ebp),%ecx 10b708: 75 8e jne 10b698 <_Heap_Walk+0x112> 10b70a: 8b 75 d0 mov -0x30(%ebp),%esi block = next_block; } while ( block != first_block ); return true; } 10b70d: 8b 46 04 mov 0x4(%esi),%eax 10b710: 89 c1 mov %eax,%ecx 10b712: 83 e1 fe and $0xfffffffe,%ecx 10b715: 89 4d e4 mov %ecx,-0x1c(%ebp) 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; 10b718: 83 e0 01 and $0x1,%eax 10b71b: 89 45 c8 mov %eax,-0x38(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10b71e: 01 f1 add %esi,%ecx 10b720: 89 4d dc mov %ecx,-0x24(%ebp) 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; 10b723: 3b 75 d4 cmp -0x2c(%ebp),%esi 10b726: 0f 95 c1 setne %cl 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; 10b729: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 10b730: 8b 55 dc mov -0x24(%ebp),%edx 10b733: 8b 45 08 mov 0x8(%ebp),%eax 10b736: 39 50 20 cmp %edx,0x20(%eax) 10b739: 77 0c ja 10b747 <_Heap_Walk+0x1c1> <== NEVER TAKEN 10b73b: 39 50 24 cmp %edx,0x24(%eax) 10b73e: 0f 93 c0 setae %al 10b741: 0f b6 c0 movzbl %al,%eax 10b744: 89 45 cc mov %eax,-0x34(%ebp) if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10b747: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10b74b: 75 11 jne 10b75e <_Heap_Walk+0x1d8> (*printer)( 10b74d: 83 ec 0c sub $0xc,%esp 10b750: ff 75 dc pushl -0x24(%ebp) 10b753: 56 push %esi 10b754: 68 27 f9 11 00 push $0x11f927 10b759: e9 e4 00 00 00 jmp 10b842 <_Heap_Walk+0x2bc> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10b75e: 8b 45 e4 mov -0x1c(%ebp),%eax 10b761: 31 d2 xor %edx,%edx 10b763: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10b766: 85 d2 test %edx,%edx 10b768: 74 15 je 10b77f <_Heap_Walk+0x1f9> 10b76a: 84 c9 test %cl,%cl 10b76c: 74 11 je 10b77f <_Heap_Walk+0x1f9> (*printer)( 10b76e: 83 ec 0c sub $0xc,%esp 10b771: ff 75 e4 pushl -0x1c(%ebp) 10b774: 56 push %esi 10b775: 68 54 f9 11 00 push $0x11f954 10b77a: e9 c3 00 00 00 jmp 10b842 <_Heap_Walk+0x2bc> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10b77f: 8b 45 d8 mov -0x28(%ebp),%eax 10b782: 39 45 e4 cmp %eax,-0x1c(%ebp) 10b785: 73 15 jae 10b79c <_Heap_Walk+0x216> 10b787: 84 c9 test %cl,%cl 10b789: 74 11 je 10b79c <_Heap_Walk+0x216> <== NEVER TAKEN (*printer)( 10b78b: 51 push %ecx 10b78c: 51 push %ecx 10b78d: 50 push %eax 10b78e: ff 75 e4 pushl -0x1c(%ebp) 10b791: 56 push %esi 10b792: 68 82 f9 11 00 push $0x11f982 10b797: e9 a6 00 00 00 jmp 10b842 <_Heap_Walk+0x2bc> ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10b79c: 3b 75 dc cmp -0x24(%ebp),%esi 10b79f: 72 15 jb 10b7b6 <_Heap_Walk+0x230> 10b7a1: 84 c9 test %cl,%cl 10b7a3: 74 11 je 10b7b6 <_Heap_Walk+0x230> (*printer)( 10b7a5: 83 ec 0c sub $0xc,%esp 10b7a8: ff 75 dc pushl -0x24(%ebp) 10b7ab: 56 push %esi 10b7ac: 68 ad f9 11 00 push $0x11f9ad 10b7b1: e9 8c 00 00 00 jmp 10b842 <_Heap_Walk+0x2bc> ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10b7b6: 8b 4d dc mov -0x24(%ebp),%ecx 10b7b9: f6 41 04 01 testb $0x1,0x4(%ecx) 10b7bd: 0f 85 b0 00 00 00 jne 10b873 <_Heap_Walk+0x2ed> return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10b7c3: 8b 45 08 mov 0x8(%ebp),%eax 10b7c6: 8b 48 08 mov 0x8(%eax),%ecx block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? 10b7c9: 8b 56 08 mov 0x8(%esi),%edx 10b7cc: 89 55 c4 mov %edx,-0x3c(%ebp) 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)( 10b7cf: 3b 50 0c cmp 0xc(%eax),%edx 10b7d2: 74 14 je 10b7e8 <_Heap_Walk+0x262> " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10b7d4: b8 a9 f5 11 00 mov $0x11f5a9,%eax 10b7d9: 8b 55 08 mov 0x8(%ebp),%edx 10b7dc: 39 55 c4 cmp %edx,-0x3c(%ebp) 10b7df: 75 0c jne 10b7ed <_Heap_Walk+0x267> 10b7e1: b8 dc f6 11 00 mov $0x11f6dc,%eax 10b7e6: eb 05 jmp 10b7ed <_Heap_Walk+0x267> 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)( 10b7e8: b8 cd f6 11 00 mov $0x11f6cd,%eax 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 ? 10b7ed: 8b 56 0c mov 0xc(%esi),%edx 10b7f0: 89 55 cc mov %edx,-0x34(%ebp) 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)( 10b7f3: 39 ca cmp %ecx,%edx 10b7f5: 74 14 je 10b80b <_Heap_Walk+0x285> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10b7f7: ba a9 f5 11 00 mov $0x11f5a9,%edx 10b7fc: 8b 4d 08 mov 0x8(%ebp),%ecx 10b7ff: 39 4d cc cmp %ecx,-0x34(%ebp) 10b802: 75 0c jne 10b810 <_Heap_Walk+0x28a> 10b804: ba f6 f6 11 00 mov $0x11f6f6,%edx 10b809: eb 05 jmp 10b810 <_Heap_Walk+0x28a> 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)( 10b80b: ba e6 f6 11 00 mov $0x11f6e6,%edx 10b810: 83 ec 0c sub $0xc,%esp 10b813: 50 push %eax 10b814: ff 75 c4 pushl -0x3c(%ebp) 10b817: 52 push %edx 10b818: ff 75 cc pushl -0x34(%ebp) 10b81b: ff 75 e4 pushl -0x1c(%ebp) 10b81e: 56 push %esi 10b81f: 68 e1 f9 11 00 push $0x11f9e1 10b824: 6a 00 push $0x0 10b826: 57 push %edi 10b827: ff d3 call *%ebx block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 10b829: 8b 4d dc mov -0x24(%ebp),%ecx 10b82c: 8b 01 mov (%ecx),%eax 10b82e: 83 c4 30 add $0x30,%esp 10b831: 39 45 e4 cmp %eax,-0x1c(%ebp) 10b834: 74 16 je 10b84c <_Heap_Walk+0x2c6> (*printer)( 10b836: 52 push %edx 10b837: 51 push %ecx 10b838: 50 push %eax 10b839: ff 75 e4 pushl -0x1c(%ebp) 10b83c: 56 push %esi 10b83d: 68 16 fa 11 00 push $0x11fa16 10b842: 6a 01 push $0x1 10b844: 57 push %edi 10b845: ff d3 call *%ebx 10b847: 83 c4 20 add $0x20,%esp 10b84a: eb 61 jmp 10b8ad <_Heap_Walk+0x327> ); return false; } if ( !prev_used ) { 10b84c: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10b850: 75 0b jne 10b85d <_Heap_Walk+0x2d7> (*printer)( 10b852: 56 push %esi 10b853: 68 4f fa 11 00 push $0x11fa4f 10b858: e9 80 fe ff ff jmp 10b6dd <_Heap_Walk+0x157> 10b85d: 8b 4d 08 mov 0x8(%ebp),%ecx 10b860: 8b 41 08 mov 0x8(%ecx),%eax 10b863: eb 07 jmp 10b86c <_Heap_Walk+0x2e6> { 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 ) { if ( free_block == block ) { 10b865: 39 f0 cmp %esi,%eax 10b867: 74 33 je 10b89c <_Heap_Walk+0x316> return true; } free_block = free_block->next; 10b869: 8b 40 08 mov 0x8(%eax),%eax ) { 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 ) { 10b86c: 3b 45 08 cmp 0x8(%ebp),%eax 10b86f: 75 f4 jne 10b865 <_Heap_Walk+0x2df> 10b871: eb 3e jmp 10b8b1 <_Heap_Walk+0x32b> if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 10b873: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10b877: 74 0e je 10b887 <_Heap_Walk+0x301> (*printer)( 10b879: 83 ec 0c sub $0xc,%esp 10b87c: ff 75 e4 pushl -0x1c(%ebp) 10b87f: 56 push %esi 10b880: 68 7e fa 11 00 push $0x11fa7e 10b885: eb 0d jmp 10b894 <_Heap_Walk+0x30e> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10b887: 50 push %eax 10b888: 50 push %eax 10b889: ff 36 pushl (%esi) 10b88b: ff 75 e4 pushl -0x1c(%ebp) 10b88e: 56 push %esi 10b88f: 68 95 fa 11 00 push $0x11fa95 10b894: 6a 00 push $0x0 10b896: 57 push %edi 10b897: ff d3 call *%ebx 10b899: 83 c4 20 add $0x20,%esp 10b89c: 8b 75 dc mov -0x24(%ebp),%esi block->prev_size ); } block = next_block; } while ( block != first_block ); 10b89f: 3b 75 d0 cmp -0x30(%ebp),%esi 10b8a2: 0f 85 65 fe ff ff jne 10b70d <_Heap_Walk+0x187> 10b8a8: e9 1c fd ff ff jmp 10b5c9 <_Heap_Walk+0x43> if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 10b8ad: 31 c0 xor %eax,%eax 10b8af: eb 0b jmp 10b8bc <_Heap_Walk+0x336> return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10b8b1: 56 push %esi 10b8b2: 68 ba fa 11 00 push $0x11faba 10b8b7: e9 21 fe ff ff jmp 10b6dd <_Heap_Walk+0x157> block = next_block; } while ( block != first_block ); return true; } 10b8bc: 8d 65 f4 lea -0xc(%ebp),%esp 10b8bf: 5b pop %ebx 10b8c0: 5e pop %esi 10b8c1: 5f pop %edi 10b8c2: 5d pop %ebp 10b8c3: c3 ret =============================================================================== 0010ad80 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10ad80: 55 push %ebp 10ad81: 89 e5 mov %esp,%ebp 10ad83: 53 push %ebx 10ad84: 83 ec 08 sub $0x8,%esp 10ad87: 8b 55 08 mov 0x8(%ebp),%edx 10ad8a: 8b 45 0c mov 0xc(%ebp),%eax 10ad8d: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10ad90: 89 15 ec c3 12 00 mov %edx,0x12c3ec _Internal_errors_What_happened.is_internal = is_internal; 10ad96: a2 f0 c3 12 00 mov %al,0x12c3f0 _Internal_errors_What_happened.the_error = the_error; 10ad9b: 89 1d f4 c3 12 00 mov %ebx,0x12c3f4 _User_extensions_Fatal( the_source, is_internal, the_error ); 10ada1: 53 push %ebx 10ada2: 0f b6 c0 movzbl %al,%eax 10ada5: 50 push %eax 10ada6: 52 push %edx 10ada7: e8 a9 19 00 00 call 10c755 <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10adac: c7 05 a8 c4 12 00 05 movl $0x5,0x12c4a8 <== NOT EXECUTED 10adb3: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10adb6: fa cli <== NOT EXECUTED 10adb7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10adb9: f4 hlt <== NOT EXECUTED 10adba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adbd: eb fe jmp 10adbd <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010ae10 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10ae10: 55 push %ebp 10ae11: 89 e5 mov %esp,%ebp 10ae13: 56 push %esi 10ae14: 53 push %ebx 10ae15: 8b 5d 08 mov 0x8(%ebp),%ebx * 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 ) 10ae18: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10ae1c: 75 04 jne 10ae22 <_Objects_Allocate+0x12><== ALWAYS TAKEN return NULL; 10ae1e: 31 c9 xor %ecx,%ecx 10ae20: eb 51 jmp 10ae73 <_Objects_Allocate+0x63> /* * 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 ); 10ae22: 8d 73 20 lea 0x20(%ebx),%esi 10ae25: 83 ec 0c sub $0xc,%esp 10ae28: 56 push %esi 10ae29: e8 06 f8 ff ff call 10a634 <_Chain_Get> 10ae2e: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10ae30: 83 c4 10 add $0x10,%esp 10ae33: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10ae37: 74 3a je 10ae73 <_Objects_Allocate+0x63> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10ae39: 85 c0 test %eax,%eax 10ae3b: 75 1a jne 10ae57 <_Objects_Allocate+0x47> _Objects_Extend_information( information ); 10ae3d: 83 ec 0c sub $0xc,%esp 10ae40: 53 push %ebx 10ae41: e8 56 00 00 00 call 10ae9c <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10ae46: 89 34 24 mov %esi,(%esp) 10ae49: e8 e6 f7 ff ff call 10a634 <_Chain_Get> 10ae4e: 89 c1 mov %eax,%ecx } if ( the_object ) { 10ae50: 83 c4 10 add $0x10,%esp 10ae53: 85 c0 test %eax,%eax 10ae55: 74 c7 je 10ae1e <_Objects_Allocate+0xe> uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10ae57: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10ae5b: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10ae5f: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10ae61: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10ae65: 31 d2 xor %edx,%edx 10ae67: f7 f6 div %esi information->inactive_per_block[ block ]--; 10ae69: 8b 53 30 mov 0x30(%ebx),%edx 10ae6c: ff 0c 82 decl (%edx,%eax,4) information->inactive--; 10ae6f: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10ae73: 89 c8 mov %ecx,%eax 10ae75: 8d 65 f8 lea -0x8(%ebp),%esp 10ae78: 5b pop %ebx 10ae79: 5e pop %esi 10ae7a: 5d pop %ebp 10ae7b: c3 ret =============================================================================== 0010ae9c <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10ae9c: 55 push %ebp 10ae9d: 89 e5 mov %esp,%ebp 10ae9f: 57 push %edi 10aea0: 56 push %esi 10aea1: 53 push %ebx 10aea2: 83 ec 3c sub $0x3c,%esp 10aea5: 8b 5d 08 mov 0x8(%ebp),%ebx /* * 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 ); 10aea8: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10aeac: 89 45 c8 mov %eax,-0x38(%ebp) index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 10aeaf: 8b 73 34 mov 0x34(%ebx),%esi 10aeb2: 85 f6 test %esi,%esi 10aeb4: 74 40 je 10aef6 <_Objects_Extend_information+0x5a> block_count = 0; else { block_count = information->maximum / information->allocation_size; 10aeb6: 0f b7 4b 14 movzwl 0x14(%ebx),%ecx 10aeba: 8b 43 10 mov 0x10(%ebx),%eax 10aebd: 31 d2 xor %edx,%edx 10aebf: 66 f7 f1 div %cx 10aec2: 0f b7 c0 movzwl %ax,%eax 10aec5: 89 45 d0 mov %eax,-0x30(%ebp) /* * 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 ); 10aec8: 8b 55 c8 mov -0x38(%ebp),%edx 10aecb: 89 55 cc mov %edx,-0x34(%ebp) index_base = minimum_index; block = 0; 10aece: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) if ( information->object_blocks == NULL ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10aed5: eb 10 jmp 10aee7 <_Objects_Extend_information+0x4b> if ( information->object_blocks[ block ] == NULL ) { 10aed7: 8b 55 d4 mov -0x2c(%ebp),%edx 10aeda: 83 3c 96 00 cmpl $0x0,(%esi,%edx,4) 10aede: 74 31 je 10af11 <_Objects_Extend_information+0x75> * information - object information table * * Output parameters: NONE */ void _Objects_Extend_information( 10aee0: 01 4d cc add %ecx,-0x34(%ebp) if ( information->object_blocks == NULL ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10aee3: 42 inc %edx 10aee4: 89 55 d4 mov %edx,-0x2c(%ebp) 10aee7: 8b 55 d0 mov -0x30(%ebp),%edx 10aeea: 39 55 d4 cmp %edx,-0x2c(%ebp) 10aeed: 72 e8 jb 10aed7 <_Objects_Extend_information+0x3b> /* * 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; 10aeef: be 01 00 00 00 mov $0x1,%esi 10aef4: eb 1d jmp 10af13 <_Objects_Extend_information+0x77> minimum_index = _Objects_Get_index( information->minimum_id ); 10aef6: 8b 4d c8 mov -0x38(%ebp),%ecx 10aef9: 89 4d cc mov %ecx,-0x34(%ebp) /* * 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; 10aefc: be 01 00 00 00 mov $0x1,%esi minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10af01: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) block_count = 0; 10af08: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 10af0f: eb 02 jmp 10af13 <_Objects_Extend_information+0x77> else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { do_extend = false; 10af11: 31 f6 xor %esi,%esi } else index_base += information->allocation_size; } } maximum = (uint32_t) information->maximum + information->allocation_size; 10af13: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10af17: 0f b7 53 10 movzwl 0x10(%ebx),%edx 10af1b: 01 c2 add %eax,%edx 10af1d: 89 55 bc mov %edx,-0x44(%ebp) /* * 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 ) { 10af20: 81 fa ff ff 00 00 cmp $0xffff,%edx 10af26: 0f 87 bb 01 00 00 ja 10b0e7 <_Objects_Extend_information+0x24b><== NEVER TAKEN /* * 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; 10af2c: 0f af 43 18 imul 0x18(%ebx),%eax if ( information->auto_extend ) { 10af30: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10af34: 74 18 je 10af4e <_Objects_Extend_information+0xb2> new_object_block = _Workspace_Allocate( block_size ); 10af36: 83 ec 0c sub $0xc,%esp 10af39: 50 push %eax 10af3a: e8 61 1b 00 00 call 10caa0 <_Workspace_Allocate> 10af3f: 89 45 c0 mov %eax,-0x40(%ebp) if ( !new_object_block ) 10af42: 83 c4 10 add $0x10,%esp 10af45: 85 c0 test %eax,%eax 10af47: 75 14 jne 10af5d <_Objects_Extend_information+0xc1> 10af49: e9 99 01 00 00 jmp 10b0e7 <_Objects_Extend_information+0x24b> return; } else { new_object_block = _Workspace_Allocate_or_fatal_error( block_size ); 10af4e: 83 ec 0c sub $0xc,%esp 10af51: 50 push %eax 10af52: e8 7a 1b 00 00 call 10cad1 <_Workspace_Allocate_or_fatal_error> 10af57: 89 45 c0 mov %eax,-0x40(%ebp) 10af5a: 83 c4 10 add $0x10,%esp } /* * Do we need to grow the tables? */ if ( do_extend ) { 10af5d: 89 f0 mov %esi,%eax 10af5f: 84 c0 test %al,%al 10af61: 0f 84 fd 00 00 00 je 10b064 <_Objects_Extend_information+0x1c8> */ /* * Up the block count and maximum */ block_count++; 10af67: 8b 75 d0 mov -0x30(%ebp),%esi 10af6a: 46 inc %esi * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); 10af6b: 83 ec 0c sub $0xc,%esp /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); 10af6e: 8b 55 bc mov -0x44(%ebp),%edx 10af71: 03 55 c8 add -0x38(%ebp),%edx /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 10af74: 8d 04 76 lea (%esi,%esi,2),%eax 10af77: 01 d0 add %edx,%eax block_count++; /* * Allocate the tables and break it up. */ block_size = block_count * 10af79: c1 e0 02 shl $0x2,%eax (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); 10af7c: 50 push %eax 10af7d: e8 1e 1b 00 00 call 10caa0 <_Workspace_Allocate> 10af82: 89 c2 mov %eax,%edx if ( !object_blocks ) { 10af84: 83 c4 10 add $0x10,%esp 10af87: 85 c0 test %eax,%eax 10af89: 75 13 jne 10af9e <_Objects_Extend_information+0x102> _Workspace_Free( new_object_block ); 10af8b: 83 ec 0c sub $0xc,%esp 10af8e: ff 75 c0 pushl -0x40(%ebp) 10af91: e8 23 1b 00 00 call 10cab9 <_Workspace_Free> 10af96: 83 c4 10 add $0x10,%esp 10af99: e9 49 01 00 00 jmp 10b0e7 <_Objects_Extend_information+0x24b> 10af9e: 8d 0c b0 lea (%eax,%esi,4),%ecx 10afa1: 89 4d b8 mov %ecx,-0x48(%ebp) 10afa4: 8d 34 f0 lea (%eax,%esi,8),%esi 10afa7: 89 75 c4 mov %esi,-0x3c(%ebp) * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10afaa: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10afae: 31 c0 xor %eax,%eax 10afb0: 3b 4d c8 cmp -0x38(%ebp),%ecx 10afb3: 76 38 jbe 10afed <_Objects_Extend_information+0x151> /* * 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, 10afb5: 8b 45 d0 mov -0x30(%ebp),%eax 10afb8: c1 e0 02 shl $0x2,%eax 10afbb: 8b 73 34 mov 0x34(%ebx),%esi 10afbe: 89 d7 mov %edx,%edi 10afc0: 89 c1 mov %eax,%ecx 10afc2: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10afc4: 8b 73 30 mov 0x30(%ebx),%esi 10afc7: 8b 7d b8 mov -0x48(%ebp),%edi 10afca: 89 c1 mov %eax,%ecx 10afcc: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, information->local_table, (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 10afce: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10afd2: 03 4d c8 add -0x38(%ebp),%ecx information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10afd5: c1 e1 02 shl $0x2,%ecx 10afd8: 8b 73 1c mov 0x1c(%ebx),%esi 10afdb: 8b 7d c4 mov -0x3c(%ebp),%edi 10afde: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10afe0: eb 10 jmp 10aff2 <_Objects_Extend_information+0x156> /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 10afe2: 8b 75 c4 mov -0x3c(%ebp),%esi 10afe5: c7 04 86 00 00 00 00 movl $0x0,(%esi,%eax,4) } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10afec: 40 inc %eax 10afed: 3b 45 c8 cmp -0x38(%ebp),%eax 10aff0: 75 f0 jne 10afe2 <_Objects_Extend_information+0x146> } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10aff2: 8b 45 d0 mov -0x30(%ebp),%eax 10aff5: c7 04 82 00 00 00 00 movl $0x0,(%edx,%eax,4) inactive_per_block[block_count] = 0; 10affc: 8b 4d b8 mov -0x48(%ebp),%ecx 10afff: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4) for ( index=index_base ; index < ( information->allocation_size + index_base ); 10b006: 0f b7 4b 14 movzwl 0x14(%ebx),%ecx 10b00a: 03 4d cc add -0x34(%ebp),%ecx * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10b00d: 8b 45 cc mov -0x34(%ebp),%eax 10b010: eb 0b jmp 10b01d <_Objects_Extend_information+0x181> index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; 10b012: 8b 75 c4 mov -0x3c(%ebp),%esi 10b015: c7 04 86 00 00 00 00 movl $0x0,(%esi,%eax,4) object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 10b01c: 40 inc %eax * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10b01d: 39 c8 cmp %ecx,%eax 10b01f: 72 f1 jb 10b012 <_Objects_Extend_information+0x176> index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10b021: 9c pushf 10b022: fa cli 10b023: 5e pop %esi old_tables = information->object_blocks; 10b024: 8b 4b 34 mov 0x34(%ebx),%ecx information->object_blocks = object_blocks; 10b027: 89 53 34 mov %edx,0x34(%ebx) information->inactive_per_block = inactive_per_block; 10b02a: 8b 45 b8 mov -0x48(%ebp),%eax 10b02d: 89 43 30 mov %eax,0x30(%ebx) information->local_table = local_table; 10b030: 8b 55 c4 mov -0x3c(%ebp),%edx 10b033: 89 53 1c mov %edx,0x1c(%ebx) information->maximum = (Objects_Maximum) maximum; 10b036: 8b 45 bc mov -0x44(%ebp),%eax 10b039: 66 89 43 10 mov %ax,0x10(%ebx) uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10b03d: 8b 03 mov (%ebx),%eax 10b03f: c1 e0 18 shl $0x18,%eax 10b042: 0d 00 00 01 00 or $0x10000,%eax (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10b047: 0b 45 bc or -0x44(%ebp),%eax information->maximum_id = _Objects_Build_id( 10b04a: 0f b7 53 04 movzwl 0x4(%ebx),%edx 10b04e: c1 e2 1b shl $0x1b,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10b051: 09 d0 or %edx,%eax 10b053: 89 43 0c mov %eax,0xc(%ebx) information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10b056: 56 push %esi 10b057: 9d popf _Workspace_Free( old_tables ); 10b058: 83 ec 0c sub $0xc,%esp 10b05b: 51 push %ecx 10b05c: e8 58 1a 00 00 call 10cab9 <_Workspace_Free> 10b061: 83 c4 10 add $0x10,%esp } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 10b064: 8b 55 d4 mov -0x2c(%ebp),%edx 10b067: c1 e2 02 shl $0x2,%edx 10b06a: 89 55 d0 mov %edx,-0x30(%ebp) 10b06d: 8b 43 34 mov 0x34(%ebx),%eax 10b070: 8b 4d c0 mov -0x40(%ebp),%ecx 10b073: 8b 55 d4 mov -0x2c(%ebp),%edx 10b076: 89 0c 90 mov %ecx,(%eax,%edx,4) /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10b079: ff 73 18 pushl 0x18(%ebx) 10b07c: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10b080: 50 push %eax 10b081: 8b 43 34 mov 0x34(%ebx),%eax 10b084: ff 34 90 pushl (%eax,%edx,4) 10b087: 8d 7d dc lea -0x24(%ebp),%edi 10b08a: 57 push %edi 10b08b: e8 c8 f5 ff ff call 10a658 <_Chain_Initialize> /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10b090: 83 c4 10 add $0x10,%esp ); /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; 10b093: 8b 75 cc mov -0x34(%ebp),%esi information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b096: 8d 7b 20 lea 0x20(%ebx),%edi /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10b099: eb 26 jmp 10b0c1 <_Objects_Extend_information+0x225> 10b09b: 8b 13 mov (%ebx),%edx 10b09d: c1 e2 18 shl $0x18,%edx 10b0a0: 81 ca 00 00 01 00 or $0x10000,%edx the_object->id = _Objects_Build_id( 10b0a6: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10b0aa: c1 e1 1b shl $0x1b,%ecx 10b0ad: 09 ca or %ecx,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10b0af: 09 f2 or %esi,%edx 10b0b1: 89 50 08 mov %edx,0x8(%eax) information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b0b4: 52 push %edx 10b0b5: 52 push %edx 10b0b6: 50 push %eax 10b0b7: 57 push %edi 10b0b8: e8 53 f5 ff ff call 10a610 <_Chain_Append> index++; 10b0bd: 46 inc %esi 10b0be: 83 c4 10 add $0x10,%esp /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10b0c1: 83 ec 0c sub $0xc,%esp 10b0c4: 8d 45 dc lea -0x24(%ebp),%eax 10b0c7: 50 push %eax 10b0c8: e8 67 f5 ff ff call 10a634 <_Chain_Get> 10b0cd: 83 c4 10 add $0x10,%esp 10b0d0: 85 c0 test %eax,%eax 10b0d2: 75 c7 jne 10b09b <_Objects_Extend_information+0x1ff> _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10b0d4: 8b 43 14 mov 0x14(%ebx),%eax 10b0d7: 8b 53 30 mov 0x30(%ebx),%edx 10b0da: 0f b7 c8 movzwl %ax,%ecx 10b0dd: 8b 75 d0 mov -0x30(%ebp),%esi 10b0e0: 89 0c 32 mov %ecx,(%edx,%esi,1) information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 10b0e3: 66 01 43 2c add %ax,0x2c(%ebx) } 10b0e7: 8d 65 f4 lea -0xc(%ebp),%esp 10b0ea: 5b pop %ebx 10b0eb: 5e pop %esi 10b0ec: 5f pop %edi 10b0ed: 5d pop %ebp 10b0ee: c3 ret =============================================================================== 0010b180 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b180: 55 push %ebp 10b181: 89 e5 mov %esp,%ebp 10b183: 56 push %esi 10b184: 53 push %ebx 10b185: 8b 5d 08 mov 0x8(%ebp),%ebx 10b188: 0f b7 75 0c movzwl 0xc(%ebp),%esi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b18c: 66 85 f6 test %si,%si 10b18f: 75 04 jne 10b195 <_Objects_Get_information+0x15> return NULL; 10b191: 31 c0 xor %eax,%eax 10b193: eb 2d jmp 10b1c2 <_Objects_Get_information+0x42> /* * 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 ); 10b195: 83 ec 0c sub $0xc,%esp 10b198: 53 push %ebx 10b199: e8 92 3b 00 00 call 10ed30 <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10b19e: 83 c4 10 add $0x10,%esp 10b1a1: 85 c0 test %eax,%eax 10b1a3: 74 ec je 10b191 <_Objects_Get_information+0x11> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b1a5: 39 c6 cmp %eax,%esi 10b1a7: 77 e8 ja 10b191 <_Objects_Get_information+0x11> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b1a9: 8b 04 9d 44 c3 12 00 mov 0x12c344(,%ebx,4),%eax 10b1b0: 85 c0 test %eax,%eax 10b1b2: 74 dd je 10b191 <_Objects_Get_information+0x11><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10b1b4: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !info ) 10b1b7: 85 c0 test %eax,%eax 10b1b9: 74 d6 je 10b191 <_Objects_Get_information+0x11><== NEVER TAKEN * 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 ) 10b1bb: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10b1c0: 74 cf je 10b191 <_Objects_Get_information+0x11> return NULL; #endif return info; } 10b1c2: 8d 65 f8 lea -0x8(%ebp),%esp 10b1c5: 5b pop %ebx 10b1c6: 5e pop %esi 10b1c7: 5d pop %ebp 10b1c8: c3 ret =============================================================================== 001186b8 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 1186b8: 55 push %ebp 1186b9: 89 e5 mov %esp,%ebp 1186bb: 53 push %ebx 1186bc: 8b 55 08 mov 0x8(%ebp),%edx 1186bf: 8b 4d 10 mov 0x10(%ebp),%ecx /* * 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; 1186c2: b8 01 00 00 00 mov $0x1,%eax 1186c7: 2b 42 08 sub 0x8(%edx),%eax 1186ca: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 1186cd: 0f b7 5a 10 movzwl 0x10(%edx),%ebx 1186d1: 39 c3 cmp %eax,%ebx 1186d3: 72 12 jb 1186e7 <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 1186d5: 8b 52 1c mov 0x1c(%edx),%edx 1186d8: 8b 04 82 mov (%edx,%eax,4),%eax 1186db: 85 c0 test %eax,%eax 1186dd: 74 08 je 1186e7 <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 1186df: c7 01 00 00 00 00 movl $0x0,(%ecx) return the_object; 1186e5: eb 08 jmp 1186ef <_Objects_Get_no_protection+0x37> /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 1186e7: c7 01 01 00 00 00 movl $0x1,(%ecx) return NULL; 1186ed: 31 c0 xor %eax,%eax } 1186ef: 5b pop %ebx 1186f0: 5d pop %ebp 1186f1: c3 ret =============================================================================== 0010e2c4 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10e2c4: 55 push %ebp 10e2c5: 89 e5 mov %esp,%ebp 10e2c7: 83 ec 18 sub $0x18,%esp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10e2ca: 8b 45 08 mov 0x8(%ebp),%eax 10e2cd: 85 c0 test %eax,%eax 10e2cf: 75 08 jne 10e2d9 <_Objects_Id_to_name+0x15> 10e2d1: a1 40 95 13 00 mov 0x139540,%eax 10e2d6: 8b 40 08 mov 0x8(%eax),%eax 10e2d9: 89 c2 mov %eax,%edx 10e2db: c1 ea 18 shr $0x18,%edx 10e2de: 83 e2 07 and $0x7,%edx */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 10e2e1: 8d 4a ff lea -0x1(%edx),%ecx 10e2e4: 83 f9 02 cmp $0x2,%ecx 10e2e7: 76 37 jbe 10e320 <_Objects_Id_to_name+0x5c> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10e2e9: b8 03 00 00 00 mov $0x3,%eax 10e2ee: eb 3d jmp 10e32d <_Objects_Id_to_name+0x69> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10e2f0: 89 c1 mov %eax,%ecx 10e2f2: c1 e9 1b shr $0x1b,%ecx if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10e2f5: 8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10e2f8: 85 d2 test %edx,%edx 10e2fa: 74 ed je 10e2e9 <_Objects_Id_to_name+0x25><== NEVER TAKEN #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 ); 10e2fc: 51 push %ecx 10e2fd: 8d 4d f4 lea -0xc(%ebp),%ecx 10e300: 51 push %ecx 10e301: 50 push %eax 10e302: 52 push %edx 10e303: e8 5c ff ff ff call 10e264 <_Objects_Get> if ( !the_object ) 10e308: 83 c4 10 add $0x10,%esp 10e30b: 85 c0 test %eax,%eax 10e30d: 74 da je 10e2e9 <_Objects_Id_to_name+0x25> return OBJECTS_INVALID_ID; *name = the_object->name; 10e30f: 8b 50 0c mov 0xc(%eax),%edx 10e312: 8b 45 0c mov 0xc(%ebp),%eax 10e315: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10e317: e8 34 0b 00 00 call 10ee50 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10e31c: 31 c0 xor %eax,%eax 10e31e: eb 0d jmp 10e32d <_Objects_Id_to_name+0x69> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10e320: 8b 14 95 dc 92 13 00 mov 0x1392dc(,%edx,4),%edx 10e327: 85 d2 test %edx,%edx 10e329: 75 c5 jne 10e2f0 <_Objects_Id_to_name+0x2c> 10e32b: eb bc jmp 10e2e9 <_Objects_Id_to_name+0x25> return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 10e32d: c9 leave 10e32e: c3 ret =============================================================================== 0010bf98 <_RBTree_Extract_unprotected>: */ void _RBTree_Extract_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { 10bf98: 55 push %ebp 10bf99: 89 e5 mov %esp,%ebp 10bf9b: 57 push %edi 10bf9c: 56 push %esi 10bf9d: 53 push %ebx 10bf9e: 83 ec 1c sub $0x1c,%esp 10bfa1: 8b 7d 08 mov 0x8(%ebp),%edi 10bfa4: 8b 5d 0c mov 0xc(%ebp),%ebx RBTree_Node *leaf, *target; RBTree_Color victim_color; RBTree_Direction dir; if (!the_node) return; 10bfa7: 85 db test %ebx,%ebx 10bfa9: 0f 84 0d 01 00 00 je 10c0bc <_RBTree_Extract_unprotected+0x124> /* check if min needs to be updated */ if (the_node == the_rbtree->first[RBT_LEFT]) { 10bfaf: 3b 5f 08 cmp 0x8(%edi),%ebx 10bfb2: 75 10 jne 10bfc4 <_RBTree_Extract_unprotected+0x2c> */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected( const RBTree_Node *node ) { return _RBTree_Next_unprotected( node, RBT_RIGHT ); 10bfb4: 50 push %eax 10bfb5: 50 push %eax 10bfb6: 6a 01 push $0x1 10bfb8: 53 push %ebx 10bfb9: e8 5a 03 00 00 call 10c318 <_RBTree_Next_unprotected> RBTree_Node *next; next = _RBTree_Successor_unprotected(the_node); the_rbtree->first[RBT_LEFT] = next; 10bfbe: 89 47 08 mov %eax,0x8(%edi) 10bfc1: 83 c4 10 add $0x10,%esp } /* 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]) { 10bfc4: 3b 5f 0c cmp 0xc(%edi),%ebx 10bfc7: 75 10 jne 10bfd9 <_RBTree_Extract_unprotected+0x41> */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected( const RBTree_Node *node ) { return _RBTree_Next_unprotected( node, RBT_LEFT ); 10bfc9: 56 push %esi 10bfca: 56 push %esi 10bfcb: 6a 00 push $0x0 10bfcd: 53 push %ebx 10bfce: e8 45 03 00 00 call 10c318 <_RBTree_Next_unprotected> RBTree_Node *previous; previous = _RBTree_Predecessor_unprotected(the_node); the_rbtree->first[RBT_RIGHT] = previous; 10bfd3: 89 47 0c mov %eax,0xc(%edi) 10bfd6: 83 c4 10 add $0x10,%esp * 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]) { 10bfd9: 8b 73 04 mov 0x4(%ebx),%esi 10bfdc: 85 f6 test %esi,%esi 10bfde: 74 77 je 10c057 <_RBTree_Extract_unprotected+0xbf> 10bfe0: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10bfe4: 75 04 jne 10bfea <_RBTree_Extract_unprotected+0x52> 10bfe6: eb 78 jmp 10c060 <_RBTree_Extract_unprotected+0xc8> target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */ while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT]; 10bfe8: 89 c6 mov %eax,%esi 10bfea: 8b 46 08 mov 0x8(%esi),%eax 10bfed: 85 c0 test %eax,%eax 10bfef: 75 f7 jne 10bfe8 <_RBTree_Extract_unprotected+0x50> * 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]; 10bff1: 8b 56 04 mov 0x4(%esi),%edx if(leaf) { 10bff4: 85 d2 test %edx,%edx 10bff6: 74 06 je 10bffe <_RBTree_Extract_unprotected+0x66> leaf->parent = target->parent; 10bff8: 8b 06 mov (%esi),%eax 10bffa: 89 02 mov %eax,(%edx) 10bffc: eb 0d jmp 10c00b <_RBTree_Extract_unprotected+0x73> } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(target); 10bffe: 89 f0 mov %esi,%eax 10c000: 89 55 e0 mov %edx,-0x20(%ebp) 10c003: e8 53 fe ff ff call 10be5b <_RBTree_Extract_validate_unprotected> 10c008: 8b 55 e0 mov -0x20(%ebp),%edx } victim_color = target->color; 10c00b: 8b 46 0c mov 0xc(%esi),%eax 10c00e: 89 45 e4 mov %eax,-0x1c(%ebp) dir = target != target->parent->child[0]; 10c011: 8b 06 mov (%esi),%eax 10c013: 31 c9 xor %ecx,%ecx 10c015: 3b 70 04 cmp 0x4(%eax),%esi 10c018: 0f 95 c1 setne %cl target->parent->child[dir] = leaf; 10c01b: 89 54 88 04 mov %edx,0x4(%eax,%ecx,4) /* now replace the_node with target */ dir = the_node != the_node->parent->child[0]; 10c01f: 8b 03 mov (%ebx),%eax 10c021: 31 c9 xor %ecx,%ecx 10c023: 3b 58 04 cmp 0x4(%eax),%ebx 10c026: 0f 95 c1 setne %cl the_node->parent->child[dir] = target; 10c029: 89 74 88 04 mov %esi,0x4(%eax,%ecx,4) /* set target's new children to the original node's children */ target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT]; 10c02d: 8b 43 08 mov 0x8(%ebx),%eax 10c030: 89 46 08 mov %eax,0x8(%esi) if (the_node->child[RBT_RIGHT]) 10c033: 8b 43 08 mov 0x8(%ebx),%eax 10c036: 85 c0 test %eax,%eax 10c038: 74 02 je 10c03c <_RBTree_Extract_unprotected+0xa4><== NEVER TAKEN the_node->child[RBT_RIGHT]->parent = target; 10c03a: 89 30 mov %esi,(%eax) target->child[RBT_LEFT] = the_node->child[RBT_LEFT]; 10c03c: 8b 43 04 mov 0x4(%ebx),%eax 10c03f: 89 46 04 mov %eax,0x4(%esi) if (the_node->child[RBT_LEFT]) 10c042: 8b 43 04 mov 0x4(%ebx),%eax 10c045: 85 c0 test %eax,%eax 10c047: 74 02 je 10c04b <_RBTree_Extract_unprotected+0xb3> the_node->child[RBT_LEFT]->parent = target; 10c049: 89 30 mov %esi,(%eax) /* 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; 10c04b: 8b 03 mov (%ebx),%eax 10c04d: 89 06 mov %eax,(%esi) target->color = the_node->color; 10c04f: 8b 43 0c mov 0xc(%ebx),%eax 10c052: 89 46 0c mov %eax,0xc(%esi) 10c055: eb 32 jmp 10c089 <_RBTree_Extract_unprotected+0xf1> * the_node's location in the tree. This may cause the coloring to be * 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]; 10c057: 8b 53 08 mov 0x8(%ebx),%edx if( leaf ) { 10c05a: 85 d2 test %edx,%edx 10c05c: 75 04 jne 10c062 <_RBTree_Extract_unprotected+0xca> 10c05e: eb 08 jmp 10c068 <_RBTree_Extract_unprotected+0xd0> * 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]) { 10c060: 89 f2 mov %esi,%edx * 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; 10c062: 8b 03 mov (%ebx),%eax 10c064: 89 02 mov %eax,(%edx) 10c066: eb 0d jmp 10c075 <_RBTree_Extract_unprotected+0xdd> } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(the_node); 10c068: 89 d8 mov %ebx,%eax 10c06a: 89 55 e0 mov %edx,-0x20(%ebp) 10c06d: e8 e9 fd ff ff call 10be5b <_RBTree_Extract_validate_unprotected> 10c072: 8b 55 e0 mov -0x20(%ebp),%edx } victim_color = the_node->color; 10c075: 8b 43 0c mov 0xc(%ebx),%eax 10c078: 89 45 e4 mov %eax,-0x1c(%ebp) /* remove the_node from the tree */ dir = the_node != the_node->parent->child[0]; 10c07b: 8b 03 mov (%ebx),%eax 10c07d: 31 c9 xor %ecx,%ecx 10c07f: 3b 58 04 cmp 0x4(%eax),%ebx 10c082: 0f 95 c1 setne %cl the_node->parent->child[dir] = leaf; 10c085: 89 54 88 04 mov %edx,0x4(%eax,%ecx,4) /* 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 */ 10c089: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10c08d: 75 0b jne 10c09a <_RBTree_Extract_unprotected+0x102> if (leaf) { 10c08f: 85 d2 test %edx,%edx 10c091: 74 07 je 10c09a <_RBTree_Extract_unprotected+0x102> leaf->color = RBT_BLACK; /* case 2 */ 10c093: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) */ RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree( RBTree_Node *node ) { node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL; 10c09a: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10c0a1: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) 10c0a8: c7 03 00 00 00 00 movl $0x0,(%ebx) /* 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; 10c0ae: 8b 47 04 mov 0x4(%edi),%eax 10c0b1: 85 c0 test %eax,%eax 10c0b3: 74 07 je 10c0bc <_RBTree_Extract_unprotected+0x124> 10c0b5: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) } 10c0bc: 8d 65 f4 lea -0xc(%ebp),%esp 10c0bf: 5b pop %ebx 10c0c0: 5e pop %esi 10c0c1: 5f pop %edi 10c0c2: 5d pop %ebp 10c0c3: c3 ret =============================================================================== 0010cab0 <_RBTree_Initialize>: void *starting_address, size_t number_nodes, size_t node_size, bool is_unique ) { 10cab0: 55 push %ebp 10cab1: 89 e5 mov %esp,%ebp 10cab3: 57 push %edi 10cab4: 56 push %esi 10cab5: 53 push %ebx 10cab6: 83 ec 0c sub $0xc,%esp 10cab9: 8b 5d 08 mov 0x8(%ebp),%ebx 10cabc: 8b 75 14 mov 0x14(%ebp),%esi 10cabf: 8b 45 1c mov 0x1c(%ebp),%eax size_t count; RBTree_Node *next; /* TODO: Error message? */ if (!the_rbtree) return; 10cac2: 85 db test %ebx,%ebx 10cac4: 74 3d je 10cb03 <_RBTree_Initialize+0x53><== NEVER TAKEN RBTree_Control *the_rbtree, RBTree_Compare_function compare_function, bool is_unique ) { the_rbtree->permanent_null = NULL; 10cac6: c7 03 00 00 00 00 movl $0x0,(%ebx) the_rbtree->root = NULL; 10cacc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) the_rbtree->first[0] = NULL; 10cad3: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) the_rbtree->first[1] = NULL; 10cada: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) the_rbtree->compare_function = compare_function; 10cae1: 8b 55 0c mov 0xc(%ebp),%edx 10cae4: 89 53 10 mov %edx,0x10(%ebx) the_rbtree->is_unique = is_unique; 10cae7: 88 43 14 mov %al,0x14(%ebx) /* could do sanity checks here */ _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique); count = number_nodes; next = starting_address; 10caea: 8b 7d 10 mov 0x10(%ebp),%edi while ( count-- ) { 10caed: eb 10 jmp 10caff <_RBTree_Initialize+0x4f> _RBTree_Insert_unprotected(the_rbtree, next); 10caef: 50 push %eax 10caf0: 50 push %eax 10caf1: 57 push %edi 10caf2: 53 push %ebx 10caf3: e8 a8 fd ff ff call 10c8a0 <_RBTree_Insert_unprotected> * node_size - size of node in bytes * * Output parameters: NONE */ void _RBTree_Initialize( 10caf8: 03 7d 18 add 0x18(%ebp),%edi 10cafb: 4e dec %esi 10cafc: 83 c4 10 add $0x10,%esp /* could do sanity checks here */ _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique); count = number_nodes; next = starting_address; while ( count-- ) { 10caff: 85 f6 test %esi,%esi 10cb01: 75 ec jne 10caef <_RBTree_Initialize+0x3f> _RBTree_Insert_unprotected(the_rbtree, next); next = (RBTree_Node *) _Addresses_Add_offset( (void *) next, node_size ); } } 10cb03: 8d 65 f4 lea -0xc(%ebp),%esp 10cb06: 5b pop %ebx 10cb07: 5e pop %esi 10cb08: 5f pop %edi 10cb09: 5d pop %ebp 10cb0a: c3 ret =============================================================================== 0010c128 <_RBTree_Insert_unprotected>: */ RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { 10c128: 55 push %ebp 10c129: 89 e5 mov %esp,%ebp 10c12b: 57 push %edi 10c12c: 56 push %esi 10c12d: 53 push %ebx 10c12e: 83 ec 1c sub $0x1c,%esp 10c131: 8b 75 08 mov 0x8(%ebp),%esi 10c134: 8b 5d 0c mov 0xc(%ebp),%ebx if(!the_node) return (RBTree_Node*)-1; 10c137: 85 db test %ebx,%ebx 10c139: 0f 84 55 01 00 00 je 10c294 <_RBTree_Insert_unprotected+0x16c> RBTree_Node *iter_node = the_rbtree->root; 10c13f: 8b 7e 04 mov 0x4(%esi),%edi int compare_result; if (!iter_node) { /* special case: first node inserted */ 10c142: 89 f9 mov %edi,%ecx 10c144: 85 ff test %edi,%edi 10c146: 75 27 jne 10c16f <_RBTree_Insert_unprotected+0x47> the_node->color = RBT_BLACK; 10c148: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) the_rbtree->root = the_node; 10c14f: 89 5e 04 mov %ebx,0x4(%esi) the_rbtree->first[0] = the_rbtree->first[1] = the_node; 10c152: 89 5e 0c mov %ebx,0xc(%esi) 10c155: 89 5e 08 mov %ebx,0x8(%esi) the_node->parent = (RBTree_Node *) the_rbtree; 10c158: 89 33 mov %esi,(%ebx) the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; 10c15a: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10c161: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) 10c168: e9 37 01 00 00 jmp 10c2a4 <_RBTree_Insert_unprotected+0x17c> (dir && _RBTree_Is_greater(compare_result)) ) { the_rbtree->first[dir] = the_node; } break; } else { iter_node = iter_node->child[dir]; 10c16d: 89 f9 mov %edi,%ecx 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); 10c16f: 52 push %edx 10c170: 52 push %edx 10c171: 57 push %edi 10c172: 53 push %ebx 10c173: 89 4d e4 mov %ecx,-0x1c(%ebp) 10c176: ff 56 10 call *0x10(%esi) if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) 10c179: 83 c4 10 add $0x10,%esp 10c17c: 80 7e 14 00 cmpb $0x0,0x14(%esi) 10c180: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c183: 74 08 je 10c18d <_RBTree_Insert_unprotected+0x65> 10c185: 85 c0 test %eax,%eax 10c187: 0f 84 17 01 00 00 je 10c2a4 <_RBTree_Insert_unprotected+0x17c> return iter_node; RBTree_Direction dir = !_RBTree_Is_lesser( compare_result ); 10c18d: 89 c2 mov %eax,%edx 10c18f: f7 d2 not %edx 10c191: c1 ea 1f shr $0x1f,%edx if (!iter_node->child[dir]) { 10c194: 8b 7c 97 04 mov 0x4(%edi,%edx,4),%edi 10c198: 85 ff test %edi,%edi 10c19a: 75 d1 jne 10c16d <_RBTree_Insert_unprotected+0x45> the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; 10c19c: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10c1a3: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) the_node->color = RBT_RED; 10c1aa: c7 43 0c 01 00 00 00 movl $0x1,0xc(%ebx) iter_node->child[dir] = the_node; 10c1b1: 89 5c 91 04 mov %ebx,0x4(%ecx,%edx,4) the_node->parent = iter_node; 10c1b5: 89 0b mov %ecx,(%ebx) /* update min/max */ compare_result = the_rbtree->compare_function( 10c1b7: 50 push %eax 10c1b8: 50 push %eax 10c1b9: ff 74 96 08 pushl 0x8(%esi,%edx,4) 10c1bd: 53 push %ebx 10c1be: 89 55 e4 mov %edx,-0x1c(%ebp) 10c1c1: ff 56 10 call *0x10(%esi) the_node, _RBTree_First(the_rbtree, dir) ); if ( (!dir && _RBTree_Is_lesser(compare_result)) || 10c1c4: 83 c4 10 add $0x10,%esp 10c1c7: 8b 55 e4 mov -0x1c(%ebp),%edx 10c1ca: 85 d2 test %edx,%edx 10c1cc: 75 0a jne 10c1d8 <_RBTree_Insert_unprotected+0xb0> 10c1ce: 85 c0 test %eax,%eax 10c1d0: 0f 89 9f 00 00 00 jns 10c275 <_RBTree_Insert_unprotected+0x14d> 10c1d6: eb 08 jmp 10c1e0 <_RBTree_Insert_unprotected+0xb8> (dir && _RBTree_Is_greater(compare_result)) ) { 10c1d8: 85 c0 test %eax,%eax 10c1da: 0f 8e 95 00 00 00 jle 10c275 <_RBTree_Insert_unprotected+0x14d> the_rbtree->first[dir] = the_node; 10c1e0: 89 5c 96 08 mov %ebx,0x8(%esi,%edx,4) 10c1e4: e9 8c 00 00 00 jmp 10c275 <_RBTree_Insert_unprotected+0x14d> const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; 10c1e9: 85 f6 test %esi,%esi 10c1eb: 74 1b je 10c208 <_RBTree_Insert_unprotected+0xe0><== NEVER TAKEN if(!(the_node->parent->parent->parent)) return NULL; 10c1ed: 83 3e 00 cmpl $0x0,(%esi) 10c1f0: 74 16 je 10c208 <_RBTree_Insert_unprotected+0xe0><== NEVER TAKEN { 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]) 10c1f2: 8b 56 04 mov 0x4(%esi),%edx 10c1f5: 39 d0 cmp %edx,%eax 10c1f7: 75 03 jne 10c1fc <_RBTree_Insert_unprotected+0xd4> return the_node->parent->child[RBT_RIGHT]; 10c1f9: 8b 56 08 mov 0x8(%esi),%edx */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10c1fc: 85 d2 test %edx,%edx 10c1fe: 74 0a je 10c20a <_RBTree_Insert_unprotected+0xe2> 10c200: 83 7a 0c 01 cmpl $0x1,0xc(%edx) 10c204: 75 04 jne 10c20a <_RBTree_Insert_unprotected+0xe2> 10c206: eb 06 jmp 10c20e <_RBTree_Insert_unprotected+0xe6> ) { 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; 10c208: 31 d2 xor %edx,%edx <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10c20a: 31 c9 xor %ecx,%ecx 10c20c: eb 05 jmp 10c213 <_RBTree_Insert_unprotected+0xeb> 10c20e: b9 01 00 00 00 mov $0x1,%ecx while (_RBTree_Is_red(_RBTree_Parent(the_node))) { u = _RBTree_Parent_sibling(the_node); g = the_node->parent->parent; /* if uncle is red, repaint uncle/parent black and grandparent red */ if(_RBTree_Is_red(u)) { 10c213: 85 c9 test %ecx,%ecx 10c215: 74 17 je 10c22e <_RBTree_Insert_unprotected+0x106> the_node->parent->color = RBT_BLACK; 10c217: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) u->color = RBT_BLACK; 10c21e: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) g->color = RBT_RED; 10c225: c7 46 0c 01 00 00 00 movl $0x1,0xc(%esi) 10c22c: eb 45 jmp 10c273 <_RBTree_Insert_unprotected+0x14b> the_node = g; } else { /* if uncle is black */ RBTree_Direction dir = the_node != the_node->parent->child[0]; RBTree_Direction pdir = the_node->parent != g->child[0]; 10c22e: 31 c9 xor %ecx,%ecx 10c230: 3b 46 04 cmp 0x4(%esi),%eax 10c233: 0f 95 c1 setne %cl 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]; 10c236: 31 d2 xor %edx,%edx 10c238: 3b 58 04 cmp 0x4(%eax),%ebx 10c23b: 0f 95 c2 setne %dl RBTree_Direction pdir = the_node->parent != g->child[0]; /* ensure node is on the same branch direction as parent */ if (dir != pdir) { 10c23e: 39 ca cmp %ecx,%edx 10c240: 74 11 je 10c253 <_RBTree_Insert_unprotected+0x12b> _RBTree_Rotate(the_node->parent, pdir); 10c242: 89 ca mov %ecx,%edx 10c244: 89 4d e4 mov %ecx,-0x1c(%ebp) 10c247: e8 98 fe ff ff call 10c0e4 <_RBTree_Rotate> the_node = the_node->child[pdir]; 10c24c: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c24f: 8b 5c 8b 04 mov 0x4(%ebx,%ecx,4),%ebx } the_node->parent->color = RBT_BLACK; 10c253: 8b 03 mov (%ebx),%eax 10c255: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) g->color = RBT_RED; 10c25c: c7 46 0c 01 00 00 00 movl $0x1,0xc(%esi) /* now rotate grandparent in the other branch direction (toward uncle) */ _RBTree_Rotate(g, (1-pdir)); 10c263: ba 01 00 00 00 mov $0x1,%edx 10c268: 29 ca sub %ecx,%edx 10c26a: 89 f0 mov %esi,%eax 10c26c: e8 73 fe ff ff call 10c0e4 <_RBTree_Rotate> 10c271: 89 de mov %ebx,%esi 10c273: 89 f3 mov %esi,%ebx _ISR_Disable( level ); return_node = _RBTree_Insert_unprotected( tree, node ); _ISR_Enable( level ); return return_node; } 10c275: 8b 03 mov (%ebx),%eax */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent( const RBTree_Node *the_node ) { if (!the_node->parent->parent) return NULL; 10c277: 8b 30 mov (%eax),%esi 10c279: 85 f6 test %esi,%esi 10c27b: 75 1c jne 10c299 <_RBTree_Insert_unprotected+0x171> */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10c27d: 31 d2 xor %edx,%edx RBTree_Node *u,*g; /* note: the insert root case is handled already */ /* if the parent is black, nothing needs to be done * otherwise may need to loop a few times */ while (_RBTree_Is_red(_RBTree_Parent(the_node))) { 10c27f: 85 d2 test %edx,%edx 10c281: 0f 85 62 ff ff ff jne 10c1e9 <_RBTree_Insert_unprotected+0xc1> /* now rotate grandparent in the other branch direction (toward uncle) */ _RBTree_Rotate(g, (1-pdir)); } } if(!the_node->parent->parent) the_node->color = RBT_BLACK; 10c287: 85 f6 test %esi,%esi 10c289: 75 19 jne 10c2a4 <_RBTree_Insert_unprotected+0x17c> 10c28b: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) 10c292: eb 10 jmp 10c2a4 <_RBTree_Insert_unprotected+0x17c> RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { if(!the_node) return (RBTree_Node*)-1; 10c294: 83 cf ff or $0xffffffff,%edi 10c297: eb 0b jmp 10c2a4 <_RBTree_Insert_unprotected+0x17c> 10c299: 31 d2 xor %edx,%edx 10c29b: 83 78 0c 01 cmpl $0x1,0xc(%eax) 10c29f: 0f 94 c2 sete %dl 10c2a2: eb db jmp 10c27f <_RBTree_Insert_unprotected+0x157> /* verify red-black properties */ _RBTree_Validate_insert_unprotected(the_node); } return (RBTree_Node*)0; } 10c2a4: 89 f8 mov %edi,%eax 10c2a6: 8d 65 f4 lea -0xc(%ebp),%esp 10c2a9: 5b pop %ebx 10c2aa: 5e pop %esi 10c2ab: 5f pop %edi 10c2ac: 5d pop %ebp 10c2ad: c3 ret =============================================================================== 0010c2cc <_RBTree_Iterate_unprotected>: const RBTree_Control *rbtree, RBTree_Direction dir, RBTree_Visitor visitor, void *visitor_arg ) { 10c2cc: 55 push %ebp 10c2cd: 89 e5 mov %esp,%ebp 10c2cf: 57 push %edi 10c2d0: 56 push %esi 10c2d1: 53 push %ebx 10c2d2: 83 ec 0c sub $0xc,%esp 10c2d5: 8b 5d 0c mov 0xc(%ebp),%ebx */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 10c2d8: 31 d2 xor %edx,%edx 10c2da: 85 db test %ebx,%ebx 10c2dc: 0f 94 c2 sete %dl RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First( const RBTree_Control *the_rbtree, RBTree_Direction dir ) { return the_rbtree->first[dir]; 10c2df: 8b 45 08 mov 0x8(%ebp),%eax 10c2e2: 8b 74 90 08 mov 0x8(%eax,%edx,4),%esi RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; 10c2e6: 31 ff xor %edi,%edi while ( !stop && current != NULL ) { 10c2e8: eb 1b jmp 10c305 <_RBTree_Iterate_unprotected+0x39> stop = (*visitor)( current, dir, visitor_arg ); 10c2ea: 50 push %eax 10c2eb: ff 75 14 pushl 0x14(%ebp) 10c2ee: 53 push %ebx 10c2ef: 56 push %esi 10c2f0: 8b 55 10 mov 0x10(%ebp),%edx 10c2f3: ff d2 call *%edx 10c2f5: 89 c7 mov %eax,%edi current = _RBTree_Next_unprotected( current, dir ); 10c2f7: 5a pop %edx 10c2f8: 59 pop %ecx 10c2f9: 53 push %ebx 10c2fa: 56 push %esi 10c2fb: e8 18 00 00 00 call 10c318 <_RBTree_Next_unprotected> 10c300: 89 c6 mov %eax,%esi 10c302: 83 c4 10 add $0x10,%esp { RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { 10c305: 85 f6 test %esi,%esi 10c307: 74 06 je 10c30f <_RBTree_Iterate_unprotected+0x43> 10c309: 89 f8 mov %edi,%eax 10c30b: fe c8 dec %al 10c30d: 75 db jne 10c2ea <_RBTree_Iterate_unprotected+0x1e><== ALWAYS TAKEN stop = (*visitor)( current, dir, visitor_arg ); current = _RBTree_Next_unprotected( current, dir ); } } 10c30f: 8d 65 f4 lea -0xc(%ebp),%esp 10c312: 5b pop %ebx 10c313: 5e pop %esi 10c314: 5f pop %edi 10c315: 5d pop %ebp 10c316: c3 ret =============================================================================== 0010be17 <_RBTree_Rotate>: RBTree_Node *the_node, RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; 10be17: 85 c0 test %eax,%eax 10be19: 74 3f je 10be5a <_RBTree_Rotate+0x43> <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _RBTree_Rotate( RBTree_Node *the_node, RBTree_Direction dir ) { 10be1b: 55 push %ebp 10be1c: 89 e5 mov %esp,%ebp 10be1e: 56 push %esi 10be1f: 53 push %ebx */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 10be20: 31 db xor %ebx,%ebx 10be22: 85 d2 test %edx,%edx 10be24: 0f 94 c3 sete %bl RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 10be27: 8b 4c 98 04 mov 0x4(%eax,%ebx,4),%ecx 10be2b: 85 c9 test %ecx,%ecx 10be2d: 74 28 je 10be57 <_RBTree_Rotate+0x40> <== NEVER TAKEN c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 10be2f: 8b 74 91 04 mov 0x4(%ecx,%edx,4),%esi 10be33: 89 74 98 04 mov %esi,0x4(%eax,%ebx,4) if (c->child[dir]) 10be37: 8b 5c 91 04 mov 0x4(%ecx,%edx,4),%ebx 10be3b: 85 db test %ebx,%ebx 10be3d: 74 02 je 10be41 <_RBTree_Rotate+0x2a> c->child[dir]->parent = the_node; 10be3f: 89 03 mov %eax,(%ebx) c->child[dir] = the_node; 10be41: 89 44 91 04 mov %eax,0x4(%ecx,%edx,4) the_node->parent->child[the_node != the_node->parent->child[0]] = c; 10be45: 8b 10 mov (%eax),%edx 10be47: 31 db xor %ebx,%ebx 10be49: 3b 42 04 cmp 0x4(%edx),%eax 10be4c: 0f 95 c3 setne %bl 10be4f: 89 4c 9a 04 mov %ecx,0x4(%edx,%ebx,4) c->parent = the_node->parent; 10be53: 89 11 mov %edx,(%ecx) the_node->parent = c; 10be55: 89 08 mov %ecx,(%eax) } 10be57: 5b pop %ebx 10be58: 5e pop %esi 10be59: 5d pop %ebp 10be5a: c3 ret =============================================================================== 0010bdf3 <_RBTree_Sibling>: * exists, and NULL if not. */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { 10bdf3: 55 push %ebp 10bdf4: 89 e5 mov %esp,%ebp if(!the_node) return NULL; 10bdf6: 85 c0 test %eax,%eax 10bdf8: 74 17 je 10be11 <_RBTree_Sibling+0x1e> <== NEVER TAKEN if(!(the_node->parent)) return NULL; 10bdfa: 8b 08 mov (%eax),%ecx 10bdfc: 85 c9 test %ecx,%ecx 10bdfe: 74 11 je 10be11 <_RBTree_Sibling+0x1e> <== NEVER TAKEN if(!(the_node->parent->parent)) return NULL; 10be00: 83 39 00 cmpl $0x0,(%ecx) 10be03: 74 0c je 10be11 <_RBTree_Sibling+0x1e> if(the_node == the_node->parent->child[RBT_LEFT]) 10be05: 8b 51 04 mov 0x4(%ecx),%edx 10be08: 39 d0 cmp %edx,%eax 10be0a: 75 07 jne 10be13 <_RBTree_Sibling+0x20> return the_node->parent->child[RBT_RIGHT]; 10be0c: 8b 51 08 mov 0x8(%ecx),%edx 10be0f: eb 02 jmp 10be13 <_RBTree_Sibling+0x20> */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; 10be11: 31 d2 xor %edx,%edx if(the_node == the_node->parent->child[RBT_LEFT]) return the_node->parent->child[RBT_RIGHT]; else return the_node->parent->child[RBT_LEFT]; } 10be13: 89 d0 mov %edx,%eax 10be15: 5d pop %ebp 10be16: c3 ret =============================================================================== 0010e418 <_RTEMS_tasks_Post_switch_extension>: */ static void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10e418: 55 push %ebp 10e419: 89 e5 mov %esp,%ebp 10e41b: 57 push %edi 10e41c: 56 push %esi 10e41d: 53 push %ebx 10e41e: 83 ec 1c sub $0x1c,%esp RTEMS_API_Control *api; ASR_Information *asr; rtems_signal_set signal_set; Modes_Control prev_mode; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10e421: 8b 45 08 mov 0x8(%ebp),%eax 10e424: 8b 98 e0 00 00 00 mov 0xe0(%eax),%ebx if ( !api ) 10e42a: 85 db test %ebx,%ebx 10e42c: 74 45 je 10e473 <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10e42e: 9c pushf 10e42f: fa cli 10e430: 58 pop %eax signal_set = asr->signals_posted; 10e431: 8b 7b 14 mov 0x14(%ebx),%edi asr->signals_posted = 0; 10e434: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) _ISR_Enable( level ); 10e43b: 50 push %eax 10e43c: 9d popf if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10e43d: 85 ff test %edi,%edi 10e43f: 74 32 je 10e473 <_RTEMS_tasks_Post_switch_extension+0x5b> return; asr->nest_level += 1; 10e441: ff 43 1c incl 0x1c(%ebx) rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10e444: 51 push %ecx 10e445: 8d 75 e4 lea -0x1c(%ebp),%esi 10e448: 56 push %esi 10e449: 68 ff ff 00 00 push $0xffff 10e44e: ff 73 10 pushl 0x10(%ebx) 10e451: e8 de 19 00 00 call 10fe34 (*asr->handler)( signal_set ); 10e456: 89 3c 24 mov %edi,(%esp) 10e459: ff 53 0c call *0xc(%ebx) asr->nest_level -= 1; 10e45c: ff 4b 1c decl 0x1c(%ebx) rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10e45f: 83 c4 0c add $0xc,%esp 10e462: 56 push %esi 10e463: 68 ff ff 00 00 push $0xffff 10e468: ff 75 e4 pushl -0x1c(%ebp) 10e46b: e8 c4 19 00 00 call 10fe34 10e470: 83 c4 10 add $0x10,%esp } 10e473: 8d 65 f4 lea -0xc(%ebp),%esp 10e476: 5b pop %ebx 10e477: 5e pop %esi 10e478: 5f pop %edi 10e479: 5d pop %ebp 10e47a: c3 ret =============================================================================== 0012cf10 <_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 ) { 12cf10: 55 push %ebp 12cf11: 89 e5 mov %esp,%ebp 12cf13: 57 push %edi 12cf14: 56 push %esi 12cf15: 53 push %ebx 12cf16: 83 ec 28 sub $0x28,%esp #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ Timestamp_Control uptime; #endif Thread_Control *owning_thread = the_period->owner; 12cf19: 8b 45 08 mov 0x8(%ebp),%eax 12cf1c: 8b 78 40 mov 0x40(%eax),%edi /* * Determine elapsed wall time since period initiated. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _TOD_Get_uptime( &uptime ); 12cf1f: 8d 45 e0 lea -0x20(%ebp),%eax 12cf22: 50 push %eax 12cf23: e8 30 35 fe ff call 110458 <_TOD_Get_uptime> _Timestamp_Subtract( 12cf28: 8b 45 e0 mov -0x20(%ebp),%eax 12cf2b: 8b 55 e4 mov -0x1c(%ebp),%edx const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 12cf2e: 89 c1 mov %eax,%ecx 12cf30: 89 d3 mov %edx,%ebx 12cf32: 8b 75 08 mov 0x8(%ebp),%esi 12cf35: 2b 4e 4c sub 0x4c(%esi),%ecx 12cf38: 1b 5e 50 sbb 0x50(%esi),%ebx 12cf3b: 8b 75 0c mov 0xc(%ebp),%esi 12cf3e: 89 0e mov %ecx,(%esi) 12cf40: 89 5e 04 mov %ebx,0x4(%esi) #endif /* * Determine cpu usage since period initiated. */ used = owning_thread->cpu_time_used; 12cf43: 8b 8f 80 00 00 00 mov 0x80(%edi),%ecx 12cf49: 8b 9f 84 00 00 00 mov 0x84(%edi),%ebx #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ if (owning_thread == _Thread_Executing) { 12cf4f: 83 c4 10 add $0x10,%esp if (used < the_period->cpu_usage_period_initiated) return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; 12cf52: be 01 00 00 00 mov $0x1,%esi * Determine cpu usage since period initiated. */ used = owning_thread->cpu_time_used; #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ if (owning_thread == _Thread_Executing) { 12cf57: 3b 3d 78 cb 16 00 cmp 0x16cb78,%edi 12cf5d: 75 38 jne 12cf97 <_Rate_monotonic_Get_status+0x87> 12cf5f: 2b 05 88 cb 16 00 sub 0x16cb88,%eax 12cf65: 1b 15 8c cb 16 00 sbb 0x16cb8c,%edx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 12cf6b: 01 c8 add %ecx,%eax 12cf6d: 11 da adc %ebx,%edx case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12cf6f: 8b 75 08 mov 0x8(%ebp),%esi 12cf72: 8b 4e 44 mov 0x44(%esi),%ecx 12cf75: 8b 5e 48 mov 0x48(%esi),%ebx /* * The cpu usage info was reset while executing. Can't * determine a status. */ if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated)) 12cf78: 39 da cmp %ebx,%edx 12cf7a: 7c 19 jl 12cf95 <_Rate_monotonic_Get_status+0x85><== NEVER TAKEN 12cf7c: 7f 04 jg 12cf82 <_Rate_monotonic_Get_status+0x72> 12cf7e: 39 c8 cmp %ecx,%eax 12cf80: 72 13 jb 12cf95 <_Rate_monotonic_Get_status+0x85> const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 12cf82: 29 c8 sub %ecx,%eax 12cf84: 19 da sbb %ebx,%edx 12cf86: 8b 4d 10 mov 0x10(%ebp),%ecx 12cf89: 89 01 mov %eax,(%ecx) 12cf8b: 89 51 04 mov %edx,0x4(%ecx) if (used < the_period->cpu_usage_period_initiated) return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; 12cf8e: be 01 00 00 00 mov $0x1,%esi 12cf93: eb 02 jmp 12cf97 <_Rate_monotonic_Get_status+0x87> /* * The cpu usage info was reset while executing. Can't * determine a status. */ if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated)) return false; 12cf95: 31 f6 xor %esi,%esi return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; } 12cf97: 89 f0 mov %esi,%eax 12cf99: 8d 65 f4 lea -0xc(%ebp),%esp 12cf9c: 5b pop %ebx 12cf9d: 5e pop %esi 12cf9e: 5f pop %edi 12cf9f: 5d pop %ebp 12cfa0: c3 ret =============================================================================== 0012d234 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 12d234: 55 push %ebp 12d235: 89 e5 mov %esp,%ebp 12d237: 53 push %ebx 12d238: 83 ec 18 sub $0x18,%esp /* * 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 ); 12d23b: 8d 45 f4 lea -0xc(%ebp),%eax 12d23e: 50 push %eax 12d23f: ff 75 08 pushl 0x8(%ebp) 12d242: 68 74 cd 16 00 push $0x16cd74 12d247: e8 a8 dd fd ff call 10aff4 <_Objects_Get> switch ( location ) { 12d24c: 83 c4 10 add $0x10,%esp 12d24f: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 12d253: 75 6b jne 12d2c0 <_Rate_monotonic_Timeout+0x8c><== NEVER TAKEN 12d255: 89 c3 mov %eax,%ebx case OBJECTS_LOCAL: the_thread = the_period->owner; 12d257: 8b 40 40 mov 0x40(%eax),%eax if ( _States_Is_waiting_for_period( the_thread->current_state ) && 12d25a: f6 40 11 40 testb $0x40,0x11(%eax) 12d25e: 74 18 je 12d278 <_Rate_monotonic_Timeout+0x44> 12d260: 8b 53 08 mov 0x8(%ebx),%edx 12d263: 39 50 20 cmp %edx,0x20(%eax) 12d266: 75 10 jne 12d278 <_Rate_monotonic_Timeout+0x44> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 12d268: 51 push %ecx 12d269: 51 push %ecx 12d26a: 68 f8 ff 03 10 push $0x1003fff8 12d26f: 50 push %eax 12d270: e8 5f e5 fd ff call 10b7d4 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 12d275: 58 pop %eax 12d276: eb 10 jmp 12d288 <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 12d278: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 12d27c: 75 2b jne 12d2a9 <_Rate_monotonic_Timeout+0x75> the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 12d27e: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) _Rate_monotonic_Initiate_statistics( the_period ); 12d285: 83 ec 0c sub $0xc,%esp 12d288: 53 push %ebx 12d289: e8 b2 fd ff ff call 12d040 <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 12d28e: 8b 43 3c mov 0x3c(%ebx),%eax 12d291: 89 43 1c mov %eax,0x1c(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 12d294: 58 pop %eax 12d295: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 12d296: 83 c3 10 add $0x10,%ebx 12d299: 53 push %ebx 12d29a: 68 20 ca 16 00 push $0x16ca20 12d29f: e8 24 f3 fd ff call 10c5c8 <_Watchdog_Insert> 12d2a4: 83 c4 10 add $0x10,%esp 12d2a7: eb 07 jmp 12d2b0 <_Rate_monotonic_Timeout+0x7c> } else the_period->state = RATE_MONOTONIC_EXPIRED; 12d2a9: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 12d2b0: a1 7c c9 16 00 mov 0x16c97c,%eax 12d2b5: 48 dec %eax 12d2b6: a3 7c c9 16 00 mov %eax,0x16c97c return _Thread_Dispatch_disable_level; 12d2bb: a1 7c c9 16 00 mov 0x16c97c,%eax case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 12d2c0: 8b 5d fc mov -0x4(%ebp),%ebx 12d2c3: c9 leave 12d2c4: c3 ret =============================================================================== 0012cfa1 <_Rate_monotonic_Update_statistics>: } static void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 12cfa1: 55 push %ebp 12cfa2: 89 e5 mov %esp,%ebp 12cfa4: 56 push %esi 12cfa5: 53 push %ebx 12cfa6: 83 ec 10 sub $0x10,%esp 12cfa9: 89 c6 mov %eax,%esi /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 12cfab: ff 40 54 incl 0x54(%eax) if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 12cfae: 83 78 38 04 cmpl $0x4,0x38(%eax) 12cfb2: 75 03 jne 12cfb7 <_Rate_monotonic_Update_statistics+0x16> stats->missed_count++; 12cfb4: ff 40 58 incl 0x58(%eax) /* * Grab status for time statistics. */ valid_status = 12cfb7: 50 push %eax _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 12cfb8: 8d 45 e8 lea -0x18(%ebp),%eax stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 12cfbb: 50 push %eax _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 12cfbc: 8d 45 f0 lea -0x10(%ebp),%eax stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 12cfbf: 50 push %eax 12cfc0: 56 push %esi 12cfc1: e8 4a ff ff ff call 12cf10 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) 12cfc6: 83 c4 10 add $0x10,%esp 12cfc9: 84 c0 test %al,%al 12cfcb: 74 6c je 12d039 <_Rate_monotonic_Update_statistics+0x98> /* * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); 12cfcd: 8b 4d e8 mov -0x18(%ebp),%ecx 12cfd0: 8b 5d ec mov -0x14(%ebp),%ebx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 12cfd3: 01 4e 6c add %ecx,0x6c(%esi) 12cfd6: 11 5e 70 adc %ebx,0x70(%esi) if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 12cfd9: 3b 5e 60 cmp 0x60(%esi),%ebx 12cfdc: 7f 0d jg 12cfeb <_Rate_monotonic_Update_statistics+0x4a><== NEVER TAKEN 12cfde: 7c 05 jl 12cfe5 <_Rate_monotonic_Update_statistics+0x44> 12cfe0: 3b 4e 5c cmp 0x5c(%esi),%ecx 12cfe3: 73 06 jae 12cfeb <_Rate_monotonic_Update_statistics+0x4a> stats->min_cpu_time = executed; 12cfe5: 89 4e 5c mov %ecx,0x5c(%esi) 12cfe8: 89 5e 60 mov %ebx,0x60(%esi) if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 12cfeb: 39 5e 68 cmp %ebx,0x68(%esi) 12cfee: 7f 0d jg 12cffd <_Rate_monotonic_Update_statistics+0x5c><== NEVER TAKEN 12cff0: 7c 05 jl 12cff7 <_Rate_monotonic_Update_statistics+0x56><== NEVER TAKEN 12cff2: 39 4e 64 cmp %ecx,0x64(%esi) 12cff5: 73 06 jae 12cffd <_Rate_monotonic_Update_statistics+0x5c> stats->max_cpu_time = executed; 12cff7: 89 4e 64 mov %ecx,0x64(%esi) 12cffa: 89 5e 68 mov %ebx,0x68(%esi) /* * Update Wall time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 12cffd: 8b 4d f0 mov -0x10(%ebp),%ecx 12d000: 8b 5d f4 mov -0xc(%ebp),%ebx 12d003: 01 8e 84 00 00 00 add %ecx,0x84(%esi) 12d009: 11 9e 88 00 00 00 adc %ebx,0x88(%esi) if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 12d00f: 3b 5e 78 cmp 0x78(%esi),%ebx 12d012: 7f 0d jg 12d021 <_Rate_monotonic_Update_statistics+0x80><== NEVER TAKEN 12d014: 7c 05 jl 12d01b <_Rate_monotonic_Update_statistics+0x7a> 12d016: 3b 4e 74 cmp 0x74(%esi),%ecx 12d019: 73 06 jae 12d021 <_Rate_monotonic_Update_statistics+0x80> stats->min_wall_time = since_last_period; 12d01b: 89 4e 74 mov %ecx,0x74(%esi) 12d01e: 89 5e 78 mov %ebx,0x78(%esi) if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 12d021: 39 9e 80 00 00 00 cmp %ebx,0x80(%esi) 12d027: 7f 10 jg 12d039 <_Rate_monotonic_Update_statistics+0x98> 12d029: 7c 05 jl 12d030 <_Rate_monotonic_Update_statistics+0x8f><== NEVER TAKEN 12d02b: 39 4e 7c cmp %ecx,0x7c(%esi) 12d02e: 73 09 jae 12d039 <_Rate_monotonic_Update_statistics+0x98> stats->max_wall_time = since_last_period; 12d030: 89 4e 7c mov %ecx,0x7c(%esi) 12d033: 89 9e 80 00 00 00 mov %ebx,0x80(%esi) stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #endif } 12d039: 8d 65 f8 lea -0x8(%ebp),%esp 12d03c: 5b pop %ebx 12d03d: 5e pop %esi 12d03e: 5d pop %ebp 12d03f: c3 ret =============================================================================== 0011b6d0 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 11b6d0: 55 push %ebp 11b6d1: 89 e5 mov %esp,%ebp 11b6d3: 57 push %edi 11b6d4: 56 push %esi 11b6d5: 53 push %ebx 11b6d6: 83 ec 28 sub $0x28,%esp 11b6d9: 8b 5d 08 mov 0x8(%ebp),%ebx * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 11b6dc: a1 1c 57 14 00 mov 0x14571c,%eax 11b6e1: 40 inc %eax 11b6e2: a3 1c 57 14 00 mov %eax,0x14571c return _Thread_Dispatch_disable_level; 11b6e7: a1 1c 57 14 00 mov 0x14571c,%eax * NOTE: Be sure to disable dispatching before unlocking the mutex * since we do not want to open a window where a context * switch could occur. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 11b6ec: ff 35 a8 57 14 00 pushl 0x1457a8 11b6f2: e8 1d b8 ff ff call 116f14 <_API_Mutex_Unlock> 11b6f7: 83 c4 10 add $0x10,%esp /* * NOTE: The following loop is O(n) where n is the number of * threads whose memory request is satisfied. */ for ( ; ; ) { the_thread = _Thread_queue_First( &the_region->Wait_queue ); 11b6fa: 8d 73 10 lea 0x10(%ebx),%esi RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uintptr_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 11b6fd: 8d 43 68 lea 0x68(%ebx),%eax 11b700: 89 45 e4 mov %eax,-0x1c(%ebp) 11b703: 83 ec 0c sub $0xc,%esp 11b706: 56 push %esi 11b707: e8 20 06 00 00 call 11bd2c <_Thread_queue_First> 11b70c: 89 c7 mov %eax,%edi if ( the_thread == NULL ) 11b70e: 83 c4 10 add $0x10,%esp 11b711: 85 c0 test %eax,%eax 11b713: 74 33 je 11b748 <_Region_Process_queue+0x78> 11b715: 6a 00 push $0x0 11b717: 6a 00 push $0x0 11b719: ff 70 24 pushl 0x24(%eax) 11b71c: ff 75 e4 pushl -0x1c(%ebp) 11b71f: e8 d0 c0 ff ff call 1177f4 <_Heap_Allocate_aligned_with_boundary> the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 11b724: 83 c4 10 add $0x10,%esp 11b727: 85 c0 test %eax,%eax 11b729: 74 1d je 11b748 <_Region_Process_queue+0x78><== NEVER TAKEN break; *(void **)the_thread->Wait.return_argument = the_segment; 11b72b: 8b 4f 28 mov 0x28(%edi),%ecx 11b72e: 89 01 mov %eax,(%ecx) the_region->number_of_used_blocks += 1; 11b730: ff 43 64 incl 0x64(%ebx) _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 11b733: 50 push %eax 11b734: 50 push %eax 11b735: 57 push %edi 11b736: 56 push %esi 11b737: e8 10 05 00 00 call 11bc4c <_Thread_queue_Extract> the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 11b73c: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) } 11b743: 83 c4 10 add $0x10,%esp 11b746: eb bb jmp 11b703 <_Region_Process_queue+0x33> _Thread_Enable_dispatch(); } 11b748: 8d 65 f4 lea -0xc(%ebp),%esp 11b74b: 5b pop %ebx 11b74c: 5e pop %esi 11b74d: 5f pop %edi 11b74e: 5d pop %ebp *(void **)the_thread->Wait.return_argument = the_segment; the_region->number_of_used_blocks += 1; _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); the_thread->Wait.return_code = RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 11b74f: e9 20 db ff ff jmp 119274 <_Thread_Enable_dispatch> =============================================================================== 0010bc6c <_Scheduler_CBS_Allocate>: #include void *_Scheduler_CBS_Allocate( Thread_Control *the_thread ) { 10bc6c: 55 push %ebp 10bc6d: 89 e5 mov %esp,%ebp 10bc6f: 53 push %ebx 10bc70: 83 ec 10 sub $0x10,%esp 10bc73: 8b 5d 08 mov 0x8(%ebp),%ebx void *sched; Scheduler_CBS_Per_thread *schinfo; sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread)); 10bc76: 6a 1c push $0x1c 10bc78: e8 6f 15 00 00 call 10d1ec <_Workspace_Allocate> if ( sched ) { 10bc7d: 83 c4 10 add $0x10,%esp 10bc80: 85 c0 test %eax,%eax 10bc82: 74 16 je 10bc9a <_Scheduler_CBS_Allocate+0x2e><== NEVER TAKEN the_thread->scheduler_info = sched; 10bc84: 89 83 88 00 00 00 mov %eax,0x88(%ebx) schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info); schinfo->edf_per_thread.thread = the_thread; 10bc8a: 89 18 mov %ebx,(%eax) schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN; 10bc8c: c7 40 14 02 00 00 00 movl $0x2,0x14(%eax) schinfo->cbs_server = NULL; 10bc93: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) } return sched; } 10bc9a: 8b 5d fc mov -0x4(%ebp),%ebx 10bc9d: c9 leave 10bc9e: c3 ret =============================================================================== 0010d098 <_Scheduler_CBS_Budget_callout>: Scheduler_CBS_Server **_Scheduler_CBS_Server_list; void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) { 10d098: 55 push %ebp 10d099: 89 e5 mov %esp,%ebp 10d09b: 53 push %ebx 10d09c: 83 ec 14 sub $0x14,%esp 10d09f: 8b 5d 08 mov 0x8(%ebp),%ebx 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; 10d0a2: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax if ( the_thread->real_priority != new_priority ) 10d0a8: 39 43 18 cmp %eax,0x18(%ebx) 10d0ab: 74 03 je 10d0b0 <_Scheduler_CBS_Budget_callout+0x18><== NEVER TAKEN the_thread->real_priority = new_priority; 10d0ad: 89 43 18 mov %eax,0x18(%ebx) if ( the_thread->current_priority != new_priority ) 10d0b0: 39 43 14 cmp %eax,0x14(%ebx) 10d0b3: 74 0d je 10d0c2 <_Scheduler_CBS_Budget_callout+0x2a><== NEVER TAKEN _Thread_Change_priority(the_thread, new_priority, true); 10d0b5: 52 push %edx 10d0b6: 6a 01 push $0x1 10d0b8: 50 push %eax 10d0b9: 53 push %ebx 10d0ba: e8 b1 04 00 00 call 10d570 <_Thread_Change_priority> 10d0bf: 83 c4 10 add $0x10,%esp /* Invoke callback function if any. */ sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; 10d0c2: 8b 9b 88 00 00 00 mov 0x88(%ebx),%ebx if ( sched_info->cbs_server->cbs_budget_overrun ) { 10d0c8: 8b 43 18 mov 0x18(%ebx),%eax 10d0cb: 83 78 0c 00 cmpl $0x0,0xc(%eax) 10d0cf: 74 1a je 10d0eb <_Scheduler_CBS_Budget_callout+0x53> _Scheduler_CBS_Get_server_id( 10d0d1: 52 push %edx 10d0d2: 52 push %edx 10d0d3: 8d 55 f4 lea -0xc(%ebp),%edx 10d0d6: 52 push %edx 10d0d7: ff 30 pushl (%eax) 10d0d9: e8 7e ff ff ff call 10d05c <_Scheduler_CBS_Get_server_id> sched_info->cbs_server->task_id, &server_id ); sched_info->cbs_server->cbs_budget_overrun( server_id ); 10d0de: 59 pop %ecx 10d0df: 8b 43 18 mov 0x18(%ebx),%eax 10d0e2: ff 75 f4 pushl -0xc(%ebp) 10d0e5: ff 50 0c call *0xc(%eax) 10d0e8: 83 c4 10 add $0x10,%esp } } 10d0eb: 8b 5d fc mov -0x4(%ebp),%ebx 10d0ee: c9 leave 10d0ef: c3 ret =============================================================================== 0010cd60 <_Scheduler_CBS_Create_server>: int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) { 10cd60: 55 push %ebp 10cd61: 89 e5 mov %esp,%ebp 10cd63: 57 push %edi 10cd64: 56 push %esi 10cd65: 53 push %ebx 10cd66: 83 ec 0c sub $0xc,%esp 10cd69: 8b 5d 08 mov 0x8(%ebp),%ebx 10cd6c: 8b 75 10 mov 0x10(%ebp),%esi unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 10cd6f: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10cd73: 7e 42 jle 10cdb7 <_Scheduler_CBS_Create_server+0x57> 10cd75: 83 3b 00 cmpl $0x0,(%ebx) 10cd78: 7e 3d jle 10cdb7 <_Scheduler_CBS_Create_server+0x57> 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++ ) { 10cd7a: 8b 15 0c c5 12 00 mov 0x12c50c,%edx if ( !_Scheduler_CBS_Server_list[i] ) 10cd80: 8b 0d c8 08 13 00 mov 0x1308c8,%ecx 10cd86: 31 c0 xor %eax,%eax 10cd88: eb 07 jmp 10cd91 <_Scheduler_CBS_Create_server+0x31> 10cd8a: 83 3c 81 00 cmpl $0x0,(%ecx,%eax,4) 10cd8e: 74 35 je 10cdc5 <_Scheduler_CBS_Create_server+0x65> 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++ ) { 10cd90: 40 inc %eax 10cd91: 39 d0 cmp %edx,%eax 10cd93: 75 f5 jne 10cd8a <_Scheduler_CBS_Create_server+0x2a> if ( !_Scheduler_CBS_Server_list[i] ) break; } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; 10cd95: b8 e6 ff ff ff mov $0xffffffe6,%eax 10cd9a: eb 53 jmp 10cdef <_Scheduler_CBS_Create_server+0x8f> _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; 10cd9c: 8b 03 mov (%ebx),%eax 10cd9e: 8b 53 04 mov 0x4(%ebx),%edx 10cda1: 89 41 04 mov %eax,0x4(%ecx) 10cda4: 89 51 08 mov %edx,0x8(%ecx) the_server->task_id = -1; 10cda7: c7 01 ff ff ff ff movl $0xffffffff,(%ecx) the_server->cbs_budget_overrun = budget_overrun_callback; 10cdad: 8b 45 0c mov 0xc(%ebp),%eax 10cdb0: 89 41 0c mov %eax,0xc(%ecx) return SCHEDULER_CBS_OK; 10cdb3: 31 c0 xor %eax,%eax 10cdb5: eb 38 jmp 10cdef <_Scheduler_CBS_Create_server+0x8f> 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; 10cdb7: b8 ee ff ff ff mov $0xffffffee,%eax 10cdbc: eb 31 jmp 10cdef <_Scheduler_CBS_Create_server+0x8f> *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; 10cdbe: b8 ef ff ff ff mov $0xffffffef,%eax <== NOT EXECUTED 10cdc3: eb 2a jmp 10cdef <_Scheduler_CBS_Create_server+0x8f><== NOT EXECUTED } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; 10cdc5: 89 06 mov %eax,(%esi) _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 10cdc7: 8b 15 c8 08 13 00 mov 0x1308c8,%edx 10cdcd: 8d 3c 82 lea (%edx,%eax,4),%edi _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); 10cdd0: 83 ec 0c sub $0xc,%esp 10cdd3: 6a 10 push $0x10 10cdd5: e8 8a 18 00 00 call 10e664 <_Workspace_Allocate> if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 10cdda: 89 07 mov %eax,(%edi) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; 10cddc: 8b 16 mov (%esi),%edx 10cdde: a1 c8 08 13 00 mov 0x1308c8,%eax 10cde3: 8b 0c 90 mov (%eax,%edx,4),%ecx if ( !the_server ) 10cde6: 83 c4 10 add $0x10,%esp 10cde9: 85 c9 test %ecx,%ecx 10cdeb: 75 af jne 10cd9c <_Scheduler_CBS_Create_server+0x3c><== ALWAYS TAKEN 10cded: eb cf jmp 10cdbe <_Scheduler_CBS_Create_server+0x5e><== NOT EXECUTED the_server->parameters = *params; the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback; return SCHEDULER_CBS_OK; } 10cdef: 8d 65 f4 lea -0xc(%ebp),%esp 10cdf2: 5b pop %ebx 10cdf3: 5e pop %esi 10cdf4: 5f pop %edi 10cdf5: 5d pop %ebp 10cdf6: c3 ret =============================================================================== 0010ce68 <_Scheduler_CBS_Detach_thread>: int _Scheduler_CBS_Detach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 10ce68: 55 push %ebp 10ce69: 89 e5 mov %esp,%ebp 10ce6b: 57 push %edi 10ce6c: 56 push %esi 10ce6d: 53 push %ebx 10ce6e: 83 ec 24 sub $0x24,%esp 10ce71: 8b 7d 08 mov 0x8(%ebp),%edi 10ce74: 8b 75 0c mov 0xc(%ebp),%esi Objects_Locations location; Thread_Control *the_thread; Scheduler_CBS_Per_thread *sched_info; the_thread = _Thread_Get(task_id, &location); 10ce77: 8d 45 e4 lea -0x1c(%ebp),%eax 10ce7a: 50 push %eax 10ce7b: 56 push %esi 10ce7c: e8 ff 0a 00 00 call 10d980 <_Thread_Get> 10ce81: 89 c3 mov %eax,%ebx /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 10ce83: 83 c4 10 add $0x10,%esp 10ce86: 85 c0 test %eax,%eax 10ce88: 74 05 je 10ce8f <_Scheduler_CBS_Detach_thread+0x27> _Thread_Enable_dispatch(); 10ce8a: e8 d1 0a 00 00 call 10d960 <_Thread_Enable_dispatch> } if ( server_id >= _Scheduler_CBS_Maximum_servers ) 10ce8f: 3b 3d 0c c5 12 00 cmp 0x12c50c,%edi 10ce95: 73 4d jae 10cee4 <_Scheduler_CBS_Detach_thread+0x7c> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !the_thread ) 10ce97: 85 db test %ebx,%ebx 10ce99: 74 49 je 10cee4 <_Scheduler_CBS_Detach_thread+0x7c> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) 10ce9b: a1 c8 08 13 00 mov 0x1308c8,%eax 10cea0: 8b 04 b8 mov (%eax,%edi,4),%eax 10cea3: 85 c0 test %eax,%eax 10cea5: 74 36 je 10cedd <_Scheduler_CBS_Detach_thread+0x75> return SCHEDULER_CBS_ERROR_NOSERVER; /* Thread and server are not attached. */ if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id ) 10cea7: 39 30 cmp %esi,(%eax) 10cea9: 75 39 jne 10cee4 <_Scheduler_CBS_Detach_thread+0x7c><== NEVER TAKEN return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; _Scheduler_CBS_Server_list[server_id]->task_id = -1; 10ceab: c7 00 ff ff ff ff movl $0xffffffff,(%eax) sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL; 10ceb1: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10ceb7: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10cebe: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 10cec4: 89 43 78 mov %eax,0x78(%ebx) the_thread->budget_callout = the_thread->Start.budget_callout; 10cec7: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax 10cecd: 89 43 7c mov %eax,0x7c(%ebx) the_thread->is_preemptible = the_thread->Start.is_preemptible; 10ced0: 8a 83 9c 00 00 00 mov 0x9c(%ebx),%al 10ced6: 88 43 70 mov %al,0x70(%ebx) return SCHEDULER_CBS_OK; 10ced9: 31 c0 xor %eax,%eax 10cedb: eb 0c jmp 10cee9 <_Scheduler_CBS_Detach_thread+0x81> 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] ) return SCHEDULER_CBS_ERROR_NOSERVER; 10cedd: b8 e7 ff ff ff mov $0xffffffe7,%eax 10cee2: eb 05 jmp 10cee9 <_Scheduler_CBS_Detach_thread+0x81> if ( the_thread ) { _Thread_Enable_dispatch(); } if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 10cee4: b8 ee ff ff ff mov $0xffffffee,%eax 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; } 10cee9: 8d 65 f4 lea -0xc(%ebp),%esp 10ceec: 5b pop %ebx 10ceed: 5e pop %esi 10ceee: 5f pop %edi 10ceef: 5d pop %ebp 10cef0: c3 ret =============================================================================== 0010cf2c <_Scheduler_CBS_Get_execution_time>: int _Scheduler_CBS_Get_execution_time ( Scheduler_CBS_Server_id server_id, time_t *exec_time, time_t *abs_time ) { 10cf2c: 55 push %ebp 10cf2d: 89 e5 mov %esp,%ebp 10cf2f: 57 push %edi 10cf30: 56 push %esi 10cf31: 53 push %ebx 10cf32: 83 ec 1c sub $0x1c,%esp 10cf35: 8b 5d 08 mov 0x8(%ebp),%ebx 10cf38: 8b 75 0c mov 0xc(%ebp),%esi Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 10cf3b: 3b 1d 0c c5 12 00 cmp 0x12c50c,%ebx 10cf41: 73 58 jae 10cf9b <_Scheduler_CBS_Get_execution_time+0x6f> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 10cf43: a1 c8 08 13 00 mov 0x1308c8,%eax 10cf48: 8b 04 98 mov (%eax,%ebx,4),%eax 10cf4b: 85 c0 test %eax,%eax 10cf4d: 74 53 je 10cfa2 <_Scheduler_CBS_Get_execution_time+0x76> return SCHEDULER_CBS_ERROR_NOSERVER; if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) { 10cf4f: 8b 00 mov (%eax),%eax 10cf51: 83 f8 ff cmp $0xffffffff,%eax 10cf54: 75 08 jne 10cf5e <_Scheduler_CBS_Get_execution_time+0x32> *exec_time = 0; 10cf56: c7 06 00 00 00 00 movl $0x0,(%esi) 10cf5c: eb 39 jmp 10cf97 <_Scheduler_CBS_Get_execution_time+0x6b> return SCHEDULER_CBS_OK; } the_thread = _Thread_Get( 10cf5e: 52 push %edx 10cf5f: 52 push %edx 10cf60: 8d 55 e4 lea -0x1c(%ebp),%edx 10cf63: 52 push %edx 10cf64: 50 push %eax 10cf65: e8 16 0a 00 00 call 10d980 <_Thread_Get> 10cf6a: 89 c7 mov %eax,%edi _Scheduler_CBS_Server_list[server_id]->task_id, &location ); /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 10cf6c: 83 c4 10 add $0x10,%esp 10cf6f: 85 c0 test %eax,%eax 10cf71: 74 17 je 10cf8a <_Scheduler_CBS_Get_execution_time+0x5e><== NEVER TAKEN _Thread_Enable_dispatch(); 10cf73: e8 e8 09 00 00 call 10d960 <_Thread_Enable_dispatch> *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget - 10cf78: a1 c8 08 13 00 mov 0x1308c8,%eax 10cf7d: 8b 04 98 mov (%eax,%ebx,4),%eax 10cf80: 8b 50 08 mov 0x8(%eax),%edx 10cf83: 2b 57 74 sub 0x74(%edi),%edx 10cf86: 89 16 mov %edx,(%esi) 10cf88: eb 0d jmp 10cf97 <_Scheduler_CBS_Get_execution_time+0x6b> the_thread->cpu_time_budget; } else { *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget; 10cf8a: a1 c8 08 13 00 mov 0x1308c8,%eax <== NOT EXECUTED 10cf8f: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED 10cf92: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10cf95: 89 06 mov %eax,(%esi) <== NOT EXECUTED } return SCHEDULER_CBS_OK; 10cf97: 31 c0 xor %eax,%eax 10cf99: eb 0c jmp 10cfa7 <_Scheduler_CBS_Get_execution_time+0x7b> { Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 10cf9b: b8 ee ff ff ff mov $0xffffffee,%eax 10cfa0: eb 05 jmp 10cfa7 <_Scheduler_CBS_Get_execution_time+0x7b> if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; 10cfa2: b8 e7 ff ff ff mov $0xffffffe7,%eax } else { *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget; } return SCHEDULER_CBS_OK; } 10cfa7: 8d 65 f4 lea -0xc(%ebp),%esp 10cfaa: 5b pop %ebx 10cfab: 5e pop %esi 10cfac: 5f pop %edi 10cfad: 5d pop %ebp 10cfae: c3 ret =============================================================================== 0010cfec <_Scheduler_CBS_Get_remaining_budget>: int _Scheduler_CBS_Get_remaining_budget ( Scheduler_CBS_Server_id server_id, time_t *remaining_budget ) { 10cfec: 55 push %ebp 10cfed: 89 e5 mov %esp,%ebp 10cfef: 56 push %esi 10cff0: 53 push %ebx 10cff1: 83 ec 10 sub $0x10,%esp 10cff4: 8b 45 08 mov 0x8(%ebp),%eax 10cff7: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 10cffa: 3b 05 0c c5 12 00 cmp 0x12c50c,%eax 10d000: 73 44 jae 10d046 <_Scheduler_CBS_Get_remaining_budget+0x5a> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 10d002: 8b 15 c8 08 13 00 mov 0x1308c8,%edx 10d008: 8b 04 82 mov (%edx,%eax,4),%eax 10d00b: 85 c0 test %eax,%eax 10d00d: 74 3e je 10d04d <_Scheduler_CBS_Get_remaining_budget+0x61> return SCHEDULER_CBS_ERROR_NOSERVER; if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) { 10d00f: 8b 10 mov (%eax),%edx 10d011: 83 fa ff cmp $0xffffffff,%edx 10d014: 75 05 jne 10d01b <_Scheduler_CBS_Get_remaining_budget+0x2f> *remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget; 10d016: 8b 40 08 mov 0x8(%eax),%eax 10d019: eb 1d jmp 10d038 <_Scheduler_CBS_Get_remaining_budget+0x4c> return SCHEDULER_CBS_OK; } the_thread = _Thread_Get( 10d01b: 50 push %eax 10d01c: 50 push %eax 10d01d: 8d 45 f4 lea -0xc(%ebp),%eax 10d020: 50 push %eax 10d021: 52 push %edx 10d022: e8 59 09 00 00 call 10d980 <_Thread_Get> 10d027: 89 c6 mov %eax,%esi _Scheduler_CBS_Server_list[server_id]->task_id, &location ); /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 10d029: 83 c4 10 add $0x10,%esp 10d02c: 85 c0 test %eax,%eax 10d02e: 74 0c je 10d03c <_Scheduler_CBS_Get_remaining_budget+0x50><== NEVER TAKEN _Thread_Enable_dispatch(); 10d030: e8 2b 09 00 00 call 10d960 <_Thread_Enable_dispatch> *remaining_budget = the_thread->cpu_time_budget; 10d035: 8b 46 74 mov 0x74(%esi),%eax 10d038: 89 03 mov %eax,(%ebx) 10d03a: eb 06 jmp 10d042 <_Scheduler_CBS_Get_remaining_budget+0x56> } else { *remaining_budget = 0; 10d03c: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED } return SCHEDULER_CBS_OK; 10d042: 31 c0 xor %eax,%eax 10d044: eb 0c jmp 10d052 <_Scheduler_CBS_Get_remaining_budget+0x66> { Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 10d046: b8 ee ff ff ff mov $0xffffffee,%eax 10d04b: eb 05 jmp 10d052 <_Scheduler_CBS_Get_remaining_budget+0x66> if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; 10d04d: b8 e7 ff ff ff mov $0xffffffe7,%eax else { *remaining_budget = 0; } return SCHEDULER_CBS_OK; } 10d052: 8d 65 f8 lea -0x8(%ebp),%esp 10d055: 5b pop %ebx 10d056: 5e pop %esi 10d057: 5d pop %ebp 10d058: c3 ret =============================================================================== 0010d0f0 <_Scheduler_CBS_Initialize>: int _Scheduler_CBS_Initialize(void) { 10d0f0: 55 push %ebp 10d0f1: 89 e5 mov %esp,%ebp 10d0f3: 83 ec 14 sub $0x14,%esp unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( 10d0f6: a1 0c c5 12 00 mov 0x12c50c,%eax 10d0fb: c1 e0 02 shl $0x2,%eax 10d0fe: 50 push %eax 10d0ff: e8 60 15 00 00 call 10e664 <_Workspace_Allocate> 10d104: a3 c8 08 13 00 mov %eax,0x1308c8 _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) 10d109: 83 c4 10 add $0x10,%esp 10d10c: 85 c0 test %eax,%eax 10d10e: 74 20 je 10d130 <_Scheduler_CBS_Initialize+0x40><== NEVER TAKEN return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 10d110: 8b 15 0c c5 12 00 mov 0x12c50c,%edx 10d116: 31 c0 xor %eax,%eax 10d118: eb 0e jmp 10d128 <_Scheduler_CBS_Initialize+0x38> _Scheduler_CBS_Server_list[i] = NULL; 10d11a: 8b 0d c8 08 13 00 mov 0x1308c8,%ecx 10d120: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4) 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++) { 10d127: 40 inc %eax 10d128: 39 d0 cmp %edx,%eax 10d12a: 75 ee jne 10d11a <_Scheduler_CBS_Initialize+0x2a> _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; 10d12c: 31 c0 xor %eax,%eax 10d12e: eb 05 jmp 10d135 <_Scheduler_CBS_Initialize+0x45> { 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; 10d130: b8 ef ff ff ff mov $0xffffffef,%eax <== NOT EXECUTED for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; } 10d135: c9 leave 10d136: c3 ret =============================================================================== 0010bca0 <_Scheduler_CBS_Release_job>: void _Scheduler_CBS_Release_job( Thread_Control *the_thread, uint32_t deadline ) { 10bca0: 55 push %ebp 10bca1: 89 e5 mov %esp,%ebp 10bca3: 83 ec 08 sub $0x8,%esp 10bca6: 8b 55 08 mov 0x8(%ebp),%edx 10bca9: 8b 45 0c mov 0xc(%ebp),%eax 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; 10bcac: 8b 8a 88 00 00 00 mov 0x88(%edx),%ecx ) { Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; Scheduler_CBS_Server *serv_info = 10bcb2: 8b 49 18 mov 0x18(%ecx),%ecx (Scheduler_CBS_Server *) sched_info->cbs_server; if (deadline) { 10bcb5: 85 c0 test %eax,%eax 10bcb7: 74 22 je 10bcdb <_Scheduler_CBS_Release_job+0x3b> /* Initializing or shifting deadline. */ if (serv_info) 10bcb9: 85 c9 test %ecx,%ecx 10bcbb: 74 0f je 10bccc <_Scheduler_CBS_Release_job+0x2c> new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline) 10bcbd: a1 28 ea 12 00 mov 0x12ea28,%eax 10bcc2: 03 41 04 add 0x4(%ecx),%eax 10bcc5: 25 ff ff ff 7f and $0x7fffffff,%eax 10bcca: eb 19 jmp 10bce5 <_Scheduler_CBS_Release_job+0x45> & ~SCHEDULER_EDF_PRIO_MSB; else new_priority = (_Watchdog_Ticks_since_boot + deadline) 10bccc: 8b 0d 28 ea 12 00 mov 0x12ea28,%ecx 10bcd2: 01 c8 add %ecx,%eax 10bcd4: 25 ff ff ff 7f and $0x7fffffff,%eax 10bcd9: eb 10 jmp 10bceb <_Scheduler_CBS_Release_job+0x4b> & ~SCHEDULER_EDF_PRIO_MSB; } else { /* Switch back to background priority. */ new_priority = the_thread->Start.initial_priority; 10bcdb: 8b 82 ac 00 00 00 mov 0xac(%edx),%eax } /* Budget replenishment for the next job. */ if (serv_info) 10bce1: 85 c9 test %ecx,%ecx 10bce3: 74 06 je 10bceb <_Scheduler_CBS_Release_job+0x4b><== NEVER TAKEN the_thread->cpu_time_budget = serv_info->parameters.budget; 10bce5: 8b 49 08 mov 0x8(%ecx),%ecx 10bce8: 89 4a 74 mov %ecx,0x74(%edx) the_thread->real_priority = new_priority; 10bceb: 89 42 18 mov %eax,0x18(%edx) _Thread_Change_priority(the_thread, new_priority, true); 10bcee: 51 push %ecx 10bcef: 6a 01 push $0x1 10bcf1: 50 push %eax 10bcf2: 52 push %edx 10bcf3: e8 98 03 00 00 call 10c090 <_Thread_Change_priority> 10bcf8: 83 c4 10 add $0x10,%esp } 10bcfb: c9 leave 10bcfc: c3 ret =============================================================================== 0010bd00 <_Scheduler_CBS_Unblock>: #include void _Scheduler_CBS_Unblock( Thread_Control *the_thread ) { 10bd00: 55 push %ebp 10bd01: 89 e5 mov %esp,%ebp 10bd03: 56 push %esi 10bd04: 53 push %ebx 10bd05: 8b 5d 08 mov 0x8(%ebp),%ebx Scheduler_CBS_Per_thread *sched_info; Scheduler_CBS_Server *serv_info; Priority_Control new_priority; _Scheduler_EDF_Enqueue(the_thread); 10bd08: 83 ec 0c sub $0xc,%esp 10bd0b: 53 push %ebx 10bd0c: e8 cf 00 00 00 call 10bde0 <_Scheduler_EDF_Enqueue> /* TODO: flash critical section? */ sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server; 10bd11: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10bd17: 8b 40 18 mov 0x18(%eax),%eax * 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) { 10bd1a: 83 c4 10 add $0x10,%esp 10bd1d: 85 c0 test %eax,%eax 10bd1f: 74 3d je 10bd5e <_Scheduler_CBS_Unblock+0x5e> 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 - 10bd21: 8b 4b 18 mov 0x18(%ebx),%ecx 10bd24: 8b 15 28 ea 12 00 mov 0x12ea28,%edx 10bd2a: 89 ce mov %ecx,%esi 10bd2c: 29 d6 sub %edx,%esi _Watchdog_Ticks_since_boot; if ( deadline*budget_left > budget*deadline_left ) { 10bd2e: 8b 50 04 mov 0x4(%eax),%edx 10bd31: 0f af d6 imul %esi,%edx 10bd34: 8b 40 08 mov 0x8(%eax),%eax 10bd37: 0f af 43 74 imul 0x74(%ebx),%eax 10bd3b: 39 c2 cmp %eax,%edx 10bd3d: 7e 1f jle 10bd5e <_Scheduler_CBS_Unblock+0x5e> /* Put late unblocked task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; 10bd3f: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax if ( the_thread->real_priority != new_priority ) 10bd45: 39 c1 cmp %eax,%ecx 10bd47: 74 03 je 10bd4c <_Scheduler_CBS_Unblock+0x4c> the_thread->real_priority = new_priority; 10bd49: 89 43 18 mov %eax,0x18(%ebx) if ( the_thread->current_priority != new_priority ) 10bd4c: 39 43 14 cmp %eax,0x14(%ebx) 10bd4f: 74 0d je 10bd5e <_Scheduler_CBS_Unblock+0x5e> _Thread_Change_priority(the_thread, new_priority, true); 10bd51: 52 push %edx 10bd52: 6a 01 push $0x1 10bd54: 50 push %eax 10bd55: 53 push %ebx 10bd56: e8 35 03 00 00 call 10c090 <_Thread_Change_priority> 10bd5b: 83 c4 10 add $0x10,%esp 10bd5e: 50 push %eax 10bd5f: 50 push %eax * 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, 10bd60: a1 34 eb 12 00 mov 0x12eb34,%eax 10bd65: ff 70 14 pushl 0x14(%eax) 10bd68: ff 73 14 pushl 0x14(%ebx) 10bd6b: ff 15 c0 a7 12 00 call *0x12a7c0 10bd71: 83 c4 10 add $0x10,%esp 10bd74: 85 c0 test %eax,%eax 10bd76: 7e 1e jle 10bd96 <_Scheduler_CBS_Unblock+0x96> _Thread_Heir->current_priority)) { _Thread_Heir = the_thread; 10bd78: 89 1d 34 eb 12 00 mov %ebx,0x12eb34 if ( _Thread_Executing->is_preemptible || 10bd7e: a1 30 eb 12 00 mov 0x12eb30,%eax 10bd83: 80 78 70 00 cmpb $0x0,0x70(%eax) 10bd87: 75 06 jne 10bd8f <_Scheduler_CBS_Unblock+0x8f> 10bd89: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10bd8d: 75 07 jne 10bd96 <_Scheduler_CBS_Unblock+0x96><== ALWAYS TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10bd8f: c6 05 3c eb 12 00 01 movb $0x1,0x12eb3c } } 10bd96: 8d 65 f8 lea -0x8(%ebp),%esp 10bd99: 5b pop %ebx 10bd9a: 5e pop %esi 10bd9b: 5d pop %ebp 10bd9c: c3 ret =============================================================================== 0010bc6c <_Scheduler_EDF_Allocate>: #include void *_Scheduler_EDF_Allocate( Thread_Control *the_thread ) { 10bc6c: 55 push %ebp 10bc6d: 89 e5 mov %esp,%ebp 10bc6f: 53 push %ebx 10bc70: 83 ec 10 sub $0x10,%esp 10bc73: 8b 5d 08 mov 0x8(%ebp),%ebx void *sched; Scheduler_EDF_Per_thread *schinfo; sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) ); 10bc76: 6a 18 push $0x18 10bc78: e8 ef 14 00 00 call 10d16c <_Workspace_Allocate> if ( sched ) { 10bc7d: 83 c4 10 add $0x10,%esp 10bc80: 85 c0 test %eax,%eax 10bc82: 74 0f je 10bc93 <_Scheduler_EDF_Allocate+0x27><== NEVER TAKEN the_thread->scheduler_info = sched; 10bc84: 89 83 88 00 00 00 mov %eax,0x88(%ebx) schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info); schinfo->thread = the_thread; 10bc8a: 89 18 mov %ebx,(%eax) schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN; 10bc8c: c7 40 14 02 00 00 00 movl $0x2,0x14(%eax) } return sched; } 10bc93: 8b 5d fc mov -0x4(%ebp),%ebx 10bc96: c9 leave 10bc97: c3 ret =============================================================================== 0010be34 <_Scheduler_EDF_Unblock>: #include void _Scheduler_EDF_Unblock( Thread_Control *the_thread ) { 10be34: 55 push %ebp 10be35: 89 e5 mov %esp,%ebp 10be37: 53 push %ebx 10be38: 83 ec 10 sub $0x10,%esp 10be3b: 8b 5d 08 mov 0x8(%ebp),%ebx _Scheduler_EDF_Enqueue(the_thread); 10be3e: 53 push %ebx 10be3f: e8 94 fe ff ff call 10bcd8 <_Scheduler_EDF_Enqueue> 10be44: 58 pop %eax 10be45: 5a pop %edx 10be46: ff 73 14 pushl 0x14(%ebx) * 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( 10be49: a1 94 ea 12 00 mov 0x12ea94,%eax 10be4e: ff 70 14 pushl 0x14(%eax) 10be51: ff 15 20 a7 12 00 call *0x12a720 10be57: 83 c4 10 add $0x10,%esp 10be5a: 85 c0 test %eax,%eax 10be5c: 79 1e jns 10be7c <_Scheduler_EDF_Unblock+0x48> _Thread_Heir->current_priority, the_thread->current_priority )) { _Thread_Heir = the_thread; 10be5e: 89 1d 94 ea 12 00 mov %ebx,0x12ea94 if ( _Thread_Executing->is_preemptible || 10be64: a1 90 ea 12 00 mov 0x12ea90,%eax 10be69: 80 78 70 00 cmpb $0x0,0x70(%eax) 10be6d: 75 06 jne 10be75 <_Scheduler_EDF_Unblock+0x41> 10be6f: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10be73: 75 07 jne 10be7c <_Scheduler_EDF_Unblock+0x48><== ALWAYS TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10be75: c6 05 9c ea 12 00 01 movb $0x1,0x12ea9c } } 10be7c: 8b 5d fc mov -0x4(%ebp),%ebx 10be7f: c9 leave 10be80: c3 ret =============================================================================== 0010a6c0 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10a6c0: 55 push %ebp 10a6c1: 89 e5 mov %esp,%ebp 10a6c3: 53 push %ebx 10a6c4: 8b 4d 08 mov 0x8(%ebp),%ecx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10a6c7: b8 40 42 0f 00 mov $0xf4240,%eax 10a6cc: 31 d2 xor %edx,%edx 10a6ce: f7 35 6c a1 12 00 divl 0x12a16c (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; 10a6d4: 31 db xor %ebx,%ebx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10a6d6: 85 c9 test %ecx,%ecx 10a6d8: 74 4c je 10a726 <_TOD_Validate+0x66> <== NEVER TAKEN 10a6da: 39 41 18 cmp %eax,0x18(%ecx) 10a6dd: 73 47 jae 10a726 <_TOD_Validate+0x66> (the_tod->ticks >= ticks_per_second) || 10a6df: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10a6e3: 77 41 ja 10a726 <_TOD_Validate+0x66> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10a6e5: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10a6e9: 77 3b ja 10a726 <_TOD_Validate+0x66> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10a6eb: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10a6ef: 77 35 ja 10a726 <_TOD_Validate+0x66> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10a6f1: 8b 51 04 mov 0x4(%ecx),%edx 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) || 10a6f4: 85 d2 test %edx,%edx 10a6f6: 74 2e je 10a726 <_TOD_Validate+0x66> <== NEVER TAKEN (the_tod->month == 0) || 10a6f8: 83 fa 0c cmp $0xc,%edx 10a6fb: 77 29 ja 10a726 <_TOD_Validate+0x66> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10a6fd: 8b 01 mov (%ecx),%eax (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) || 10a6ff: 3d c3 07 00 00 cmp $0x7c3,%eax 10a704: 76 20 jbe 10a726 <_TOD_Validate+0x66> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10a706: 8b 49 08 mov 0x8(%ecx),%ecx (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) || 10a709: 85 c9 test %ecx,%ecx 10a70b: 74 19 je 10a726 <_TOD_Validate+0x66> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10a70d: a8 03 test $0x3,%al 10a70f: 75 09 jne 10a71a <_TOD_Validate+0x5a> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10a711: 8b 04 95 b8 07 12 00 mov 0x1207b8(,%edx,4),%eax 10a718: eb 07 jmp 10a721 <_TOD_Validate+0x61> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10a71a: 8b 04 95 84 07 12 00 mov 0x120784(,%edx,4),%eax if ( the_tod->day > days_in_month ) 10a721: 39 c1 cmp %eax,%ecx 10a723: 0f 96 c3 setbe %bl return false; return true; } 10a726: 88 d8 mov %bl,%al 10a728: 5b pop %ebx 10a729: 5d pop %ebp 10a72a: c3 ret =============================================================================== 0010b9ac <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10b9ac: 55 push %ebp 10b9ad: 89 e5 mov %esp,%ebp 10b9af: 57 push %edi 10b9b0: 56 push %esi 10b9b1: 53 push %ebx 10b9b2: 83 ec 28 sub $0x28,%esp 10b9b5: 8b 7d 08 mov 0x8(%ebp),%edi 10b9b8: 8b 5d 0c mov 0xc(%ebp),%ebx 10b9bb: 8a 45 10 mov 0x10(%ebp),%al 10b9be: 88 45 e7 mov %al,-0x19(%ebp) States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 10b9c1: 8b 77 10 mov 0x10(%edi),%esi /* * 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 ); 10b9c4: 57 push %edi 10b9c5: e8 4a 0b 00 00 call 10c514 <_Thread_Set_transient> /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 10b9ca: 83 c4 10 add $0x10,%esp 10b9cd: 39 5f 14 cmp %ebx,0x14(%edi) 10b9d0: 74 0c je 10b9de <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10b9d2: 50 push %eax 10b9d3: 50 push %eax 10b9d4: 53 push %ebx 10b9d5: 57 push %edi 10b9d6: e8 ed 0a 00 00 call 10c4c8 <_Thread_Set_priority> 10b9db: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10b9de: 9c pushf 10b9df: fa cli 10b9e0: 5b pop %ebx /* * 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; 10b9e1: 8b 47 10 mov 0x10(%edi),%eax if ( state != STATES_TRANSIENT ) { 10b9e4: 83 f8 04 cmp $0x4,%eax 10b9e7: 74 2b je 10ba14 <_Thread_Change_priority+0x68> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10b9e9: 83 e6 04 and $0x4,%esi 10b9ec: 75 08 jne 10b9f6 <_Thread_Change_priority+0x4a><== NEVER TAKEN RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 10b9ee: 89 c2 mov %eax,%edx 10b9f0: 83 e2 fb and $0xfffffffb,%edx 10b9f3: 89 57 10 mov %edx,0x10(%edi) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10b9f6: 53 push %ebx 10b9f7: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10b9f8: a9 e0 be 03 00 test $0x3bee0,%eax 10b9fd: 74 65 je 10ba64 <_Thread_Change_priority+0xb8> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10b9ff: 89 7d 0c mov %edi,0xc(%ebp) 10ba02: 8b 47 44 mov 0x44(%edi),%eax 10ba05: 89 45 08 mov %eax,0x8(%ebp) if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10ba08: 8d 65 f4 lea -0xc(%ebp),%esp 10ba0b: 5b pop %ebx 10ba0c: 5e pop %esi 10ba0d: 5f pop %edi 10ba0e: 5d pop %ebp /* 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 ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10ba0f: e9 24 0a 00 00 jmp 10c438 <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10ba14: 83 e6 04 and $0x4,%esi 10ba17: 75 26 jne 10ba3f <_Thread_Change_priority+0x93><== NEVER TAKEN * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * 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 ); 10ba19: c7 47 10 00 00 00 00 movl $0x0,0x10(%edi) if ( prepend_it ) 10ba20: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10ba24: 74 0c je 10ba32 <_Thread_Change_priority+0x86> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 10ba26: 83 ec 0c sub $0xc,%esp 10ba29: 57 push %edi 10ba2a: ff 15 58 82 12 00 call *0x128258 10ba30: eb 0a jmp 10ba3c <_Thread_Change_priority+0x90> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 10ba32: 83 ec 0c sub $0xc,%esp 10ba35: 57 push %edi 10ba36: ff 15 54 82 12 00 call *0x128254 10ba3c: 83 c4 10 add $0x10,%esp _Scheduler_Enqueue_first( the_thread ); else _Scheduler_Enqueue( the_thread ); } _ISR_Flash( level ); 10ba3f: 53 push %ebx 10ba40: 9d popf 10ba41: fa cli * 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(); 10ba42: ff 15 38 82 12 00 call *0x128238 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10ba48: a1 68 c5 12 00 mov 0x12c568,%eax * 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() && 10ba4d: 3b 05 6c c5 12 00 cmp 0x12c56c,%eax 10ba53: 74 0d je 10ba62 <_Thread_Change_priority+0xb6> 10ba55: 80 78 70 00 cmpb $0x0,0x70(%eax) 10ba59: 74 07 je 10ba62 <_Thread_Change_priority+0xb6> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10ba5b: c6 05 74 c5 12 00 01 movb $0x1,0x12c574 _ISR_Enable( level ); 10ba62: 53 push %ebx 10ba63: 9d popf } 10ba64: 8d 65 f4 lea -0xc(%ebp),%esp 10ba67: 5b pop %ebx 10ba68: 5e pop %esi 10ba69: 5f pop %edi 10ba6a: 5d pop %ebp 10ba6b: c3 ret =============================================================================== 0010bc20 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10bc20: 55 push %ebp 10bc21: 89 e5 mov %esp,%ebp 10bc23: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10bc26: 8d 45 f4 lea -0xc(%ebp),%eax 10bc29: 50 push %eax 10bc2a: ff 75 08 pushl 0x8(%ebp) 10bc2d: e8 8a 01 00 00 call 10bdbc <_Thread_Get> switch ( location ) { 10bc32: 83 c4 10 add $0x10,%esp 10bc35: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bc39: 75 20 jne 10bc5b <_Thread_Delay_ended+0x3b><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10bc3b: 52 push %edx 10bc3c: 52 push %edx 10bc3d: 68 18 00 00 10 push $0x10000018 10bc42: 50 push %eax 10bc43: e8 24 fe ff ff call 10ba6c <_Thread_Clear_state> * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 10bc48: a1 6c c3 12 00 mov 0x12c36c,%eax 10bc4d: 48 dec %eax 10bc4e: a3 6c c3 12 00 mov %eax,0x12c36c return _Thread_Dispatch_disable_level; 10bc53: a1 6c c3 12 00 mov 0x12c36c,%eax 10bc58: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10bc5b: c9 leave 10bc5c: c3 ret =============================================================================== 0010bc60 <_Thread_Dispatch>: * INTERRUPT LATENCY: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10bc60: 55 push %ebp 10bc61: 89 e5 mov %esp,%ebp 10bc63: 57 push %edi 10bc64: 56 push %esi 10bc65: 53 push %ebx 10bc66: 83 ec 1c sub $0x1c,%esp * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10bc69: a1 6c c3 12 00 mov 0x12c36c,%eax 10bc6e: 40 inc %eax 10bc6f: a3 6c c3 12 00 mov %eax,0x12c36c return _Thread_Dispatch_disable_level; 10bc74: a1 6c c3 12 00 mov 0x12c36c,%eax void _Thread_Disable_dispatch( void ); #else RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void ) { _Thread_Dispatch_increment_disable_level(); RTEMS_COMPILER_MEMORY_BARRIER(); 10bc79: e9 f9 00 00 00 jmp 10bd77 <_Thread_Dispatch+0x117> */ executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { heir = _Thread_Heir; 10bc7e: 8b 35 6c c5 12 00 mov 0x12c56c,%esi _Thread_Dispatch_necessary = false; 10bc84: c6 05 74 c5 12 00 00 movb $0x0,0x12c574 _Thread_Executing = heir; 10bc8b: 89 35 68 c5 12 00 mov %esi,0x12c568 /* * 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 ) 10bc91: 39 fe cmp %edi,%esi 10bc93: 75 1c jne 10bcb1 <_Thread_Dispatch+0x51> _ISR_Disable( level ); } post_switch: _ISR_Enable( level ); 10bc95: 50 push %eax 10bc96: 9d popf * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 10bc97: a1 6c c3 12 00 mov 0x12c36c,%eax 10bc9c: 48 dec %eax 10bc9d: a3 6c c3 12 00 mov %eax,0x12c36c return _Thread_Dispatch_disable_level; 10bca2: a1 6c c3 12 00 mov 0x12c36c,%eax _Thread_Unnest_dispatch(); _API_extensions_Run_postswitch(); 10bca7: e8 5d e8 ff ff call 10a509 <_API_extensions_Run_postswitch> 10bcac: e9 e2 00 00 00 jmp 10bd93 <_Thread_Dispatch+0x133> */ #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 ) 10bcb1: 83 7e 78 01 cmpl $0x1,0x78(%esi) 10bcb5: 75 09 jne 10bcc0 <_Thread_Dispatch+0x60> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10bcb7: 8b 15 40 c3 12 00 mov 0x12c340,%edx 10bcbd: 89 56 74 mov %edx,0x74(%esi) _ISR_Enable( level ); 10bcc0: 50 push %eax 10bcc1: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10bcc2: 83 ec 0c sub $0xc,%esp 10bcc5: 8d 45 e0 lea -0x20(%ebp),%eax 10bcc8: 50 push %eax 10bcc9: e8 0a 2c 00 00 call 10e8d8 <_TOD_Get_uptime> _Timestamp_Subtract( 10bcce: 8b 45 e0 mov -0x20(%ebp),%eax 10bcd1: 8b 55 e4 mov -0x1c(%ebp),%edx const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 10bcd4: 89 c1 mov %eax,%ecx 10bcd6: 89 d3 mov %edx,%ebx 10bcd8: 2b 0d 78 c5 12 00 sub 0x12c578,%ecx 10bcde: 1b 1d 7c c5 12 00 sbb 0x12c57c,%ebx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 10bce4: 01 8f 80 00 00 00 add %ecx,0x80(%edi) 10bcea: 11 9f 84 00 00 00 adc %ebx,0x84(%edi) &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); _Thread_Time_of_last_context_switch = uptime; 10bcf0: a3 78 c5 12 00 mov %eax,0x12c578 10bcf5: 89 15 7c c5 12 00 mov %edx,0x12c57c #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10bcfb: a1 e4 c3 12 00 mov 0x12c3e4,%eax 10bd00: 83 c4 10 add $0x10,%esp 10bd03: 85 c0 test %eax,%eax 10bd05: 74 10 je 10bd17 <_Thread_Dispatch+0xb7> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10bd07: 8b 10 mov (%eax),%edx 10bd09: 89 97 dc 00 00 00 mov %edx,0xdc(%edi) *_Thread_libc_reent = heir->libc_reent; 10bd0f: 8b 96 dc 00 00 00 mov 0xdc(%esi),%edx 10bd15: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10bd17: 50 push %eax 10bd18: 50 push %eax 10bd19: 56 push %esi 10bd1a: 57 push %edi 10bd1b: e8 14 0b 00 00 call 10c834 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10bd20: 5a pop %edx 10bd21: 59 pop %ecx 10bd22: 8d 86 c0 00 00 00 lea 0xc0(%esi),%eax 10bd28: 50 push %eax 10bd29: 8d 87 c0 00 00 00 lea 0xc0(%edi),%eax 10bd2f: 50 push %eax 10bd30: e8 cb 0d 00 00 call 10cb00 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10bd35: 83 c4 10 add $0x10,%esp 10bd38: 83 bf d8 00 00 00 00 cmpl $0x0,0xd8(%edi) 10bd3f: 74 36 je 10bd77 <_Thread_Dispatch+0x117> #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 ); 10bd41: a1 e0 c3 12 00 mov 0x12c3e0,%eax 10bd46: 39 c7 cmp %eax,%edi 10bd48: 74 2d je 10bd77 <_Thread_Dispatch+0x117> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10bd4a: 85 c0 test %eax,%eax 10bd4c: 74 11 je 10bd5f <_Thread_Dispatch+0xff> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10bd4e: 83 ec 0c sub $0xc,%esp 10bd51: 05 d8 00 00 00 add $0xd8,%eax 10bd56: 50 push %eax 10bd57: e8 d8 0d 00 00 call 10cb34 <_CPU_Context_save_fp> 10bd5c: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10bd5f: 83 ec 0c sub $0xc,%esp 10bd62: 8d 87 d8 00 00 00 lea 0xd8(%edi),%eax 10bd68: 50 push %eax 10bd69: e8 d0 0d 00 00 call 10cb3e <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10bd6e: 89 3d e0 c3 12 00 mov %edi,0x12c3e0 10bd74: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10bd77: 8b 3d 68 c5 12 00 mov 0x12c568,%edi _ISR_Disable( level ); 10bd7d: 9c pushf 10bd7e: fa cli 10bd7f: 58 pop %eax /* * Now determine if we need to perform a dispatch on the current CPU. */ executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10bd80: 8a 15 74 c5 12 00 mov 0x12c574,%dl 10bd86: 84 d2 test %dl,%dl 10bd88: 0f 85 f0 fe ff ff jne 10bc7e <_Thread_Dispatch+0x1e> 10bd8e: e9 02 ff ff ff jmp 10bc95 <_Thread_Dispatch+0x35> _ISR_Enable( level ); _Thread_Unnest_dispatch(); _API_extensions_Run_postswitch(); } 10bd93: 8d 65 f4 lea -0xc(%ebp),%esp 10bd96: 5b pop %ebx 10bd97: 5e pop %esi 10bd98: 5f pop %edi 10bd99: 5d pop %ebp 10bd9a: c3 ret =============================================================================== 00110088 <_Thread_Handler>: * Input parameters: NONE * * Output parameters: NONE */ void _Thread_Handler( void ) { 110088: 55 push %ebp 110089: 89 e5 mov %esp,%ebp 11008b: 53 push %ebx 11008c: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static bool doneConstructors; bool doCons; #endif executing = _Thread_Executing; 11008f: 8b 1d 68 c5 12 00 mov 0x12c568,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110095: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax _ISR_Set_level(level); 11009b: 85 c0 test %eax,%eax 11009d: 74 03 je 1100a2 <_Thread_Handler+0x1a> 11009f: fa cli 1100a0: eb 01 jmp 1100a3 <_Thread_Handler+0x1b> 1100a2: fb sti doCons = !doneConstructors && _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API; if (doCons) doneConstructors = true; #else doCons = !doneConstructors; 1100a3: a0 58 c0 12 00 mov 0x12c058,%al 1100a8: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = true; 1100ab: c6 05 58 c0 12 00 01 movb $0x1,0x12c058 #endif #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 1100b2: 83 bb d8 00 00 00 00 cmpl $0x0,0xd8(%ebx) 1100b9: 74 24 je 1100df <_Thread_Handler+0x57> #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 ); 1100bb: a1 e0 c3 12 00 mov 0x12c3e0,%eax 1100c0: 39 c3 cmp %eax,%ebx 1100c2: 74 1b je 1100df <_Thread_Handler+0x57> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 1100c4: 85 c0 test %eax,%eax 1100c6: 74 11 je 1100d9 <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 1100c8: 83 ec 0c sub $0xc,%esp 1100cb: 05 d8 00 00 00 add $0xd8,%eax 1100d0: 50 push %eax 1100d1: e8 5e ca ff ff call 10cb34 <_CPU_Context_save_fp> 1100d6: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 1100d9: 89 1d e0 c3 12 00 mov %ebx,0x12c3e0 /* * 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 ); 1100df: 83 ec 0c sub $0xc,%esp 1100e2: 53 push %ebx 1100e3: e8 10 c6 ff ff call 10c6f8 <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 1100e8: e8 af bc ff ff call 10bd9c <_Thread_Enable_dispatch> /* * _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) */ { 1100ed: 83 c4 10 add $0x10,%esp 1100f0: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 1100f4: 75 05 jne 1100fb <_Thread_Handler+0x73> INIT_NAME (); 1100f6: e8 45 cc 00 00 call 11cd40 <__start_set_sysctl_set> _Thread_Enable_dispatch(); #endif } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 1100fb: 83 bb 90 00 00 00 00 cmpl $0x0,0x90(%ebx) 110102: 75 15 jne 110119 <_Thread_Handler+0x91> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 110104: 83 ec 0c sub $0xc,%esp 110107: ff b3 98 00 00 00 pushl 0x98(%ebx) 11010d: ff 93 8c 00 00 00 call *0x8c(%ebx) #endif } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { executing->Wait.return_argument = 110113: 89 43 28 mov %eax,0x28(%ebx) 110116: 83 c4 10 add $0x10,%esp * 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 ); 110119: 83 ec 0c sub $0xc,%esp 11011c: 53 push %ebx 11011d: e8 04 c6 ff ff call 10c726 <_User_extensions_Thread_exitted> _Internal_error_Occurred( 110122: 83 c4 0c add $0xc,%esp 110125: 6a 05 push $0x5 110127: 6a 01 push $0x1 110129: 6a 00 push $0x0 11012b: e8 50 ac ff ff call 10ad80 <_Internal_error_Occurred> =============================================================================== 0010c040 <_Thread_Handler_initialization>: * * Output parameters: NONE */ void _Thread_Handler_initialization(void) { 10c040: 55 push %ebp 10c041: 89 e5 mov %esp,%ebp 10c043: 56 push %esi 10c044: 53 push %ebx uint32_t ticks_per_timeslice = 10c045: 8b 1d 54 81 12 00 mov 0x128154,%ebx rtems_configuration_get_ticks_per_timeslice(); uint32_t maximum_extensions = 10c04b: 8b 35 48 81 12 00 mov 0x128148,%esi rtems_configuration_get_maximum_extensions(); rtems_stack_allocate_init_hook stack_allocate_init_hook = 10c051: a1 64 81 12 00 mov 0x128164,%eax #if defined(RTEMS_MULTIPROCESSING) uint32_t maximum_proxies = _Configuration_MP_table->maximum_proxies; #endif if ( rtems_configuration_get_stack_allocate_hook() == NULL || 10c056: 83 3d 68 81 12 00 00 cmpl $0x0,0x128168 10c05d: 74 09 je 10c068 <_Thread_Handler_initialization+0x28> 10c05f: 83 3d 6c 81 12 00 00 cmpl $0x0,0x12816c 10c066: 75 0c jne 10c074 <_Thread_Handler_initialization+0x34><== ALWAYS TAKEN rtems_configuration_get_stack_free_hook() == NULL) _Internal_error_Occurred( 10c068: 52 push %edx 10c069: 6a 0e push $0xe 10c06b: 6a 01 push $0x1 10c06d: 6a 00 push $0x0 10c06f: e8 0c ed ff ff call 10ad80 <_Internal_error_Occurred> INTERNAL_ERROR_CORE, true, INTERNAL_ERROR_BAD_STACK_HOOK ); if ( stack_allocate_init_hook != NULL ) 10c074: 85 c0 test %eax,%eax 10c076: 74 0e je 10c086 <_Thread_Handler_initialization+0x46> (*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() ); 10c078: 83 ec 0c sub $0xc,%esp 10c07b: ff 35 44 81 12 00 pushl 0x128144 10c081: ff d0 call *%eax 10c083: 83 c4 10 add $0x10,%esp _Thread_Dispatch_necessary = false; 10c086: c6 05 74 c5 12 00 00 movb $0x0,0x12c574 _Thread_Executing = NULL; 10c08d: c7 05 68 c5 12 00 00 movl $0x0,0x12c568 10c094: 00 00 00 _Thread_Heir = NULL; 10c097: c7 05 6c c5 12 00 00 movl $0x0,0x12c56c 10c09e: 00 00 00 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10c0a1: c7 05 e0 c3 12 00 00 movl $0x0,0x12c3e0 10c0a8: 00 00 00 #endif _Thread_Maximum_extensions = maximum_extensions; 10c0ab: 89 35 e8 c3 12 00 mov %esi,0x12c3e8 _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10c0b1: 89 1d 40 c3 12 00 mov %ebx,0x12c340 #if defined(RTEMS_MULTIPROCESSING) if ( _System_state_Is_multiprocessing ) maximum_internal_threads += 1; #endif _Objects_Initialize_information( 10c0b7: 50 push %eax 10c0b8: 6a 08 push $0x8 10c0ba: 6a 00 push $0x0 10c0bc: 68 f0 00 00 00 push $0xf0 10c0c1: 6a 01 push $0x1 10c0c3: 6a 01 push $0x1 10c0c5: 6a 01 push $0x1 10c0c7: 68 68 c4 12 00 push $0x12c468 10c0cc: e8 ab f1 ff ff call 10b27c <_Objects_Initialize_information> 10c0d1: 83 c4 20 add $0x20,%esp false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10c0d4: 8d 65 f8 lea -0x8(%ebp),%esp 10c0d7: 5b pop %ebx 10c0d8: 5e pop %esi 10c0d9: 5d pop %ebp 10c0da: c3 ret =============================================================================== 0010be3c <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10be3c: 55 push %ebp 10be3d: 89 e5 mov %esp,%ebp 10be3f: 57 push %edi 10be40: 56 push %esi 10be41: 53 push %ebx 10be42: 83 ec 24 sub $0x24,%esp 10be45: 8b 5d 0c mov 0xc(%ebp),%ebx 10be48: 8b 75 14 mov 0x14(%ebp),%esi 10be4b: 8a 55 18 mov 0x18(%ebp),%dl 10be4e: 8a 45 20 mov 0x20(%ebp),%al 10be51: 88 45 e7 mov %al,-0x19(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10be54: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 10be5b: 00 00 00 10be5e: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10be65: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10be68: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) 10be6f: 00 00 00 /* * Allocate and Initialize the stack for this thread. */ #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10be72: 56 push %esi 10be73: 53 push %ebx 10be74: 88 55 e0 mov %dl,-0x20(%ebp) 10be77: e8 c8 06 00 00 call 10c544 <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10be7c: 83 c4 10 add $0x10,%esp 10be7f: 39 f0 cmp %esi,%eax 10be81: 8a 55 e0 mov -0x20(%ebp),%dl 10be84: 0f 82 a7 01 00 00 jb 10c031 <_Thread_Initialize+0x1f5> 10be8a: 85 c0 test %eax,%eax 10be8c: 0f 84 9f 01 00 00 je 10c031 <_Thread_Initialize+0x1f5><== NEVER TAKEN Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10be92: 8b 8b bc 00 00 00 mov 0xbc(%ebx),%ecx 10be98: 89 8b b4 00 00 00 mov %ecx,0xb4(%ebx) the_stack->size = size; 10be9e: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) extensions_area = NULL; the_thread->libc_reent = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) fp_area = NULL; 10bea4: 31 f6 xor %esi,%esi /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10bea6: 84 d2 test %dl,%dl 10bea8: 74 17 je 10bec1 <_Thread_Initialize+0x85> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10beaa: 83 ec 0c sub $0xc,%esp 10bead: 6a 6c push $0x6c 10beaf: e8 ec 0b 00 00 call 10caa0 <_Workspace_Allocate> 10beb4: 89 c6 mov %eax,%esi if ( !fp_area ) 10beb6: 83 c4 10 add $0x10,%esp 10beb9: 85 c0 test %eax,%eax 10bebb: 0f 84 1d 01 00 00 je 10bfde <_Thread_Initialize+0x1a2><== NEVER TAKEN goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10bec1: 89 b3 d8 00 00 00 mov %esi,0xd8(%ebx) the_thread->Start.fp_context = fp_area; 10bec7: 89 b3 b8 00 00 00 mov %esi,0xb8(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10becd: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10bed4: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10bedb: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10bee2: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10bee9: a1 e8 c3 12 00 mov 0x12c3e8,%eax * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10beee: 31 ff xor %edi,%edi #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10bef0: 85 c0 test %eax,%eax 10bef2: 74 1d je 10bf11 <_Thread_Initialize+0xd5> extensions_area = _Workspace_Allocate( 10bef4: 83 ec 0c sub $0xc,%esp 10bef7: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10befe: 50 push %eax 10beff: e8 9c 0b 00 00 call 10caa0 <_Workspace_Allocate> 10bf04: 89 c7 mov %eax,%edi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10bf06: 83 c4 10 add $0x10,%esp 10bf09: 85 c0 test %eax,%eax 10bf0b: 0f 84 cf 00 00 00 je 10bfe0 <_Thread_Initialize+0x1a4><== NEVER TAKEN goto failed; } the_thread->extensions = (void **) extensions_area; 10bf11: 89 bb e8 00 00 00 mov %edi,0xe8(%ebx) * if they are linked to the thread. An extension user may * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { 10bf17: 85 ff test %edi,%edi 10bf19: 75 5a jne 10bf75 <_Thread_Initialize+0x139> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10bf1b: 8a 45 e7 mov -0x19(%ebp),%al 10bf1e: 88 83 9c 00 00 00 mov %al,0x9c(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10bf24: 8b 45 24 mov 0x24(%ebp),%eax 10bf27: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) the_thread->Start.budget_callout = budget_callout; 10bf2d: 8b 45 28 mov 0x28(%ebp),%eax 10bf30: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10bf36: 8b 45 2c mov 0x2c(%ebp),%eax 10bf39: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) the_thread->current_state = STATES_DORMANT; 10bf3f: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10bf46: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10bf4d: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10bf54: 8b 45 1c mov 0x1c(%ebp),%eax 10bf57: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10bf5a: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) */ RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate( Thread_Control *the_thread ) { return _Scheduler.Operations.allocate( the_thread ); 10bf60: 83 ec 0c sub $0xc,%esp 10bf63: 53 push %ebx 10bf64: ff 15 48 82 12 00 call *0x128248 10bf6a: 89 c2 mov %eax,%edx sched =_Scheduler_Allocate( the_thread ); if ( !sched ) 10bf6c: 83 c4 10 add $0x10,%esp 10bf6f: 85 c0 test %eax,%eax 10bf71: 75 20 jne 10bf93 <_Thread_Initialize+0x157> 10bf73: eb 6d jmp 10bfe2 <_Thread_Initialize+0x1a6> * 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++ ) 10bf75: 8b 0d e8 c3 12 00 mov 0x12c3e8,%ecx 10bf7b: 31 c0 xor %eax,%eax 10bf7d: eb 0e jmp 10bf8d <_Thread_Initialize+0x151> the_thread->extensions[i] = NULL; 10bf7f: 8b 93 e8 00 00 00 mov 0xe8(%ebx),%edx 10bf85: c7 04 82 00 00 00 00 movl $0x0,(%edx,%eax,4) * 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++ ) 10bf8c: 40 inc %eax 10bf8d: 39 c8 cmp %ecx,%eax 10bf8f: 76 ee jbe 10bf7f <_Thread_Initialize+0x143> 10bf91: eb 88 jmp 10bf1b <_Thread_Initialize+0xdf> the_thread->real_priority = priority; the_thread->Start.initial_priority = priority; sched =_Scheduler_Allocate( the_thread ); if ( !sched ) goto failed; _Thread_Set_priority( the_thread, priority ); 10bf93: 51 push %ecx 10bf94: 51 push %ecx 10bf95: ff 75 1c pushl 0x1c(%ebp) 10bf98: 53 push %ebx 10bf99: 89 45 e0 mov %eax,-0x20(%ebp) 10bf9c: e8 27 05 00 00 call 10c4c8 <_Thread_Set_priority> static inline void _Timestamp64_implementation_Set_to_zero( Timestamp64_Control *_time ) { *_time = 0; 10bfa1: c7 83 80 00 00 00 00 movl $0x0,0x80(%ebx) 10bfa8: 00 00 00 10bfab: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10bfb2: 00 00 00 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10bfb5: 0f b7 4b 08 movzwl 0x8(%ebx),%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10bfb9: 8b 45 08 mov 0x8(%ebp),%eax 10bfbc: 8b 40 1c mov 0x1c(%eax),%eax 10bfbf: 89 1c 88 mov %ebx,(%eax,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10bfc2: 8b 45 30 mov 0x30(%ebp),%eax 10bfc5: 89 43 0c mov %eax,0xc(%ebx) * 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 ); 10bfc8: 89 1c 24 mov %ebx,(%esp) 10bfcb: e8 bc 07 00 00 call 10c78c <_User_extensions_Thread_create> if ( extension_status ) 10bfd0: 83 c4 10 add $0x10,%esp return true; 10bfd3: b1 01 mov $0x1,%cl * 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 ); if ( extension_status ) 10bfd5: 84 c0 test %al,%al 10bfd7: 8b 55 e0 mov -0x20(%ebp),%edx 10bfda: 74 06 je 10bfe2 <_Thread_Initialize+0x1a6> 10bfdc: eb 55 jmp 10c033 <_Thread_Initialize+0x1f7> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10bfde: 31 ff xor %edi,%edi 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; 10bfe0: 31 d2 xor %edx,%edx extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; failed: _Workspace_Free( the_thread->libc_reent ); 10bfe2: 83 ec 0c sub $0xc,%esp 10bfe5: ff b3 dc 00 00 00 pushl 0xdc(%ebx) 10bfeb: 89 55 e0 mov %edx,-0x20(%ebp) 10bfee: e8 c6 0a 00 00 call 10cab9 <_Workspace_Free> for ( i=0 ; i <= THREAD_API_LAST ; i++ ) _Workspace_Free( the_thread->API_Extensions[i] ); 10bff3: 58 pop %eax 10bff4: ff b3 e0 00 00 00 pushl 0xe0(%ebx) 10bffa: e8 ba 0a 00 00 call 10cab9 <_Workspace_Free> 10bfff: 5a pop %edx 10c000: ff b3 e4 00 00 00 pushl 0xe4(%ebx) 10c006: e8 ae 0a 00 00 call 10cab9 <_Workspace_Free> _Workspace_Free( extensions_area ); 10c00b: 89 3c 24 mov %edi,(%esp) 10c00e: e8 a6 0a 00 00 call 10cab9 <_Workspace_Free> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 10c013: 89 34 24 mov %esi,(%esp) 10c016: e8 9e 0a 00 00 call 10cab9 <_Workspace_Free> #endif _Workspace_Free( sched ); 10c01b: 8b 55 e0 mov -0x20(%ebp),%edx 10c01e: 89 14 24 mov %edx,(%esp) 10c021: e8 93 0a 00 00 call 10cab9 <_Workspace_Free> _Thread_Stack_Free( the_thread ); 10c026: 89 1c 24 mov %ebx,(%esp) 10c029: e8 52 05 00 00 call 10c580 <_Thread_Stack_Free> return false; 10c02e: 83 c4 10 add $0x10,%esp * Allocate and Initialize the stack for this thread. */ #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ 10c031: 31 c9 xor %ecx,%ecx _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10c033: 88 c8 mov %cl,%al 10c035: 8d 65 f4 lea -0xc(%ebp),%esp 10c038: 5b pop %ebx 10c039: 5e pop %esi 10c03a: 5f pop %edi 10c03b: 5d pop %ebp 10c03c: c3 ret =============================================================================== 0010c260 <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10c260: 55 push %ebp 10c261: 89 e5 mov %esp,%ebp 10c263: 57 push %edi 10c264: 56 push %esi 10c265: 53 push %ebx 10c266: 83 ec 14 sub $0x14,%esp 10c269: 8b 4d 08 mov 0x8(%ebp),%ecx 10c26c: 8b 45 0c mov 0xc(%ebp),%eax 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 ); 10c26f: 8d 50 38 lea 0x38(%eax),%edx 10c272: 8d 58 3c lea 0x3c(%eax),%ebx 10c275: 89 58 38 mov %ebx,0x38(%eax) head->next = tail; head->previous = NULL; 10c278: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10c27f: 89 50 40 mov %edx,0x40(%eax) Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10c282: 8b 50 14 mov 0x14(%eax),%edx 10c285: 89 55 f0 mov %edx,-0x10(%ebp) RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 10c288: 89 d6 mov %edx,%esi 10c28a: c1 ee 06 shr $0x6,%esi header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10c28d: 6b f6 0c imul $0xc,%esi,%esi 10c290: 01 ce add %ecx,%esi block_state = the_thread_queue->state; 10c292: 8b 59 38 mov 0x38(%ecx),%ebx 10c295: 89 5d e8 mov %ebx,-0x18(%ebp) if ( _Thread_queue_Is_reverse_search( priority ) ) 10c298: 80 e2 20 and $0x20,%dl 10c29b: 75 66 jne 10c303 <_Thread_queue_Enqueue_priority+0xa3> 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 )); 10c29d: 8d 56 04 lea 0x4(%esi),%edx 10c2a0: 89 55 e4 mov %edx,-0x1c(%ebp) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10c2a3: 9c pushf 10c2a4: fa cli 10c2a5: 8f 45 e0 popl -0x20(%ebp) 10c2a8: 8b 5d e0 mov -0x20(%ebp),%ebx 10c2ab: 89 5d ec mov %ebx,-0x14(%ebp) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10c2ae: 8b 16 mov (%esi),%edx if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; 10c2b0: 83 cf ff or $0xffffffff,%edi _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c2b3: eb 1d jmp 10c2d2 <_Thread_queue_Enqueue_priority+0x72> search_priority = search_thread->current_priority; 10c2b5: 8b 7a 14 mov 0x14(%edx),%edi if ( priority <= search_priority ) 10c2b8: 39 7d f0 cmp %edi,-0x10(%ebp) 10c2bb: 76 1a jbe 10c2d7 <_Thread_queue_Enqueue_priority+0x77> break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c2bd: ff 75 e0 pushl -0x20(%ebp) 10c2c0: 9d popf 10c2c1: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c2c2: 8b 5d e8 mov -0x18(%ebp),%ebx 10c2c5: 85 5a 10 test %ebx,0x10(%edx) 10c2c8: 75 06 jne 10c2d0 <_Thread_queue_Enqueue_priority+0x70><== ALWAYS TAKEN _ISR_Enable( level ); 10c2ca: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10c2cd: 9d popf <== NOT EXECUTED goto restart_forward_search; 10c2ce: eb d3 jmp 10c2a3 <_Thread_queue_Enqueue_priority+0x43><== NOT EXECUTED } search_thread = 10c2d0: 8b 12 mov (%edx),%edx restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c2d2: 3b 55 e4 cmp -0x1c(%ebp),%edx 10c2d5: 75 de jne 10c2b5 <_Thread_queue_Enqueue_priority+0x55> } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c2d7: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c2db: 0f 85 a1 00 00 00 jne 10c382 <_Thread_queue_Enqueue_priority+0x122> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c2e1: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c2e8: 39 7d f0 cmp %edi,-0x10(%ebp) 10c2eb: 74 7c je 10c369 <_Thread_queue_Enqueue_priority+0x109> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c2ed: 8b 72 04 mov 0x4(%edx),%esi the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c2f0: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c2f2: 89 70 04 mov %esi,0x4(%eax) previous_node->next = the_node; 10c2f5: 89 06 mov %eax,(%esi) search_node->previous = the_node; 10c2f7: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c2fa: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c2fd: ff 75 e0 pushl -0x20(%ebp) 10c300: 9d popf 10c301: eb 5f jmp 10c362 <_Thread_queue_Enqueue_priority+0x102> return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10c303: 0f b6 3d 88 81 12 00 movzbl 0x128188,%edi 10c30a: 47 inc %edi _ISR_Disable( level ); 10c30b: 9c pushf 10c30c: fa cli 10c30d: 8f 45 e4 popl -0x1c(%ebp) 10c310: 8b 55 e4 mov -0x1c(%ebp),%edx 10c313: 89 55 ec mov %edx,-0x14(%ebp) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 10c316: 8b 56 08 mov 0x8(%esi),%edx search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c319: eb 1e jmp 10c339 <_Thread_queue_Enqueue_priority+0xd9> search_priority = search_thread->current_priority; 10c31b: 8b 7a 14 mov 0x14(%edx),%edi if ( priority >= search_priority ) 10c31e: 39 7d f0 cmp %edi,-0x10(%ebp) 10c321: 73 1a jae 10c33d <_Thread_queue_Enqueue_priority+0xdd> break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c323: ff 75 e4 pushl -0x1c(%ebp) 10c326: 9d popf 10c327: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c328: 8b 5d e8 mov -0x18(%ebp),%ebx 10c32b: 85 5a 10 test %ebx,0x10(%edx) 10c32e: 75 06 jne 10c336 <_Thread_queue_Enqueue_priority+0xd6> _ISR_Enable( level ); 10c330: ff 75 e4 pushl -0x1c(%ebp) 10c333: 9d popf goto restart_reverse_search; 10c334: eb cd jmp 10c303 <_Thread_queue_Enqueue_priority+0xa3> } search_thread = (Thread_Control *) 10c336: 8b 52 04 mov 0x4(%edx),%edx restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c339: 39 f2 cmp %esi,%edx 10c33b: 75 de jne 10c31b <_Thread_queue_Enqueue_priority+0xbb> } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c33d: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c341: 75 3f jne 10c382 <_Thread_queue_Enqueue_priority+0x122> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c343: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c34a: 39 7d f0 cmp %edi,-0x10(%ebp) 10c34d: 74 1a je 10c369 <_Thread_queue_Enqueue_priority+0x109> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c34f: 8b 32 mov (%edx),%esi the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c351: 89 30 mov %esi,(%eax) the_node->previous = search_node; 10c353: 89 50 04 mov %edx,0x4(%eax) search_node->next = the_node; 10c356: 89 02 mov %eax,(%edx) next_node->previous = the_node; 10c358: 89 46 04 mov %eax,0x4(%esi) the_thread->Wait.queue = the_thread_queue; 10c35b: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c35e: ff 75 e4 pushl -0x1c(%ebp) 10c361: 9d popf return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c362: b8 01 00 00 00 mov $0x1,%eax 10c367: eb 24 jmp 10c38d <_Thread_queue_Enqueue_priority+0x12d> equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10c369: 8b 5a 40 mov 0x40(%edx),%ebx the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); 10c36c: 8d 72 3c lea 0x3c(%edx),%esi 10c36f: 89 30 mov %esi,(%eax) previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; 10c371: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c374: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c376: 89 42 40 mov %eax,0x40(%edx) the_thread->Wait.queue = the_thread_queue; 10c379: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c37c: ff 75 ec pushl -0x14(%ebp) 10c37f: 9d popf 10c380: eb e0 jmp 10c362 <_Thread_queue_Enqueue_priority+0x102> * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10c382: 8b 45 10 mov 0x10(%ebp),%eax 10c385: 8b 55 ec mov -0x14(%ebp),%edx 10c388: 89 10 mov %edx,(%eax) return the_thread_queue->sync_state; 10c38a: 8b 41 30 mov 0x30(%ecx),%eax } 10c38d: 83 c4 14 add $0x14,%esp 10c390: 5b pop %ebx 10c391: 5e pop %esi 10c392: 5f pop %edi 10c393: 5d pop %ebp 10c394: c3 ret =============================================================================== 0010ef54 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10ef54: 55 push %ebp 10ef55: 89 e5 mov %esp,%ebp 10ef57: 83 ec 08 sub $0x8,%esp 10ef5a: 8b 55 08 mov 0x8(%ebp),%edx Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10ef5d: 8b 42 44 mov 0x44(%edx),%eax * 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. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && 10ef60: 8b 48 30 mov 0x30(%eax),%ecx 10ef63: 85 c9 test %ecx,%ecx 10ef65: 74 1c je 10ef83 <_Thread_queue_Process_timeout+0x2f> 10ef67: 3b 15 68 c5 12 00 cmp 0x12c568,%edx 10ef6d: 75 14 jne 10ef83 <_Thread_queue_Process_timeout+0x2f><== NEVER TAKEN _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 10ef6f: 83 f9 03 cmp $0x3,%ecx 10ef72: 74 21 je 10ef95 <_Thread_queue_Process_timeout+0x41> the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10ef74: 8b 48 3c mov 0x3c(%eax),%ecx 10ef77: 89 4a 34 mov %ecx,0x34(%edx) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10ef7a: c7 40 30 02 00 00 00 movl $0x2,0x30(%eax) 10ef81: eb 12 jmp 10ef95 <_Thread_queue_Process_timeout+0x41> } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10ef83: 8b 48 3c mov 0x3c(%eax),%ecx 10ef86: 89 4a 34 mov %ecx,0x34(%edx) _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10ef89: 51 push %ecx 10ef8a: 51 push %ecx 10ef8b: 52 push %edx 10ef8c: 50 push %eax 10ef8d: e8 e2 fe ff ff call 10ee74 <_Thread_queue_Extract> 10ef92: 83 c4 10 add $0x10,%esp } } 10ef95: c9 leave 10ef96: c3 ret =============================================================================== 0010c438 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10c438: 55 push %ebp 10c439: 89 e5 mov %esp,%ebp 10c43b: 57 push %edi 10c43c: 56 push %esi 10c43d: 53 push %ebx 10c43e: 83 ec 1c sub $0x1c,%esp 10c441: 8b 5d 08 mov 0x8(%ebp),%ebx 10c444: 8b 75 0c mov 0xc(%ebp),%esi /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10c447: 85 db test %ebx,%ebx 10c449: 74 36 je 10c481 <_Thread_queue_Requeue+0x49><== NEVER TAKEN /* * 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 ) { 10c44b: 83 7b 34 01 cmpl $0x1,0x34(%ebx) 10c44f: 75 30 jne 10c481 <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10c451: 9c pushf 10c452: fa cli 10c453: 5f pop %edi if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10c454: f7 46 10 e0 be 03 00 testl $0x3bee0,0x10(%esi) 10c45b: 74 22 je 10c47f <_Thread_queue_Requeue+0x47><== NEVER TAKEN 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; 10c45d: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 10c464: 50 push %eax 10c465: 6a 01 push $0x1 10c467: 56 push %esi 10c468: 53 push %ebx 10c469: e8 36 2a 00 00 call 10eea4 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10c46e: 83 c4 0c add $0xc,%esp 10c471: 8d 45 e4 lea -0x1c(%ebp),%eax 10c474: 50 push %eax 10c475: 56 push %esi 10c476: 53 push %ebx 10c477: e8 e4 fd ff ff call 10c260 <_Thread_queue_Enqueue_priority> 10c47c: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10c47f: 57 push %edi 10c480: 9d popf } } 10c481: 8d 65 f4 lea -0xc(%ebp),%esp 10c484: 5b pop %ebx 10c485: 5e pop %esi 10c486: 5f pop %edi 10c487: 5d pop %ebp 10c488: c3 ret =============================================================================== 0010c48c <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c48c: 55 push %ebp 10c48d: 89 e5 mov %esp,%ebp 10c48f: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c492: 8d 45 f4 lea -0xc(%ebp),%eax 10c495: 50 push %eax 10c496: ff 75 08 pushl 0x8(%ebp) 10c499: e8 1e f9 ff ff call 10bdbc <_Thread_Get> switch ( location ) { 10c49e: 83 c4 10 add $0x10,%esp 10c4a1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c4a5: 75 1c jne 10c4c3 <_Thread_queue_Timeout+0x37><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10c4a7: 83 ec 0c sub $0xc,%esp 10c4aa: 50 push %eax 10c4ab: e8 a4 2a 00 00 call 10ef54 <_Thread_queue_Process_timeout> * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 10c4b0: a1 6c c3 12 00 mov 0x12c36c,%eax 10c4b5: 48 dec %eax 10c4b6: a3 6c c3 12 00 mov %eax,0x12c36c return _Thread_Dispatch_disable_level; 10c4bb: a1 6c c3 12 00 mov 0x12c36c,%eax 10c4c0: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c4c3: c9 leave 10c4c4: c3 ret =============================================================================== 00116732 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 116732: 55 push %ebp 116733: 89 e5 mov %esp,%ebp 116735: 57 push %edi 116736: 56 push %esi 116737: 53 push %ebx 116738: 83 ec 3c sub $0x3c,%esp 11673b: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 11673e: 8d 45 d0 lea -0x30(%ebp),%eax 116741: 8d 55 d4 lea -0x2c(%ebp),%edx 116744: 89 55 d0 mov %edx,-0x30(%ebp) head->previous = NULL; 116747: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 11674e: 89 45 d8 mov %eax,-0x28(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116751: 8d 75 dc lea -0x24(%ebp),%esi 116754: 8d 55 e0 lea -0x20(%ebp),%edx 116757: 89 55 dc mov %edx,-0x24(%ebp) head->previous = NULL; 11675a: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 116761: 89 75 e4 mov %esi,-0x1c(%ebp) { /* * 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; 116764: 8d 45 d0 lea -0x30(%ebp),%eax 116767: 89 43 78 mov %eax,0x78(%ebx) */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 11676a: 8d 7b 30 lea 0x30(%ebx),%edi static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 11676d: a1 10 58 14 00 mov 0x145810,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 116772: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 116775: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116778: 51 push %ecx 116779: 56 push %esi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 11677a: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 11677c: 50 push %eax 11677d: 57 push %edi 11677e: e8 d1 36 00 00 call 119e54 <_Watchdog_Adjust_to_chain> 116783: 6a 00 push $0x0 116785: 68 00 ca 9a 3b push $0x3b9aca00 11678a: ff 35 dc 56 14 00 pushl 0x1456dc 116790: ff 35 d8 56 14 00 pushl 0x1456d8 116796: e8 99 31 01 00 call 129934 <__divdi3> Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 11679b: 8b 53 74 mov 0x74(%ebx),%edx /* * 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 ) { 11679e: 83 c4 20 add $0x20,%esp 1167a1: 39 d0 cmp %edx,%eax 1167a3: 76 15 jbe 1167ba <_Timer_server_Body+0x88> /* * 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 ); 1167a5: 51 push %ecx 1167a6: 56 push %esi if ( snapshot > last_snapshot ) { /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; 1167a7: 89 c1 mov %eax,%ecx 1167a9: 29 d1 sub %edx,%ecx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1167ab: 51 push %ecx 1167ac: 8d 53 68 lea 0x68(%ebx),%edx 1167af: 52 push %edx 1167b0: 89 45 c0 mov %eax,-0x40(%ebp) 1167b3: e8 9c 36 00 00 call 119e54 <_Watchdog_Adjust_to_chain> 1167b8: eb 14 jmp 1167ce <_Timer_server_Body+0x9c> } else if ( snapshot < last_snapshot ) { 1167ba: 73 18 jae 1167d4 <_Timer_server_Body+0xa2> /* * 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 ); 1167bc: 51 push %ecx } else if ( snapshot < last_snapshot ) { /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; 1167bd: 29 c2 sub %eax,%edx _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 1167bf: 52 push %edx 1167c0: 6a 01 push $0x1 1167c2: 8d 53 68 lea 0x68(%ebx),%edx 1167c5: 52 push %edx 1167c6: 89 45 c0 mov %eax,-0x40(%ebp) 1167c9: e8 1e 36 00 00 call 119dec <_Watchdog_Adjust> 1167ce: 83 c4 10 add $0x10,%esp 1167d1: 8b 45 c0 mov -0x40(%ebp),%eax } watchdogs->last_snapshot = snapshot; 1167d4: 89 43 74 mov %eax,0x74(%ebx) ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 1167d7: 8d 4b 68 lea 0x68(%ebx),%ecx 1167da: 89 4d c4 mov %ecx,-0x3c(%ebp) } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 1167dd: 8b 43 78 mov 0x78(%ebx),%eax 1167e0: 83 ec 0c sub $0xc,%esp 1167e3: 50 push %eax 1167e4: e8 83 07 00 00 call 116f6c <_Chain_Get> if ( timer == NULL ) { 1167e9: 83 c4 10 add $0x10,%esp 1167ec: 85 c0 test %eax,%eax 1167ee: 74 29 je 116819 <_Timer_server_Body+0xe7><== ALWAYS TAKEN static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 1167f0: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 1167f3: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 1167f6: 75 09 jne 116801 <_Timer_server_Body+0xcf><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 1167f8: 52 push %edx <== NOT EXECUTED 1167f9: 52 push %edx <== NOT EXECUTED 1167fa: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 1167fd: 50 push %eax <== NOT EXECUTED 1167fe: 57 push %edi <== NOT EXECUTED 1167ff: eb 0e jmp 11680f <_Timer_server_Body+0xdd><== NOT EXECUTED } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116801: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 116804: 75 d7 jne 1167dd <_Timer_server_Body+0xab><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116806: 51 push %ecx <== NOT EXECUTED 116807: 51 push %ecx <== NOT EXECUTED 116808: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11680b: 50 push %eax <== NOT EXECUTED 11680c: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 11680f: e8 c4 36 00 00 call 119ed8 <_Watchdog_Insert> <== NOT EXECUTED 116814: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116817: eb c4 jmp 1167dd <_Timer_server_Body+0xab><== 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 ); 116819: 9c pushf 11681a: fa cli 11681b: 58 pop %eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 11681c: 8d 55 d4 lea -0x2c(%ebp),%edx if ( _Chain_Is_empty( insert_chain ) ) { 11681f: 39 55 d0 cmp %edx,-0x30(%ebp) 116822: 75 13 jne 116837 <_Timer_server_Body+0x105><== NEVER TAKEN ts->insert_chain = NULL; 116824: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) _ISR_Enable( level ); 11682b: 50 push %eax 11682c: 9d popf 11682d: 8d 7d e0 lea -0x20(%ebp),%edi _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 ) ) { 116830: 39 7d dc cmp %edi,-0x24(%ebp) 116833: 75 09 jne 11683e <_Timer_server_Body+0x10c> 116835: eb 39 jmp 116870 <_Timer_server_Body+0x13e> ts->insert_chain = NULL; _ISR_Enable( level ); break; } else { _ISR_Enable( level ); 116837: 50 push %eax <== NOT EXECUTED 116838: 9d popf <== NOT EXECUTED 116839: e9 2f ff ff ff jmp 11676d <_Timer_server_Body+0x3b><== NOT EXECUTED /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 11683e: 9c pushf 11683f: fa cli 116840: 5a pop %edx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 116841: 8b 45 dc mov -0x24(%ebp),%eax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 116844: 39 f8 cmp %edi,%eax 116846: 74 21 je 116869 <_Timer_server_Body+0x137> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 116848: 8b 08 mov (%eax),%ecx head->next = new_first; 11684a: 89 4d dc mov %ecx,-0x24(%ebp) new_first->previous = head; 11684d: 89 71 04 mov %esi,0x4(%ecx) watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 116850: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 116857: 52 push %edx 116858: 9d popf /* * 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 ); 116859: 52 push %edx 11685a: 52 push %edx 11685b: ff 70 24 pushl 0x24(%eax) 11685e: ff 70 20 pushl 0x20(%eax) 116861: ff 50 1c call *0x1c(%eax) } 116864: 83 c4 10 add $0x10,%esp 116867: eb d5 jmp 11683e <_Timer_server_Body+0x10c> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 116869: 52 push %edx 11686a: 9d popf 11686b: e9 f4 fe ff ff jmp 116764 <_Timer_server_Body+0x32> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 116870: c6 43 7c 00 movb $0x0,0x7c(%ebx) 116874: e8 ef fc ff ff call 116568 <_Thread_Dispatch_increment_disable_level> /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 116879: 57 push %edi 11687a: 57 push %edi 11687b: 6a 08 push $0x8 11687d: ff 33 pushl (%ebx) 11687f: e8 b0 31 00 00 call 119a34 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 116884: 89 d8 mov %ebx,%eax 116886: e8 f2 fc ff ff call 11657d <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 11688b: 89 d8 mov %ebx,%eax 11688d: e8 31 fd ff ff call 1165c3 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 116892: e8 dd 29 00 00 call 119274 <_Thread_Enable_dispatch> ts->active = true; 116897: c6 43 7c 01 movb $0x1,0x7c(%ebx) static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 11689b: 8d 43 08 lea 0x8(%ebx),%eax 11689e: 89 04 24 mov %eax,(%esp) 1168a1: e8 46 37 00 00 call 119fec <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 1168a6: 8d 43 40 lea 0x40(%ebx),%eax 1168a9: 89 04 24 mov %eax,(%esp) 1168ac: e8 3b 37 00 00 call 119fec <_Watchdog_Remove> 1168b1: 83 c4 10 add $0x10,%esp 1168b4: e9 ab fe ff ff jmp 116764 <_Timer_server_Body+0x32> =============================================================================== 00116609 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 116609: 55 push %ebp 11660a: 89 e5 mov %esp,%ebp 11660c: 57 push %edi 11660d: 56 push %esi 11660e: 53 push %ebx 11660f: 83 ec 1c sub $0x1c,%esp 116612: 8b 5d 08 mov 0x8(%ebp),%ebx 116615: 8b 7d 0c mov 0xc(%ebp),%edi if ( ts->insert_chain == NULL ) { 116618: 8b 43 78 mov 0x78(%ebx),%eax 11661b: 85 c0 test %eax,%eax 11661d: 0f 85 fa 00 00 00 jne 11671d <_Timer_server_Schedule_operation_method+0x114><== NEVER TAKEN #if defined ( __THREAD_DO_NOT_INLINE_DISABLE_DISPATCH__ ) void _Thread_Disable_dispatch( void ); #else RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void ) { _Thread_Dispatch_increment_disable_level(); 116623: e8 40 ff ff ff call 116568 <_Thread_Dispatch_increment_disable_level> * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116628: 8b 47 38 mov 0x38(%edi),%eax 11662b: 83 f8 01 cmp $0x1,%eax 11662e: 75 61 jne 116691 <_Timer_server_Schedule_operation_method+0x88> /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 116630: 9c pushf 116631: fa cli 116632: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116635: 8b 15 10 58 14 00 mov 0x145810,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 11663b: 8b 4b 3c mov 0x3c(%ebx),%ecx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 11663e: 8b 43 30 mov 0x30(%ebx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 116641: 8d 73 34 lea 0x34(%ebx),%esi if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 116644: 39 f0 cmp %esi,%eax 116646: 74 19 je 116661 <_Timer_server_Schedule_operation_method+0x58> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116648: 89 d6 mov %edx,%esi 11664a: 29 ce sub %ecx,%esi 11664c: 89 75 e4 mov %esi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 11664f: 8b 70 10 mov 0x10(%eax),%esi if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116652: 31 c9 xor %ecx,%ecx * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { 116654: 3b 75 e4 cmp -0x1c(%ebp),%esi 116657: 76 05 jbe 11665e <_Timer_server_Schedule_operation_method+0x55> delta_interval -= delta; 116659: 89 f1 mov %esi,%ecx 11665b: 2b 4d e4 sub -0x1c(%ebp),%ecx } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 11665e: 89 48 10 mov %ecx,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 116661: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 116664: ff 75 e0 pushl -0x20(%ebp) 116667: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116668: 56 push %esi 116669: 56 push %esi 11666a: 8d 47 10 lea 0x10(%edi),%eax 11666d: 50 push %eax 11666e: 8d 43 30 lea 0x30(%ebx),%eax 116671: 50 push %eax 116672: e8 61 38 00 00 call 119ed8 <_Watchdog_Insert> if ( !ts->active ) { 116677: 8a 43 7c mov 0x7c(%ebx),%al 11667a: 83 c4 10 add $0x10,%esp 11667d: 84 c0 test %al,%al 11667f: 0f 85 8c 00 00 00 jne 116711 <_Timer_server_Schedule_operation_method+0x108> _Timer_server_Reset_interval_system_watchdog( ts ); 116685: 89 d8 mov %ebx,%eax 116687: e8 f1 fe ff ff call 11657d <_Timer_server_Reset_interval_system_watchdog> 11668c: e9 80 00 00 00 jmp 116711 <_Timer_server_Schedule_operation_method+0x108> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116691: 83 f8 03 cmp $0x3,%eax 116694: 75 7b jne 116711 <_Timer_server_Schedule_operation_method+0x108> /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 116696: 9c pushf 116697: fa cli 116698: 8f 45 e0 popl -0x20(%ebp) 11669b: 6a 00 push $0x0 11669d: 68 00 ca 9a 3b push $0x3b9aca00 1166a2: ff 35 dc 56 14 00 pushl 0x1456dc 1166a8: ff 35 d8 56 14 00 pushl 0x1456d8 1166ae: e8 81 32 01 00 call 129934 <__divdi3> 1166b3: 83 c4 10 add $0x10,%esp snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); last_snapshot = ts->TOD_watchdogs.last_snapshot; 1166b6: 8b 53 74 mov 0x74(%ebx),%edx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 1166b9: 8b 4b 68 mov 0x68(%ebx),%ecx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 1166bc: 8d 73 6c lea 0x6c(%ebx),%esi if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 1166bf: 39 f1 cmp %esi,%ecx 1166c1: 74 27 je 1166ea <_Timer_server_Schedule_operation_method+0xe1> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 1166c3: 8b 71 10 mov 0x10(%ecx),%esi 1166c6: 89 75 dc mov %esi,-0x24(%ebp) if ( snapshot > last_snapshot ) { 1166c9: 39 d0 cmp %edx,%eax 1166cb: 76 15 jbe 1166e2 <_Timer_server_Schedule_operation_method+0xd9> /* * We advanced in time. */ delta = snapshot - last_snapshot; 1166cd: 89 c6 mov %eax,%esi 1166cf: 29 d6 sub %edx,%esi 1166d1: 89 75 e4 mov %esi,-0x1c(%ebp) if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 1166d4: 31 d2 xor %edx,%edx if ( snapshot > last_snapshot ) { /* * We advanced in time. */ delta = snapshot - last_snapshot; if (delta_interval > delta) { 1166d6: 39 75 dc cmp %esi,-0x24(%ebp) 1166d9: 76 0c jbe 1166e7 <_Timer_server_Schedule_operation_method+0xde><== NEVER TAKEN delta_interval -= delta; 1166db: 8b 55 dc mov -0x24(%ebp),%edx 1166de: 29 f2 sub %esi,%edx 1166e0: eb 05 jmp 1166e7 <_Timer_server_Schedule_operation_method+0xde> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 1166e2: 03 55 dc add -0x24(%ebp),%edx delta_interval += delta; 1166e5: 29 c2 sub %eax,%edx } first_watchdog->delta_interval = delta_interval; 1166e7: 89 51 10 mov %edx,0x10(%ecx) } ts->TOD_watchdogs.last_snapshot = snapshot; 1166ea: 89 43 74 mov %eax,0x74(%ebx) _ISR_Enable( level ); 1166ed: ff 75 e0 pushl -0x20(%ebp) 1166f0: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 1166f1: 51 push %ecx 1166f2: 51 push %ecx 1166f3: 8d 47 10 lea 0x10(%edi),%eax 1166f6: 50 push %eax 1166f7: 8d 43 68 lea 0x68(%ebx),%eax 1166fa: 50 push %eax 1166fb: e8 d8 37 00 00 call 119ed8 <_Watchdog_Insert> if ( !ts->active ) { 116700: 8a 43 7c mov 0x7c(%ebx),%al 116703: 83 c4 10 add $0x10,%esp 116706: 84 c0 test %al,%al 116708: 75 07 jne 116711 <_Timer_server_Schedule_operation_method+0x108> _Timer_server_Reset_tod_system_watchdog( ts ); 11670a: 89 d8 mov %ebx,%eax 11670c: e8 b2 fe ff ff call 1165c3 <_Timer_server_Reset_tod_system_watchdog> * 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 ); } } 116711: 8d 65 f4 lea -0xc(%ebp),%esp 116714: 5b pop %ebx 116715: 5e pop %esi 116716: 5f pop %edi 116717: 5d pop %ebp if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 116718: e9 57 2b 00 00 jmp 119274 <_Thread_Enable_dispatch> * 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 ); 11671d: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 116720: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 116723: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } 116726: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116729: 5b pop %ebx <== NOT EXECUTED 11672a: 5e pop %esi <== NOT EXECUTED 11672b: 5f pop %edi <== NOT EXECUTED 11672c: 5d pop %ebp <== NOT EXECUTED * 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 ); 11672d: e9 16 08 00 00 jmp 116f48 <_Chain_Append> <== NOT EXECUTED =============================================================================== 0010d8bc <_Timestamp64_Divide>: const Timestamp64_Control *_lhs, const Timestamp64_Control *_rhs, uint32_t *_ival_percentage, uint32_t *_fval_percentage ) { 10d8bc: 55 push %ebp 10d8bd: 89 e5 mov %esp,%ebp 10d8bf: 57 push %edi 10d8c0: 56 push %esi 10d8c1: 53 push %ebx 10d8c2: 83 ec 0c sub $0xc,%esp 10d8c5: 8b 55 08 mov 0x8(%ebp),%edx Timestamp64_Control answer; if ( *_rhs == 0 ) { 10d8c8: 8b 45 0c mov 0xc(%ebp),%eax 10d8cb: 8b 08 mov (%eax),%ecx 10d8cd: 8b 58 04 mov 0x4(%eax),%ebx 10d8d0: 89 d8 mov %ebx,%eax 10d8d2: 09 c8 or %ecx,%eax 10d8d4: 75 14 jne 10d8ea <_Timestamp64_Divide+0x2e><== ALWAYS TAKEN *_ival_percentage = 0; 10d8d6: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10d8d9: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *_fval_percentage = 0; 10d8df: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10d8e2: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED return; 10d8e8: eb 4c jmp 10d936 <_Timestamp64_Divide+0x7a><== 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; 10d8ea: 69 72 04 a0 86 01 00 imul $0x186a0,0x4(%edx),%esi 10d8f1: b8 a0 86 01 00 mov $0x186a0,%eax 10d8f6: f7 22 mull (%edx) 10d8f8: 01 f2 add %esi,%edx 10d8fa: 53 push %ebx 10d8fb: 51 push %ecx 10d8fc: 52 push %edx 10d8fd: 50 push %eax 10d8fe: e8 35 04 01 00 call 11dd38 <__divdi3> 10d903: 83 c4 10 add $0x10,%esp 10d906: 89 c6 mov %eax,%esi 10d908: 89 d7 mov %edx,%edi *_ival_percentage = answer / 1000; 10d90a: 6a 00 push $0x0 10d90c: 68 e8 03 00 00 push $0x3e8 10d911: 52 push %edx 10d912: 50 push %eax 10d913: e8 20 04 01 00 call 11dd38 <__divdi3> 10d918: 83 c4 10 add $0x10,%esp 10d91b: 8b 55 10 mov 0x10(%ebp),%edx 10d91e: 89 02 mov %eax,(%edx) *_fval_percentage = answer % 1000; 10d920: 6a 00 push $0x0 10d922: 68 e8 03 00 00 push $0x3e8 10d927: 57 push %edi 10d928: 56 push %esi 10d929: e8 5e 05 01 00 call 11de8c <__moddi3> 10d92e: 83 c4 10 add $0x10,%esp 10d931: 8b 55 14 mov 0x14(%ebp),%edx 10d934: 89 02 mov %eax,(%edx) } 10d936: 8d 65 f4 lea -0xc(%ebp),%esp 10d939: 5b pop %ebx 10d93a: 5e pop %esi 10d93b: 5f pop %edi 10d93c: 5d pop %ebp 10d93d: c3 ret =============================================================================== 0010c648 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10c648: 55 push %ebp 10c649: 89 e5 mov %esp,%ebp 10c64b: 57 push %edi 10c64c: 56 push %esi 10c64d: 53 push %ebx 10c64e: 83 ec 1c sub $0x1c,%esp 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; 10c651: a1 80 81 12 00 mov 0x128180,%eax 10c656: 89 45 e4 mov %eax,-0x1c(%ebp) initial_extensions = Configuration.User_extension_table; 10c659: 8b 1d 84 81 12 00 mov 0x128184,%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c65f: c7 05 18 c5 12 00 1c movl $0x12c51c,0x12c518 10c666: c5 12 00 head->previous = NULL; 10c669: c7 05 1c c5 12 00 00 movl $0x0,0x12c51c 10c670: 00 00 00 tail->previous = head; 10c673: c7 05 20 c5 12 00 18 movl $0x12c518,0x12c520 10c67a: c5 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10c67d: c7 05 70 c3 12 00 74 movl $0x12c374,0x12c370 10c684: c3 12 00 head->previous = NULL; 10c687: c7 05 74 c3 12 00 00 movl $0x0,0x12c374 10c68e: 00 00 00 tail->previous = head; 10c691: c7 05 78 c3 12 00 70 movl $0x12c370,0x12c378 10c698: c3 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10c69b: 85 db test %ebx,%ebx 10c69d: 74 4f je 10c6ee <_User_extensions_Handler_initialization+0xa6><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10c69f: 6b f0 34 imul $0x34,%eax,%esi _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { extension = (User_extensions_Control *) 10c6a2: 83 ec 0c sub $0xc,%esp 10c6a5: 56 push %esi 10c6a6: e8 26 04 00 00 call 10cad1 <_Workspace_Allocate_or_fatal_error> 10c6ab: 89 c2 mov %eax,%edx _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10c6ad: 31 c0 xor %eax,%eax 10c6af: 89 d7 mov %edx,%edi 10c6b1: 89 f1 mov %esi,%ecx 10c6b3: f3 aa rep stos %al,%es:(%edi) extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10c6b5: 83 c4 10 add $0x10,%esp 10c6b8: 31 c0 xor %eax,%eax 10c6ba: eb 2d jmp 10c6e9 <_User_extensions_Handler_initialization+0xa1> #include #include #include #include void _User_extensions_Handler_initialization(void) 10c6bc: 89 c6 mov %eax,%esi 10c6be: c1 e6 05 shl $0x5,%esi RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 10c6c1: 8d 7a 14 lea 0x14(%edx),%edi 10c6c4: 01 de add %ebx,%esi 10c6c6: b9 08 00 00 00 mov $0x8,%ecx 10c6cb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10c6cd: 83 ec 0c sub $0xc,%esp 10c6d0: 52 push %edx 10c6d1: 89 45 dc mov %eax,-0x24(%ebp) 10c6d4: 89 55 e0 mov %edx,-0x20(%ebp) 10c6d7: e8 e4 28 00 00 call 10efc0 <_User_extensions_Add_set> number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10c6dc: 8b 55 e0 mov -0x20(%ebp),%edx 10c6df: 83 c2 34 add $0x34,%edx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10c6e2: 8b 45 dc mov -0x24(%ebp),%eax 10c6e5: 40 inc %eax 10c6e6: 83 c4 10 add $0x10,%esp 10c6e9: 3b 45 e4 cmp -0x1c(%ebp),%eax 10c6ec: 75 ce jne 10c6bc <_User_extensions_Handler_initialization+0x74> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10c6ee: 8d 65 f4 lea -0xc(%ebp),%esp 10c6f1: 5b pop %ebx 10c6f2: 5e pop %esi 10c6f3: 5f pop %edi 10c6f4: 5d pop %ebp 10c6f5: c3 ret =============================================================================== 0010db94 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10db94: 55 push %ebp 10db95: 89 e5 mov %esp,%ebp 10db97: 57 push %edi 10db98: 56 push %esi 10db99: 53 push %ebx 10db9a: 83 ec 0c sub $0xc,%esp 10db9d: 8b 75 08 mov 0x8(%ebp),%esi 10dba0: 8b 4d 0c mov 0xc(%ebp),%ecx 10dba3: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10dba6: 9c pushf 10dba7: fa cli 10dba8: 58 pop %eax */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10dba9: 8b 16 mov (%esi),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10dbab: 8d 7e 04 lea 0x4(%esi),%edi * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 10dbae: 39 fa cmp %edi,%edx 10dbb0: 74 3e je 10dbf0 <_Watchdog_Adjust+0x5c> switch ( direction ) { 10dbb2: 85 c9 test %ecx,%ecx 10dbb4: 74 36 je 10dbec <_Watchdog_Adjust+0x58> 10dbb6: 49 dec %ecx 10dbb7: 75 37 jne 10dbf0 <_Watchdog_Adjust+0x5c> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10dbb9: 01 5a 10 add %ebx,0x10(%edx) break; 10dbbc: eb 32 jmp 10dbf0 <_Watchdog_Adjust+0x5c> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10dbbe: 8b 16 mov (%esi),%edx case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10dbc0: 8b 4a 10 mov 0x10(%edx),%ecx 10dbc3: 39 cb cmp %ecx,%ebx 10dbc5: 73 07 jae 10dbce <_Watchdog_Adjust+0x3a> _Watchdog_First( header )->delta_interval -= units; 10dbc7: 29 d9 sub %ebx,%ecx 10dbc9: 89 4a 10 mov %ecx,0x10(%edx) break; 10dbcc: eb 22 jmp 10dbf0 <_Watchdog_Adjust+0x5c> } else { units -= _Watchdog_First( header )->delta_interval; 10dbce: 29 cb sub %ecx,%ebx _Watchdog_First( header )->delta_interval = 1; 10dbd0: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10dbd7: 50 push %eax 10dbd8: 9d popf _Watchdog_Tickle( header ); 10dbd9: 83 ec 0c sub $0xc,%esp 10dbdc: 56 push %esi 10dbdd: e8 96 01 00 00 call 10dd78 <_Watchdog_Tickle> _ISR_Disable( level ); 10dbe2: 9c pushf 10dbe3: fa cli 10dbe4: 58 pop %eax if ( _Chain_Is_empty( header ) ) 10dbe5: 83 c4 10 add $0x10,%esp 10dbe8: 39 3e cmp %edi,(%esi) 10dbea: 74 04 je 10dbf0 <_Watchdog_Adjust+0x5c> switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10dbec: 85 db test %ebx,%ebx 10dbee: 75 ce jne 10dbbe <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10dbf0: 50 push %eax 10dbf1: 9d popf } 10dbf2: 8d 65 f4 lea -0xc(%ebp),%esp 10dbf5: 5b pop %ebx 10dbf6: 5e pop %esi 10dbf7: 5f pop %edi 10dbf8: 5d pop %ebp 10dbf9: c3 ret =============================================================================== 0010c974 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10c974: 55 push %ebp 10c975: 89 e5 mov %esp,%ebp 10c977: 56 push %esi 10c978: 53 push %ebx 10c979: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10c97c: 9c pushf 10c97d: fa cli 10c97e: 5e pop %esi previous_state = the_watchdog->state; 10c97f: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10c982: 83 f8 01 cmp $0x1,%eax 10c985: 74 09 je 10c990 <_Watchdog_Remove+0x1c> 10c987: 72 42 jb 10c9cb <_Watchdog_Remove+0x57> 10c989: 83 f8 03 cmp $0x3,%eax 10c98c: 77 3d ja 10c9cb <_Watchdog_Remove+0x57> <== NEVER TAKEN 10c98e: eb 09 jmp 10c999 <_Watchdog_Remove+0x25> /* * 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; 10c990: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10c997: eb 32 jmp 10c9cb <_Watchdog_Remove+0x57> case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10c999: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; _ISR_Enable( level ); return( previous_state ); } 10c9a0: 8b 0a mov (%edx),%ecx case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10c9a2: 83 39 00 cmpl $0x0,(%ecx) 10c9a5: 74 06 je 10c9ad <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10c9a7: 8b 5a 10 mov 0x10(%edx),%ebx 10c9aa: 01 59 10 add %ebx,0x10(%ecx) if ( _Watchdog_Sync_count ) 10c9ad: 8b 1d 5c c4 12 00 mov 0x12c45c,%ebx 10c9b3: 85 db test %ebx,%ebx 10c9b5: 74 0c je 10c9c3 <_Watchdog_Remove+0x4f> _Watchdog_Sync_level = _ISR_Nest_level; 10c9b7: 8b 1d 64 c5 12 00 mov 0x12c564,%ebx 10c9bd: 89 1d fc c3 12 00 mov %ebx,0x12c3fc { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10c9c3: 8b 5a 04 mov 0x4(%edx),%ebx next->previous = previous; 10c9c6: 89 59 04 mov %ebx,0x4(%ecx) previous->next = next; 10c9c9: 89 0b mov %ecx,(%ebx) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10c9cb: 8b 0d 60 c4 12 00 mov 0x12c460,%ecx 10c9d1: 89 4a 18 mov %ecx,0x18(%edx) _ISR_Enable( level ); 10c9d4: 56 push %esi 10c9d5: 9d popf return( previous_state ); } 10c9d6: 5b pop %ebx 10c9d7: 5e pop %esi 10c9d8: 5d pop %ebp 10c9d9: c3 ret =============================================================================== 0010c9dc <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10c9dc: 55 push %ebp 10c9dd: 89 e5 mov %esp,%ebp 10c9df: 57 push %edi 10c9e0: 56 push %esi 10c9e1: 53 push %ebx 10c9e2: 83 ec 1c sub $0x1c,%esp 10c9e5: 8b 75 08 mov 0x8(%ebp),%esi * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 10c9e8: 9c pushf 10c9e9: fa cli 10c9ea: 5a pop %edx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10c9eb: 8b 1e mov (%esi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10c9ed: 8d 7e 04 lea 0x4(%esi),%edi if ( _Chain_Is_empty( header ) ) 10c9f0: 39 fb cmp %edi,%ebx 10c9f2: 74 45 je 10ca39 <_Watchdog_Tickle+0x5d> * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 10c9f4: 8b 43 10 mov 0x10(%ebx),%eax 10c9f7: 85 c0 test %eax,%eax 10c9f9: 74 08 je 10ca03 <_Watchdog_Tickle+0x27> the_watchdog->delta_interval--; 10c9fb: 48 dec %eax 10c9fc: 89 43 10 mov %eax,0x10(%ebx) if ( the_watchdog->delta_interval != 0 ) 10c9ff: 85 c0 test %eax,%eax 10ca01: 75 36 jne 10ca39 <_Watchdog_Tickle+0x5d> goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10ca03: 83 ec 0c sub $0xc,%esp 10ca06: 53 push %ebx 10ca07: 89 55 e4 mov %edx,-0x1c(%ebp) 10ca0a: e8 65 ff ff ff call 10c974 <_Watchdog_Remove> _ISR_Enable( level ); 10ca0f: 8b 55 e4 mov -0x1c(%ebp),%edx 10ca12: 52 push %edx 10ca13: 9d popf switch( watchdog_state ) { 10ca14: 83 c4 10 add $0x10,%esp 10ca17: 83 f8 02 cmp $0x2,%eax 10ca1a: 75 0e jne 10ca2a <_Watchdog_Tickle+0x4e> <== NEVER TAKEN case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10ca1c: 50 push %eax 10ca1d: 50 push %eax 10ca1e: ff 73 24 pushl 0x24(%ebx) 10ca21: ff 73 20 pushl 0x20(%ebx) 10ca24: ff 53 1c call *0x1c(%ebx) the_watchdog->id, the_watchdog->user_data ); break; 10ca27: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10ca2a: 9c pushf 10ca2b: fa cli 10ca2c: 5a pop %edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10ca2d: 8b 1e mov (%esi),%ebx the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10ca2f: 39 fb cmp %edi,%ebx 10ca31: 74 06 je 10ca39 <_Watchdog_Tickle+0x5d> } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 10ca33: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10ca37: eb c8 jmp 10ca01 <_Watchdog_Tickle+0x25> (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10ca39: 52 push %edx 10ca3a: 9d popf } 10ca3b: 8d 65 f4 lea -0xc(%ebp),%esp 10ca3e: 5b pop %ebx 10ca3f: 5e pop %esi 10ca40: 5f pop %edi 10ca41: 5d pop %ebp 10ca42: c3 ret =============================================================================== 0010cc60 <_Workspace_String_duplicate>: char *_Workspace_String_duplicate( const char *string, size_t len ) { 10cc60: 55 push %ebp 10cc61: 89 e5 mov %esp,%ebp 10cc63: 57 push %edi 10cc64: 56 push %esi 10cc65: 53 push %ebx 10cc66: 83 ec 18 sub $0x18,%esp 10cc69: 8b 75 08 mov 0x8(%ebp),%esi 10cc6c: 8b 5d 0c mov 0xc(%ebp),%ebx char *dup = _Workspace_Allocate(len + 1); 10cc6f: 8d 43 01 lea 0x1(%ebx),%eax 10cc72: 50 push %eax 10cc73: e8 88 ff ff ff call 10cc00 <_Workspace_Allocate> if (dup != NULL) { 10cc78: 83 c4 10 add $0x10,%esp 10cc7b: 85 c0 test %eax,%eax 10cc7d: 74 0a je 10cc89 <_Workspace_String_duplicate+0x29><== NEVER TAKEN dup [len] = '\0'; 10cc7f: c6 04 18 00 movb $0x0,(%eax,%ebx,1) memcpy(dup, string, len); 10cc83: 89 c7 mov %eax,%edi 10cc85: 89 d9 mov %ebx,%ecx 10cc87: f3 a4 rep movsb %ds:(%esi),%es:(%edi) } return dup; } 10cc89: 8d 65 f4 lea -0xc(%ebp),%esp 10cc8c: 5b pop %ebx 10cc8d: 5e pop %esi 10cc8e: 5f pop %edi 10cc8f: 5d pop %ebp 10cc90: c3 ret =============================================================================== 0010a718 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10a718: 55 push %ebp 10a719: 89 e5 mov %esp,%ebp 10a71b: 56 push %esi 10a71c: 53 push %ebx 10a71d: 83 ec 10 sub $0x10,%esp while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 10a720: 8d 5d f4 lea -0xc(%ebp),%ebx 10a723: eb 15 jmp 10a73a 10a725: 53 push %ebx 10a726: ff 75 10 pushl 0x10(%ebp) 10a729: 6a 00 push $0x0 10a72b: ff 75 0c pushl 0xc(%ebp) 10a72e: e8 99 f5 ff ff call 109ccc ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10a733: 83 c4 10 add $0x10,%esp 10a736: 85 c0 test %eax,%eax 10a738: 75 16 jne 10a750 <== ALWAYS TAKEN */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10a73a: 83 ec 0c sub $0xc,%esp 10a73d: ff 75 08 pushl 0x8(%ebp) 10a740: e8 83 04 00 00 call 10abc8 <_Chain_Get> 10a745: 89 c6 mov %eax,%esi sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10a747: 83 c4 10 add $0x10,%esp 10a74a: 85 c0 test %eax,%eax 10a74c: 74 d7 je 10a725 10a74e: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10a750: 8b 55 14 mov 0x14(%ebp),%edx 10a753: 89 32 mov %esi,(%edx) return sc; } 10a755: 8d 65 f8 lea -0x8(%ebp),%esp 10a758: 5b pop %ebx 10a759: 5e pop %esi 10a75a: 5d pop %ebp 10a75b: c3 ret =============================================================================== 0010bfdc : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10bfdc: 55 push %ebp 10bfdd: 89 e5 mov %esp,%ebp 10bfdf: 57 push %edi 10bfe0: 56 push %esi 10bfe1: 53 push %ebx 10bfe2: 83 ec 0c sub $0xc,%esp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10bfe5: bb 01 00 00 00 mov $0x1,%ebx 10bfea: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10bfee: 74 40 je 10c030 return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) 10bff0: 8b 04 9d 24 e7 12 00 mov 0x12e724(,%ebx,4),%eax 10bff7: 85 c0 test %eax,%eax 10bff9: 75 06 jne 10c001 Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10bffb: 43 inc %ebx 10bffc: 83 fb 04 cmp $0x4,%ebx 10bfff: eb ed jmp 10bfee #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10c001: 8b 78 04 mov 0x4(%eax),%edi if ( !information ) 10c004: 85 ff test %edi,%edi 10c006: 74 f3 je 10bffb 10c008: be 01 00 00 00 mov $0x1,%esi 10c00d: eb 17 jmp 10c026 continue; for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10c00f: 8b 57 1c mov 0x1c(%edi),%edx 10c012: 8b 14 b2 mov (%edx,%esi,4),%edx if ( !the_thread ) 10c015: 85 d2 test %edx,%edx 10c017: 74 0c je 10c025 <== NEVER TAKEN continue; (*routine)(the_thread); 10c019: 83 ec 0c sub $0xc,%esp 10c01c: 52 push %edx 10c01d: 8b 45 08 mov 0x8(%ebp),%eax 10c020: ff d0 call *%eax 10c022: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10c025: 46 inc %esi 10c026: 0f b7 57 10 movzwl 0x10(%edi),%edx 10c02a: 39 d6 cmp %edx,%esi 10c02c: 76 e1 jbe 10c00f 10c02e: eb cb jmp 10bffb (*routine)(the_thread); } } } 10c030: 8d 65 f4 lea -0xc(%ebp),%esp 10c033: 5b pop %ebx 10c034: 5e pop %esi 10c035: 5f pop %edi 10c036: 5d pop %ebp 10c037: c3 ret =============================================================================== 0010e09c : */ rtems_status_code rtems_message_queue_delete( rtems_id id ) { 10e09c: 55 push %ebp 10e09d: 89 e5 mov %esp,%ebp 10e09f: 53 push %ebx 10e0a0: 83 ec 18 sub $0x18,%esp register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); 10e0a3: 8d 45 f4 lea -0xc(%ebp),%eax RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 10e0a6: 50 push %eax 10e0a7: ff 75 08 pushl 0x8(%ebp) 10e0aa: 68 70 c6 12 00 push $0x12c670 10e0af: e8 68 d1 ff ff call 10b21c <_Objects_Get> switch ( location ) { 10e0b4: 83 c4 10 add $0x10,%esp 10e0b7: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10e0bb: 75 38 jne 10e0f5 <== NEVER TAKEN 10e0bd: 89 c3 mov %eax,%ebx case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 10e0bf: 50 push %eax 10e0c0: 50 push %eax 10e0c1: 53 push %ebx 10e0c2: 68 70 c6 12 00 push $0x12c670 10e0c7: e8 b0 cd ff ff call 10ae7c <_Objects_Close> &the_message_queue->Object ); _CORE_message_queue_Close( 10e0cc: 83 c4 0c add $0xc,%esp 10e0cf: 6a 05 push $0x5 10e0d1: 6a 00 push $0x0 10e0d3: 8d 43 14 lea 0x14(%ebx),%eax 10e0d6: 50 push %eax 10e0d7: e8 a0 04 00 00 call 10e57c <_CORE_message_queue_Close> */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 10e0dc: 5a pop %edx 10e0dd: 59 pop %ecx 10e0de: 53 push %ebx 10e0df: 68 70 c6 12 00 push $0x12c670 10e0e4: e8 07 d0 ff ff call 10b0f0 <_Objects_Free> 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 10e0e9: e8 ae dc ff ff call 10bd9c <_Thread_Enable_dispatch> 10e0ee: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; 10e0f1: 31 c0 xor %eax,%eax 10e0f3: eb 05 jmp 10e0fa case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10e0f5: b8 04 00 00 00 mov $0x4,%eax } 10e0fa: 8b 5d fc mov -0x4(%ebp),%ebx 10e0fd: c9 leave 10e0fe: c3 ret =============================================================================== 00114260 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 114260: 55 push %ebp 114261: 89 e5 mov %esp,%ebp 114263: 57 push %edi 114264: 56 push %esi 114265: 53 push %ebx 114266: 83 ec 0c sub $0xc,%esp 114269: 8b 7d 0c mov 0xc(%ebp),%edi 11426c: 8b 75 14 mov 0x14(%ebp),%esi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 11426f: b8 03 00 00 00 mov $0x3,%eax rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 114274: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 114278: 0f 84 d9 00 00 00 je 114357 return RTEMS_INVALID_NAME; if ( !starting_address ) 11427e: 85 ff test %edi,%edi 114280: 0f 84 c5 00 00 00 je 11434b return RTEMS_INVALID_ADDRESS; if ( !id ) 114286: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 11428a: 0f 84 bb 00 00 00 je 11434b <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 114290: 85 f6 test %esi,%esi 114292: 0f 84 ba 00 00 00 je 114352 114298: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 11429c: 0f 84 b0 00 00 00 je 114352 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 1142a2: b0 08 mov $0x8,%al return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 1142a4: 39 75 10 cmp %esi,0x10(%ebp) 1142a7: 0f 82 aa 00 00 00 jb 114357 1142ad: f7 c6 03 00 00 00 test $0x3,%esi 1142b3: 0f 85 9e 00 00 00 jne 114357 if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 1142b9: b0 09 mov $0x9,%al if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 1142bb: f7 c7 03 00 00 00 test $0x3,%edi 1142c1: 0f 85 90 00 00 00 jne 114357 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 1142c7: a1 1c 57 14 00 mov 0x14571c,%eax 1142cc: 40 inc %eax 1142cd: a3 1c 57 14 00 mov %eax,0x14571c return _Thread_Dispatch_disable_level; 1142d2: a1 1c 57 14 00 mov 0x14571c,%eax * 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 ); 1142d7: 83 ec 0c sub $0xc,%esp 1142da: 68 98 55 14 00 push $0x145598 1142df: e8 c8 3f 00 00 call 1182ac <_Objects_Allocate> 1142e4: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 1142e6: 83 c4 10 add $0x10,%esp 1142e9: 85 c0 test %eax,%eax 1142eb: 75 0c jne 1142f9 _Thread_Enable_dispatch(); 1142ed: e8 82 4f 00 00 call 119274 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 1142f2: b8 05 00 00 00 mov $0x5,%eax 1142f7: eb 5e jmp 114357 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 1142f9: 89 78 10 mov %edi,0x10(%eax) the_partition->length = length; 1142fc: 8b 45 10 mov 0x10(%ebp),%eax 1142ff: 89 43 14 mov %eax,0x14(%ebx) the_partition->buffer_size = buffer_size; 114302: 89 73 18 mov %esi,0x18(%ebx) the_partition->attribute_set = attribute_set; 114305: 8b 45 18 mov 0x18(%ebp),%eax 114308: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 11430b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 114312: 56 push %esi 114313: 8b 45 10 mov 0x10(%ebp),%eax 114316: 31 d2 xor %edx,%edx 114318: f7 f6 div %esi 11431a: 50 push %eax 11431b: 57 push %edi 11431c: 8d 43 24 lea 0x24(%ebx),%eax 11431f: 50 push %eax 114320: e8 6b 2c 00 00 call 116f90 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 114325: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 114328: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 11432b: 8b 15 b4 55 14 00 mov 0x1455b4,%edx 114331: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 114334: 8b 55 08 mov 0x8(%ebp),%edx 114337: 89 53 0c mov %edx,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 11433a: 8b 55 1c mov 0x1c(%ebp),%edx 11433d: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 11433f: e8 30 4f 00 00 call 119274 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 114344: 83 c4 10 add $0x10,%esp 114347: 31 c0 xor %eax,%eax 114349: eb 0c jmp 114357 if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 11434b: b8 09 00 00 00 mov $0x9,%eax 114350: eb 05 jmp 114357 if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 114352: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 114357: 8d 65 f4 lea -0xc(%ebp),%esp 11435a: 5b pop %ebx 11435b: 5e pop %esi 11435c: 5f pop %edi 11435d: 5d pop %ebp 11435e: c3 ret =============================================================================== 0011445c : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 11445c: 55 push %ebp 11445d: 89 e5 mov %esp,%ebp 11445f: 56 push %esi 114460: 53 push %ebx 114461: 83 ec 14 sub $0x14,%esp 114464: 8b 75 0c mov 0xc(%ebp),%esi register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); 114467: 8d 45 f4 lea -0xc(%ebp),%eax RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 11446a: 50 push %eax 11446b: ff 75 08 pushl 0x8(%ebp) 11446e: 68 98 55 14 00 push $0x145598 114473: e8 7c 42 00 00 call 1186f4 <_Objects_Get> switch ( location ) { 114478: 83 c4 10 add $0x10,%esp 11447b: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 11447f: 75 53 jne 1144d4 114481: 89 c3 mov %eax,%ebx ) { void *starting; void *ending; starting = the_partition->starting_address; 114483: 8b 40 10 mov 0x10(%eax),%eax 114486: 8b 53 14 mov 0x14(%ebx),%edx 114489: 01 c2 add %eax,%edx ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 11448b: 39 d6 cmp %edx,%esi 11448d: 77 18 ja 1144a7 <== NEVER TAKEN 11448f: 39 c6 cmp %eax,%esi 114491: 72 14 jb 1144a7 RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 114493: 89 f2 mov %esi,%edx 114495: 29 c2 sub %eax,%edx 114497: 89 d0 mov %edx,%eax offset = (uint32_t) _Addresses_Subtract( the_buffer, the_partition->starting_address ); return ((offset % the_partition->buffer_size) == 0); 114499: 31 d2 xor %edx,%edx 11449b: f7 73 18 divl 0x18(%ebx) starting = the_partition->starting_address; ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 11449e: 31 c0 xor %eax,%eax 1144a0: 85 d2 test %edx,%edx 1144a2: 0f 94 c0 sete %al 1144a5: eb 02 jmp 1144a9 1144a7: 31 c0 xor %eax,%eax case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { 1144a9: 85 c0 test %eax,%eax 1144ab: 74 1b je 1144c8 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 1144ad: 50 push %eax 1144ae: 50 push %eax 1144af: 56 push %esi 1144b0: 8d 43 24 lea 0x24(%ebx),%eax 1144b3: 50 push %eax 1144b4: e8 8f 2a 00 00 call 116f48 <_Chain_Append> _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 1144b9: ff 4b 20 decl 0x20(%ebx) _Thread_Enable_dispatch(); 1144bc: e8 b3 4d 00 00 call 119274 <_Thread_Enable_dispatch> 1144c1: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; 1144c4: 31 c0 xor %eax,%eax 1144c6: eb 11 jmp 1144d9 } _Thread_Enable_dispatch(); 1144c8: e8 a7 4d 00 00 call 119274 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 1144cd: b8 09 00 00 00 mov $0x9,%eax 1144d2: eb 05 jmp 1144d9 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1144d4: b8 04 00 00 00 mov $0x4,%eax } 1144d9: 8d 65 f8 lea -0x8(%ebp),%esp 1144dc: 5b pop %ebx 1144dd: 5e pop %esi 1144de: 5d pop %ebp 1144df: c3 ret =============================================================================== 0012d0b0 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 12d0b0: 55 push %ebp 12d0b1: 89 e5 mov %esp,%ebp 12d0b3: 57 push %edi 12d0b4: 56 push %esi 12d0b5: 53 push %ebx 12d0b6: 83 ec 30 sub $0x30,%esp 12d0b9: 8b 7d 08 mov 0x8(%ebp),%edi 12d0bc: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); 12d0bf: 8d 45 e4 lea -0x1c(%ebp),%eax 12d0c2: 50 push %eax 12d0c3: 57 push %edi 12d0c4: 68 74 cd 16 00 push $0x16cd74 12d0c9: e8 26 df fd ff call 10aff4 <_Objects_Get> switch ( location ) { 12d0ce: 83 c4 10 add $0x10,%esp 12d0d1: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 12d0d5: 0f 85 47 01 00 00 jne 12d222 12d0db: 89 c6 mov %eax,%esi case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 12d0dd: a1 78 cb 16 00 mov 0x16cb78,%eax 12d0e2: 39 46 40 cmp %eax,0x40(%esi) 12d0e5: 74 0f je 12d0f6 _Thread_Enable_dispatch(); 12d0e7: e8 18 ea fd ff call 10bb04 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 12d0ec: bf 17 00 00 00 mov $0x17,%edi 12d0f1: e9 31 01 00 00 jmp 12d227 } if ( length == RTEMS_PERIOD_STATUS ) { 12d0f6: 85 db test %ebx,%ebx 12d0f8: 75 1b jne 12d115 switch ( the_period->state ) { 12d0fa: 8b 46 38 mov 0x38(%esi),%eax 12d0fd: 31 ff xor %edi,%edi 12d0ff: 83 f8 04 cmp $0x4,%eax 12d102: 77 07 ja 12d10b <== NEVER TAKEN case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12d104: 0f b6 b8 b8 1d 15 00 movzbl 0x151db8(%eax),%edi case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 12d10b: e8 f4 e9 fd ff call 10bb04 <_Thread_Enable_dispatch> 12d110: e9 12 01 00 00 jmp 12d227 return( return_value ); } _ISR_Disable( level ); 12d115: 9c pushf 12d116: fa cli 12d117: 8f 45 d4 popl -0x2c(%ebp) if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 12d11a: 8b 46 38 mov 0x38(%esi),%eax 12d11d: 85 c0 test %eax,%eax 12d11f: 75 4c jne 12d16d _ISR_Enable( level ); 12d121: ff 75 d4 pushl -0x2c(%ebp) 12d124: 9d popf the_period->next_length = length; 12d125: 89 5e 3c mov %ebx,0x3c(%esi) /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 12d128: 83 ec 0c sub $0xc,%esp 12d12b: 56 push %esi 12d12c: e8 0f ff ff ff call 12d040 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 12d131: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 12d138: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) the_watchdog->routine = routine; 12d13f: c7 46 2c 34 d2 12 00 movl $0x12d234,0x2c(%esi) the_watchdog->id = id; 12d146: 89 7e 30 mov %edi,0x30(%esi) the_watchdog->user_data = user_data; 12d149: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 12d150: 89 5e 1c mov %ebx,0x1c(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 12d153: 59 pop %ecx 12d154: 5b pop %ebx _Rate_monotonic_Timeout, id, NULL ); _Watchdog_Insert_ticks( &the_period->Timer, length ); 12d155: 8d 56 10 lea 0x10(%esi),%edx 12d158: 52 push %edx 12d159: 68 20 ca 16 00 push $0x16ca20 12d15e: e8 65 f4 fd ff call 10c5c8 <_Watchdog_Insert> _Thread_Enable_dispatch(); 12d163: e8 9c e9 fd ff call 10bb04 <_Thread_Enable_dispatch> 12d168: 83 c4 10 add $0x10,%esp 12d16b: eb 63 jmp 12d1d0 return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 12d16d: 83 f8 02 cmp $0x2,%eax 12d170: 75 62 jne 12d1d4 /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 12d172: 89 f0 mov %esi,%eax 12d174: e8 28 fe ff ff call 12cfa1 <_Rate_monotonic_Update_statistics> /* * 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; 12d179: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi) the_period->next_length = length; 12d180: 89 5e 3c mov %ebx,0x3c(%esi) _ISR_Enable( level ); 12d183: ff 75 d4 pushl -0x2c(%ebp) 12d186: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 12d187: a1 78 cb 16 00 mov 0x16cb78,%eax 12d18c: 8b 4e 08 mov 0x8(%esi),%ecx 12d18f: 89 48 20 mov %ecx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 12d192: 52 push %edx 12d193: 52 push %edx 12d194: 68 00 40 00 00 push $0x4000 12d199: 50 push %eax 12d19a: e8 a5 f0 fd ff call 10c244 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 12d19f: 9c pushf 12d1a0: fa cli 12d1a1: 59 pop %ecx local_state = the_period->state; 12d1a2: 8b 46 38 mov 0x38(%esi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 12d1a5: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) _ISR_Enable( level ); 12d1ac: 51 push %ecx 12d1ad: 9d popf /* * 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 ) 12d1ae: 83 c4 10 add $0x10,%esp 12d1b1: 83 f8 03 cmp $0x3,%eax 12d1b4: 75 15 jne 12d1cb _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 12d1b6: 50 push %eax 12d1b7: 50 push %eax 12d1b8: 68 00 40 00 00 push $0x4000 12d1bd: ff 35 78 cb 16 00 pushl 0x16cb78 12d1c3: e8 0c e6 fd ff call 10b7d4 <_Thread_Clear_state> 12d1c8: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 12d1cb: e8 34 e9 fd ff call 10bb04 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 12d1d0: 31 ff xor %edi,%edi 12d1d2: eb 53 jmp 12d227 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 12d1d4: bf 04 00 00 00 mov $0x4,%edi _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 12d1d9: 83 f8 04 cmp $0x4,%eax 12d1dc: 75 49 jne 12d227 <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 12d1de: 89 f0 mov %esi,%eax 12d1e0: e8 bc fd ff ff call 12cfa1 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 12d1e5: ff 75 d4 pushl -0x2c(%ebp) 12d1e8: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 12d1e9: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) the_period->next_length = length; 12d1f0: 89 5e 3c mov %ebx,0x3c(%esi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 12d1f3: 89 5e 1c mov %ebx,0x1c(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 12d1f6: 51 push %ecx 12d1f7: 51 push %ecx _Watchdog_Insert_ticks( &the_period->Timer, length ); 12d1f8: 8d 46 10 lea 0x10(%esi),%eax 12d1fb: 50 push %eax 12d1fc: 68 20 ca 16 00 push $0x16ca20 12d201: e8 c2 f3 fd ff call 10c5c8 <_Watchdog_Insert> 12d206: 5b pop %ebx 12d207: 58 pop %eax 12d208: ff 76 3c pushl 0x3c(%esi) 12d20b: ff 76 40 pushl 0x40(%esi) 12d20e: ff 15 10 51 16 00 call *0x165110 _Scheduler_Release_job(the_period->owner, the_period->next_length); _Thread_Enable_dispatch(); 12d214: e8 eb e8 fd ff call 10bb04 <_Thread_Enable_dispatch> 12d219: 83 c4 10 add $0x10,%esp return RTEMS_TIMEOUT; 12d21c: 66 bf 06 00 mov $0x6,%di 12d220: eb 05 jmp 12d227 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 12d222: bf 04 00 00 00 mov $0x4,%edi } 12d227: 89 f8 mov %edi,%eax 12d229: 8d 65 f4 lea -0xc(%ebp),%esp 12d22c: 5b pop %ebx 12d22d: 5e pop %esi 12d22e: 5f pop %edi 12d22f: 5d pop %ebp 12d230: c3 ret =============================================================================== 00122f08 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 122f08: 55 push %ebp 122f09: 89 e5 mov %esp,%ebp 122f0b: 57 push %edi 122f0c: 56 push %esi 122f0d: 53 push %ebx 122f0e: 83 ec 7c sub $0x7c,%esp 122f11: 8b 75 08 mov 0x8(%ebp),%esi 122f14: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 122f17: 85 db test %ebx,%ebx 122f19: 0f 84 2e 01 00 00 je 12304d <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 122f1f: 57 push %edi 122f20: 57 push %edi 122f21: 68 fc f1 14 00 push $0x14f1fc 122f26: 56 push %esi 122f27: ff d3 call *%ebx #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 122f29: 58 pop %eax 122f2a: 5a pop %edx 122f2b: 68 1a f2 14 00 push $0x14f21a 122f30: 56 push %esi 122f31: ff d3 call *%ebx (*print)( context, "--- Wall times are in seconds ---\n" ); 122f33: 59 pop %ecx 122f34: 5f pop %edi 122f35: 68 3c f2 14 00 push $0x14f23c 122f3a: 56 push %esi 122f3b: ff d3 call *%ebx Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 122f3d: 58 pop %eax 122f3e: 5a pop %edx 122f3f: 68 5f f2 14 00 push $0x14f25f 122f44: 56 push %esi 122f45: ff d3 call *%ebx #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 122f47: 59 pop %ecx 122f48: 5f pop %edi 122f49: 68 aa f2 14 00 push $0x14f2aa 122f4e: 56 push %esi 122f4f: ff d3 call *%ebx /* * 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 ; 122f51: 8b 3d 7c cd 16 00 mov 0x16cd7c,%edi 122f57: 83 c4 10 add $0x10,%esp 122f5a: e9 e2 00 00 00 jmp 123041 id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 122f5f: 51 push %ecx 122f60: 51 push %ecx 122f61: 8d 45 b0 lea -0x50(%ebp),%eax 122f64: 50 push %eax 122f65: 57 push %edi 122f66: e8 1d 9d 00 00 call 12cc88 if ( status != RTEMS_SUCCESSFUL ) 122f6b: 83 c4 10 add $0x10,%esp 122f6e: 85 c0 test %eax,%eax 122f70: 0f 85 ca 00 00 00 jne 123040 #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 ); 122f76: 50 push %eax 122f77: 50 push %eax 122f78: 8d 55 98 lea -0x68(%ebp),%edx 122f7b: 52 push %edx 122f7c: 57 push %edi 122f7d: e8 92 9e 00 00 call 12ce14 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 122f82: 83 c4 0c add $0xc,%esp 122f85: 8d 55 8b lea -0x75(%ebp),%edx 122f88: 52 push %edx 122f89: 6a 05 push $0x5 122f8b: ff 75 98 pushl -0x68(%ebp) 122f8e: 89 55 84 mov %edx,-0x7c(%ebp) 122f91: e8 52 ce fe ff call 10fde8 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 122f96: 58 pop %eax 122f97: 5a pop %edx 122f98: ff 75 b4 pushl -0x4c(%ebp) 122f9b: ff 75 b0 pushl -0x50(%ebp) 122f9e: 8b 55 84 mov -0x7c(%ebp),%edx 122fa1: 52 push %edx 122fa2: 57 push %edi 122fa3: 68 f6 f2 14 00 push $0x14f2f6 122fa8: 56 push %esi 122fa9: ff d3 call *%ebx ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 122fab: 8b 45 b0 mov -0x50(%ebp),%eax 122fae: 83 c4 20 add $0x20,%esp 122fb1: 85 c0 test %eax,%eax 122fb3: 75 0f jne 122fc4 (*print)( context, "\n" ); 122fb5: 51 push %ecx 122fb6: 51 push %ecx 122fb7: 68 65 a0 14 00 push $0x14a065 122fbc: 56 push %esi 122fbd: ff d3 call *%ebx continue; 122fbf: 83 c4 10 add $0x10,%esp 122fc2: eb 7c jmp 123040 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 ); 122fc4: 52 push %edx 122fc5: 8d 55 90 lea -0x70(%ebp),%edx 122fc8: 52 push %edx 122fc9: 50 push %eax { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ 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; 122fca: 8d 45 c8 lea -0x38(%ebp),%eax _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 122fcd: 50 push %eax 122fce: e8 e5 08 00 00 call 1238b8 <_Timespec_Divide_by_integer> (*print)( context, 122fd3: 8b 45 94 mov -0x6c(%ebp),%eax 122fd6: b9 e8 03 00 00 mov $0x3e8,%ecx 122fdb: 99 cltd 122fdc: f7 f9 idiv %ecx 122fde: 50 push %eax 122fdf: ff 75 90 pushl -0x70(%ebp) 122fe2: 8b 45 c4 mov -0x3c(%ebp),%eax 122fe5: 99 cltd 122fe6: f7 f9 idiv %ecx 122fe8: 50 push %eax 122fe9: ff 75 c0 pushl -0x40(%ebp) 122fec: 8b 45 bc mov -0x44(%ebp),%eax 122fef: 99 cltd 122ff0: f7 f9 idiv %ecx 122ff2: 50 push %eax 122ff3: ff 75 b8 pushl -0x48(%ebp) 122ff6: 68 0d f3 14 00 push $0x14f30d 122ffb: 56 push %esi 122ffc: 89 4d 84 mov %ecx,-0x7c(%ebp) 122fff: ff d3 call *%ebx 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); 123001: 83 c4 2c add $0x2c,%esp 123004: 8d 45 90 lea -0x70(%ebp),%eax 123007: 50 push %eax 123008: ff 75 b0 pushl -0x50(%ebp) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ 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; 12300b: 8d 45 e0 lea -0x20(%ebp),%eax _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 12300e: 50 push %eax 12300f: e8 a4 08 00 00 call 1238b8 <_Timespec_Divide_by_integer> (*print)( context, 123014: 8b 45 94 mov -0x6c(%ebp),%eax 123017: 8b 4d 84 mov -0x7c(%ebp),%ecx 12301a: 99 cltd 12301b: f7 f9 idiv %ecx 12301d: 50 push %eax 12301e: ff 75 90 pushl -0x70(%ebp) 123021: 8b 45 dc mov -0x24(%ebp),%eax 123024: 99 cltd 123025: f7 f9 idiv %ecx 123027: 50 push %eax 123028: ff 75 d8 pushl -0x28(%ebp) 12302b: 8b 45 d4 mov -0x2c(%ebp),%eax 12302e: 99 cltd 12302f: f7 f9 idiv %ecx 123031: 50 push %eax 123032: ff 75 d0 pushl -0x30(%ebp) 123035: 68 2c f3 14 00 push $0x14f32c 12303a: 56 push %esi 12303b: ff d3 call *%ebx 12303d: 83 c4 30 add $0x30,%esp * 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++ ) { 123040: 47 inc %edi /* * 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 ; 123041: 3b 3d 80 cd 16 00 cmp 0x16cd80,%edi 123047: 0f 86 12 ff ff ff jbe 122f5f the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 12304d: 8d 65 f4 lea -0xc(%ebp),%esp 123050: 5b pop %ebx 123051: 5e pop %esi 123052: 5f pop %edi 123053: 5d pop %ebp 123054: c3 ret =============================================================================== 0010ab69 : return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { 10ab69: 55 push %ebp 10ab6a: 89 e5 mov %esp,%ebp 10ab6c: 57 push %edi 10ab6d: 56 push %esi 10ab6e: 53 push %ebx 10ab6f: 83 ec 1c sub $0x1c,%esp 10ab72: 8b 4d 08 mov 0x8(%ebp),%ecx 10ab75: 8b 5d 0c mov 0xc(%ebp),%ebx 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; 10ab78: 8b 79 30 mov 0x30(%ecx),%edi #include static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 10ab7b: 89 d8 mov %ebx,%eax 10ab7d: 31 d2 xor %edx,%edx 10ab7f: f7 f7 div %edi if (excess > 0) { 10ab81: 89 de mov %ebx,%esi 10ab83: 85 d2 test %edx,%edx 10ab85: 74 05 je 10ab8c <== ALWAYS TAKEN value += alignment - excess; 10ab87: 8d 34 3b lea (%ebx,%edi,1),%esi <== NOT EXECUTED 10ab8a: 29 d6 sub %edx,%esi <== 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) { 10ab8c: 39 f3 cmp %esi,%ebx 10ab8e: 77 04 ja 10ab94 <== NEVER TAKEN 10ab90: 85 db test %ebx,%ebx 10ab92: 75 07 jne 10ab9b return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; 10ab94: 31 c0 xor %eax,%eax 10ab96: e9 8f 00 00 00 jmp 10ac2a */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10ab9b: 8b 01 mov (%ecx),%eax rtems_chain_control *free_chain, size_t size ) { rtems_chain_node *current = rtems_chain_first(free_chain); const rtems_chain_node *tail = rtems_chain_tail(free_chain); 10ab9d: 8d 51 04 lea 0x4(%ecx),%edx rtems_rbheap_chunk *big_enough = NULL; 10aba0: 31 db xor %ebx,%ebx 10aba2: eb 0e jmp 10abb2 while (current != tail && big_enough == NULL) { rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current; if (free_chunk->size >= size) { 10aba4: 31 db xor %ebx,%ebx 10aba6: 39 70 1c cmp %esi,0x1c(%eax) 10aba9: 0f 93 c3 setae %bl 10abac: f7 db neg %ebx 10abae: 21 c3 and %eax,%ebx rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk)); if (chunk != NULL) { rtems_rbheap_add_to_spare_descriptor_chain(control, chunk); } } 10abb0: 8b 00 mov (%eax),%eax { 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) { 10abb2: 85 db test %ebx,%ebx 10abb4: 75 04 jne 10abba 10abb6: 39 d0 cmp %edx,%eax 10abb8: 75 ea jne 10aba4 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) { 10abba: 85 db test %ebx,%ebx 10abbc: 74 d6 je 10ab94 uintptr_t free_size = free_chunk->size; 10abbe: 8b 53 1c mov 0x1c(%ebx),%edx if (free_size > aligned_size) { 10abc1: 39 f2 cmp %esi,%edx 10abc3: 76 4b jbe 10ac10 rtems_rbheap_chunk *new_chunk = get_chunk(control); 10abc5: 89 c8 mov %ecx,%eax 10abc7: 89 55 e4 mov %edx,-0x1c(%ebp) 10abca: 89 4d e0 mov %ecx,-0x20(%ebp) 10abcd: e8 49 fe ff ff call 10aa1b 10abd2: 89 c7 mov %eax,%edi if (new_chunk != NULL) { 10abd4: 85 c0 test %eax,%eax 10abd6: 8b 55 e4 mov -0x1c(%ebp),%edx 10abd9: 8b 4d e0 mov -0x20(%ebp),%ecx 10abdc: 74 b6 je 10ab94 <== NEVER TAKEN uintptr_t new_free_size = free_size - aligned_size; 10abde: 29 f2 sub %esi,%edx free_chunk->size = new_free_size; 10abe0: 89 53 1c mov %edx,0x1c(%ebx) new_chunk->begin = free_chunk->begin + new_free_size; 10abe3: 03 53 18 add 0x18(%ebx),%edx 10abe6: 89 50 18 mov %edx,0x18(%eax) new_chunk->size = aligned_size; 10abe9: 89 70 1c mov %esi,0x1c(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 10abec: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 10abf3: c7 00 00 00 00 00 movl $0x0,(%eax) static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 10abf9: 53 push %ebx 10abfa: 53 push %ebx 10abfb: 8d 40 08 lea 0x8(%eax),%eax 10abfe: 50 push %eax void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; 10abff: 83 c1 18 add $0x18,%ecx static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 10ac02: 51 push %ecx 10ac03: e8 20 15 00 00 call 10c128 <_RBTree_Insert_unprotected> 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; 10ac08: 8b 47 18 mov 0x18(%edi),%eax 10ac0b: 83 c4 10 add $0x10,%esp 10ac0e: eb 1a jmp 10ac2a ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10ac10: 8b 13 mov (%ebx),%edx previous = the_node->previous; 10ac12: 8b 43 04 mov 0x4(%ebx),%eax next->previous = previous; 10ac15: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 10ac18: 89 10 mov %edx,(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 10ac1a: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) 10ac21: c7 03 00 00 00 00 movl $0x0,(%ebx) } } else { rtems_chain_extract_unprotected(&free_chunk->chain_node); rtems_chain_set_off_chain(&free_chunk->chain_node); ptr = (void *) free_chunk->begin; 10ac27: 8b 43 18 mov 0x18(%ebx),%eax } } } return ptr; } 10ac2a: 8d 65 f4 lea -0xc(%ebp),%esp 10ac2d: 5b pop %ebx 10ac2e: 5e pop %esi 10ac2f: 5f pop %edi 10ac30: 5d pop %ebp 10ac31: c3 ret =============================================================================== 0010ad25 : void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control) { 10ad25: 55 push %ebp <== NOT EXECUTED 10ad26: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad28: 53 push %ebx <== NOT EXECUTED 10ad29: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ad2c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk)); 10ad2f: 6a 20 push $0x20 <== NOT EXECUTED 10ad31: e8 3e c2 ff ff call 106f74 <== NOT EXECUTED if (chunk != NULL) { 10ad36: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad39: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad3b: 74 11 je 10ad4e <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node); 10ad3d: 8d 53 0c lea 0xc(%ebx),%edx <== NOT EXECUTED 10ad40: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 10ad43: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED after_node->next = the_node; 10ad46: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED the_node->next = before_node; 10ad49: 89 10 mov %edx,(%eax) <== NOT EXECUTED before_node->previous = the_node; 10ad4b: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED rtems_rbheap_add_to_spare_descriptor_chain(control, chunk); } } 10ad4e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ad51: c9 leave <== NOT EXECUTED 10ad52: c3 ret <== NOT EXECUTED =============================================================================== 0010ac32 : _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { 10ac32: 55 push %ebp 10ac33: 89 e5 mov %esp,%ebp 10ac35: 57 push %edi 10ac36: 56 push %esi 10ac37: 53 push %ebx 10ac38: 83 ec 3c sub $0x3c,%esp 10ac3b: 8b 5d 08 mov 0x8(%ebp),%ebx 10ac3e: 8b 55 0c mov 0xc(%ebp),%edx rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { 10ac41: 85 d2 test %edx,%edx 10ac43: 0f 84 c6 00 00 00 je 10ad0f rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; 10ac49: 8d 73 18 lea 0x18(%ebx),%esi #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 }; 10ac4c: 8d 7d c8 lea -0x38(%ebp),%edi 10ac4f: b9 08 00 00 00 mov $0x8,%ecx 10ac54: 31 c0 xor %eax,%eax 10ac56: f3 ab rep stos %eax,%es:(%edi) 10ac58: 89 55 e0 mov %edx,-0x20(%ebp) RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; 10ac5b: 8b 53 1c mov 0x1c(%ebx),%edx RBTree_Node* found = NULL; 10ac5e: 31 ff xor %edi,%edi return rtems_rbheap_chunk_of_node( 10ac60: 8d 4d d0 lea -0x30(%ebp),%ecx 10ac63: eb 2e jmp 10ac93 int compare_result; while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); 10ac65: 50 push %eax 10ac66: 50 push %eax 10ac67: 52 push %edx 10ac68: 51 push %ecx 10ac69: 89 55 c0 mov %edx,-0x40(%ebp) 10ac6c: 89 4d bc mov %ecx,-0x44(%ebp) 10ac6f: ff 56 10 call *0x10(%esi) if ( _RBTree_Is_equal( compare_result ) ) { 10ac72: 83 c4 10 add $0x10,%esp 10ac75: 85 c0 test %eax,%eax 10ac77: 8b 55 c0 mov -0x40(%ebp),%edx 10ac7a: 8b 4d bc mov -0x44(%ebp),%ecx 10ac7d: 75 08 jne 10ac87 found = iter_node; if ( the_rbtree->is_unique ) 10ac7f: 80 7e 14 00 cmpb $0x0,0x14(%esi) 10ac83: 75 14 jne 10ac99 <== ALWAYS TAKEN 10ac85: 89 d7 mov %edx,%edi <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater( int compare_result ) { return compare_result > 0; 10ac87: 85 c0 test %eax,%eax 10ac89: 0f 9f c0 setg %al 10ac8c: 0f b6 c0 movzbl %al,%eax break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 10ac8f: 8b 54 82 04 mov 0x4(%edx,%eax,4),%edx ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { 10ac93: 85 d2 test %edx,%edx 10ac95: 75 ce jne 10ac65 10ac97: 89 fa mov %edi,%edx 10ac99: 8d 7a f8 lea -0x8(%edx),%edi 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) { 10ac9c: 83 ff f8 cmp $0xfffffff8,%edi 10ac9f: 74 72 je 10ad13 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 10aca1: 31 c9 xor %ecx,%ecx 10aca3: 83 7a f8 00 cmpl $0x0,-0x8(%edx) 10aca7: 75 09 jne 10acb2 10aca9: 31 c9 xor %ecx,%ecx 10acab: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10acaf: 0f 94 c1 sete %cl check_and_merge(free_chain, chunk_tree, chunk, succ); add_to_chain(free_chain, chunk); check_and_merge(free_chain, chunk_tree, chunk, pred); } else { sc = RTEMS_INCORRECT_STATE; 10acb2: b8 0e 00 00 00 mov $0xe,%eax 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) { if (!rtems_rbheap_is_chunk_free(chunk)) { 10acb7: 85 c9 test %ecx,%ecx 10acb9: 74 5d je 10ad18 static rtems_rbheap_chunk *get_next( const rtems_rbheap_chunk *chunk, RBTree_Direction dir ) { return rtems_rbheap_chunk_of_node( 10acbb: 8d 57 08 lea 0x8(%edi),%edx 10acbe: 50 push %eax 10acbf: 50 push %eax 10acc0: 6a 00 push $0x0 10acc2: 52 push %edx 10acc3: 89 55 c0 mov %edx,-0x40(%ebp) 10acc6: e8 4d 16 00 00 call 10c318 <_RBTree_Next_unprotected> 10accb: 89 45 c4 mov %eax,-0x3c(%ebp) 10acce: 58 pop %eax 10accf: 5a pop %edx 10acd0: 6a 01 push $0x1 10acd2: 8b 55 c0 mov -0x40(%ebp),%edx 10acd5: 52 push %edx 10acd6: e8 3d 16 00 00 call 10c318 <_RBTree_Next_unprotected> 10acdb: 83 e8 08 sub $0x8,%eax 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); 10acde: 89 04 24 mov %eax,(%esp) 10ace1: 89 f9 mov %edi,%ecx 10ace3: 89 f2 mov %esi,%edx 10ace5: 89 d8 mov %ebx,%eax 10ace7: e8 c5 fc ff ff call 10a9b1 Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10acec: 89 5f 04 mov %ebx,0x4(%edi) before_node = after_node->next; 10acef: 8b 03 mov (%ebx),%eax after_node->next = the_node; 10acf1: 89 3b mov %edi,(%ebx) the_node->next = before_node; 10acf3: 89 07 mov %eax,(%edi) before_node->previous = the_node; 10acf5: 89 78 04 mov %edi,0x4(%eax) static rtems_rbheap_chunk *get_next( const rtems_rbheap_chunk *chunk, RBTree_Direction dir ) { return rtems_rbheap_chunk_of_node( 10acf8: 8b 45 c4 mov -0x3c(%ebp),%eax 10acfb: 83 e8 08 sub $0x8,%eax 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); add_to_chain(free_chain, chunk); check_and_merge(free_chain, chunk_tree, chunk, pred); 10acfe: 89 04 24 mov %eax,(%esp) 10ad01: 89 f9 mov %edi,%ecx 10ad03: 89 f2 mov %esi,%edx 10ad05: 89 d8 mov %ebx,%eax 10ad07: e8 a5 fc ff ff call 10a9b1 10ad0c: 83 c4 10 add $0x10,%esp } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { rtems_status_code sc = RTEMS_SUCCESSFUL; 10ad0f: 31 c0 xor %eax,%eax 10ad11: eb 05 jmp 10ad18 check_and_merge(free_chain, chunk_tree, chunk, pred); } else { sc = RTEMS_INCORRECT_STATE; } } else { sc = RTEMS_INVALID_ID; 10ad13: b8 04 00 00 00 mov $0x4,%eax } } return sc; } 10ad18: 8d 65 f4 lea -0xc(%ebp),%esp 10ad1b: 5b pop %ebx 10ad1c: 5e pop %esi 10ad1d: 5f pop %edi 10ad1e: 5d pop %ebp 10ad1f: c3 ret =============================================================================== 00114e78 : rtems_status_code rtems_region_extend( rtems_id id, void *starting_address, uintptr_t length ) { 114e78: 55 push %ebp 114e79: 89 e5 mov %esp,%ebp 114e7b: 57 push %edi 114e7c: 56 push %esi 114e7d: 53 push %ebx 114e7e: 83 ec 1c sub $0x1c,%esp 114e81: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 114e84: be 09 00 00 00 mov $0x9,%esi bool extend_ok; Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) 114e89: 85 ff test %edi,%edi 114e8b: 74 69 je 114ef6 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 114e8d: 83 ec 0c sub $0xc,%esp 114e90: ff 35 a8 57 14 00 pushl 0x1457a8 114e96: e8 31 20 00 00 call 116ecc <_API_Mutex_Lock> RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 114e9b: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 114e9e: 8d 45 e4 lea -0x1c(%ebp),%eax 114ea1: 50 push %eax 114ea2: ff 75 08 pushl 0x8(%ebp) 114ea5: 68 18 56 14 00 push $0x145618 114eaa: e8 09 38 00 00 call 1186b8 <_Objects_Get_no_protection> 114eaf: 89 c3 mov %eax,%ebx switch ( location ) { 114eb1: 83 c4 10 add $0x10,%esp 114eb4: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 114eb8: 75 26 jne 114ee0 case OBJECTS_LOCAL: extend_ok = _Heap_Extend( 114eba: 8d 45 e0 lea -0x20(%ebp),%eax 114ebd: 50 push %eax 114ebe: ff 75 10 pushl 0x10(%ebp) 114ec1: 57 push %edi 114ec2: 8d 43 68 lea 0x68(%ebx),%eax 114ec5: 50 push %eax 114ec6: e8 9c 2a 00 00 call 117967 <_Heap_Extend> starting_address, length, &amount_extended ); if ( extend_ok ) { 114ecb: 83 c4 10 add $0x10,%esp 114ece: 84 c0 test %al,%al 114ed0: 74 13 je 114ee5 <== ALWAYS TAKEN the_region->length += amount_extended; 114ed2: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 114ed5: 01 43 54 add %eax,0x54(%ebx) <== NOT EXECUTED the_region->maximum_segment_size += amount_extended; 114ed8: 01 43 5c add %eax,0x5c(%ebx) <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; 114edb: 66 31 f6 xor %si,%si <== NOT EXECUTED 114ede: eb 05 jmp 114ee5 <== NOT EXECUTED break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 114ee0: be 04 00 00 00 mov $0x4,%esi break; } _RTEMS_Unlock_allocator(); 114ee5: 83 ec 0c sub $0xc,%esp 114ee8: ff 35 a8 57 14 00 pushl 0x1457a8 114eee: e8 21 20 00 00 call 116f14 <_API_Mutex_Unlock> 114ef3: 83 c4 10 add $0x10,%esp return return_status; } 114ef6: 89 f0 mov %esi,%eax 114ef8: 8d 65 f4 lea -0xc(%ebp),%esp 114efb: 5b pop %ebx 114efc: 5e pop %esi 114efd: 5f pop %edi 114efe: 5d pop %ebp 114eff: c3 ret =============================================================================== 00115724 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 115724: 55 push %ebp 115725: 89 e5 mov %esp,%ebp 115727: 53 push %ebx 115728: 83 ec 14 sub $0x14,%esp 11572b: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; 11572e: b8 0a 00 00 00 mov $0xa,%eax register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 115733: 85 db test %ebx,%ebx 115735: 74 6d je 1157a4 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 115737: 50 push %eax 115738: 50 push %eax 115739: 8d 45 f4 lea -0xc(%ebp),%eax 11573c: 50 push %eax 11573d: ff 75 08 pushl 0x8(%ebp) 115740: e8 4f 3b 00 00 call 119294 <_Thread_Get> switch ( location ) { 115745: 83 c4 10 add $0x10,%esp 115748: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 11574c: 75 51 jne 11579f case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 11574e: 8b 90 e0 00 00 00 mov 0xe0(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 115754: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 115758: 74 39 je 115793 if ( asr->is_enabled ) { 11575a: 80 7a 08 00 cmpb $0x0,0x8(%edx) 11575e: 74 22 je 115782 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115760: 9c pushf 115761: fa cli 115762: 59 pop %ecx *signal_set |= signals; 115763: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 115766: 51 push %ecx 115767: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 115768: 83 3d 1c 59 14 00 00 cmpl $0x0,0x14591c 11576f: 74 19 je 11578a 115771: 3b 05 20 59 14 00 cmp 0x145920,%eax 115777: 75 11 jne 11578a <== NEVER TAKEN _Thread_Dispatch_necessary = true; 115779: c6 05 2c 59 14 00 01 movb $0x1,0x14592c 115780: eb 08 jmp 11578a rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115782: 9c pushf 115783: fa cli 115784: 58 pop %eax *signal_set |= signals; 115785: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 115788: 50 push %eax 115789: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 11578a: e8 e5 3a 00 00 call 119274 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11578f: 31 c0 xor %eax,%eax 115791: eb 11 jmp 1157a4 } _Thread_Enable_dispatch(); 115793: e8 dc 3a 00 00 call 119274 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 115798: b8 0b 00 00 00 mov $0xb,%eax 11579d: eb 05 jmp 1157a4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11579f: b8 04 00 00 00 mov $0x4,%eax } 1157a4: 8b 5d fc mov -0x4(%ebp),%ebx 1157a7: c9 leave 1157a8: c3 ret =============================================================================== 0010b68c : rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 10b68c: 55 push %ebp 10b68d: 89 e5 mov %esp,%ebp 10b68f: 56 push %esi 10b690: 53 push %ebx 10b691: 83 ec 10 sub $0x10,%esp 10b694: 8b 55 08 mov 0x8(%ebp),%edx 10b697: 8b 75 0c mov 0xc(%ebp),%esi 10b69a: 8b 5d 10 mov 0x10(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; 10b69d: b8 16 00 00 00 mov $0x16,%eax { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10b6a2: 80 3d 74 b7 12 00 00 cmpb $0x0,0x12b774 10b6a9: 74 5d je 10b708 <== NEVER TAKEN return RTEMS_NOT_CONFIGURED; if ( !note ) 10b6ab: 85 db test %ebx,%ebx 10b6ad: 74 4d je 10b6fc * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) return RTEMS_INVALID_NUMBER; 10b6af: b0 0a mov $0xa,%al /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10b6b1: 83 fe 0f cmp $0xf,%esi 10b6b4: 77 52 ja 10b708 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10b6b6: 85 d2 test %edx,%edx 10b6b8: a1 d8 fd 12 00 mov 0x12fdd8,%eax 10b6bd: 74 05 je 10b6c4 10b6bf: 3b 50 08 cmp 0x8(%eax),%edx 10b6c2: 75 0e jne 10b6d2 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10b6c4: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 10b6ca: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10b6ce: 89 03 mov %eax,(%ebx) 10b6d0: eb 26 jmp 10b6f8 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10b6d2: 50 push %eax 10b6d3: 50 push %eax 10b6d4: 8d 45 f4 lea -0xc(%ebp),%eax 10b6d7: 50 push %eax 10b6d8: 52 push %edx 10b6d9: e8 8e 1f 00 00 call 10d66c <_Thread_Get> switch ( location ) { 10b6de: 83 c4 10 add $0x10,%esp 10b6e1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10b6e5: 75 1c jne 10b703 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10b6e7: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax 10b6ed: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10b6f1: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b6f3: e8 54 1f 00 00 call 10d64c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b6f8: 31 c0 xor %eax,%eax 10b6fa: eb 0c jmp 10b708 if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) return RTEMS_INVALID_ADDRESS; 10b6fc: b8 09 00 00 00 mov $0x9,%eax 10b701: eb 05 jmp 10b708 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b703: b8 04 00 00 00 mov $0x4,%eax } 10b708: 8d 65 f8 lea -0x8(%ebp),%esp 10b70b: 5b pop %ebx 10b70c: 5e pop %esi 10b70d: 5d pop %ebp 10b70e: c3 ret =============================================================================== 0010fe34 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 10fe34: 55 push %ebp 10fe35: 89 e5 mov %esp,%ebp 10fe37: 57 push %edi 10fe38: 56 push %esi 10fe39: 53 push %ebx 10fe3a: 83 ec 1c sub $0x1c,%esp ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 10fe3d: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fe41: 0f 84 00 01 00 00 je 10ff47 return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 10fe47: 8b 35 68 c5 12 00 mov 0x12c568,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10fe4d: 8b 9e e0 00 00 00 mov 0xe0(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 10fe53: 80 7e 70 01 cmpb $0x1,0x70(%esi) 10fe57: 19 ff sbb %edi,%edi 10fe59: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 10fe5f: 83 7e 78 00 cmpl $0x0,0x78(%esi) 10fe63: 74 06 je 10fe6b old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 10fe65: 81 cf 00 02 00 00 or $0x200,%edi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 10fe6b: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 10fe6f: 19 c9 sbb %ecx,%ecx 10fe71: 81 e1 00 04 00 00 and $0x400,%ecx old_mode |= _ISR_Get_level(); 10fe77: 89 4d e4 mov %ecx,-0x1c(%ebp) 10fe7a: e8 d1 cf ff ff call 10ce50 <_CPU_ISR_Get_level> 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; 10fe7f: 8b 4d e4 mov -0x1c(%ebp),%ecx 10fe82: 09 c8 or %ecx,%eax old_mode |= _ISR_Get_level(); 10fe84: 09 f8 or %edi,%eax 10fe86: 8b 55 10 mov 0x10(%ebp),%edx 10fe89: 89 02 mov %eax,(%edx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 10fe8b: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 10fe92: 74 0f je 10fea3 10fe94: 8b 45 08 mov 0x8(%ebp),%eax 10fe97: c1 e8 08 shr $0x8,%eax 10fe9a: 83 f0 01 xor $0x1,%eax 10fe9d: 83 e0 01 and $0x1,%eax 10fea0: 88 46 70 mov %al,0x70(%esi) executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; if ( mask & RTEMS_TIMESLICE_MASK ) { 10fea3: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 10feaa: 74 21 je 10fecd if ( _Modes_Is_timeslice(mode_set) ) { 10feac: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 10feb3: 74 11 je 10fec6 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10feb5: c7 46 78 01 00 00 00 movl $0x1,0x78(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10febc: a1 40 c3 12 00 mov 0x12c340,%eax 10fec1: 89 46 74 mov %eax,0x74(%esi) 10fec4: eb 07 jmp 10fecd } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10fec6: c7 46 78 00 00 00 00 movl $0x0,0x78(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10fecd: f6 45 0c 01 testb $0x1,0xc(%ebp) 10fed1: 74 0a je 10fedd */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 10fed3: f6 45 08 01 testb $0x1,0x8(%ebp) 10fed7: 74 03 je 10fedc 10fed9: fa cli 10feda: eb 01 jmp 10fedd 10fedc: fb sti /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 10fedd: 31 d2 xor %edx,%edx if ( mask & RTEMS_ASR_MASK ) { 10fedf: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 10fee6: 74 2c je 10ff14 is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; 10fee8: 8b 45 08 mov 0x8(%ebp),%eax 10feeb: c1 e8 0a shr $0xa,%eax 10feee: 83 f0 01 xor $0x1,%eax 10fef1: 83 e0 01 and $0x1,%eax if ( is_asr_enabled != asr->is_enabled ) { 10fef4: 3a 43 08 cmp 0x8(%ebx),%al 10fef7: 74 1b je 10ff14 asr->is_enabled = is_asr_enabled; 10fef9: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 10fefc: 9c pushf 10fefd: fa cli 10fefe: 58 pop %eax _signals = information->signals_pending; 10feff: 8b 53 18 mov 0x18(%ebx),%edx information->signals_pending = information->signals_posted; 10ff02: 8b 4b 14 mov 0x14(%ebx),%ecx 10ff05: 89 4b 18 mov %ecx,0x18(%ebx) information->signals_posted = _signals; 10ff08: 89 53 14 mov %edx,0x14(%ebx) _ISR_Enable( _level ); 10ff0b: 50 push %eax 10ff0c: 9d popf _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 10ff0d: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10ff11: 0f 95 c2 setne %dl if ( _System_state_Is_up( _System_state_Get() ) ) { if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; 10ff14: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 10ff16: 83 3d a8 c4 12 00 03 cmpl $0x3,0x12c4a8 10ff1d: 75 2d jne 10ff4c bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 10ff1f: 8b 0d 68 c5 12 00 mov 0x12c568,%ecx if ( are_signals_pending || 10ff25: 84 d2 test %dl,%dl 10ff27: 75 0e jne 10ff37 10ff29: 3b 0d 6c c5 12 00 cmp 0x12c56c,%ecx 10ff2f: 74 1b je 10ff4c (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 10ff31: 80 79 70 00 cmpb $0x0,0x70(%ecx) 10ff35: 74 15 je 10ff4c <== NEVER TAKEN _Thread_Dispatch_necessary = true; 10ff37: c6 05 74 c5 12 00 01 movb $0x1,0x12c574 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 10ff3e: e8 1d bd ff ff call 10bc60 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 10ff43: 31 c0 xor %eax,%eax 10ff45: eb 05 jmp 10ff4c bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) return RTEMS_INVALID_ADDRESS; 10ff47: b8 09 00 00 00 mov $0x9,%eax if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; } 10ff4c: 83 c4 1c add $0x1c,%esp 10ff4f: 5b pop %ebx 10ff50: 5e pop %esi 10ff51: 5f pop %edi 10ff52: 5d pop %ebp 10ff53: c3 ret =============================================================================== 0010d48c : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10d48c: 55 push %ebp 10d48d: 89 e5 mov %esp,%ebp 10d48f: 56 push %esi 10d490: 53 push %ebx 10d491: 83 ec 10 sub $0x10,%esp 10d494: 8b 5d 0c mov 0xc(%ebp),%ebx 10d497: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10d49a: 85 db test %ebx,%ebx 10d49c: 74 10 je 10d4ae 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 ) ); 10d49e: 0f b6 15 88 c1 12 00 movzbl 0x12c188,%edx !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10d4a5: b8 13 00 00 00 mov $0x13,%eax ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10d4aa: 39 d3 cmp %edx,%ebx 10d4ac: 77 52 ja 10d500 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10d4ae: b8 09 00 00 00 mov $0x9,%eax if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10d4b3: 85 f6 test %esi,%esi 10d4b5: 74 49 je 10d500 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10d4b7: 51 push %ecx 10d4b8: 51 push %ecx 10d4b9: 8d 45 f4 lea -0xc(%ebp),%eax 10d4bc: 50 push %eax 10d4bd: ff 75 08 pushl 0x8(%ebp) 10d4c0: e8 67 1d 00 00 call 10f22c <_Thread_Get> switch ( location ) { 10d4c5: 83 c4 10 add $0x10,%esp 10d4c8: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10d4cc: 75 2d jne 10d4fb case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10d4ce: 8b 50 14 mov 0x14(%eax),%edx 10d4d1: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10d4d3: 85 db test %ebx,%ebx 10d4d5: 74 1b je 10d4f2 the_thread->real_priority = new_priority; 10d4d7: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10d4da: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10d4de: 74 05 je 10d4e5 10d4e0: 39 58 14 cmp %ebx,0x14(%eax) 10d4e3: 76 0d jbe 10d4f2 <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10d4e5: 52 push %edx 10d4e6: 6a 00 push $0x0 10d4e8: 53 push %ebx 10d4e9: 50 push %eax 10d4ea: e8 2d 19 00 00 call 10ee1c <_Thread_Change_priority> 10d4ef: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10d4f2: e8 15 1d 00 00 call 10f20c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10d4f7: 31 c0 xor %eax,%eax 10d4f9: eb 05 jmp 10d500 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10d4fb: b8 04 00 00 00 mov $0x4,%eax } 10d500: 8d 65 f8 lea -0x8(%ebp),%esp 10d503: 5b pop %ebx 10d504: 5e pop %esi 10d505: 5d pop %ebp 10d506: c3 ret =============================================================================== 00115fac : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 115fac: 55 push %ebp 115fad: 89 e5 mov %esp,%ebp 115faf: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 115fb2: 8d 45 f4 lea -0xc(%ebp),%eax RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 115fb5: 50 push %eax 115fb6: ff 75 08 pushl 0x8(%ebp) 115fb9: 68 a0 59 14 00 push $0x1459a0 115fbe: e8 31 27 00 00 call 1186f4 <_Objects_Get> switch ( location ) { 115fc3: 83 c4 10 add $0x10,%esp 115fc6: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 115fca: 75 1e jne 115fea case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 115fcc: 83 78 38 04 cmpl $0x4,0x38(%eax) 115fd0: 74 0f je 115fe1 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 115fd2: 83 ec 0c sub $0xc,%esp 115fd5: 83 c0 10 add $0x10,%eax 115fd8: 50 push %eax 115fd9: e8 0e 40 00 00 call 119fec <_Watchdog_Remove> 115fde: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 115fe1: e8 8e 32 00 00 call 119274 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115fe6: 31 c0 xor %eax,%eax 115fe8: eb 05 jmp 115fef #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115fea: b8 04 00 00 00 mov $0x4,%eax } 115fef: c9 leave 115ff0: c3 ret =============================================================================== 001168b9 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 1168b9: 55 push %ebp 1168ba: 89 e5 mov %esp,%ebp 1168bc: 53 push %ebx 1168bd: 83 ec 24 sub $0x24,%esp 1168c0: 8b 55 08 mov 0x8(%ebp),%edx */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 1168c3: 31 c0 xor %eax,%eax 1168c5: 85 d2 test %edx,%edx 1168c7: 74 0f je 1168d8 ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 1168c9: 0f b6 05 88 d1 13 00 movzbl 0x13d188,%eax */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 1168d0: 39 c2 cmp %eax,%edx 1168d2: 0f 96 c0 setbe %al 1168d5: 0f b6 c0 movzbl %al,%eax * Make sure the requested priority is valid. The if is * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { 1168d8: 85 c0 test %eax,%eax 1168da: 75 0d jne 1168e9 if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) return RTEMS_INVALID_PRIORITY; 1168dc: b0 13 mov $0x13,%al * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 1168de: 42 inc %edx 1168df: 0f 85 5c 01 00 00 jne 116a41 return RTEMS_INVALID_PRIORITY; _priority = 0; 1168e5: 31 db xor %ebx,%ebx 1168e7: eb 02 jmp 1168eb * Make sure the requested priority is valid. The if is * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { 1168e9: 89 d3 mov %edx,%ebx 1168eb: e8 78 fc ff ff call 116568 <_Thread_Dispatch_increment_disable_level> /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 1168f0: 8a 15 84 10 14 00 mov 0x141084,%dl initialized = true; 1168f6: c6 05 84 10 14 00 01 movb $0x1,0x141084 _Thread_Enable_dispatch(); 1168fd: 88 55 e4 mov %dl,-0x1c(%ebp) 116900: e8 6f 29 00 00 call 119274 <_Thread_Enable_dispatch> if ( tmpInitialized ) return RTEMS_INCORRECT_STATE; 116905: b8 0e 00 00 00 mov $0xe,%eax _Thread_Disable_dispatch(); tmpInitialized = initialized; initialized = true; _Thread_Enable_dispatch(); if ( tmpInitialized ) 11690a: 8a 55 e4 mov -0x1c(%ebp),%dl 11690d: 84 d2 test %dl,%dl 11690f: 0f 85 2c 01 00 00 jne 116a41 <== NEVER TAKEN * other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 116915: 50 push %eax 116916: 50 push %eax 116917: 8d 45 f4 lea -0xc(%ebp),%eax 11691a: 50 push %eax 11691b: 8b 45 10 mov 0x10(%ebp),%eax 11691e: 80 cc 80 or $0x80,%ah 116921: 50 push %eax 116922: 68 00 01 00 00 push $0x100 116927: ff 75 0c pushl 0xc(%ebp) 11692a: 53 push %ebx 11692b: 68 45 4d 49 54 push $0x54494d45 116930: e8 77 ee ff ff call 1157ac /* user may want floating point but we need */ /* system task specified for 0 priority */ attribute_set | RTEMS_SYSTEM_TASK, &id /* get the id back */ ); if (status) { 116935: 83 c4 20 add $0x20,%esp 116938: 85 c0 test %eax,%eax 11693a: 74 0c je 116948 initialized = false; 11693c: c6 05 84 10 14 00 00 movb $0x0,0x141084 116943: e9 f9 00 00 00 jmp 116a41 * We work with the TCB pointer, not the ID, so we need to convert * to a TCB pointer from here out. */ ts->thread = (Thread_Control *)_Objects_Get_local_object( &_RTEMS_tasks_Information, _Objects_Get_index(id) 116948: 8b 5d f4 mov -0xc(%ebp),%ebx */ #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return NULL; #endif return information->local_table[ index ]; 11694b: 0f b7 d3 movzwl %bx,%edx 11694e: a1 b4 56 14 00 mov 0x1456b4,%eax 116953: 8b 04 90 mov (%eax,%edx,4),%eax /* * We work with the TCB pointer, not the ID, so we need to convert * to a TCB pointer from here out. */ ts->thread = (Thread_Control *)_Objects_Get_local_object( 116956: a3 88 10 14 00 mov %eax,0x141088 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 11695b: c7 05 b8 10 14 00 bc movl $0x1410bc,0x1410b8 116962: 10 14 00 head->previous = NULL; 116965: c7 05 bc 10 14 00 00 movl $0x0,0x1410bc 11696c: 00 00 00 tail->previous = head; 11696f: c7 05 c0 10 14 00 b8 movl $0x1410b8,0x1410c0 116976: 10 14 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116979: c7 05 f0 10 14 00 f4 movl $0x1410f4,0x1410f0 116980: 10 14 00 head->previous = NULL; 116983: c7 05 f4 10 14 00 00 movl $0x0,0x1410f4 11698a: 00 00 00 tail->previous = head; 11698d: c7 05 f8 10 14 00 f0 movl $0x1410f0,0x1410f8 116994: 10 14 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 116997: c7 05 98 10 14 00 00 movl $0x0,0x141098 11699e: 00 00 00 the_watchdog->routine = routine; 1169a1: c7 05 ac 10 14 00 f8 movl $0x1190f8,0x1410ac 1169a8: 90 11 00 the_watchdog->id = id; 1169ab: 89 1d b0 10 14 00 mov %ebx,0x1410b0 the_watchdog->user_data = user_data; 1169b1: c7 05 b4 10 14 00 00 movl $0x0,0x1410b4 1169b8: 00 00 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1169bb: c7 05 d0 10 14 00 00 movl $0x0,0x1410d0 1169c2: 00 00 00 the_watchdog->routine = routine; 1169c5: c7 05 e4 10 14 00 f8 movl $0x1190f8,0x1410e4 1169cc: 90 11 00 the_watchdog->id = id; 1169cf: 89 1d e8 10 14 00 mov %ebx,0x1410e8 the_watchdog->user_data = user_data; 1169d5: c7 05 ec 10 14 00 00 movl $0x0,0x1410ec 1169dc: 00 00 00 /* * Initialize the pointer to the timer schedule method so applications that * do not use the Timer Server do not have to pull it in. */ ts->schedule_operation = _Timer_server_Schedule_operation_method; 1169df: c7 05 8c 10 14 00 09 movl $0x116609,0x14108c 1169e6: 66 11 00 ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; 1169e9: a1 10 58 14 00 mov 0x145810,%eax 1169ee: a3 c4 10 14 00 mov %eax,0x1410c4 1169f3: 6a 00 push $0x0 1169f5: 68 00 ca 9a 3b push $0x3b9aca00 1169fa: ff 35 dc 56 14 00 pushl 0x1456dc 116a00: ff 35 d8 56 14 00 pushl 0x1456d8 116a06: e8 29 2f 01 00 call 129934 <__divdi3> 116a0b: 83 c4 0c add $0xc,%esp ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 116a0e: a3 fc 10 14 00 mov %eax,0x1410fc ts->insert_chain = NULL; 116a13: c7 05 00 11 14 00 00 movl $0x0,0x141100 116a1a: 00 00 00 ts->active = false; 116a1d: c6 05 04 11 14 00 00 movb $0x0,0x141104 /* * The default timer server is now available. */ _Timer_server = ts; 116a24: c7 05 e0 59 14 00 88 movl $0x141088,0x1459e0 116a2b: 10 14 00 /* * Start the timer server */ status = rtems_task_start( 116a2e: 68 88 10 14 00 push $0x141088 116a33: 68 32 67 11 00 push $0x116732 116a38: 53 push %ebx 116a39: e8 56 f3 ff ff call 115d94 116a3e: 83 c4 10 add $0x10,%esp initialized = false; } #endif return status; } 116a41: 8b 5d fc mov -0x4(%ebp),%ebx 116a44: c9 leave 116a45: c3 ret =============================================================================== 0011645c : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 11645c: 55 push %ebp 11645d: 89 e5 mov %esp,%ebp 11645f: 57 push %edi 116460: 56 push %esi 116461: 53 push %ebx 116462: 83 ec 1c sub $0x1c,%esp 116465: 8b 75 0c mov 0xc(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 116468: 8b 1d e0 59 14 00 mov 0x1459e0,%ebx if ( !timer_server ) 11646e: 85 db test %ebx,%ebx 116470: 0f 84 e1 00 00 00 je 116557 return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; 116476: b8 0b 00 00 00 mov $0xb,%eax Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) 11647b: 80 3d ec 56 14 00 00 cmpb $0x0,0x1456ec 116482: 0f 84 d6 00 00 00 je 11655e <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 116488: b0 09 mov $0x9,%al return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 11648a: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 11648e: 0f 84 ca 00 00 00 je 11655e return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116494: 83 ec 0c sub $0xc,%esp 116497: 56 push %esi 116498: e8 b3 d4 ff ff call 113950 <_TOD_Validate> 11649d: 83 c4 10 add $0x10,%esp 1164a0: 84 c0 test %al,%al 1164a2: 75 0a jne 1164ae return RTEMS_INVALID_CLOCK; 1164a4: b8 14 00 00 00 mov $0x14,%eax 1164a9: e9 b0 00 00 00 jmp 11655e seconds = _TOD_To_seconds( wall_time ); 1164ae: 83 ec 0c sub $0xc,%esp 1164b1: 56 push %esi 1164b2: e8 25 d4 ff ff call 1138dc <_TOD_To_seconds> 1164b7: 89 c6 mov %eax,%esi 1164b9: 6a 00 push $0x0 1164bb: 68 00 ca 9a 3b push $0x3b9aca00 1164c0: ff 35 dc 56 14 00 pushl 0x1456dc 1164c6: ff 35 d8 56 14 00 pushl 0x1456d8 1164cc: e8 63 34 01 00 call 129934 <__divdi3> if ( seconds <= _TOD_Seconds_since_epoch() ) 1164d1: 83 c4 20 add $0x20,%esp 1164d4: 39 c6 cmp %eax,%esi 1164d6: 76 cc jbe 1164a4 1164d8: 50 push %eax return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 1164d9: 8d 45 e4 lea -0x1c(%ebp),%eax 1164dc: 50 push %eax 1164dd: ff 75 08 pushl 0x8(%ebp) 1164e0: 68 a0 59 14 00 push $0x1459a0 1164e5: e8 0a 22 00 00 call 1186f4 <_Objects_Get> 1164ea: 89 c7 mov %eax,%edi switch ( location ) { 1164ec: 83 c4 10 add $0x10,%esp #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1164ef: b8 04 00 00 00 mov $0x4,%eax seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1164f4: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 1164f8: 75 64 jne 11655e case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1164fa: 83 ec 0c sub $0xc,%esp 1164fd: 8d 47 10 lea 0x10(%edi),%eax 116500: 50 push %eax 116501: e8 e6 3a 00 00 call 119fec <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 116506: c7 47 38 03 00 00 00 movl $0x3,0x38(%edi) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 11650d: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 116514: 8b 45 10 mov 0x10(%ebp),%eax 116517: 89 47 2c mov %eax,0x2c(%edi) the_watchdog->id = id; 11651a: 8b 45 08 mov 0x8(%ebp),%eax 11651d: 89 47 30 mov %eax,0x30(%edi) the_watchdog->user_data = user_data; 116520: 8b 45 14 mov 0x14(%ebp),%eax 116523: 89 47 34 mov %eax,0x34(%edi) 116526: 6a 00 push $0x0 116528: 68 00 ca 9a 3b push $0x3b9aca00 11652d: ff 35 dc 56 14 00 pushl 0x1456dc 116533: ff 35 d8 56 14 00 pushl 0x1456d8 116539: e8 f6 33 01 00 call 129934 <__divdi3> _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 11653e: 29 c6 sub %eax,%esi 116540: 89 77 1c mov %esi,0x1c(%edi) (*timer_server->schedule_operation)( timer_server, the_timer ); 116543: 83 c4 18 add $0x18,%esp 116546: 57 push %edi 116547: 53 push %ebx 116548: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 11654b: e8 24 2d 00 00 call 119274 <_Thread_Enable_dispatch> 116550: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; 116553: 31 c0 xor %eax,%eax 116555: eb 07 jmp 11655e Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 116557: b8 0e 00 00 00 mov $0xe,%eax 11655c: eb 00 jmp 11655e case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11655e: 8d 65 f4 lea -0xc(%ebp),%esp 116561: 5b pop %ebx 116562: 5e pop %esi 116563: 5f pop %edi 116564: 5d pop %ebp 116565: c3 ret