RTEMS 4.11Annotated Report
Wed Sep 12 21:12:59 2012
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 <rtems_task_mode>
(*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 <rtems_task_mode>
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 <rtems/score/wkspace.h>
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 <rtems/score/schedulercbs.h>
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 <rtems/score/wkspace.h>
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 <rtems/score/scheduleredf.h>
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
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 <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
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 <rtems/config.h>
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
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_get_with_wait>:
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 <rtems_chain_get_with_wait+0x22>
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_event_receive>
)
{
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 <rtems_chain_get_with_wait+0x38><== 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 <rtems_chain_get_with_wait+0xd>
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 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
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 <rtems_iterate_over_all_threads+0x54>
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 <rtems_iterate_over_all_threads+0x25>
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 <rtems_iterate_over_all_threads+0x12>
#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 <rtems_iterate_over_all_threads+0x1f>
10c008: be 01 00 00 00 mov $0x1,%esi
10c00d: eb 17 jmp 10c026 <rtems_iterate_over_all_threads+0x4a>
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 <rtems_iterate_over_all_threads+0x49><== 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 <rtems_iterate_over_all_threads+0x33>
10c02e: eb cb jmp 10bffb <rtems_iterate_over_all_threads+0x1f>
(*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_message_queue_delete>:
*/
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 <rtems_message_queue_delete+0x59><== 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 <rtems_message_queue_delete+0x5e>
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 <rtems_partition_create>:
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 <rtems_partition_create+0xf7>
return RTEMS_INVALID_NAME;
if ( !starting_address )
11427e: 85 ff test %edi,%edi
114280: 0f 84 c5 00 00 00 je 11434b <rtems_partition_create+0xeb>
return RTEMS_INVALID_ADDRESS;
if ( !id )
114286: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
11428a: 0f 84 bb 00 00 00 je 11434b <rtems_partition_create+0xeb><== 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 <rtems_partition_create+0xf2>
114298: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
11429c: 0f 84 b0 00 00 00 je 114352 <rtems_partition_create+0xf2>
!_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 <rtems_partition_create+0xf7>
1142ad: f7 c6 03 00 00 00 test $0x3,%esi
1142b3: 0f 85 9e 00 00 00 jne 114357 <rtems_partition_create+0xf7>
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 <rtems_partition_create+0xf7>
*
* 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 <rtems_partition_create+0x99>
_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 <rtems_partition_create+0xf7>
_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 <rtems_partition_create+0xf7>
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 <rtems_partition_create+0xf7>
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_partition_return_buffer>:
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 <rtems_partition_return_buffer+0x78>
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 <rtems_partition_return_buffer+0x4b><== NEVER TAKEN
11448f: 39 c6 cmp %eax,%esi
114491: 72 14 jb 1144a7 <rtems_partition_return_buffer+0x4b>
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 <rtems_partition_return_buffer+0x4d>
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_partition_return_buffer+0x6c>
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 <rtems_partition_return_buffer+0x7d>
}
_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 <rtems_partition_return_buffer+0x7d>
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_rate_monotonic_period>:
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 <rtems_rate_monotonic_period+0x172>
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 <rtems_rate_monotonic_period+0x46>
_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 <rtems_rate_monotonic_period+0x177>
}
if ( length == RTEMS_PERIOD_STATUS ) {
12d0f6: 85 db test %ebx,%ebx
12d0f8: 75 1b jne 12d115 <rtems_rate_monotonic_period+0x65>
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 <rtems_rate_monotonic_period+0x5b><== 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 <rtems_rate_monotonic_period+0x177>
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 <rtems_rate_monotonic_period+0xbd>
_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 <rtems_rate_monotonic_period+0x120>
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
12d16d: 83 f8 02 cmp $0x2,%eax
12d170: 75 62 jne 12d1d4 <rtems_rate_monotonic_period+0x124>
/*
* 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 <rtems_rate_monotonic_period+0x11b>
_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 <rtems_rate_monotonic_period+0x177>
#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 <rtems_rate_monotonic_period+0x177><== 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 <rtems_rate_monotonic_period+0x177>
#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 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
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 <rtems_rate_monotonic_report_statistics_with_plugin+0x145><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x139>
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 <rtems_rate_monotonic_get_statistics>
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 <rtems_rate_monotonic_report_statistics_with_plugin+0x138>
#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 <rtems_rate_monotonic_get_status>
#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 <rtems_object_get_name>
/*
* 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 <rtems_rate_monotonic_report_statistics_with_plugin+0xbc>
(*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 <rtems_rate_monotonic_report_statistics_with_plugin+0x138>
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 <rtems_rate_monotonic_report_statistics_with_plugin+0x57>
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 <rtems_rbheap_allocate>:
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 <stdlib.h>
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 <rtems_rbheap_allocate+0x23><== 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 <rtems_rbheap_allocate+0x2b><== NEVER TAKEN
10ab90: 85 db test %ebx,%ebx
10ab92: 75 07 jne 10ab9b <rtems_rbheap_allocate+0x32>
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_rbheap_allocate+0xc1>
*/
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 <rtems_rbheap_allocate+0x49>
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 <rtems_rbheap_allocate+0x51>
10abb6: 39 d0 cmp %edx,%eax
10abb8: 75 ea jne 10aba4 <rtems_rbheap_allocate+0x3b>
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 <rtems_rbheap_allocate+0x2b>
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_allocate+0xa7>
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 <get_chunk>
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 <rtems_rbheap_allocate+0x2b><== 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 <rtems_rbheap_allocate+0xc1>
)
{
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 <rtems_rbheap_extend_descriptors_with_malloc>:
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 <malloc> <== 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 <rtems_rbheap_extend_descriptors_with_malloc+0x29><== 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 <rtems_rbheap_free>:
_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_rbheap_free+0xdd>
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 <rtems_rbheap_free+0x61>
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 <rtems_rbheap_free+0x55>
found = iter_node;
if ( the_rbtree->is_unique )
10ac7f: 80 7e 14 00 cmpb $0x0,0x14(%esi)
10ac83: 75 14 jne 10ac99 <rtems_rbheap_free+0x67><== 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 <rtems_rbheap_free+0x33>
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_rbheap_free+0xe1>
*/
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 <rtems_rbheap_free+0x80>
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 <rtems_rbheap_free+0xe6>
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 <check_and_merge>
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 <check_and_merge>
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 <rtems_rbheap_free+0xe6>
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_region_extend>:
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 <rtems_region_extend+0x7e>
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 <rtems_region_extend+0x68>
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 <rtems_region_extend+0x6d><== 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 <rtems_region_extend+0x6d><== 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_signal_send>:
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 <rtems_signal_send+0x80>
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 <rtems_signal_send+0x7b>
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 <rtems_signal_send+0x6f>
if ( asr->is_enabled ) {
11575a: 80 7a 08 00 cmpb $0x0,0x8(%edx)
11575e: 74 22 je 115782 <rtems_signal_send+0x5e>
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 <rtems_signal_send+0x66>
115771: 3b 05 20 59 14 00 cmp 0x145920,%eax
115777: 75 11 jne 11578a <rtems_signal_send+0x66><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
115779: c6 05 2c 59 14 00 01 movb $0x1,0x14592c
115780: eb 08 jmp 11578a <rtems_signal_send+0x66>
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 <rtems_signal_send+0x80>
}
_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 <rtems_signal_send+0x80>
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_task_get_note>:
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 <rtems_task_get_note+0x7c><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if ( !note )
10b6ab: 85 db test %ebx,%ebx
10b6ad: 74 4d je 10b6fc <rtems_task_get_note+0x70>
* 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 <rtems_task_get_note+0x7c>
/*
* 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 <rtems_task_get_note+0x38>
10b6bf: 3b 50 08 cmp 0x8(%eax),%edx
10b6c2: 75 0e jne 10b6d2 <rtems_task_get_note+0x46>
_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 <rtems_task_get_note+0x6c>
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 <rtems_task_get_note+0x77>
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 <rtems_task_get_note+0x7c>
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 <rtems_task_get_note+0x7c>
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_task_mode>:
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 <rtems_task_mode+0x113>
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 <rtems_task_mode+0x37>
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 <rtems_task_mode+0x6f>
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 <rtems_task_mode+0x99>
if ( _Modes_Is_timeslice(mode_set) ) {
10feac: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
10feb3: 74 11 je 10fec6 <rtems_task_mode+0x92>
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 <rtems_task_mode+0x99>
} 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_task_mode+0xa9>
*/
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 <rtems_task_mode+0xa8>
10fed9: fa cli
10feda: eb 01 jmp 10fedd <rtems_task_mode+0xa9>
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 <rtems_task_mode+0xe0>
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 <rtems_task_mode+0xe0>
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 <rtems_task_mode+0x118>
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 <rtems_task_mode+0x103>
10ff29: 3b 0d 6c c5 12 00 cmp 0x12c56c,%ecx
10ff2f: 74 1b je 10ff4c <rtems_task_mode+0x118>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
10ff31: 80 79 70 00 cmpb $0x0,0x70(%ecx)
10ff35: 74 15 je 10ff4c <rtems_task_mode+0x118> <== 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 <rtems_task_mode+0x118>
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_task_set_priority>:
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_task_set_priority+0x22>
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_task_set_priority+0x74>
!_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 <rtems_task_set_priority+0x74>
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 <rtems_task_set_priority+0x6f>
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 <rtems_task_set_priority+0x66>
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 <rtems_task_set_priority+0x59>
10d4e0: 39 58 14 cmp %ebx,0x14(%eax)
10d4e3: 76 0d jbe 10d4f2 <rtems_task_set_priority+0x66><== 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 <rtems_task_set_priority+0x74>
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_timer_cancel>:
*/
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 <rtems_timer_cancel+0x3e>
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 <rtems_timer_cancel+0x35><== 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 <rtems_timer_cancel+0x43>
#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_timer_initiate_server>:
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 <rtems_timer_initiate_server+0x1f>
( 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 <rtems_timer_initiate_server+0x30>
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 <rtems_timer_initiate_server+0x188>
return RTEMS_INVALID_PRIORITY;
_priority = 0;
1168e5: 31 db xor %ebx,%ebx
1168e7: eb 02 jmp 1168eb <rtems_timer_initiate_server+0x32>
* 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 <rtems_timer_initiate_server+0x188><== 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 <rtems_task_create>
/* 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 <rtems_timer_initiate_server+0x8f>
initialized = false;
11693c: c6 05 84 10 14 00 00 movb $0x0,0x141084
116943: e9 f9 00 00 00 jmp 116a41 <rtems_timer_initiate_server+0x188>
* 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 <rtems_task_start>
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_timer_server_fire_when>:
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 <rtems_timer_server_fire_when+0xfb>
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 <rtems_timer_server_fire_when+0x102><== 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 <rtems_timer_server_fire_when+0x102>
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 <rtems_timer_server_fire_when+0x52>
return RTEMS_INVALID_CLOCK;
1164a4: b8 14 00 00 00 mov $0x14,%eax
1164a9: e9 b0 00 00 00 jmp 11655e <rtems_timer_server_fire_when+0x102>
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 <rtems_timer_server_fire_when+0x48>
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 <rtems_timer_server_fire_when+0x102>
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 <rtems_timer_server_fire_when+0x102>
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 <rtems_timer_server_fire_when+0x102>
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