RTEMS-6
Annotated Report
score
Sun Feb 28 22:58:23 2021
00107cb0 <_CORE_message_queue_Broadcast>:
const void *buffer,
size_t size,
uint32_t *count,
Thread_queue_Context *queue_context
)
{
107cb0: 55 push %ebp
107cb1: 89 e5 mov %esp,%ebp
107cb3: 57 push %edi
107cb4: 56 push %esi
107cb5: 53 push %ebx
107cb6: 83 ec 2c sub $0x2c,%esp
107cb9: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
uint32_t number_broadcasted;
if ( size > the_message_queue->maximum_message_size ) {
107cbc: 8b 45 10 mov 0x10(%ebp),%eax
107cbf: 39 43 18 cmp %eax,0x18(%ebx)
107cc2: 0f 82 08 01 00 00 jb 107dd0 <_CORE_message_queue_Broadcast+0x120>
*
* 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 ) {
107cc8: 8b 43 14 mov 0x14(%ebx),%eax
107ccb: 89 45 e4 mov %eax,-0x1c(%ebp)
107cce: 85 c0 test %eax,%eax
107cd0: 74 3c je 107d0e <_CORE_message_queue_Broadcast+0x5e>
107cd2: e9 99 00 00 00 jmp 107d70 <_CORE_message_queue_Broadcast+0xc0>
107cd7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107cde: 66 90 xchg %ax,%ax
memcpy(destination, source, size);
107ce0: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
_Thread_queue_Extract_critical(
107ce2: 89 44 24 08 mov %eax,0x8(%esp)
107ce6: 8b 4d 18 mov 0x18(%ebp),%ecx
107ce9: 89 4c 24 0c mov %ecx,0xc(%esp)
107ced: 8b 43 0c mov 0xc(%ebx),%eax
107cf0: 89 1c 24 mov %ebx,(%esp)
107cf3: 89 44 24 04 mov %eax,0x4(%esp)
107cf7: e8 94 2d 00 00 call 10aa90 <_Thread_queue_Extract_critical>
0,
queue_context
)
)
) {
number_broadcasted += 1;
107cfc: ff 45 e4 incl -0x1c(%ebp)
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
107cff: 9c pushf
107d00: fa cli
107d01: 58 pop %eax
107d02: 8b 7d 18 mov 0x18(%ebp),%edi
107d05: 89 07 mov %eax,(%edi)
if ( the_message_queue->number_of_pending_messages != 0 ) {
107d07: 8b 43 14 mov 0x14(%ebx),%eax
107d0a: 85 c0 test %eax,%eax
107d0c: 75 69 jne 107d77 <_CORE_message_queue_Broadcast+0xc7> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE Thread_Control *_Thread_queue_First_locked(
Thread_queue_Control *the_thread_queue,
const Thread_queue_Operations *operations
)
{
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
107d0e: 8b 03 mov (%ebx),%eax
the_thread = _Thread_queue_First_locked(
107d10: 8b 53 0c mov 0xc(%ebx),%edx
if ( heads != NULL ) {
107d13: 85 c0 test %eax,%eax
107d15: 74 60 je 107d77 <_CORE_message_queue_Broadcast+0xc7>
return ( *operations->first )( heads );
107d17: 89 04 24 mov %eax,(%esp)
107d1a: ff 52 10 call *0x10(%edx)
if ( the_thread == NULL ) {
107d1d: 85 c0 test %eax,%eax
107d1f: 74 56 je 107d77 <_CORE_message_queue_Broadcast+0xc7> <== NEVER TAKEN
*(size_t *) the_thread->Wait.return_argument = size;
107d21: 8b 75 10 mov 0x10(%ebp),%esi
107d24: 8b 50 40 mov 0x40(%eax),%edx
memcpy(destination, source, size);
107d27: 89 f1 mov %esi,%ecx
*(size_t *) the_thread->Wait.return_argument = size;
107d29: 89 32 mov %esi,(%edx)
memcpy(destination, source, size);
107d2b: 8b 50 44 mov 0x44(%eax),%edx
107d2e: 83 f9 08 cmp $0x8,%ecx
the_thread->Wait.count = (uint32_t) submit_type;
107d31: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax)
memcpy(destination, source, size);
107d38: 8b 75 0c mov 0xc(%ebp),%esi
107d3b: 89 d7 mov %edx,%edi
107d3d: 72 a1 jb 107ce0 <_CORE_message_queue_Broadcast+0x30> <== NEVER TAKEN
107d3f: f6 c2 01 test $0x1,%dl
107d42: 75 6c jne 107db0 <_CORE_message_queue_Broadcast+0x100> <== NEVER TAKEN
107d44: f7 c7 02 00 00 00 test $0x2,%edi
107d4a: 75 44 jne 107d90 <_CORE_message_queue_Broadcast+0xe0> <== NEVER TAKEN
107d4c: f7 c7 04 00 00 00 test $0x4,%edi
107d52: 74 8c je 107ce0 <_CORE_message_queue_Broadcast+0x30>
107d54: 8b 16 mov (%esi),%edx
107d56: 83 c7 04 add $0x4,%edi
107d59: 83 c6 04 add $0x4,%esi
107d5c: 83 e9 04 sub $0x4,%ecx
107d5f: 89 57 fc mov %edx,-0x4(%edi)
107d62: e9 79 ff ff ff jmp 107ce0 <_CORE_message_queue_Broadcast+0x30>
107d67: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107d6e: 66 90 xchg %ax,%ax
number_broadcasted = 0;
107d70: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
107d77: 8b 45 18 mov 0x18(%ebp),%eax
107d7a: ff 30 push (%eax)
107d7c: 9d popf
_CORE_message_queue_Acquire( the_message_queue, queue_context );
}
_CORE_message_queue_Release( the_message_queue, queue_context );
*count = number_broadcasted;
107d7d: 8b 45 14 mov 0x14(%ebp),%eax
107d80: 8b 75 e4 mov -0x1c(%ebp),%esi
107d83: 89 30 mov %esi,(%eax)
return STATUS_SUCCESSFUL;
}
107d85: 83 c4 2c add $0x2c,%esp
return STATUS_SUCCESSFUL;
107d88: 31 c0 xor %eax,%eax
}
107d8a: 5b pop %ebx
107d8b: 5e pop %esi
107d8c: 5f pop %edi
107d8d: 5d pop %ebp
107d8e: c3 ret
107d8f: 90 nop
107d90: 0f b7 16 movzwl (%esi),%edx <== NOT EXECUTED
107d93: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
107d96: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
107d99: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
107d9c: 66 89 57 fe mov %dx,-0x2(%edi) <== NOT EXECUTED
107da0: eb aa jmp 107d4c <_CORE_message_queue_Broadcast+0x9c> <== NOT EXECUTED
107da2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107da9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107db0: 0f b6 0e movzbl (%esi),%ecx <== NOT EXECUTED
107db3: 47 inc %edi <== NOT EXECUTED
107db4: 88 4d e3 mov %cl,-0x1d(%ebp) <== NOT EXECUTED
107db7: 88 0a mov %cl,(%edx) <== NOT EXECUTED
107db9: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
107dbc: 8d 71 01 lea 0x1(%ecx),%esi <== NOT EXECUTED
107dbf: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED
107dc2: 49 dec %ecx <== NOT EXECUTED
107dc3: e9 7c ff ff ff jmp 107d44 <_CORE_message_queue_Broadcast+0x94> <== NOT EXECUTED
107dc8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107dcf: 90 nop <== NOT EXECUTED
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
107dd0: 8b 45 18 mov 0x18(%ebp),%eax
107dd3: ff 30 push (%eax)
107dd5: 9d popf
}
107dd6: 83 c4 2c add $0x2c,%esp
return STATUS_MESSAGE_INVALID_SIZE;
107dd9: b8 08 7a 00 00 mov $0x7a08,%eax
}
107dde: 5b pop %ebx
107ddf: 5e pop %esi
107de0: 5f pop %edi
107de1: 5d pop %ebp
107de2: c3 ret
107de3: 90 nop
107de4: 90 nop
107de5: 90 nop
107de6: 90 nop
107de7: 90 nop
107de8: 90 nop
107de9: 90 nop
107dea: 90 nop
107deb: 90 nop
107dec: 90 nop
107ded: 90 nop
107dee: 90 nop
107def: 90 nop
00115db0 <_CORE_message_queue_Insert_message>:
CORE_message_queue_Buffer *the_message,
const void *content_source,
size_t content_size,
CORE_message_queue_Submit_types submit_type
)
{
115db0: 55 push %ebp
115db1: 89 e5 mov %esp,%ebp
115db3: 57 push %edi
115db4: 8b 4d 14 mov 0x14(%ebp),%ecx
115db7: 56 push %esi
115db8: 8b 55 0c mov 0xc(%ebp),%edx
115dbb: 53 push %ebx
115dbc: 8b 45 08 mov 0x8(%ebp),%eax
memcpy(destination, source, size);
115dbf: 8b 75 10 mov 0x10(%ebp),%esi
115dc2: 83 f9 08 cmp $0x8,%ecx
Chain_Control *pending_messages;
the_message->size = content_size;
115dc5: 89 4a 08 mov %ecx,0x8(%edx)
115dc8: 8d 7a 10 lea 0x10(%edx),%edi
115dcb: 73 73 jae 115e40 <_CORE_message_queue_Insert_message+0x90>
115dcd: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
the_message->buffer,
content_size
);
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = submit_type;
115dcf: 8b 75 18 mov 0x18(%ebp),%esi
115dd2: 89 72 0c mov %esi,0xc(%edx)
#endif
pending_messages = &the_message_queue->Pending_messages;
++the_message_queue->number_of_pending_messages;
115dd5: ff 40 14 incl 0x14(%eax)
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
115dd8: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi
115dde: 0f 84 8c 00 00 00 je 115e70 <_CORE_message_queue_Insert_message+0xc0>
_Chain_Append_unprotected( pending_messages, &the_message->Node );
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
} else if ( submit_type != CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
115de4: 81 7d 18 00 00 00 80 cmpl $0x80000000,0x18(%ebp)
return _Chain_Immutable_head( the_chain )->next;
115deb: 8b 48 1c mov 0x1c(%eax),%ecx
115dee: 75 20 jne 115e10 <_CORE_message_queue_Insert_message+0x60>
return &the_chain->Head.Node;
115df0: 8d 58 1c lea 0x1c(%eax),%ebx
115df3: 89 5a 04 mov %ebx,0x4(%edx)
after_node->next = the_node;
115df6: 89 50 1c mov %edx,0x1c(%eax)
the_node->next = before_node;
115df9: 89 0a mov %ecx,(%edx)
before_node->previous = the_node;
115dfb: 89 51 04 mov %edx,0x4(%ecx)
);
#endif
} else {
_Chain_Prepend_unprotected( pending_messages, &the_message->Node );
}
}
115dfe: 5b pop %ebx
115dff: 5e pop %esi
115e00: 5f pop %edi
115e01: 5d pop %ebp
115e02: c3 ret
115e03: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
115e0a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return &the_chain->Tail.Node;
115e10: 83 c0 20 add $0x20,%eax
while ( next != tail && !( *order )( left, next ) ) {
115e13: 8b 5d 18 mov 0x18(%ebp),%ebx
115e16: 39 c8 cmp %ecx,%eax
115e18: 75 0c jne 115e26 <_CORE_message_queue_Insert_message+0x76>
115e1a: eb 0f jmp 115e2b <_CORE_message_queue_Insert_message+0x7b>
115e1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return the_node->next;
115e20: 8b 09 mov (%ecx),%ecx
while ( next != tail && !( *order )( left, next ) ) {
115e22: 39 c8 cmp %ecx,%eax
115e24: 74 05 je 115e2b <_CORE_message_queue_Insert_message+0x7b>
115e26: 3b 59 0c cmp 0xc(%ecx),%ebx
115e29: 7d f5 jge 115e20 <_CORE_message_queue_Insert_message+0x70>
return the_node->previous;
115e2b: 8b 41 04 mov 0x4(%ecx),%eax
the_node->previous = after_node;
115e2e: 89 42 04 mov %eax,0x4(%edx)
before_node = after_node->next;
115e31: 8b 08 mov (%eax),%ecx
after_node->next = the_node;
115e33: 89 10 mov %edx,(%eax)
the_node->next = before_node;
115e35: 89 0a mov %ecx,(%edx)
before_node->previous = the_node;
115e37: 89 51 04 mov %edx,0x4(%ecx)
115e3a: 5b pop %ebx
115e3b: 5e pop %esi
115e3c: 5f pop %edi
115e3d: 5d pop %ebp
115e3e: c3 ret
115e3f: 90 nop
115e40: f7 c7 01 00 00 00 test $0x1,%edi
115e46: 75 48 jne 115e90 <_CORE_message_queue_Insert_message+0xe0><== NEVER TAKEN
115e48: f7 c7 02 00 00 00 test $0x2,%edi
115e4e: 75 50 jne 115ea0 <_CORE_message_queue_Insert_message+0xf0><== NEVER TAKEN
115e50: f7 c7 04 00 00 00 test $0x4,%edi
115e56: 0f 84 71 ff ff ff je 115dcd <_CORE_message_queue_Insert_message+0x1d>
115e5c: 8b 1e mov (%esi),%ebx
115e5e: 83 c7 04 add $0x4,%edi
115e61: 83 c6 04 add $0x4,%esi
115e64: 83 e9 04 sub $0x4,%ecx
115e67: 89 5f fc mov %ebx,-0x4(%edi)
115e6a: e9 5e ff ff ff jmp 115dcd <_CORE_message_queue_Insert_message+0x1d>
115e6f: 90 nop
old_last = tail->previous;
115e70: 8b 48 24 mov 0x24(%eax),%ecx
return &the_chain->Tail.Node;
115e73: 8d 58 20 lea 0x20(%eax),%ebx
115e76: 89 1a mov %ebx,(%edx)
tail->previous = the_node;
115e78: 89 50 24 mov %edx,0x24(%eax)
old_last->next = the_node;
115e7b: 89 11 mov %edx,(%ecx)
the_node->previous = old_last;
115e7d: 89 4a 04 mov %ecx,0x4(%edx)
115e80: 5b pop %ebx
115e81: 5e pop %esi
115e82: 5f pop %edi
115e83: 5d pop %ebp
115e84: c3 ret
115e85: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
115e8c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
115e90: 0f b6 1e movzbl (%esi),%ebx <== NOT EXECUTED
115e93: 8d 7a 11 lea 0x11(%edx),%edi <== NOT EXECUTED
115e96: 46 inc %esi <== NOT EXECUTED
115e97: 49 dec %ecx <== NOT EXECUTED
115e98: 88 5a 10 mov %bl,0x10(%edx) <== NOT EXECUTED
115e9b: eb ab jmp 115e48 <_CORE_message_queue_Insert_message+0x98><== NOT EXECUTED
115e9d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
115ea0: 0f b7 1e movzwl (%esi),%ebx <== NOT EXECUTED
115ea3: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
115ea6: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
115ea9: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
115eac: 66 89 5f fe mov %bx,-0x2(%edi) <== NOT EXECUTED
115eb0: eb 9e jmp 115e50 <_CORE_message_queue_Insert_message+0xa0><== NOT EXECUTED
115eb2: 90 nop
115eb3: 90 nop
115eb4: 90 nop
115eb5: 90 nop
115eb6: 90 nop
115eb7: 90 nop
115eb8: 90 nop
115eb9: 90 nop
115eba: 90 nop
115ebb: 90 nop
115ebc: 90 nop
115ebd: 90 nop
115ebe: 90 nop
115ebf: 90 nop
0010f040 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Thread_queue_Context *queue_context
)
{
10f040: 55 push %ebp
10f041: 89 e5 mov %esp,%ebp
10f043: 57 push %edi
10f044: 56 push %esi
10f045: 53 push %ebx
10f046: 83 ec 3c sub $0x3c,%esp
10f049: 8b 5d 08 mov 0x8(%ebp),%ebx
10f04c: 8b 75 0c mov 0xc(%ebp),%esi
10f04f: 0f b6 45 18 movzbl 0x18(%ebp),%eax
return _Chain_Immutable_head( the_chain )->next;
10f053: 8b 53 1c mov 0x1c(%ebx),%edx
return &the_chain->Tail.Node;
10f056: 8d 7b 20 lea 0x20(%ebx),%edi
if ( !_Chain_Is_empty(the_chain))
10f059: 39 fa cmp %edi,%edx
10f05b: 0f 84 ef 00 00 00 je 10f150 <_CORE_message_queue_Seize+0x110>
new_first = old_first->next;
10f061: 8b 02 mov (%edx),%eax
10f063: 8d 4b 1c lea 0x1c(%ebx),%ecx
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
10f066: 8b 7d 10 mov 0x10(%ebp),%edi
head->next = new_first;
10f069: 89 43 1c mov %eax,0x1c(%ebx)
return &the_chain->Head.Node;
10f06c: 89 48 04 mov %ecx,0x4(%eax)
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
*size_p = the_message->size;
10f06f: 8b 4a 08 mov 0x8(%edx),%ecx
10f072: 8b 45 14 mov 0x14(%ebp),%eax
the_message_queue->number_of_pending_messages -= 1;
10f075: ff 4b 14 decl 0x14(%ebx)
10f078: 83 f9 08 cmp $0x8,%ecx
*size_p = the_message->size;
10f07b: 89 08 mov %ecx,(%eax)
executing->Wait.count =
10f07d: 8b 42 0c mov 0xc(%edx),%eax
10f080: 89 46 3c mov %eax,0x3c(%esi)
10f083: 8d 72 10 lea 0x10(%edx),%esi
10f086: 0f 83 84 00 00 00 jae 10f110 <_CORE_message_queue_Seize+0xd0>
10f08c: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
10f08e: 8b 03 mov (%ebx),%eax
* is not, then we can go ahead and free the buffer.
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_First_locked(
10f090: 8b 4b 0c mov 0xc(%ebx),%ecx
if ( heads != NULL ) {
10f093: 85 c0 test %eax,%eax
10f095: 74 59 je 10f0f0 <_CORE_message_queue_Seize+0xb0>
return ( *operations->first )( heads );
10f097: 89 04 24 mov %eax,(%esp)
10f09a: 89 55 e4 mov %edx,-0x1c(%ebp)
10f09d: ff 51 10 call *0x10(%ecx)
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
10f0a0: 8b 55 e4 mov -0x1c(%ebp),%edx
10f0a3: 85 c0 test %eax,%eax
10f0a5: 89 c6 mov %eax,%esi
10f0a7: 74 47 je 10f0f0 <_CORE_message_queue_Seize+0xb0> <== NEVER TAKEN
/*
* There was a thread waiting to send a message. This code
* puts the messages in the message queue on behalf of the
* waiting task.
*/
_CORE_message_queue_Insert_message(
10f0a9: 8b 40 3c mov 0x3c(%eax),%eax
10f0ac: 89 44 24 10 mov %eax,0x10(%esp)
10f0b0: 8b 46 48 mov 0x48(%esi),%eax
10f0b3: 89 44 24 0c mov %eax,0xc(%esp)
10f0b7: 8b 46 44 mov 0x44(%esi),%eax
10f0ba: 89 54 24 04 mov %edx,0x4(%esp)
10f0be: 89 1c 24 mov %ebx,(%esp)
10f0c1: 89 44 24 08 mov %eax,0x8(%esp)
10f0c5: e8 e6 6c 00 00 call 115db0 <_CORE_message_queue_Insert_message>
the_message,
the_thread->Wait.return_argument_second.immutable_object,
(size_t) the_thread->Wait.option,
(CORE_message_queue_Submit_types) the_thread->Wait.count
);
_Thread_queue_Extract_critical(
10f0ca: 8b 45 1c mov 0x1c(%ebp),%eax
10f0cd: 89 74 24 08 mov %esi,0x8(%esp)
10f0d1: 89 44 24 0c mov %eax,0xc(%esp)
10f0d5: 8b 43 0c mov 0xc(%ebx),%eax
10f0d8: 89 1c 24 mov %ebx,(%esp)
10f0db: 89 44 24 04 mov %eax,0x4(%esp)
10f0df: e8 3c 35 00 00 call 112620 <_Thread_queue_Extract_critical>
&the_message_queue->Wait_queue.Queue,
the_message_queue->operations,
the_thread,
queue_context
);
return STATUS_SUCCESSFUL;
10f0e4: 31 c0 xor %eax,%eax
the_message_queue->operations,
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
}
10f0e6: 83 c4 3c add $0x3c,%esp
10f0e9: 5b pop %ebx
10f0ea: 5e pop %esi
10f0eb: 5f pop %edi
10f0ec: 5d pop %ebp
10f0ed: c3 ret
10f0ee: 66 90 xchg %ax,%ax
old_last = tail->previous;
10f0f0: 8b 43 3c mov 0x3c(%ebx),%eax
return &the_chain->Tail.Node;
10f0f3: 8d 4b 38 lea 0x38(%ebx),%ecx
10f0f6: 89 0a mov %ecx,(%edx)
tail->previous = the_node;
10f0f8: 89 53 3c mov %edx,0x3c(%ebx)
old_last->next = the_node;
10f0fb: 89 10 mov %edx,(%eax)
the_node->previous = old_last;
10f0fd: 89 42 04 mov %eax,0x4(%edx)
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
10f100: 8b 45 1c mov 0x1c(%ebp),%eax
10f103: ff 30 push (%eax)
10f105: 9d popf
10f106: 83 c4 3c add $0x3c,%esp
return STATUS_SUCCESSFUL;
10f109: 31 c0 xor %eax,%eax
}
10f10b: 5b pop %ebx
10f10c: 5e pop %esi
10f10d: 5f pop %edi
10f10e: 5d pop %ebp
10f10f: c3 ret
10f110: f7 c7 01 00 00 00 test $0x1,%edi
10f116: 0f 85 84 00 00 00 jne 10f1a0 <_CORE_message_queue_Seize+0x160> <== NEVER TAKEN
10f11c: f7 c7 02 00 00 00 test $0x2,%edi
10f122: 0f 85 98 00 00 00 jne 10f1c0 <_CORE_message_queue_Seize+0x180> <== NEVER TAKEN
10f128: f7 c7 04 00 00 00 test $0x4,%edi
10f12e: 0f 84 58 ff ff ff je 10f08c <_CORE_message_queue_Seize+0x4c>
10f134: 8b 06 mov (%esi),%eax
10f136: 83 c7 04 add $0x4,%edi
10f139: 83 c6 04 add $0x4,%esi
10f13c: 83 e9 04 sub $0x4,%ecx
10f13f: 89 47 fc mov %eax,-0x4(%edi)
10f142: e9 45 ff ff ff jmp 10f08c <_CORE_message_queue_Seize+0x4c>
10f147: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10f14e: 66 90 xchg %ax,%ax
if ( !wait ) {
10f150: 84 c0 test %al,%al
10f152: 74 3c je 10f190 <_CORE_message_queue_Seize+0x150>
executing->Wait.return_argument_second.mutable_object = buffer;
10f154: 8b 45 10 mov 0x10(%ebp),%eax
10f157: 89 46 44 mov %eax,0x44(%esi)
executing->Wait.return_argument = size_p;
10f15a: 8b 45 14 mov 0x14(%ebp),%eax
10f15d: 89 46 40 mov %eax,0x40(%esi)
queue_context->thread_state = thread_state;
10f160: 8b 45 1c mov 0x1c(%ebp),%eax
10f163: c7 40 04 10 00 00 00 movl $0x10,0x4(%eax)
_Thread_queue_Enqueue(
10f16a: 89 44 24 0c mov %eax,0xc(%esp)
10f16e: 89 74 24 08 mov %esi,0x8(%esp)
10f172: 8b 43 0c mov 0xc(%ebx),%eax
10f175: 89 1c 24 mov %ebx,(%esp)
10f178: 89 44 24 04 mov %eax,0x4(%esp)
10f17c: e8 1f 33 00 00 call 1124a0 <_Thread_queue_Enqueue>
return (Status_Control) the_thread->Wait.return_code;
10f181: 8b 46 4c mov 0x4c(%esi),%eax
return _Thread_Wait_get_status( executing );
10f184: e9 5d ff ff ff jmp 10f0e6 <_CORE_message_queue_Seize+0xa6>
10f189: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
10f190: 8b 45 1c mov 0x1c(%ebp),%eax
10f193: ff 30 push (%eax)
10f195: 9d popf
return STATUS_UNSATISFIED;
10f196: b8 0d 0b 00 00 mov $0xb0d,%eax
10f19b: e9 46 ff ff ff jmp 10f0e6 <_CORE_message_queue_Seize+0xa6>
10f1a0: 0f b6 42 10 movzbl 0x10(%edx),%eax <== NOT EXECUTED
10f1a4: 47 inc %edi <== NOT EXECUTED
10f1a5: 49 dec %ecx <== NOT EXECUTED
10f1a6: 8d 72 11 lea 0x11(%edx),%esi <== NOT EXECUTED
10f1a9: 88 47 ff mov %al,-0x1(%edi) <== NOT EXECUTED
10f1ac: e9 6b ff ff ff jmp 10f11c <_CORE_message_queue_Seize+0xdc> <== NOT EXECUTED
10f1b1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10f1b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10f1bf: 90 nop <== NOT EXECUTED
10f1c0: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
10f1c3: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10f1c6: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
10f1c9: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
10f1cc: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
10f1d0: e9 53 ff ff ff jmp 10f128 <_CORE_message_queue_Seize+0xe8> <== NOT EXECUTED
10f1d5: 90 nop
10f1d6: 90 nop
10f1d7: 90 nop
10f1d8: 90 nop
10f1d9: 90 nop
10f1da: 90 nop
10f1db: 90 nop
10f1dc: 90 nop
10f1dd: 90 nop
10f1de: 90 nop
10f1df: 90 nop
0010f1e0 <_CORE_message_queue_Submit>:
size_t size,
CORE_message_queue_Submit_types submit_type,
bool wait,
Thread_queue_Context *queue_context
)
{
10f1e0: 55 push %ebp
10f1e1: 89 e5 mov %esp,%ebp
10f1e3: 83 ec 48 sub $0x48,%esp
10f1e6: 89 5d f4 mov %ebx,-0xc(%ebp)
10f1e9: 8b 5d 08 mov 0x8(%ebp),%ebx
10f1ec: 89 75 f8 mov %esi,-0x8(%ebp)
10f1ef: 0f b6 45 1c movzbl 0x1c(%ebp),%eax
10f1f3: 89 7d fc mov %edi,-0x4(%ebp)
10f1f6: 8b 75 14 mov 0x14(%ebp),%esi
CORE_message_queue_Buffer *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
10f1f9: 39 73 18 cmp %esi,0x18(%ebx)
{
10f1fc: 88 45 e7 mov %al,-0x19(%ebp)
if ( size > the_message_queue->maximum_message_size ) {
10f1ff: 0f 82 cb 00 00 00 jb 10f2d0 <_CORE_message_queue_Submit+0xf0>
*
* 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 ) {
10f205: 8b 43 14 mov 0x14(%ebx),%eax
10f208: 85 c0 test %eax,%eax
10f20a: 75 64 jne 10f270 <_CORE_message_queue_Submit+0x90>
Thread_queue_Heads *heads = the_thread_queue->Queue.heads;
10f20c: 8b 03 mov (%ebx),%eax
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
the_thread = _Thread_queue_First_locked(
10f20e: 8b 53 0c mov 0xc(%ebx),%edx
if ( heads != NULL ) {
10f211: 85 c0 test %eax,%eax
10f213: 74 5b je 10f270 <_CORE_message_queue_Submit+0x90>
return ( *operations->first )( heads );
10f215: 89 04 24 mov %eax,(%esp)
10f218: ff 52 10 call *0x10(%edx)
&the_message_queue->Wait_queue,
the_message_queue->operations
);
if ( the_thread == NULL ) {
10f21b: 85 c0 test %eax,%eax
10f21d: 74 51 je 10f270 <_CORE_message_queue_Submit+0x90> <== NEVER TAKEN
return NULL;
}
*(size_t *) the_thread->Wait.return_argument = size;
the_thread->Wait.count = (uint32_t) submit_type;
10f21f: 8b 7d 18 mov 0x18(%ebp),%edi
memcpy(destination, source, size);
10f222: 89 f1 mov %esi,%ecx
*(size_t *) the_thread->Wait.return_argument = size;
10f224: 8b 50 40 mov 0x40(%eax),%edx
memcpy(destination, source, size);
10f227: 83 f9 08 cmp $0x8,%ecx
*(size_t *) the_thread->Wait.return_argument = size;
10f22a: 89 32 mov %esi,(%edx)
memcpy(destination, source, size);
10f22c: 8b 75 10 mov 0x10(%ebp),%esi
the_thread->Wait.count = (uint32_t) submit_type;
10f22f: 89 78 3c mov %edi,0x3c(%eax)
memcpy(destination, source, size);
10f232: 8b 78 44 mov 0x44(%eax),%edi
10f235: 0f 83 d5 00 00 00 jae 10f310 <_CORE_message_queue_Submit+0x130>
10f23b: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
_Thread_queue_Extract_critical(
10f23d: 89 44 24 08 mov %eax,0x8(%esp)
10f241: 8b 4d 20 mov 0x20(%ebp),%ecx
10f244: 89 4c 24 0c mov %ecx,0xc(%esp)
10f248: 8b 43 0c mov 0xc(%ebx),%eax
10f24b: 89 1c 24 mov %ebx,(%esp)
10f24e: 89 44 24 04 mov %eax,0x4(%esp)
10f252: e8 c9 33 00 00 call 112620 <_Thread_queue_Extract_critical>
size,
submit_type,
queue_context
);
if ( the_thread != NULL ) {
return STATUS_SUCCESSFUL;
10f257: 31 c0 xor %eax,%eax
executing,
queue_context
);
return _Thread_Wait_get_status( executing );
#endif
}
10f259: 8b 5d f4 mov -0xc(%ebp),%ebx
10f25c: 8b 75 f8 mov -0x8(%ebp),%esi
10f25f: 8b 7d fc mov -0x4(%ebp),%edi
10f262: 89 ec mov %ebp,%esp
10f264: 5d pop %ebp
10f265: c3 ret
10f266: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10f26d: 8d 76 00 lea 0x0(%esi),%esi
return _Chain_Immutable_head( the_chain )->next;
10f270: 8b 43 34 mov 0x34(%ebx),%eax
return &the_chain->Tail.Node;
10f273: 8d 53 38 lea 0x38(%ebx),%edx
10f276: 8d 4b 34 lea 0x34(%ebx),%ecx
if ( !_Chain_Is_empty(the_chain))
10f279: 39 d0 cmp %edx,%eax
10f27b: 0f 84 cf 00 00 00 je 10f350 <_CORE_message_queue_Submit+0x170>
new_first = old_first->next;
10f281: 8b 10 mov (%eax),%edx
_CORE_message_queue_Insert_message(
10f283: 8b 7d 18 mov 0x18(%ebp),%edi
head->next = new_first;
10f286: 89 53 34 mov %edx,0x34(%ebx)
return &the_chain->Head.Node;
10f289: 89 4a 04 mov %ecx,0x4(%edx)
10f28c: 8b 4d 10 mov 0x10(%ebp),%ecx
10f28f: 89 7c 24 10 mov %edi,0x10(%esp)
10f293: 89 74 24 0c mov %esi,0xc(%esp)
10f297: 89 44 24 04 mov %eax,0x4(%esp)
10f29b: 89 4c 24 08 mov %ecx,0x8(%esp)
10f29f: 89 1c 24 mov %ebx,(%esp)
10f2a2: e8 09 6b 00 00 call 115db0 <_CORE_message_queue_Insert_message>
if (
10f2a7: 83 7b 14 01 cmpl $0x1,0x14(%ebx)
10f2ab: 74 43 je 10f2f0 <_CORE_message_queue_Submit+0x110>
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
10f2ad: 8b 45 20 mov 0x20(%ebp),%eax
10f2b0: ff 30 push (%eax)
10f2b2: 9d popf
}
10f2b3: 8b 5d f4 mov -0xc(%ebp),%ebx
return STATUS_SUCCESSFUL;
10f2b6: 31 c0 xor %eax,%eax
}
10f2b8: 8b 75 f8 mov -0x8(%ebp),%esi
10f2bb: 8b 7d fc mov -0x4(%ebp),%edi
10f2be: 89 ec mov %ebp,%esp
10f2c0: 5d pop %ebp
10f2c1: c3 ret
10f2c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10f2c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10f2d0: 8b 45 20 mov 0x20(%ebp),%eax
10f2d3: ff 30 push (%eax)
10f2d5: 9d popf
10f2d6: 8b 5d f4 mov -0xc(%ebp),%ebx
return STATUS_MESSAGE_INVALID_SIZE;
10f2d9: b8 08 7a 00 00 mov $0x7a08,%eax
}
10f2de: 8b 75 f8 mov -0x8(%ebp),%esi
10f2e1: 8b 7d fc mov -0x4(%ebp),%edi
10f2e4: 89 ec mov %ebp,%esp
10f2e6: 5d pop %ebp
10f2e7: c3 ret
10f2e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10f2ef: 90 nop
&& the_message_queue->notify_handler != NULL
10f2f0: 8b 43 30 mov 0x30(%ebx),%eax
10f2f3: 85 c0 test %eax,%eax
10f2f5: 74 b6 je 10f2ad <_CORE_message_queue_Submit+0xcd>
( *the_message_queue->notify_handler )(
10f2f7: 89 1c 24 mov %ebx,(%esp)
10f2fa: 8b 7d 20 mov 0x20(%ebp),%edi
10f2fd: 89 7c 24 04 mov %edi,0x4(%esp)
10f301: ff d0 call *%eax
return STATUS_SUCCESSFUL;
10f303: 31 c0 xor %eax,%eax
( *the_message_queue->notify_handler )(
10f305: e9 4f ff ff ff jmp 10f259 <_CORE_message_queue_Submit+0x79>
10f30a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memcpy(destination, source, size);
10f310: f7 c7 01 00 00 00 test $0x1,%edi
10f316: 0f 85 b4 00 00 00 jne 10f3d0 <_CORE_message_queue_Submit+0x1f0> <== NEVER TAKEN
10f31c: f7 c7 02 00 00 00 test $0x2,%edi
10f322: 0f 85 88 00 00 00 jne 10f3b0 <_CORE_message_queue_Submit+0x1d0> <== NEVER TAKEN
10f328: f7 c7 04 00 00 00 test $0x4,%edi
10f32e: 0f 84 07 ff ff ff je 10f23b <_CORE_message_queue_Submit+0x5b>
10f334: 8b 16 mov (%esi),%edx
10f336: 83 c7 04 add $0x4,%edi
10f339: 83 c6 04 add $0x4,%esi
10f33c: 83 e9 04 sub $0x4,%ecx
10f33f: 89 57 fc mov %edx,-0x4(%edi)
10f342: e9 f4 fe ff ff jmp 10f23b <_CORE_message_queue_Submit+0x5b>
10f347: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10f34e: 66 90 xchg %ax,%ax
if ( !wait ) {
10f350: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10f354: 74 4a je 10f3a0 <_CORE_message_queue_Submit+0x1c0>
if ( _ISR_Is_in_progress() ) {
10f356: e8 25 15 00 00 call 110880 <_ISR_Is_in_progress>
10f35b: 84 c0 test %al,%al
10f35d: 75 7f jne 10f3de <_CORE_message_queue_Submit+0x1fe>
executing->Wait.return_argument_second.immutable_object = buffer;
10f35f: 8b 45 0c mov 0xc(%ebp),%eax
10f362: 8b 7d 10 mov 0x10(%ebp),%edi
executing->Wait.option = (uint32_t) size;
10f365: 89 70 48 mov %esi,0x48(%eax)
executing->Wait.return_argument_second.immutable_object = buffer;
10f368: 89 78 44 mov %edi,0x44(%eax)
executing->Wait.count = submit_type;
10f36b: 8b 7d 18 mov 0x18(%ebp),%edi
10f36e: 89 78 3c mov %edi,0x3c(%eax)
queue_context->thread_state = thread_state;
10f371: 8b 45 20 mov 0x20(%ebp),%eax
10f374: c7 40 04 10 00 00 00 movl $0x10,0x4(%eax)
_Thread_queue_Enqueue(
10f37b: 89 44 24 0c mov %eax,0xc(%esp)
10f37f: 8b 45 0c mov 0xc(%ebp),%eax
10f382: 89 44 24 08 mov %eax,0x8(%esp)
10f386: 8b 43 0c mov 0xc(%ebx),%eax
10f389: 89 1c 24 mov %ebx,(%esp)
10f38c: 89 44 24 04 mov %eax,0x4(%esp)
10f390: e8 0b 31 00 00 call 1124a0 <_Thread_queue_Enqueue>
10f395: 8b 45 0c mov 0xc(%ebp),%eax
10f398: 8b 40 4c mov 0x4c(%eax),%eax
return _Thread_Wait_get_status( executing );
10f39b: e9 b9 fe ff ff jmp 10f259 <_CORE_message_queue_Submit+0x79>
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
10f3a0: 8b 45 20 mov 0x20(%ebp),%eax
10f3a3: ff 30 push (%eax)
10f3a5: 9d popf
return STATUS_TOO_MANY;
10f3a6: b8 05 0b 00 00 mov $0xb05,%eax
10f3ab: e9 a9 fe ff ff jmp 10f259 <_CORE_message_queue_Submit+0x79>
10f3b0: 0f b7 16 movzwl (%esi),%edx <== NOT EXECUTED
10f3b3: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10f3b6: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
10f3b9: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
10f3bc: 66 89 57 fe mov %dx,-0x2(%edi) <== NOT EXECUTED
10f3c0: e9 63 ff ff ff jmp 10f328 <_CORE_message_queue_Submit+0x148> <== NOT EXECUTED
10f3c5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10f3cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10f3d0: 0f b6 16 movzbl (%esi),%edx <== NOT EXECUTED
10f3d3: 47 inc %edi <== NOT EXECUTED
10f3d4: 46 inc %esi <== NOT EXECUTED
10f3d5: 49 dec %ecx <== NOT EXECUTED
10f3d6: 88 57 ff mov %dl,-0x1(%edi) <== NOT EXECUTED
10f3d9: e9 3e ff ff ff jmp 10f31c <_CORE_message_queue_Submit+0x13c> <== NOT EXECUTED
10f3de: 8b 45 20 mov 0x20(%ebp),%eax
10f3e1: ff 30 push (%eax)
10f3e3: 9d popf
return STATUS_MESSAGE_QUEUE_WAIT_IN_ISR;
10f3e4: b8 0d 0b 00 00 mov $0xb0d,%eax
10f3e9: e9 6b fe ff ff jmp 10f259 <_CORE_message_queue_Submit+0x79>
10f3ee: 90 nop
10f3ef: 90 nop
0011e1e0 <_Condition_Wait_recursive>:
{
11e1e0: 55 push %ebp <== NOT EXECUTED
11e1e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
11e1e3: 56 push %esi <== NOT EXECUTED
11e1e4: 53 push %ebx <== NOT EXECUTED
11e1e5: 83 ec 40 sub $0x40,%esp <== NOT EXECUTED
queue_context->enqueue_callout = enqueue_callout;
11e1e8: c7 45 d8 c0 e1 11 00 movl $0x11e1c0,-0x28(%ebp) <== NOT EXECUTED
11e1ef: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
context->mutex = _mutex;
11e1f2: 89 5d f4 mov %ebx,-0xc(%ebp) <== NOT EXECUTED
nest_level = _mutex->_nest_level;
11e1f5: 8b 73 14 mov 0x14(%ebx),%esi <== NOT EXECUTED
_mutex->_nest_level = 0;
11e1f8: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED
_ISR_lock_ISR_disable( &context->Base.Lock_context.Lock_context );
11e1ff: 9c pushf <== NOT EXECUTED
11e200: fa cli <== NOT EXECUTED
11e201: 58 pop %eax <== NOT EXECUTED
11e202: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
queue_context->thread_state = thread_state;
11e205: c7 45 d4 20 00 00 00 movl $0x20,-0x2c(%ebp) <== NOT EXECUTED
_Thread_queue_Enqueue(
11e20c: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED
11e20f: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
11e213: a1 b8 42 13 00 mov 0x1342b8,%eax <== NOT EXECUTED
11e218: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
11e21c: b8 70 7f 12 00 mov $0x127f70,%eax <== NOT EXECUTED
11e221: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
11e225: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
11e228: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
11e22b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
11e22e: e8 ad 90 fe ff call 1072e0 <_Thread_queue_Enqueue> <== NOT EXECUTED
_Mutex_recursive_Acquire( _mutex );
11e233: 89 1c 24 mov %ebx,(%esp)
11e236: e8 65 82 fe ff call 1064a0 <_Mutex_recursive_Acquire>
_mutex->_nest_level = nest_level;
11e23b: 89 73 14 mov %esi,0x14(%ebx)
}
11e23e: 83 c4 40 add $0x40,%esp
11e241: 5b pop %ebx
11e242: 5e pop %esi
11e243: 5d pop %ebp
11e244: c3 ret
11e245: 90 nop
11e246: 90 nop
11e247: 90 nop
11e248: 90 nop
11e249: 90 nop
11e24a: 90 nop
11e24b: 90 nop
11e24c: 90 nop
11e24d: 90 nop
11e24e: 90 nop
11e24f: 90 nop
00104c80 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
104c80: 55 push %ebp
104c81: 89 e5 mov %esp,%ebp
104c83: 57 push %edi
104c84: 56 push %esi
104c85: 53 push %ebx
104c86: 83 ec 3c sub $0x3c,%esp
104c89: 8b 5d 0c mov 0xc(%ebp),%ebx
104c8c: 8b 75 08 mov 0x8(%ebp),%esi
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
104c8f: 83 c3 04 add $0x4,%ebx
104c92: 89 5d e0 mov %ebx,-0x20(%ebp)
104c95: 0f 82 ef 01 00 00 jb 104e8a <_Heap_Allocate_aligned_with_boundary+0x20a>
104c9b: 31 c0 xor %eax,%eax
104c9d: 89 45 e4 mov %eax,-0x1c(%ebp)
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
104ca0: 8b 5e 10 mov 0x10(%esi),%ebx
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
104ca3: 85 c0 test %eax,%eax
uintptr_t const page_size = heap->page_size;
104ca5: 89 5d d8 mov %ebx,-0x28(%ebp)
if ( block_size_floor < alloc_size ) {
104ca8: 0f 85 d2 01 00 00 jne 104e80 <_Heap_Allocate_aligned_with_boundary+0x200>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
104cae: 8b 7d 14 mov 0x14(%ebp),%edi
104cb1: 85 ff test %edi,%edi
104cb3: 0f 85 a7 01 00 00 jne 104e60 <_Heap_Allocate_aligned_with_boundary+0x1e0>
*
* @return The first block of the free list.
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
104cb9: 8b 7e 08 mov 0x8(%esi),%edi
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
104cbc: 39 fe cmp %edi,%esi
104cbe: 0f 84 ff 00 00 00 je 104dc3 <_Heap_Allocate_aligned_with_boundary+0x143>
uintptr_t alloc_begin = alloc_end - alloc_size;
104cc4: 89 75 08 mov %esi,0x8(%ebp)
104cc7: 8b 55 0c mov 0xc(%ebp),%edx
104cca: b8 04 00 00 00 mov $0x4,%eax
104ccf: 8b 75 0c mov 0xc(%ebp),%esi
104cd2: 29 d0 sub %edx,%eax
104cd4: 89 45 d4 mov %eax,-0x2c(%ebp)
104cd7: eb 1e jmp 104cf7 <_Heap_Allocate_aligned_with_boundary+0x77>
104cd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
104ce0: 8b 45 dc mov -0x24(%ebp),%eax
104ce3: 85 c0 test %eax,%eax
104ce5: 0f 85 35 01 00 00 jne 104e20 <_Heap_Allocate_aligned_with_boundary+0x1a0><== ALWAYS TAKEN
break;
}
block = block->next;
104ceb: 8b 7f 08 mov 0x8(%edi),%edi
while ( block != free_list_tail ) {
104cee: 39 7d 08 cmp %edi,0x8(%ebp)
104cf1: 0f 84 c9 00 00 00 je 104dc0 <_Heap_Allocate_aligned_with_boundary+0x140>
if ( block->size_and_flag > block_size_floor ) {
104cf7: 8b 4f 04 mov 0x4(%edi),%ecx
++search_count;
104cfa: ff 45 e4 incl -0x1c(%ebp)
if ( block->size_and_flag > block_size_floor ) {
104cfd: 3b 4d e0 cmp -0x20(%ebp),%ecx
104d00: 76 e9 jbe 104ceb <_Heap_Allocate_aligned_with_boundary+0x6b>
*/
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
104d02: 8d 47 08 lea 0x8(%edi),%eax
104d05: 89 45 dc mov %eax,-0x24(%ebp)
if ( alignment == 0 ) {
104d08: 8b 45 10 mov 0x10(%ebp),%eax
104d0b: 85 c0 test %eax,%eax
104d0d: 74 d1 je 104ce0 <_Heap_Allocate_aligned_with_boundary+0x60>
alloc_begin = _Heap_Check_block(
104d0f: 8b 45 08 mov 0x8(%ebp),%eax
*
* @return The block size.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
104d12: 83 e1 fe and $0xfffffffe,%ecx
uintptr_t const block_end = block_begin + block_size;
104d15: 01 f9 add %edi,%ecx
104d17: 8b 50 14 mov 0x14(%eax),%edx
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
104d1a: 8b 45 d8 mov -0x28(%ebp),%eax
104d1d: 89 55 cc mov %edx,-0x34(%ebp)
104d20: 29 d0 sub %edx,%eax
return value - (value % alignment);
104d22: 31 d2 xor %edx,%edx
104d24: 8d 5c 08 07 lea 0x7(%eax,%ecx,1),%ebx
uintptr_t alloc_begin = alloc_end - alloc_size;
104d28: 8b 45 d4 mov -0x2c(%ebp),%eax
104d2b: 01 c1 add %eax,%ecx
104d2d: 89 c8 mov %ecx,%eax
104d2f: f7 75 10 divl 0x10(%ebp)
104d32: 29 d1 sub %edx,%ecx
if ( alloc_begin > alloc_begin_ceiling ) {
104d34: 39 cb cmp %ecx,%ebx
104d36: 73 0b jae 104d43 <_Heap_Allocate_aligned_with_boundary+0xc3>
104d38: 89 d8 mov %ebx,%eax
104d3a: 31 d2 xor %edx,%edx
104d3c: f7 75 10 divl 0x10(%ebp)
104d3f: 29 d3 sub %edx,%ebx
104d41: 89 d9 mov %ebx,%ecx
if ( boundary != 0 ) {
104d43: 8b 55 14 mov 0x14(%ebp),%edx
104d46: 85 d2 test %edx,%edx
104d48: 0f 84 95 00 00 00 je 104de3 <_Heap_Allocate_aligned_with_boundary+0x163>
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
104d4e: 8d 47 08 lea 0x8(%edi),%eax
104d51: 31 d2 xor %edx,%edx
alloc_end = alloc_begin + alloc_size;
104d53: 8d 1c 0e lea (%esi,%ecx,1),%ebx
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
104d56: 01 f0 add %esi,%eax
104d58: 89 45 d0 mov %eax,-0x30(%ebp)
104d5b: 89 d8 mov %ebx,%eax
104d5d: f7 75 14 divl 0x14(%ebp)
104d60: 89 d8 mov %ebx,%eax
104d62: 29 d0 sub %edx,%eax
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
104d64: 39 c3 cmp %eax,%ebx
104d66: 76 7b jbe 104de3 <_Heap_Allocate_aligned_with_boundary+0x163>
104d68: 39 c1 cmp %eax,%ecx
104d6a: 73 77 jae 104de3 <_Heap_Allocate_aligned_with_boundary+0x163>
if ( boundary_line < boundary_floor ) {
104d6c: 39 45 d0 cmp %eax,-0x30(%ebp)
104d6f: 0f 87 76 ff ff ff ja 104ceb <_Heap_Allocate_aligned_with_boundary+0x6b>
104d75: 89 7d c8 mov %edi,-0x38(%ebp)
104d78: 8b 7d d0 mov -0x30(%ebp),%edi
104d7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104d7f: 90 nop
alloc_begin = boundary_line - alloc_size;
104d80: 29 f0 sub %esi,%eax
104d82: 31 d2 xor %edx,%edx
104d84: 89 c1 mov %eax,%ecx
104d86: f7 75 10 divl 0x10(%ebp)
104d89: 29 d1 sub %edx,%ecx
104d8b: 31 d2 xor %edx,%edx
alloc_end = alloc_begin + alloc_size;
104d8d: 8d 1c 0e lea (%esi,%ecx,1),%ebx
104d90: 89 d8 mov %ebx,%eax
104d92: f7 75 14 divl 0x14(%ebp)
104d95: 89 d8 mov %ebx,%eax
104d97: 29 d0 sub %edx,%eax
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
104d99: 39 c1 cmp %eax,%ecx
104d9b: 73 43 jae 104de0 <_Heap_Allocate_aligned_with_boundary+0x160>
104d9d: 39 c3 cmp %eax,%ebx
104d9f: 76 3f jbe 104de0 <_Heap_Allocate_aligned_with_boundary+0x160>
if ( boundary_line < boundary_floor ) {
104da1: 39 c7 cmp %eax,%edi
104da3: 76 db jbe 104d80 <_Heap_Allocate_aligned_with_boundary+0x100><== ALWAYS TAKEN
104da5: 8b 7d c8 mov -0x38(%ebp),%edi <== NOT EXECUTED
block = block->next;
104da8: 8b 7f 08 mov 0x8(%edi),%edi <== NOT EXECUTED
while ( block != free_list_tail ) {
104dab: 39 7d 08 cmp %edi,0x8(%ebp) <== NOT EXECUTED
104dae: 0f 85 43 ff ff ff jne 104cf7 <_Heap_Allocate_aligned_with_boundary+0x77><== NOT EXECUTED
104db4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104dbb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104dbf: 90 nop <== NOT EXECUTED
104dc0: 8b 75 08 mov 0x8(%ebp),%esi
++stats->allocs;
stats->searches += search_count;
stats->lifetime_allocated += _Heap_Block_size( block );
} else {
/* Statistics */
++stats->failed_allocs;
104dc3: ff 46 5c incl 0x5c(%esi)
104dc6: 31 c0 xor %eax,%eax
}
/* Statistics */
if ( stats->max_search < search_count ) {
104dc8: 8b 55 e4 mov -0x1c(%ebp),%edx
104dcb: 39 56 50 cmp %edx,0x50(%esi)
104dce: 73 03 jae 104dd3 <_Heap_Allocate_aligned_with_boundary+0x153>
stats->max_search = search_count;
104dd0: 89 56 50 mov %edx,0x50(%esi)
}
return (void *) alloc_begin;
}
104dd3: 83 c4 3c add $0x3c,%esp
104dd6: 5b pop %ebx
104dd7: 5e pop %esi
104dd8: 5f pop %edi
104dd9: 5d pop %ebp
104dda: c3 ret
104ddb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104ddf: 90 nop
104de0: 8b 7d c8 mov -0x38(%ebp),%edi
if ( alloc_begin >= alloc_begin_floor ) {
104de3: 3b 4d dc cmp -0x24(%ebp),%ecx
104de6: 0f 82 ff fe ff ff jb 104ceb <_Heap_Allocate_aligned_with_boundary+0x6b>
uintptr_t const free_size = alloc_block_begin - block_begin;
104dec: 89 c8 mov %ecx,%eax
104dee: 31 d2 xor %edx,%edx
104df0: 29 f8 sub %edi,%eax
104df2: 8d 58 f8 lea -0x8(%eax),%ebx
104df5: 89 c8 mov %ecx,%eax
104df7: f7 75 d8 divl -0x28(%ebp)
104dfa: 29 d3 sub %edx,%ebx
if ( free_size >= min_block_size || free_size == 0 ) {
104dfc: 39 5d cc cmp %ebx,-0x34(%ebp)
104dff: 76 08 jbe 104e09 <_Heap_Allocate_aligned_with_boundary+0x189>
104e01: 85 db test %ebx,%ebx
104e03: 0f 85 e2 fe ff ff jne 104ceb <_Heap_Allocate_aligned_with_boundary+0x6b>
104e09: 89 4d dc mov %ecx,-0x24(%ebp)
if ( alloc_begin != 0 ) {
104e0c: 8b 45 dc mov -0x24(%ebp),%eax
104e0f: 85 c0 test %eax,%eax
104e11: 0f 84 d4 fe ff ff je 104ceb <_Heap_Allocate_aligned_with_boundary+0x6b><== NEVER TAKEN
104e17: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104e1e: 66 90 xchg %ax,%ax
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
104e20: 8b 75 08 mov 0x8(%ebp),%esi
104e23: 89 7c 24 04 mov %edi,0x4(%esp)
104e27: 8b 5d dc mov -0x24(%ebp),%ebx
104e2a: 8b 45 0c mov 0xc(%ebp),%eax
104e2d: 89 34 24 mov %esi,(%esp)
104e30: 89 5c 24 08 mov %ebx,0x8(%esp)
104e34: 89 44 24 0c mov %eax,0xc(%esp)
104e38: e8 63 04 00 00 call 1052a0 <_Heap_Block_allocate>
stats->searches += search_count;
104e3d: 8b 7d e4 mov -0x1c(%ebp),%edi
stats->lifetime_allocated += _Heap_Block_size( block );
104e40: 31 d2 xor %edx,%edx
++stats->allocs;
104e42: ff 46 58 incl 0x58(%esi)
stats->searches += search_count;
104e45: 01 7e 54 add %edi,0x54(%esi)
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
104e48: 8b 40 04 mov 0x4(%eax),%eax
104e4b: 83 e0 fe and $0xfffffffe,%eax
stats->lifetime_allocated += _Heap_Block_size( block );
104e4e: 01 46 28 add %eax,0x28(%esi)
return (void *) alloc_begin;
104e51: 89 d8 mov %ebx,%eax
stats->lifetime_allocated += _Heap_Block_size( block );
104e53: 11 56 2c adc %edx,0x2c(%esi)
104e56: e9 6d ff ff ff jmp 104dc8 <_Heap_Allocate_aligned_with_boundary+0x148>
104e5b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104e5f: 90 nop
if ( boundary < alloc_size ) {
104e60: 8b 45 14 mov 0x14(%ebp),%eax
104e63: 39 45 0c cmp %eax,0xc(%ebp)
104e66: 77 18 ja 104e80 <_Heap_Allocate_aligned_with_boundary+0x200>
if ( alignment == 0 ) {
104e68: 8b 4d 10 mov 0x10(%ebp),%ecx
104e6b: 85 c9 test %ecx,%ecx
104e6d: 0f 85 46 fe ff ff jne 104cb9 <_Heap_Allocate_aligned_with_boundary+0x39>
alignment = page_size;
104e73: 89 5d 10 mov %ebx,0x10(%ebp)
104e76: e9 3e fe ff ff jmp 104cb9 <_Heap_Allocate_aligned_with_boundary+0x39>
104e7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104e7f: 90 nop
}
104e80: 83 c4 3c add $0x3c,%esp
return NULL;
104e83: 31 c0 xor %eax,%eax
}
104e85: 5b pop %ebx
104e86: 5e pop %esi
104e87: 5f pop %edi
104e88: 5d pop %ebp
104e89: c3 ret
104e8a: b8 01 00 00 00 mov $0x1,%eax
104e8f: e9 09 fe ff ff jmp 104c9d <_Heap_Allocate_aligned_with_boundary+0x1d>
104e94: 90 nop
104e95: 90 nop
104e96: 90 nop
104e97: 90 nop
104e98: 90 nop
104e99: 90 nop
104e9a: 90 nop
104e9b: 90 nop
104e9c: 90 nop
104e9d: 90 nop
104e9e: 90 nop
104e9f: 90 nop
0010a690 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused RTEMS_UNUSED
)
{
10a690: 55 push %ebp
10a691: 89 e5 mov %esp,%ebp
10a693: 57 push %edi
10a694: 56 push %esi
10a695: 53 push %ebx
10a696: 83 ec 6c sub $0x6c,%esp
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
Heap_Block *extend_last_block = NULL;
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
10a699: 8b 55 0c mov 0xc(%ebp),%edx
Heap_Block *extend_first_block = NULL;
10a69c: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
{
10a6a3: 8b 7d 08 mov 0x8(%ebp),%edi
Heap_Block *extend_last_block = NULL;
10a6a6: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
{
10a6ad: 8b 45 10 mov 0x10(%ebp),%eax
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
10a6b0: 89 55 b0 mov %edx,-0x50(%ebp)
Heap_Block *const first_block = heap->first_block;
10a6b3: 8b 5f 20 mov 0x20(%edi),%ebx
10a6b6: 89 c2 mov %eax,%edx
10a6b8: 03 55 0c add 0xc(%ebp),%edx
10a6bb: 89 5d d0 mov %ebx,-0x30(%ebp)
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
10a6be: 89 55 c8 mov %edx,-0x38(%ebp)
10a6c1: 0f 82 19 02 00 00 jb 10a8e0 <_Heap_Extend+0x250>
if ( extend_area_end < extend_area_begin ) {
return 0;
}
extend_area_ok = _Heap_Get_first_and_last_block(
10a6c7: 8d 55 e4 lea -0x1c(%ebp),%edx
uintptr_t const page_size = heap->page_size;
10a6ca: 8b 77 10 mov 0x10(%edi),%esi
uintptr_t const free_size = stats->free_size;
10a6cd: 8b 5f 3c mov 0x3c(%edi),%ebx
extend_area_ok = _Heap_Get_first_and_last_block(
10a6d0: 89 54 24 14 mov %edx,0x14(%esp)
10a6d4: 8d 55 e0 lea -0x20(%ebp),%edx
10a6d7: 89 54 24 10 mov %edx,0x10(%esp)
uintptr_t const page_size = heap->page_size;
10a6db: 89 75 cc mov %esi,-0x34(%ebp)
extend_area_ok = _Heap_Get_first_and_last_block(
10a6de: 8b 57 14 mov 0x14(%edi),%edx
10a6e1: 89 44 24 04 mov %eax,0x4(%esp)
10a6e5: 8b 45 0c mov 0xc(%ebp),%eax
10a6e8: 89 74 24 08 mov %esi,0x8(%esp)
uintptr_t const free_size = stats->free_size;
10a6ec: 89 5d b4 mov %ebx,-0x4c(%ebp)
extend_area_ok = _Heap_Get_first_and_last_block(
10a6ef: 89 54 24 0c mov %edx,0xc(%esp)
10a6f3: 89 04 24 mov %eax,(%esp)
10a6f6: e8 b5 a8 ff ff call 104fb0 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
10a6fb: 84 c0 test %al,%al
10a6fd: 0f 84 dd 01 00 00 je 10a8e0 <_Heap_Extend+0x250>
Heap_Block *merge_below_block = NULL;
10a703: 89 7d 08 mov %edi,0x8(%ebp)
Heap_Block *const first_block = heap->first_block;
10a706: 8b 4d d0 mov -0x30(%ebp),%ecx
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
10a709: 3b 4d d0 cmp -0x30(%ebp),%ecx
Heap_Block *link_above_block = NULL;
10a70c: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp)
Heap_Block *merge_below_block = NULL;
10a713: 8b 7d c8 mov -0x38(%ebp),%edi
Heap_Block *link_below_block = NULL;
10a716: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp)
Heap_Block *merge_above_block = NULL;
10a71d: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp)
Heap_Block *merge_below_block = NULL;
10a724: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
(uintptr_t) start_block : heap->area_begin;
10a72b: 89 4d d4 mov %ecx,-0x2c(%ebp)
10a72e: 75 36 jne 10a766 <_Heap_Extend+0xd6> <== NEVER TAKEN
10a730: 8b 45 08 mov 0x8(%ebp),%eax
10a733: 8b 40 18 mov 0x18(%eax),%eax
10a736: 89 45 d4 mov %eax,-0x2c(%ebp)
10a739: eb 2b jmp 10a766 <_Heap_Extend+0xd6>
10a73b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10a73f: 90 nop
return 0;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10a740: 39 df cmp %ebx,%edi
10a742: 73 03 jae 10a747 <_Heap_Extend+0xb7>
10a744: 89 4d bc mov %ecx,-0x44(%ebp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
10a747: 39 5d 0c cmp %ebx,0xc(%ebp)
10a74a: 74 43 je 10a78f <_Heap_Extend+0xff>
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
10a74c: 76 03 jbe 10a751 <_Heap_Extend+0xc1>
link_above_block = end_block;
10a74e: 89 75 b8 mov %esi,-0x48(%ebp)
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10a751: 8b 4e 04 mov 0x4(%esi),%ecx
10a754: 83 e1 fe and $0xfffffffe,%ecx
return (Heap_Block *) ((uintptr_t) block + offset);
10a757: 01 f1 add %esi,%ecx
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
10a759: 39 4d d0 cmp %ecx,-0x30(%ebp)
10a75c: 74 43 je 10a7a1 <_Heap_Extend+0x111>
(uintptr_t) start_block : heap->area_begin;
10a75e: 3b 4d d0 cmp -0x30(%ebp),%ecx
10a761: 89 4d d4 mov %ecx,-0x2c(%ebp)
10a764: 74 ca je 10a730 <_Heap_Extend+0xa0> <== NEVER TAKEN
uintptr_t const sub_area_end = start_block->prev_size;
10a766: 8b 19 mov (%ecx),%ebx
return value - (value % alignment);
10a768: 31 d2 xor %edx,%edx
- HEAP_BLOCK_HEADER_SIZE);
10a76a: 8d 73 f8 lea -0x8(%ebx),%esi
return value - (value % alignment);
10a76d: 89 d8 mov %ebx,%eax
10a76f: f7 75 cc divl -0x34(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
10a772: 29 d6 sub %edx,%esi
if (
10a774: 39 5d 0c cmp %ebx,0xc(%ebp)
10a777: 73 09 jae 10a782 <_Heap_Extend+0xf2>
10a779: 39 7d d4 cmp %edi,-0x2c(%ebp)
10a77c: 0f 82 5e 01 00 00 jb 10a8e0 <_Heap_Extend+0x250>
if ( extend_area_end == sub_area_begin ) {
10a782: 39 7d d4 cmp %edi,-0x2c(%ebp)
10a785: 75 b9 jne 10a740 <_Heap_Extend+0xb0>
if ( sub_area_end == extend_area_begin ) {
10a787: 39 5d 0c cmp %ebx,0xc(%ebp)
10a78a: 89 4d c4 mov %ecx,-0x3c(%ebp)
10a78d: 75 bd jne 10a74c <_Heap_Extend+0xbc> <== ALWAYS TAKEN
start_block->prev_size = extend_area_end;
10a78f: 89 39 mov %edi,(%ecx)
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10a791: 8b 4e 04 mov 0x4(%esi),%ecx
merge_above_block = end_block;
10a794: 89 75 c0 mov %esi,-0x40(%ebp)
10a797: 83 e1 fe and $0xfffffffe,%ecx
return (Heap_Block *) ((uintptr_t) block + offset);
10a79a: 01 f1 add %esi,%ecx
} while ( start_block != first_block );
10a79c: 39 4d d0 cmp %ecx,-0x30(%ebp)
10a79f: 75 bd jne 10a75e <_Heap_Extend+0xce> <== NEVER TAKEN
if ( extend_area_begin < heap->area_begin ) {
10a7a1: 8b 7d 08 mov 0x8(%ebp),%edi
10a7a4: 8b 45 0c mov 0xc(%ebp),%eax
10a7a7: 39 47 18 cmp %eax,0x18(%edi)
10a7aa: 0f 86 60 01 00 00 jbe 10a910 <_Heap_Extend+0x280>
heap->area_begin = extend_area_begin;
10a7b0: 89 47 18 mov %eax,0x18(%edi)
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
10a7b3: 8b 5d e4 mov -0x1c(%ebp),%ebx
10a7b6: 8b 45 e0 mov -0x20(%ebp),%eax
extend_first_block->prev_size = extend_area_end;
10a7b9: 8b 75 c8 mov -0x38(%ebp),%esi
extend_first_block_size =
10a7bc: 89 da mov %ebx,%edx
10a7be: 29 c2 sub %eax,%edx
extend_first_block->prev_size = extend_area_end;
10a7c0: 89 30 mov %esi,(%eax)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10a7c2: 89 d1 mov %edx,%ecx
10a7c4: 83 c9 01 or $0x1,%ecx
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
10a7c7: 39 47 20 cmp %eax,0x20(%edi)
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10a7ca: 89 48 04 mov %ecx,0x4(%eax)
extend_last_block->prev_size = extend_first_block_size;
10a7cd: 89 13 mov %edx,(%ebx)
extend_last_block->size_and_flag = 0;
10a7cf: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
10a7d6: 0f 86 14 01 00 00 jbe 10a8f0 <_Heap_Extend+0x260>
heap->first_block = extend_first_block;
10a7dc: 89 47 20 mov %eax,0x20(%edi)
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
10a7df: 8b 45 c4 mov -0x3c(%ebp),%eax
10a7e2: 85 c0 test %eax,%eax
10a7e4: 0f 84 46 01 00 00 je 10a930 <_Heap_Extend+0x2a0>
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
10a7ea: 8b 45 0c mov 0xc(%ebp),%eax
uintptr_t remainder = value % alignment;
10a7ed: 31 d2 xor %edx,%edx
uintptr_t const page_size = heap->page_size;
10a7ef: 8b 5f 10 mov 0x10(%edi),%ebx
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
10a7f2: 8d 48 08 lea 0x8(%eax),%ecx
10a7f5: 89 c8 mov %ecx,%eax
10a7f7: f7 f3 div %ebx
if ( remainder != 0 ) {
10a7f9: 85 d2 test %edx,%edx
10a7fb: 0f 85 8f 01 00 00 jne 10a990 <_Heap_Extend+0x300> <== NEVER TAKEN
new_first_block->prev_size = first_block->prev_size;
10a801: 8b 55 c4 mov -0x3c(%ebp),%edx
10a804: 8b 5d 0c mov 0xc(%ebp),%ebx
uintptr_t const new_first_block_size =
10a807: 8b 75 b0 mov -0x50(%ebp),%esi
new_first_block->prev_size = first_block->prev_size;
10a80a: 8b 02 mov (%edx),%eax
10a80c: 89 03 mov %eax,(%ebx)
uintptr_t const new_first_block_size =
10a80e: 89 d0 mov %edx,%eax
10a810: 29 f0 sub %esi,%eax
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
10a812: 83 c8 01 or $0x1,%eax
10a815: 89 43 04 mov %eax,0x4(%ebx)
++stats->used_blocks;
10a818: ff 47 4c incl 0x4c(%edi)
--stats->frees;
10a81b: ff 4f 60 decl 0x60(%edi)
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
10a81e: 89 4c 24 04 mov %ecx,0x4(%esp)
10a822: 89 3c 24 mov %edi,(%esp)
10a825: e8 86 01 00 00 call 10a9b0 <_Heap_Free>
return _Heap_Free_list_head(heap)->next;
10a82a: 8b 47 08 mov 0x8(%edi),%eax
Heap_Block *next = block->next;
10a82d: 8b 50 08 mov 0x8(%eax),%edx
Heap_Block *prev = block->prev;
10a830: 8b 48 0c mov 0xc(%eax),%ecx
prev->next = next;
10a833: 89 51 08 mov %edx,0x8(%ecx)
next->prev = prev;
10a836: 89 4a 0c mov %ecx,0xc(%edx)
Heap_Block *prev = block_next->prev;
10a839: 8b 57 0c mov 0xc(%edi),%edx
new_block->next = block_next;
10a83c: 89 78 08 mov %edi,0x8(%eax)
new_block->prev = prev;
10a83f: 89 50 0c mov %edx,0xc(%eax)
prev->next = new_block;
10a842: 89 42 08 mov %eax,0x8(%edx)
block_next->prev = new_block;
10a845: 89 47 0c mov %eax,0xc(%edi)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
10a848: 8b 75 c0 mov -0x40(%ebp),%esi
10a84b: 85 f6 test %esi,%esi
10a84d: 0f 84 fd 00 00 00 je 10a950 <_Heap_Extend+0x2c0>
uintptr_t const last_block_new_size = _Heap_Align_down(
10a853: 8b 5d c8 mov -0x38(%ebp),%ebx
return value - (value % alignment);
10a856: 31 d2 xor %edx,%edx
10a858: 83 eb 08 sub $0x8,%ebx
10a85b: 89 d9 mov %ebx,%ecx
10a85d: 29 f1 sub %esi,%ecx
10a85f: 89 c8 mov %ecx,%eax
10a861: f7 77 10 divl 0x10(%edi)
(last_block->size_and_flag - last_block_new_size)
10a864: 8b 46 04 mov 0x4(%esi),%eax
10a867: 01 f0 add %esi,%eax
10a869: 29 d8 sub %ebx,%eax
10a86b: 29 d1 sub %edx,%ecx
10a86d: 01 c2 add %eax,%edx
| HEAP_PREV_BLOCK_USED;
10a86f: 83 ca 01 or $0x1,%edx
10a872: 89 54 0e 04 mov %edx,0x4(%esi,%ecx,1)
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
10a876: 8b 46 04 mov 0x4(%esi),%eax
10a879: 89 45 d4 mov %eax,-0x2c(%ebp)
10a87c: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
10a87f: 09 c1 or %eax,%ecx
10a881: 89 4e 04 mov %ecx,0x4(%esi)
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10a884: 8d 46 08 lea 0x8(%esi),%eax
++stats->used_blocks;
10a887: ff 47 4c incl 0x4c(%edi)
--stats->frees;
10a88a: ff 4f 60 decl 0x60(%edi)
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
10a88d: 89 44 24 04 mov %eax,0x4(%esp)
10a891: 89 3c 24 mov %edi,(%esp)
10a894: e8 17 01 00 00 call 10a9b0 <_Heap_Free>
return _Heap_Free_list_head(heap)->next;
10a899: 8b 47 08 mov 0x8(%edi),%eax
Heap_Block *next = block->next;
10a89c: 8b 50 08 mov 0x8(%eax),%edx
Heap_Block *prev = block->prev;
10a89f: 8b 48 0c mov 0xc(%eax),%ecx
prev->next = next;
10a8a2: 89 51 08 mov %edx,0x8(%ecx)
next->prev = prev;
10a8a5: 89 4a 0c mov %ecx,0xc(%edx)
Heap_Block *prev = block_next->prev;
10a8a8: 8b 57 0c mov 0xc(%edi),%edx
new_block->next = block_next;
10a8ab: 89 78 08 mov %edi,0x8(%eax)
new_block->prev = prev;
10a8ae: 89 50 0c mov %edx,0xc(%eax)
prev->next = new_block;
10a8b1: 89 42 08 mov %eax,0x8(%edx)
block_next->prev = new_block;
10a8b4: 89 47 0c mov %eax,0xc(%edi)
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
10a8b7: 8b 57 24 mov 0x24(%edi),%edx
_Heap_Block_set_size(
10a8ba: 8b 47 20 mov 0x20(%edi),%eax
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
10a8bd: 8b 4a 04 mov 0x4(%edx),%ecx
_Heap_Block_set_size(
10a8c0: 29 d0 sub %edx,%eax
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
10a8c2: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
10a8c5: 09 c8 or %ecx,%eax
10a8c7: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
10a8ca: 8b 47 3c mov 0x3c(%edi),%eax
10a8cd: 8b 55 b4 mov -0x4c(%ebp),%edx
10a8d0: 29 d0 sub %edx,%eax
/* Statistics */
stats->size += extended_size;
10a8d2: 01 47 38 add %eax,0x38(%edi)
return extended_size;
}
10a8d5: 83 c4 6c add $0x6c,%esp
10a8d8: 5b pop %ebx
10a8d9: 5e pop %esi
10a8da: 5f pop %edi
10a8db: 5d pop %ebp
10a8dc: c3 ret
10a8dd: 8d 76 00 lea 0x0(%esi),%esi
10a8e0: 83 c4 6c add $0x6c,%esp
return 0;
10a8e3: 31 c0 xor %eax,%eax
}
10a8e5: 5b pop %ebx
10a8e6: 5e pop %esi
10a8e7: 5f pop %edi
10a8e8: 5d pop %ebp
10a8e9: c3 ret
10a8ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
10a8f0: 39 5f 24 cmp %ebx,0x24(%edi)
10a8f3: 0f 83 e6 fe ff ff jae 10a7df <_Heap_Extend+0x14f>
heap->last_block = extend_last_block;
10a8f9: 89 5f 24 mov %ebx,0x24(%edi)
10a8fc: e9 de fe ff ff jmp 10a7df <_Heap_Extend+0x14f>
10a901: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a908: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a90f: 90 nop
} else if ( heap->area_end < extend_area_end ) {
10a910: 8b 45 c8 mov -0x38(%ebp),%eax
10a913: 39 47 1c cmp %eax,0x1c(%edi)
10a916: 0f 83 97 fe ff ff jae 10a7b3 <_Heap_Extend+0x123>
heap->area_end = extend_area_end;
10a91c: 89 47 1c mov %eax,0x1c(%edi)
10a91f: e9 8f fe ff ff jmp 10a7b3 <_Heap_Extend+0x123>
10a924: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a92b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10a92f: 90 nop
} else if ( link_below_block != NULL ) {
10a930: 8b 45 bc mov -0x44(%ebp),%eax
10a933: 85 c0 test %eax,%eax
10a935: 0f 84 0d ff ff ff je 10a848 <_Heap_Extend+0x1b8>
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
10a93b: 29 d8 sub %ebx,%eax
10a93d: 83 c8 01 or $0x1,%eax
10a940: 89 43 04 mov %eax,0x4(%ebx)
}
10a943: e9 00 ff ff ff jmp 10a848 <_Heap_Extend+0x1b8>
10a948: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a94f: 90 nop
} else if ( link_above_block != NULL ) {
10a950: 8b 5d b8 mov -0x48(%ebp),%ebx
10a953: 85 db test %ebx,%ebx
10a955: 74 1a je 10a971 <_Heap_Extend+0x2e1>
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
10a957: 8b 53 04 mov 0x4(%ebx),%edx
_Heap_Block_set_size( link, first_block_begin - link_begin );
10a95a: 8b 45 e0 mov -0x20(%ebp),%eax
_Heap_Link_above(
10a95d: 8b 4d e4 mov -0x1c(%ebp),%ecx
10a960: 89 55 d4 mov %edx,-0x2c(%ebp)
10a963: 83 e2 01 and $0x1,%edx
_Heap_Block_set_size( link, first_block_begin - link_begin );
10a966: 29 d8 sub %ebx,%eax
block->size_and_flag = size | flag;
10a968: 09 d0 or %edx,%eax
10a96a: 89 43 04 mov %eax,0x4(%ebx)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
10a96d: 83 49 04 01 orl $0x1,0x4(%ecx)
if ( merge_below_block == NULL && merge_above_block == NULL ) {
10a971: 8b 4d c4 mov -0x3c(%ebp),%ecx
10a974: 85 c9 test %ecx,%ecx
10a976: 0f 85 3b ff ff ff jne 10a8b7 <_Heap_Extend+0x227>
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10a97c: 8b 45 e0 mov -0x20(%ebp),%eax
++stats->used_blocks;
10a97f: ff 47 4c incl 0x4c(%edi)
--stats->frees;
10a982: ff 4f 60 decl 0x60(%edi)
10a985: 83 c0 08 add $0x8,%eax
10a988: e9 00 ff ff ff jmp 10a88d <_Heap_Extend+0x1fd>
10a98d: 8d 76 00 lea 0x0(%esi),%esi
return value - remainder + alignment;
10a990: 01 d9 add %ebx,%ecx
10a992: 29 d1 sub %edx,%ecx
uintptr_t const new_first_block_begin =
10a994: 8d 41 f8 lea -0x8(%ecx),%eax
10a997: 89 45 b0 mov %eax,-0x50(%ebp)
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
10a99a: 89 45 0c mov %eax,0xc(%ebp)
10a99d: e9 5f fe ff ff jmp 10a801 <_Heap_Extend+0x171>
10a9a2: 90 nop
10a9a3: 90 nop
10a9a4: 90 nop
10a9a5: 90 nop
10a9a6: 90 nop
10a9a7: 90 nop
10a9a8: 90 nop
10a9a9: 90 nop
10a9aa: 90 nop
10a9ab: 90 nop
10a9ac: 90 nop
10a9ad: 90 nop
10a9ae: 90 nop
10a9af: 90 nop
0010a9b0 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
10a9b0: 55 push %ebp
10a9b1: 89 e5 mov %esp,%ebp
10a9b3: 83 ec 20 sub $0x20,%esp
10a9b6: 89 5d f4 mov %ebx,-0xc(%ebp)
10a9b9: 8b 45 0c mov 0xc(%ebp),%eax
10a9bc: 89 75 f8 mov %esi,-0x8(%ebp)
10a9bf: 8b 4d 08 mov 0x8(%ebp),%ecx
10a9c2: 89 7d fc mov %edi,-0x4(%ebp)
/*
* 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 ) {
10a9c5: 85 c0 test %eax,%eax
10a9c7: 0f 84 33 01 00 00 je 10ab00 <_Heap_Free+0x150>
- HEAP_BLOCK_HEADER_SIZE);
10a9cd: 8d 70 f8 lea -0x8(%eax),%esi
return value - (value % alignment);
10a9d0: 31 d2 xor %edx,%edx
return (uintptr_t) block >= (uintptr_t) heap->first_block
10a9d2: 8b 79 20 mov 0x20(%ecx),%edi
return value - (value % alignment);
10a9d5: f7 71 10 divl 0x10(%ecx)
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;
10a9d8: 31 c0 xor %eax,%eax
- HEAP_BLOCK_HEADER_SIZE);
10a9da: 29 d6 sub %edx,%esi
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10a9dc: 39 fe cmp %edi,%esi
10a9de: 0f 82 92 00 00 00 jb 10aa76 <_Heap_Free+0xc6>
10a9e4: 8b 51 24 mov 0x24(%ecx),%edx
10a9e7: 89 55 ec mov %edx,-0x14(%ebp)
10a9ea: 39 d6 cmp %edx,%esi
10a9ec: 0f 87 84 00 00 00 ja 10aa76 <_Heap_Free+0xc6>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10a9f2: 8b 5e 04 mov 0x4(%esi),%ebx
10a9f5: 89 5d e4 mov %ebx,-0x1c(%ebp)
10a9f8: 83 e3 fe and $0xfffffffe,%ebx
10a9fb: 89 5d e8 mov %ebx,-0x18(%ebp)
return (Heap_Block *) ((uintptr_t) block + offset);
10a9fe: 01 f3 add %esi,%ebx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10aa00: 39 df cmp %ebx,%edi
10aa02: 77 72 ja 10aa76 <_Heap_Free+0xc6> <== NEVER TAKEN
10aa04: 39 5d ec cmp %ebx,-0x14(%ebp)
10aa07: 72 6d jb 10aa76 <_Heap_Free+0xc6>
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
10aa09: 8b 43 04 mov 0x4(%ebx),%eax
10aa0c: 89 c2 mov %eax,%edx
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
10aa0e: 24 01 and $0x1,%al
10aa10: 74 64 je 10aa76 <_Heap_Free+0xc6> <== NEVER TAKEN
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10aa12: 83 e2 fe and $0xfffffffe,%edx
10aa15: 89 55 e0 mov %edx,-0x20(%ebp)
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
10aa18: 0f b6 55 e4 movzbl -0x1c(%ebp),%edx
10aa1c: 80 e2 01 and $0x1,%dl
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10aa1f: 39 5d ec cmp %ebx,-0x14(%ebp)
10aa22: 88 55 e4 mov %dl,-0x1c(%ebp)
10aa25: 74 69 je 10aa90 <_Heap_Free+0xe0>
10aa27: 8b 55 e0 mov -0x20(%ebp),%edx
10aa2a: f6 44 13 04 01 testb $0x1,0x4(%ebx,%edx,1)
10aa2f: 75 5f jne 10aa90 <_Heap_Free+0xe0>
if ( !_Heap_Is_prev_used( block ) ) {
10aa31: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp)
10aa35: 0f 84 35 01 00 00 je 10ab70 <_Heap_Free+0x1c0>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
10aa3b: 8b 55 e8 mov -0x18(%ebp),%edx
10aa3e: 8b 7d e0 mov -0x20(%ebp),%edi
10aa41: 01 d7 add %edx,%edi
Heap_Block *next = old_block->next;
10aa43: 8b 53 08 mov 0x8(%ebx),%edx
Heap_Block *prev = old_block->prev;
10aa46: 8b 5b 0c mov 0xc(%ebx),%ebx
new_block->next = next;
10aa49: 89 56 08 mov %edx,0x8(%esi)
new_block->prev = prev;
10aa4c: 89 5e 0c mov %ebx,0xc(%esi)
next->prev = new_block;
10aa4f: 89 72 0c mov %esi,0xc(%edx)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10aa52: 89 fa mov %edi,%edx
prev->next = new_block;
10aa54: 89 73 08 mov %esi,0x8(%ebx)
10aa57: 83 ca 01 or $0x1,%edx
10aa5a: 89 56 04 mov %edx,0x4(%esi)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10aa5d: 89 3c 3e mov %edi,(%esi,%edi,1)
}
/* Statistics */
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
10aa60: 8b 7d e8 mov -0x18(%ebp),%edi
10aa63: 01 79 3c add %edi,0x3c(%ecx)
--stats->used_blocks;
10aa66: ff 49 4c decl 0x4c(%ecx)
++stats->frees;
10aa69: ff 41 60 incl 0x60(%ecx)
stats->lifetime_freed += block_size;
10aa6c: 89 fe mov %edi,%esi
10aa6e: 31 ff xor %edi,%edi
10aa70: 01 71 30 add %esi,0x30(%ecx)
10aa73: 11 79 34 adc %edi,0x34(%ecx)
return( true );
}
10aa76: 8b 5d f4 mov -0xc(%ebp),%ebx
10aa79: 8b 75 f8 mov -0x8(%ebp),%esi
10aa7c: 8b 7d fc mov -0x4(%ebp),%edi
10aa7f: 89 ec mov %ebp,%esp
10aa81: 5d pop %ebp
10aa82: c3 ret
10aa83: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10aa8a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if ( !_Heap_Is_prev_used( block ) ) {
10aa90: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp)
10aa94: 75 7a jne 10ab10 <_Heap_Free+0x160>
10aa96: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
uintptr_t const prev_size = block->prev_size;
10aa9d: 8b 16 mov (%esi),%edx
return (Heap_Block *) ((uintptr_t) block + offset);
10aa9f: 29 d6 sub %edx,%esi
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10aaa1: 39 fe cmp %edi,%esi
10aaa3: 72 4b jb 10aaf0 <_Heap_Free+0x140> <== NEVER TAKEN
10aaa5: 3b 75 ec cmp -0x14(%ebp),%esi
10aaa8: 77 46 ja 10aaf0 <_Heap_Free+0x140> <== NEVER TAKEN
if ( !_Heap_Is_prev_used ( prev_block) ) {
10aaaa: f6 46 04 01 testb $0x1,0x4(%esi)
10aaae: 74 40 je 10aaf0 <_Heap_Free+0x140> <== NEVER TAKEN
uintptr_t const size = block_size + prev_size + next_block_size;
10aab0: 8b 7d e8 mov -0x18(%ebp),%edi
10aab3: 01 d7 add %edx,%edi
if ( next_is_free ) { /* coalesce both */
10aab5: 8b 55 e4 mov -0x1c(%ebp),%edx
10aab8: 85 d2 test %edx,%edx
10aaba: 0f 84 90 00 00 00 je 10ab50 <_Heap_Free+0x1a0>
uintptr_t const size = block_size + prev_size + next_block_size;
10aac0: 8b 55 e0 mov -0x20(%ebp),%edx
10aac3: 01 d7 add %edx,%edi
Heap_Block *next = block->next;
10aac5: 8b 53 08 mov 0x8(%ebx),%edx
Heap_Block *prev = block->prev;
10aac8: 8b 5b 0c mov 0xc(%ebx),%ebx
prev->next = next;
10aacb: 89 53 08 mov %edx,0x8(%ebx)
next->prev = prev;
10aace: 89 5a 0c mov %ebx,0xc(%edx)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10aad1: 89 fa mov %edi,%edx
stats->free_blocks -= 1;
10aad3: ff 49 44 decl 0x44(%ecx)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10aad6: 83 ca 01 or $0x1,%edx
10aad9: 89 56 04 mov %edx,0x4(%esi)
next_block->prev_size = size;
10aadc: 89 3c 3e mov %edi,(%esi,%edi,1)
10aadf: e9 7c ff ff ff jmp 10aa60 <_Heap_Free+0xb0>
10aae4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10aaeb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10aaef: 90 nop
}
10aaf0: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
return false;
10aaf3: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
10aaf5: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
10aaf8: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
10aafb: 89 ec mov %ebp,%esp <== NOT EXECUTED
10aafd: 5d pop %ebp <== NOT EXECUTED
10aafe: c3 ret <== NOT EXECUTED
10aaff: 90 nop <== NOT EXECUTED
10ab00: 8b 5d f4 mov -0xc(%ebp),%ebx
return true;
10ab03: b0 01 mov $0x1,%al
}
10ab05: 8b 75 f8 mov -0x8(%ebp),%esi
10ab08: 8b 7d fc mov -0x4(%ebp),%edi
10ab0b: 89 ec mov %ebp,%esp
10ab0d: 5d pop %ebp
10ab0e: c3 ret
10ab0f: 90 nop
Heap_Block *next = block_before->next;
10ab10: 8b 51 08 mov 0x8(%ecx),%edx
new_block->prev = block_before;
10ab13: 89 4e 0c mov %ecx,0xc(%esi)
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
10ab16: 8b 7d e8 mov -0x18(%ebp),%edi
new_block->next = next;
10ab19: 89 56 08 mov %edx,0x8(%esi)
block_before->next = new_block;
10ab1c: 89 71 08 mov %esi,0x8(%ecx)
next->prev = new_block;
10ab1f: 89 72 0c mov %esi,0xc(%edx)
10ab22: 89 fa mov %edi,%edx
10ab24: 83 ca 01 or $0x1,%edx
10ab27: 89 56 04 mov %edx,0x4(%esi)
next_block->prev_size = block_size;
10ab2a: 89 3b mov %edi,(%ebx)
++stats->free_blocks;
10ab2c: 8b 79 44 mov 0x44(%ecx),%edi
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10ab2f: 83 63 04 fe andl $0xfffffffe,0x4(%ebx)
++stats->free_blocks;
10ab33: 8d 57 01 lea 0x1(%edi),%edx
if ( stats->max_free_blocks < stats->free_blocks ) {
10ab36: 3b 51 48 cmp 0x48(%ecx),%edx
++stats->free_blocks;
10ab39: 89 51 44 mov %edx,0x44(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
10ab3c: 0f 86 1e ff ff ff jbe 10aa60 <_Heap_Free+0xb0>
stats->max_free_blocks = stats->free_blocks;
10ab42: 89 51 48 mov %edx,0x48(%ecx)
10ab45: e9 16 ff ff ff jmp 10aa60 <_Heap_Free+0xb0>
10ab4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10ab50: 89 fa mov %edi,%edx
10ab52: 83 ca 01 or $0x1,%edx
10ab55: 89 56 04 mov %edx,0x4(%esi)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10ab58: 83 63 04 fe andl $0xfffffffe,0x4(%ebx)
next_block->prev_size = size;
10ab5c: 89 3b mov %edi,(%ebx)
10ab5e: e9 fd fe ff ff jmp 10aa60 <_Heap_Free+0xb0>
10ab63: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10ab6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10ab70: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
10ab77: e9 21 ff ff ff jmp 10aa9d <_Heap_Free+0xed>
10ab7c: 90 nop
10ab7d: 90 nop
10ab7e: 90 nop
10ab7f: 90 nop
00104fb0 <_Heap_Get_first_and_last_block>:
{
104fb0: 55 push %ebp
uintptr_t remainder = value % alignment;
104fb1: 31 d2 xor %edx,%edx
104fb3: 89 e5 mov %esp,%ebp
104fb5: 83 ec 10 sub $0x10,%esp
104fb8: 89 5d f4 mov %ebx,-0xc(%ebp)
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
104fbb: 8b 45 0c mov 0xc(%ebp),%eax
{
104fbe: 89 75 f8 mov %esi,-0x8(%ebp)
104fc1: 8b 5d 08 mov 0x8(%ebp),%ebx
104fc4: 89 7d fc mov %edi,-0x4(%ebp)
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
104fc7: 8d 4b 08 lea 0x8(%ebx),%ecx
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
104fca: 01 d8 add %ebx,%eax
104fcc: 89 45 f0 mov %eax,-0x10(%ebp)
104fcf: 89 c8 mov %ecx,%eax
104fd1: f7 75 10 divl 0x10(%ebp)
if ( remainder != 0 ) {
104fd4: 85 d2 test %edx,%edx
104fd6: 74 68 je 105040 <_Heap_Get_first_and_last_block+0x90>
uintptr_t const first_block_begin =
104fd8: 8b 45 10 mov 0x10(%ebp),%eax
104fdb: 8d 74 01 f8 lea -0x8(%ecx,%eax,1),%esi
104fdf: 29 d6 sub %edx,%esi
uintptr_t const overhead =
104fe1: 89 f0 mov %esi,%eax
104fe3: 29 d8 sub %ebx,%eax
104fe5: 8d 78 08 lea 0x8(%eax),%edi
_Heap_Align_down( heap_area_size - overhead, page_size );
104fe8: 8b 4d 0c mov 0xc(%ebp),%ecx
return value - (value % alignment);
104feb: 31 d2 xor %edx,%edx
104fed: 29 f9 sub %edi,%ecx
104fef: 89 c8 mov %ecx,%eax
104ff1: f7 75 10 divl 0x10(%ebp)
104ff4: 29 d1 sub %edx,%ecx
heap_area_end < heap_area_begin
104ff6: 3b 5d f0 cmp -0x10(%ebp),%ebx
104ff9: 0f 97 c0 seta %al
|| heap_area_size <= overhead
104ffc: 39 7d 0c cmp %edi,0xc(%ebp)
104fff: 0f 96 c2 setbe %dl
|| first_block_size < min_block_size
105002: 08 d0 or %dl,%al
105004: 75 2a jne 105030 <_Heap_Get_first_and_last_block+0x80>
105006: 39 4d 14 cmp %ecx,0x14(%ebp)
105009: 77 25 ja 105030 <_Heap_Get_first_and_last_block+0x80> <== NEVER TAKEN
*first_block_ptr = first_block;
10500b: 8b 45 18 mov 0x18(%ebp),%eax
return (Heap_Block *) ((uintptr_t) block + offset);
10500e: 01 f1 add %esi,%ecx
}
105010: 8b 5d f4 mov -0xc(%ebp),%ebx
105013: 8b 7d fc mov -0x4(%ebp),%edi
*first_block_ptr = first_block;
105016: 89 30 mov %esi,(%eax)
105018: 8b 45 1c mov 0x1c(%ebp),%eax
}
10501b: 8b 75 f8 mov -0x8(%ebp),%esi
10501e: 89 08 mov %ecx,(%eax)
105020: 89 ec mov %ebp,%esp
return true;
105022: b0 01 mov $0x1,%al
}
105024: 5d pop %ebp
105025: c3 ret
105026: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10502d: 8d 76 00 lea 0x0(%esi),%esi
105030: 8b 5d f4 mov -0xc(%ebp),%ebx
return false;
105033: 31 c0 xor %eax,%eax
}
105035: 8b 75 f8 mov -0x8(%ebp),%esi
105038: 8b 7d fc mov -0x4(%ebp),%edi
10503b: 89 ec mov %ebp,%esp
10503d: 5d pop %ebp
10503e: c3 ret
10503f: 90 nop
105040: 89 de mov %ebx,%esi
105042: bf 08 00 00 00 mov $0x8,%edi
105047: eb 9f jmp 104fe8 <_Heap_Get_first_and_last_block+0x38>
105049: 90 nop
10504a: 90 nop
10504b: 90 nop
10504c: 90 nop
10504d: 90 nop
10504e: 90 nop
10504f: 90 nop
0010f040 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
10f040: 55 push %ebp
10f041: 89 e5 mov %esp,%ebp
10f043: 57 push %edi
return _Heap_Free_list_head(heap)->next;
10f044: 8b 45 08 mov 0x8(%ebp),%eax
10f047: 56 push %esi
10f048: 8b 75 0c mov 0xc(%ebp),%esi
10f04b: 53 push %ebx
10f04c: 8b 50 08 mov 0x8(%eax),%edx
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
10f04f: c7 06 00 00 00 00 movl $0x0,(%esi)
info->largest = 0;
10f055: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
info->total = 0;
10f05c: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi)
for(the_block = _Heap_Free_list_first(the_heap);
10f063: 39 d0 cmp %edx,%eax
10f065: 74 3d je 10f0a4 <_Heap_Get_free_information+0x64> <== NEVER TAKEN
10f067: bb 01 00 00 00 mov $0x1,%ebx
10f06c: 31 ff xor %edi,%edi
10f06e: 31 c9 xor %ecx,%ecx
10f070: eb 13 jmp 10f085 <_Heap_Get_free_information+0x45>
10f072: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10f079: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
info->total += the_size;
if ( info->largest < the_size )
10f080: 8b 7e 04 mov 0x4(%esi),%edi
10f083: 89 c3 mov %eax,%ebx
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10f085: 8b 42 04 mov 0x4(%edx),%eax
10f088: 83 e0 fe and $0xfffffffe,%eax
info->total += the_size;
10f08b: 01 c1 add %eax,%ecx
if ( info->largest < the_size )
10f08d: 39 f8 cmp %edi,%eax
10f08f: 76 03 jbe 10f094 <_Heap_Get_free_information+0x54>
info->largest = the_size;
10f091: 89 46 04 mov %eax,0x4(%esi)
the_block = the_block->next)
10f094: 8b 52 08 mov 0x8(%edx),%edx
for(the_block = _Heap_Free_list_first(the_heap);
10f097: 8d 43 01 lea 0x1(%ebx),%eax
10f09a: 39 55 08 cmp %edx,0x8(%ebp)
10f09d: 75 e1 jne 10f080 <_Heap_Get_free_information+0x40>
10f09f: 89 1e mov %ebx,(%esi)
10f0a1: 89 4e 08 mov %ecx,0x8(%esi)
}
}
10f0a4: 5b pop %ebx
10f0a5: 5e pop %esi
10f0a6: 5f pop %edi
10f0a7: 5d pop %ebp
10f0a8: c3 ret
10f0a9: 90 nop
10f0aa: 90 nop
10f0ab: 90 nop
10f0ac: 90 nop
10f0ad: 90 nop
10f0ae: 90 nop
10f0af: 90 nop
00108a50 <_Heap_Get_information>:
void _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
108a50: 55 push %ebp
108a51: b9 58 00 00 00 mov $0x58,%ecx
108a56: 89 e5 mov %esp,%ebp
108a58: 57 push %edi
108a59: 56 push %esi
memset( the_info, 0, sizeof(*the_info) );
108a5a: 31 f6 xor %esi,%esi
{
108a5c: 53 push %ebx
108a5d: 83 ec 1c sub $0x1c,%esp
108a60: 8b 5d 0c mov 0xc(%ebp),%ebx
memset( the_info, 0, sizeof(*the_info) );
108a63: f6 c3 01 test $0x1,%bl
108a66: 89 da mov %ebx,%edx
108a68: 0f 85 a2 00 00 00 jne 108b10 <_Heap_Get_information+0xc0> <== NEVER TAKEN
108a6e: f6 c2 02 test $0x2,%dl
108a71: 0f 85 b9 00 00 00 jne 108b30 <_Heap_Get_information+0xe0> <== NEVER TAKEN
108a77: 89 cf mov %ecx,%edi
108a79: 31 c0 xor %eax,%eax
108a7b: 83 e7 f8 and $0xfffffff8,%edi
108a7e: 89 34 02 mov %esi,(%edx,%eax,1)
108a81: 89 74 02 04 mov %esi,0x4(%edx,%eax,1)
108a85: 83 c0 08 add $0x8,%eax
108a88: 39 f8 cmp %edi,%eax
108a8a: 72 f2 jb 108a7e <_Heap_Get_information+0x2e>
108a8c: 01 c2 add %eax,%edx
108a8e: f6 c1 04 test $0x4,%cl
108a91: 75 6d jne 108b00 <_Heap_Get_information+0xb0> <== NEVER TAKEN
108a93: f6 c1 02 test $0x2,%cl
108a96: 75 58 jne 108af0 <_Heap_Get_information+0xa0> <== NEVER TAKEN
108a98: f6 c1 01 test $0x1,%cl
108a9b: 75 43 jne 108ae0 <_Heap_Get_information+0x90> <== NEVER TAKEN
_Heap_Protection_free_all_delayed_blocks( the_heap );
_Heap_Iterate( the_heap, _Heap_Get_information_visitor, the_info );
108a9d: 89 5c 24 08 mov %ebx,0x8(%esp)
108aa1: b8 20 8a 10 00 mov $0x108a20,%eax
108aa6: 89 44 24 04 mov %eax,0x4(%esp)
108aaa: 8b 45 08 mov 0x8(%ebp),%eax
108aad: 89 04 24 mov %eax,(%esp)
108ab0: e8 8b 00 00 00 call 108b40 <_Heap_Iterate>
the_info->Stats = the_heap->stats;
108ab5: 8b 4d 08 mov 0x8(%ebp),%ecx
108ab8: 31 c0 xor %eax,%eax
108aba: 8b 54 01 28 mov 0x28(%ecx,%eax,1),%edx
108abe: 89 54 03 18 mov %edx,0x18(%ebx,%eax,1)
108ac2: 83 c0 04 add $0x4,%eax
108ac5: 83 f8 40 cmp $0x40,%eax
108ac8: 72 f0 jb 108aba <_Heap_Get_information+0x6a>
}
108aca: 83 c4 1c add $0x1c,%esp
108acd: 5b pop %ebx
108ace: 5e pop %esi
108acf: 5f pop %edi
108ad0: 5d pop %ebp
108ad1: c3 ret
108ad2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108ad9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
memset( the_info, 0, sizeof(*the_info) );
108ae0: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
108ae3: eb b8 jmp 108a9d <_Heap_Get_information+0x4d> <== NOT EXECUTED
108ae5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108aec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108af0: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
108af5: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
108af8: f6 c1 01 test $0x1,%cl <== NOT EXECUTED
108afb: 74 a0 je 108a9d <_Heap_Get_information+0x4d> <== NOT EXECUTED
108afd: eb e1 jmp 108ae0 <_Heap_Get_information+0x90> <== NOT EXECUTED
108aff: 90 nop <== NOT EXECUTED
108b00: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
108b06: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
108b09: f6 c1 02 test $0x2,%cl <== NOT EXECUTED
108b0c: 74 8a je 108a98 <_Heap_Get_information+0x48> <== NOT EXECUTED
108b0e: eb e0 jmp 108af0 <_Heap_Get_information+0xa0> <== NOT EXECUTED
108b10: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED
108b13: 8d 53 01 lea 0x1(%ebx),%edx <== NOT EXECUTED
108b16: b9 57 00 00 00 mov $0x57,%ecx <== NOT EXECUTED
108b1b: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
108b1e: 0f 84 53 ff ff ff je 108a77 <_Heap_Get_information+0x27> <== NOT EXECUTED
108b24: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108b2b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
108b2f: 90 nop <== NOT EXECUTED
108b30: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
108b35: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
108b38: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
108b3b: e9 37 ff ff ff jmp 108a77 <_Heap_Get_information+0x27> <== NOT EXECUTED
00106c50 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
106c50: 55 push %ebp
106c51: 89 e5 mov %esp,%ebp
106c53: 57 push %edi
106c54: 56 push %esi
106c55: 53 push %ebx
106c56: 83 ec 2c sub $0x2c,%esp
Heap_Block *current;
size_t i;
_Heap_Protection_free_all_delayed_blocks( heap );
for (i = 0; i < block_count; ++i) {
106c59: 8b 4d 10 mov 0x10(%ebp),%ecx
{
106c5c: 8b 5d 08 mov 0x8(%ebp),%ebx
for (i = 0; i < block_count; ++i) {
106c5f: 85 c9 test %ecx,%ecx
106c61: 0f 84 e9 00 00 00 je 106d50 <_Heap_Greedy_allocate+0x100>
Heap_Block *allocated_blocks = NULL;
106c67: 31 f6 xor %esi,%esi
for (i = 0; i < block_count; ++i) {
106c69: 31 ff xor %edi,%edi
Heap_Block *allocated_blocks = NULL;
106c6b: 89 75 e4 mov %esi,-0x1c(%ebp)
106c6e: 8b 75 0c mov 0xc(%ebp),%esi
106c71: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106c78: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106c7f: 90 nop
* @retval pointer The starting address of the allocated memory area.
* @retval NULL No memory is available of the parameters are inconsistent.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
106c80: 31 c0 xor %eax,%eax
106c82: 31 d2 xor %edx,%edx
106c84: 89 44 24 0c mov %eax,0xc(%esp)
106c88: 89 54 24 08 mov %edx,0x8(%esp)
106c8c: 8b 04 be mov (%esi,%edi,4),%eax
106c8f: 89 1c 24 mov %ebx,(%esp)
106c92: 89 44 24 04 mov %eax,0x4(%esp)
106c96: e8 a5 54 00 00 call 10c140 <_Heap_Allocate_aligned_with_boundary>
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
106c9b: 85 c0 test %eax,%eax
106c9d: 74 15 je 106cb4 <_Heap_Greedy_allocate+0x64>
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
106c9f: 8d 48 f8 lea -0x8(%eax),%ecx
return value - (value % alignment);
106ca2: 31 d2 xor %edx,%edx
106ca4: f7 73 10 divl 0x10(%ebx)
- HEAP_BLOCK_HEADER_SIZE);
106ca7: 89 c8 mov %ecx,%eax
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
106ca9: 8b 4d e4 mov -0x1c(%ebp),%ecx
106cac: 29 d0 sub %edx,%eax
106cae: 89 48 08 mov %ecx,0x8(%eax)
106cb1: 89 45 e4 mov %eax,-0x1c(%ebp)
for (i = 0; i < block_count; ++i) {
106cb4: 47 inc %edi
106cb5: 39 7d 10 cmp %edi,0x10(%ebp)
106cb8: 75 c6 jne 106c80 <_Heap_Greedy_allocate+0x30>
return _Heap_Free_list_head(heap)->next;
106cba: 8b 53 08 mov 0x8(%ebx),%edx
106cbd: 8b 75 e4 mov -0x1c(%ebp),%esi
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
106cc0: 39 d3 cmp %edx,%ebx
106cc2: 0f 84 a8 00 00 00 je 106d70 <_Heap_Greedy_allocate+0x120>
Heap_Block *blocks = NULL;
106cc8: 89 75 e4 mov %esi,-0x1c(%ebp)
106ccb: 31 ff xor %edi,%edi
106ccd: 89 fe mov %edi,%esi
106ccf: 89 df mov %ebx,%edi
106cd1: 89 d3 mov %edx,%ebx
106cd3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106cda: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*
* @return The block size.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
106ce0: 8b 43 04 mov 0x4(%ebx),%eax
_Heap_Block_allocate(
106ce3: 89 5c 24 04 mov %ebx,0x4(%esp)
106ce7: 89 3c 24 mov %edi,(%esp)
106cea: 83 e0 fe and $0xfffffffe,%eax
106ced: 83 e8 08 sub $0x8,%eax
106cf0: 89 44 24 0c mov %eax,0xc(%esp)
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
106cf4: 8d 43 08 lea 0x8(%ebx),%eax
106cf7: 89 44 24 08 mov %eax,0x8(%esp)
106cfb: e8 60 5a 00 00 call 10c760 <_Heap_Block_allocate>
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
106d00: 89 73 08 mov %esi,0x8(%ebx)
return &heap->free_list;
106d03: 89 de mov %ebx,%esi
return _Heap_Free_list_head(heap)->next;
106d05: 8b 5f 08 mov 0x8(%edi),%ebx
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
106d08: 39 df cmp %ebx,%edi
106d0a: 75 d4 jne 106ce0 <_Heap_Greedy_allocate+0x90>
106d0c: 89 fb mov %edi,%ebx
106d0e: 89 f7 mov %esi,%edi
106d10: 8b 75 e4 mov -0x1c(%ebp),%esi
106d13: eb 1f jmp 106d34 <_Heap_Greedy_allocate+0xe4>
106d15: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106d1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
blocks = current;
}
while ( allocated_blocks != NULL ) {
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
106d20: 89 f0 mov %esi,%eax
106d22: 8b 76 08 mov 0x8(%esi),%esi
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
106d25: 89 1c 24 mov %ebx,(%esp)
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
106d28: 83 c0 08 add $0x8,%eax
106d2b: 89 44 24 04 mov %eax,0x4(%esp)
106d2f: e8 6c 5e 00 00 call 10cba0 <_Heap_Free>
while ( allocated_blocks != NULL ) {
106d34: 85 f6 test %esi,%esi
106d36: 75 e8 jne 106d20 <_Heap_Greedy_allocate+0xd0>
}
return blocks;
}
106d38: 83 c4 2c add $0x2c,%esp
106d3b: 89 f8 mov %edi,%eax
106d3d: 5b pop %ebx
106d3e: 5e pop %esi
106d3f: 5f pop %edi
106d40: 5d pop %ebp
106d41: c3 ret
106d42: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106d49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return _Heap_Free_list_head(heap)->next;
106d50: 8b 53 08 mov 0x8(%ebx),%edx
Heap_Block *allocated_blocks = NULL;
106d53: 31 f6 xor %esi,%esi
Heap_Block *blocks = NULL;
106d55: 31 ff xor %edi,%edi
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
106d57: 39 da cmp %ebx,%edx
106d59: 0f 85 69 ff ff ff jne 106cc8 <_Heap_Greedy_allocate+0x78> <== ALWAYS TAKEN
106d5f: eb d7 jmp 106d38 <_Heap_Greedy_allocate+0xe8> <== NOT EXECUTED
106d61: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106d68: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106d6f: 90 nop <== NOT EXECUTED
Heap_Block *blocks = NULL;
106d70: 31 ff xor %edi,%edi
while ( allocated_blocks != NULL ) {
106d72: eb c0 jmp 106d34 <_Heap_Greedy_allocate+0xe4>
106d74: 90 nop
106d75: 90 nop
106d76: 90 nop
106d77: 90 nop
106d78: 90 nop
106d79: 90 nop
106d7a: 90 nop
106d7b: 90 nop
106d7c: 90 nop
106d7d: 90 nop
106d7e: 90 nop
106d7f: 90 nop
00104730 <_Heap_Greedy_allocate_all_except_largest>:
Heap_Block *_Heap_Greedy_allocate_all_except_largest(
Heap_Control *heap,
uintptr_t *allocatable_size
)
{
104730: 55 push %ebp
104731: 89 e5 mov %esp,%ebp
104733: 83 ec 28 sub $0x28,%esp
104736: 89 5d f8 mov %ebx,-0x8(%ebp)
104739: 8b 5d 08 mov 0x8(%ebp),%ebx
Heap_Information info;
_Heap_Get_free_information( heap, &info );
10473c: 8d 45 ec lea -0x14(%ebp),%eax
10473f: 89 44 24 04 mov %eax,0x4(%esp)
{
104743: 89 75 fc mov %esi,-0x4(%ebp)
104746: 8b 75 0c mov 0xc(%ebp),%esi
_Heap_Get_free_information( heap, &info );
104749: 89 1c 24 mov %ebx,(%esp)
10474c: e8 6f 65 00 00 call 10acc0 <_Heap_Get_free_information>
if ( info.largest > 0 ) {
104751: 8b 45 f0 mov -0x10(%ebp),%eax
104754: 85 c0 test %eax,%eax
104756: 74 03 je 10475b <_Heap_Greedy_allocate_all_except_largest+0x2b><== NEVER TAKEN
*allocatable_size = info.largest - HEAP_BLOCK_HEADER_SIZE + HEAP_ALLOC_BONUS;
104758: 83 e8 04 sub $0x4,%eax
10475b: 89 06 mov %eax,(%esi)
} else {
*allocatable_size = 0;
}
return _Heap_Greedy_allocate( heap, allocatable_size, 1 );
10475d: b8 01 00 00 00 mov $0x1,%eax
104762: 89 74 24 04 mov %esi,0x4(%esp)
104766: 89 1c 24 mov %ebx,(%esp)
104769: 89 44 24 08 mov %eax,0x8(%esp)
10476d: e8 8e fe ff ff call 104600 <_Heap_Greedy_allocate>
}
104772: 8b 5d f8 mov -0x8(%ebp),%ebx
104775: 8b 75 fc mov -0x4(%ebp),%esi
104778: 89 ec mov %ebp,%esp
10477a: 5d pop %ebp
10477b: c3 ret
10477c: 90 nop
10477d: 90 nop
10477e: 90 nop
10477f: 90 nop
00105050 <_Heap_Initialize>:
{
105050: 55 push %ebp
105051: 89 e5 mov %esp,%ebp
105053: 57 push %edi
105054: 56 push %esi
105055: 53 push %ebx
105056: 83 ec 20 sub $0x20,%esp
105059: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
105060: 8b 7d 0c mov 0xc(%ebp),%edi
105063: 8b 4d 14 mov 0x14(%ebp),%ecx
uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr;
105066: 89 7d e0 mov %edi,-0x20(%ebp)
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
105069: 89 f8 mov %edi,%eax
10506b: 03 45 10 add 0x10(%ebp),%eax
10506e: 89 45 dc mov %eax,-0x24(%ebp)
105071: 0f 82 0a 02 00 00 jb 105281 <_Heap_Initialize+0x231>
if ( page_size == 0 ) {
105077: 85 c9 test %ecx,%ecx
105079: 0f 84 41 01 00 00 je 1051c0 <_Heap_Initialize+0x170>
10507f: 89 c8 mov %ecx,%eax
105081: 83 e0 03 and $0x3,%eax
105084: 0f 85 76 01 00 00 jne 105200 <_Heap_Initialize+0x1b0>
if ( page_size < CPU_ALIGNMENT ) {
10508a: 83 f9 03 cmp $0x3,%ecx
10508d: 0f 86 7d 01 00 00 jbe 105210 <_Heap_Initialize+0x1c0> <== NEVER TAKEN
uintptr_t remainder = value % alignment;
105093: 31 d2 xor %edx,%edx
105095: b8 10 00 00 00 mov $0x10,%eax
10509a: f7 f1 div %ecx
if ( remainder != 0 ) {
10509c: 85 d2 test %edx,%edx
10509e: 0f 84 e9 01 00 00 je 10528d <_Heap_Initialize+0x23d>
return value - remainder + alignment;
1050a4: 8d 41 10 lea 0x10(%ecx),%eax
1050a7: 29 d0 sub %edx,%eax
uintptr_t remainder = value % alignment;
1050a9: 31 d2 xor %edx,%edx
return value - remainder + alignment;
1050ab: 89 45 e8 mov %eax,-0x18(%ebp)
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
1050ae: 8d 47 08 lea 0x8(%edi),%eax
uintptr_t remainder = value % alignment;
1050b1: f7 f1 div %ecx
if ( remainder != 0 ) {
1050b3: 85 d2 test %edx,%edx
1050b5: 0f 85 20 01 00 00 jne 1051db <_Heap_Initialize+0x18b> <== ALWAYS TAKEN
1050bb: c7 45 f0 08 00 00 00 movl $0x8,-0x10(%ebp)
uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr;
1050c2: 89 fb mov %edi,%ebx
_Heap_Align_down( heap_area_size - overhead, page_size );
1050c4: 8b 45 f0 mov -0x10(%ebp),%eax
return value - (value % alignment);
1050c7: 31 d2 xor %edx,%edx
1050c9: 8b 75 10 mov 0x10(%ebp),%esi
1050cc: 29 c6 sub %eax,%esi
1050ce: 89 f0 mov %esi,%eax
1050d0: f7 f1 div %ecx
heap_area_end < heap_area_begin
1050d2: 8b 45 ec mov -0x14(%ebp),%eax
1050d5: 89 55 d8 mov %edx,-0x28(%ebp)
1050d8: 29 d6 sub %edx,%esi
|| heap_area_size <= overhead
1050da: 8b 55 f0 mov -0x10(%ebp),%edx
heap_area_end < heap_area_begin
1050dd: 85 c0 test %eax,%eax
1050df: 0f 95 c0 setne %al
|| heap_area_size <= overhead
1050e2: 39 55 10 cmp %edx,0x10(%ebp)
1050e5: 0f 96 c2 setbe %dl
|| first_block_size < min_block_size
1050e8: 08 d0 or %dl,%al
1050ea: 0f 85 20 01 00 00 jne 105210 <_Heap_Initialize+0x1c0>
1050f0: 39 75 e8 cmp %esi,-0x18(%ebp)
1050f3: 0f 87 17 01 00 00 ja 105210 <_Heap_Initialize+0x1c0>
memset(heap, 0, sizeof(*heap));
1050f9: c7 45 e4 68 00 00 00 movl $0x68,-0x1c(%ebp)
105100: 8b 55 08 mov 0x8(%ebp),%edx
return (Heap_Block *) ((uintptr_t) block + offset);
105103: 8d 04 1e lea (%esi,%ebx,1),%eax
105106: 89 45 d4 mov %eax,-0x2c(%ebp)
105109: 31 db xor %ebx,%ebx
10510b: f6 c2 01 test $0x1,%dl
10510e: 0f 85 3c 01 00 00 jne 105250 <_Heap_Initialize+0x200> <== NEVER TAKEN
105114: f6 c2 02 test $0x2,%dl
105117: 0f 85 53 01 00 00 jne 105270 <_Heap_Initialize+0x220> <== NEVER TAKEN
10511d: 8b 45 e4 mov -0x1c(%ebp),%eax
105120: 83 e0 f8 and $0xfffffff8,%eax
105123: 89 45 ec mov %eax,-0x14(%ebp)
105126: 31 c0 xor %eax,%eax
105128: 89 1c 02 mov %ebx,(%edx,%eax,1)
10512b: 89 5c 02 04 mov %ebx,0x4(%edx,%eax,1)
10512f: 83 c0 08 add $0x8,%eax
105132: 3b 45 ec cmp -0x14(%ebp),%eax
105135: 72 f1 jb 105128 <_Heap_Initialize+0xd8>
105137: 01 c2 add %eax,%edx
105139: f6 45 e4 04 testb $0x4,-0x1c(%ebp)
10513d: 0f 85 fd 00 00 00 jne 105240 <_Heap_Initialize+0x1f0> <== NEVER TAKEN
105143: f6 45 e4 02 testb $0x2,-0x1c(%ebp)
105147: 0f 85 e3 00 00 00 jne 105230 <_Heap_Initialize+0x1e0> <== NEVER TAKEN
10514d: f6 45 e4 01 testb $0x1,-0x1c(%ebp)
105151: 0f 85 c9 00 00 00 jne 105220 <_Heap_Initialize+0x1d0> <== NEVER TAKEN
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
105157: 89 f0 mov %esi,%eax
first_block->prev_size = heap_area_end;
105159: 8b 5d dc mov -0x24(%ebp),%ebx
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
10515c: 83 c8 01 or $0x1,%eax
_Heap_Block_set_size(
10515f: 8b 55 10 mov 0x10(%ebp),%edx
105162: 89 47 04 mov %eax,0x4(%edi)
first_block->next = _Heap_Free_list_tail( heap );
105165: 8b 45 08 mov 0x8(%ebp),%eax
first_block->prev_size = heap_area_end;
105168: 89 1f mov %ebx,(%edi)
first_block->next = _Heap_Free_list_tail( heap );
10516a: 89 47 08 mov %eax,0x8(%edi)
first_block->prev = _Heap_Free_list_head( heap );
10516d: 89 47 0c mov %eax,0xc(%edi)
heap->page_size = page_size;
105170: 89 48 10 mov %ecx,0x10(%eax)
heap->min_block_size = min_block_size;
105173: 8b 4d e8 mov -0x18(%ebp),%ecx
heap->area_end = heap_area_end;
105176: 89 58 1c mov %ebx,0x1c(%eax)
heap->last_block = last_block;
105179: 8b 5d d4 mov -0x2c(%ebp),%ebx
heap->first_block = first_block;
10517c: 89 78 20 mov %edi,0x20(%eax)
_Heap_Free_list_head( heap )->next = first_block;
10517f: 89 78 08 mov %edi,0x8(%eax)
heap->min_block_size = min_block_size;
105182: 89 48 14 mov %ecx,0x14(%eax)
heap->area_begin = heap_area_begin;
105185: 8b 4d e0 mov -0x20(%ebp),%ecx
heap->last_block = last_block;
105188: 89 58 24 mov %ebx,0x24(%eax)
_Heap_Free_list_tail( heap )->prev = first_block;
10518b: 89 78 0c mov %edi,0xc(%eax)
heap->area_begin = heap_area_begin;
10518e: 89 48 18 mov %ecx,0x18(%eax)
105191: 8b 45 f0 mov -0x10(%ebp),%eax
last_block->prev_size = first_block_size;
105194: 89 33 mov %esi,(%ebx)
105196: 8b 4d d8 mov -0x28(%ebp),%ecx
105199: 29 d0 sub %edx,%eax
10519b: 01 c8 add %ecx,%eax
10519d: 89 43 04 mov %eax,0x4(%ebx)
stats->size = first_block_size;
1051a0: 8b 45 08 mov 0x8(%ebp),%eax
1051a3: 89 70 38 mov %esi,0x38(%eax)
stats->free_size = first_block_size;
1051a6: 89 70 3c mov %esi,0x3c(%eax)
stats->min_free_size = first_block_size;
1051a9: 89 70 40 mov %esi,0x40(%eax)
stats->free_blocks = 1;
1051ac: c7 40 44 01 00 00 00 movl $0x1,0x44(%eax)
stats->max_free_blocks = 1;
1051b3: c7 40 48 01 00 00 00 movl $0x1,0x48(%eax)
return first_block_size;
1051ba: eb 56 jmp 105212 <_Heap_Initialize+0x1c2>
1051bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return value;
1051c0: c7 45 e8 10 00 00 00 movl $0x10,-0x18(%ebp)
page_size = CPU_ALIGNMENT;
1051c7: b9 04 00 00 00 mov $0x4,%ecx
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
1051cc: 8d 47 08 lea 0x8(%edi),%eax
uintptr_t remainder = value % alignment;
1051cf: 31 d2 xor %edx,%edx
1051d1: f7 f1 div %ecx
if ( remainder != 0 ) {
1051d3: 85 d2 test %edx,%edx
1051d5: 0f 84 e0 fe ff ff je 1050bb <_Heap_Initialize+0x6b>
uintptr_t const first_block_begin =
1051db: 8d 1c 0f lea (%edi,%ecx,1),%ebx
1051de: 29 d3 sub %edx,%ebx
uintptr_t const overhead =
1051e0: 89 d8 mov %ebx,%eax
1051e2: 29 f8 sub %edi,%eax
Heap_Block *const first_block = (Heap_Block *) first_block_begin;
1051e4: 89 df mov %ebx,%edi
uintptr_t const overhead =
1051e6: 83 c0 08 add $0x8,%eax
1051e9: 89 45 f0 mov %eax,-0x10(%ebp)
return value - remainder + alignment;
1051ec: e9 d3 fe ff ff jmp 1050c4 <_Heap_Initialize+0x74>
1051f1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1051f8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1051ff: 90 nop
105200: 83 c1 04 add $0x4,%ecx
105203: 29 c1 sub %eax,%ecx
if ( page_size < CPU_ALIGNMENT ) {
105205: 83 f9 03 cmp $0x3,%ecx
105208: 0f 87 85 fe ff ff ja 105093 <_Heap_Initialize+0x43>
10520e: 66 90 xchg %ax,%ax
return 0;
105210: 31 f6 xor %esi,%esi
}
105212: 83 c4 20 add $0x20,%esp
105215: 89 f0 mov %esi,%eax
105217: 5b pop %ebx
105218: 5e pop %esi
105219: 5f pop %edi
10521a: 5d pop %ebp
10521b: c3 ret
10521c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memset(heap, 0, sizeof(*heap));
105220: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
105223: e9 2f ff ff ff jmp 105157 <_Heap_Initialize+0x107> <== NOT EXECUTED
105228: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10522f: 90 nop <== NOT EXECUTED
105230: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
105235: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
105238: e9 10 ff ff ff jmp 10514d <_Heap_Initialize+0xfd> <== NOT EXECUTED
10523d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
105240: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
105246: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
105249: e9 f5 fe ff ff jmp 105143 <_Heap_Initialize+0xf3> <== NOT EXECUTED
10524e: 66 90 xchg %ax,%ax <== NOT EXECUTED
105250: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
105253: c7 45 e4 67 00 00 00 movl $0x67,-0x1c(%ebp) <== NOT EXECUTED
10525a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10525d: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED
105260: e9 af fe ff ff jmp 105114 <_Heap_Initialize+0xc4> <== NOT EXECUTED
105265: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10526c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
105270: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
105275: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
105278: 83 6d e4 02 subl $0x2,-0x1c(%ebp) <== NOT EXECUTED
10527c: e9 9c fe ff ff jmp 10511d <_Heap_Initialize+0xcd> <== NOT EXECUTED
105281: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp)
105288: e9 ea fd ff ff jmp 105077 <_Heap_Initialize+0x27>
return value;
10528d: c7 45 e8 10 00 00 00 movl $0x10,-0x18(%ebp)
105294: e9 33 ff ff ff jmp 1051cc <_Heap_Initialize+0x17c>
105299: 90 nop
10529a: 90 nop
10529b: 90 nop
10529c: 90 nop
10529d: 90 nop
10529e: 90 nop
10529f: 90 nop
00108b40 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
108b40: 55 push %ebp
108b41: 89 e5 mov %esp,%ebp
108b43: 57 push %edi
108b44: 56 push %esi
108b45: 53 push %ebx
108b46: 83 ec 2c sub $0x2c,%esp
108b49: 8b 45 08 mov 0x8(%ebp),%eax
108b4c: 8b 7d 0c mov 0xc(%ebp),%edi
108b4f: 8b 75 10 mov 0x10(%ebp),%esi
Heap_Block *current = heap->first_block;
108b52: 8b 58 20 mov 0x20(%eax),%ebx
Heap_Block *end = heap->last_block;
108b55: 8b 40 24 mov 0x24(%eax),%eax
108b58: 89 45 e4 mov %eax,-0x1c(%ebp)
bool stop = false;
while ( !stop && current != end ) {
108b5b: 39 c3 cmp %eax,%ebx
108b5d: 74 2b je 108b8a <_Heap_Iterate+0x4a> <== NEVER TAKEN
108b5f: 90 nop
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
108b60: 8b 43 04 mov 0x4(%ebx),%eax
108b63: 89 d9 mov %ebx,%ecx
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 );
108b65: 89 74 24 0c mov %esi,0xc(%esp)
108b69: 83 e0 fe and $0xfffffffe,%eax
return (Heap_Block *) ((uintptr_t) block + offset);
108b6c: 01 c3 add %eax,%ebx
108b6e: 8b 53 04 mov 0x4(%ebx),%edx
108b71: 89 44 24 04 mov %eax,0x4(%esp)
108b75: 89 0c 24 mov %ecx,(%esp)
108b78: 83 e2 01 and $0x1,%edx
108b7b: 89 54 24 08 mov %edx,0x8(%esp)
108b7f: ff d7 call *%edi
while ( !stop && current != end ) {
108b81: fe c8 dec %al
108b83: 74 05 je 108b8a <_Heap_Iterate+0x4a> <== NEVER TAKEN
108b85: 39 5d e4 cmp %ebx,-0x1c(%ebp)
108b88: 75 d6 jne 108b60 <_Heap_Iterate+0x20>
current = next;
}
}
108b8a: 83 c4 2c add $0x2c,%esp
108b8d: 5b pop %ebx
108b8e: 5e pop %esi
108b8f: 5f pop %edi
108b90: 5d pop %ebp
108b91: c3 ret
108b92: 90 nop
108b93: 90 nop
108b94: 90 nop
108b95: 90 nop
108b96: 90 nop
108b97: 90 nop
108b98: 90 nop
108b99: 90 nop
108b9a: 90 nop
108b9b: 90 nop
108b9c: 90 nop
108b9d: 90 nop
108b9e: 90 nop
108b9f: 90 nop
00118ce0 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
118ce0: 55 push %ebp
return value - (value % alignment);
118ce1: 31 d2 xor %edx,%edx
118ce3: 89 e5 mov %esp,%ebp
118ce5: 83 ec 38 sub $0x38,%esp
118ce8: 89 5d f4 mov %ebx,-0xc(%ebp)
118ceb: 8b 4d 0c mov 0xc(%ebp),%ecx
118cee: 89 7d fc mov %edi,-0x4(%ebp)
118cf1: 8b 5d 08 mov 0x8(%ebp),%ebx
118cf4: 89 75 f8 mov %esi,-0x8(%ebp)
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
*old_size = 0;
118cf7: 8b 7d 14 mov 0x14(%ebp),%edi
- HEAP_BLOCK_HEADER_SIZE);
118cfa: 8d 71 f8 lea -0x8(%ecx),%esi
return value - (value % alignment);
118cfd: 89 c8 mov %ecx,%eax
118cff: f7 73 10 divl 0x10(%ebx)
- HEAP_BLOCK_HEADER_SIZE);
118d02: 89 f0 mov %esi,%eax
118d04: c7 07 00 00 00 00 movl $0x0,(%edi)
*new_size = 0;
118d0a: 8b 7d 18 mov 0x18(%ebp),%edi
118d0d: c7 07 00 00 00 00 movl $0x0,(%edi)
118d13: 29 d0 sub %edx,%eax
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
118d15: ba 02 00 00 00 mov $0x2,%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
118d1a: 39 43 20 cmp %eax,0x20(%ebx)
118d1d: 0f 87 b0 00 00 00 ja 118dd3 <_Heap_Resize_block+0xf3> <== NEVER TAKEN
118d23: 39 43 24 cmp %eax,0x24(%ebx)
118d26: 0f 82 a7 00 00 00 jb 118dd3 <_Heap_Resize_block+0xf3>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
118d2c: 8b 70 04 mov 0x4(%eax),%esi
118d2f: ba 04 00 00 00 mov $0x4,%edx
118d34: 29 ca sub %ecx,%edx
118d36: 89 55 dc mov %edx,-0x24(%ebp)
118d39: 83 e6 fe and $0xfffffffe,%esi
118d3c: 89 75 d8 mov %esi,-0x28(%ebp)
uintptr_t block_end = block_begin + block_size;
118d3f: 01 c6 add %eax,%esi
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
118d41: 8d 3c 16 lea (%esi,%edx,1),%edi
118d44: 8b 56 04 mov 0x4(%esi),%edx
118d47: 83 e2 fe and $0xfffffffe,%edx
118d4a: 89 55 e4 mov %edx,-0x1c(%ebp)
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
118d4d: 0f b6 54 16 04 movzbl 0x4(%esi,%edx,1),%edx
118d52: 80 e2 01 and $0x1,%dl
118d55: 88 55 e3 mov %dl,-0x1d(%ebp)
*old_size = alloc_size;
118d58: 8b 55 14 mov 0x14(%ebp),%edx
if ( next_block_is_free ) {
118d5b: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
*old_size = alloc_size;
118d5f: 89 3a mov %edi,(%edx)
if ( next_block_is_free ) {
118d61: 75 3d jne 118da0 <_Heap_Resize_block+0xc0>
alloc_size += next_block_size;
118d63: 8b 55 e4 mov -0x1c(%ebp),%edx
118d66: 01 d7 add %edx,%edi
if ( new_alloc_size > alloc_size ) {
118d68: 39 7d 10 cmp %edi,0x10(%ebp)
118d6b: 0f 87 7f 00 00 00 ja 118df0 <_Heap_Resize_block+0x110>
block_size += next_block_size;
118d71: 8b 7d d8 mov -0x28(%ebp),%edi
118d74: 01 d7 add %edx,%edi
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
118d76: 8b 50 04 mov 0x4(%eax),%edx
118d79: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
118d7c: 09 fa or %edi,%edx
118d7e: 89 50 04 mov %edx,0x4(%eax)
Heap_Block *next = block->next;
118d81: 8b 56 08 mov 0x8(%esi),%edx
Heap_Block *prev = block->prev;
118d84: 8b 76 0c mov 0xc(%esi),%esi
prev->next = next;
118d87: 89 56 08 mov %edx,0x8(%esi)
next->prev = prev;
118d8a: 89 72 0c mov %esi,0xc(%edx)
stats->free_size -= next_block_size;
118d8d: 8b 55 e4 mov -0x1c(%ebp),%edx
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
118d90: 83 4c 38 04 01 orl $0x1,0x4(%eax,%edi,1)
--stats->free_blocks;
118d95: ff 4b 44 decl 0x44(%ebx)
stats->free_size -= next_block_size;
118d98: 29 53 3c sub %edx,0x3c(%ebx)
118d9b: eb 08 jmp 118da5 <_Heap_Resize_block+0xc5>
118d9d: 8d 76 00 lea 0x0(%esi),%esi
if ( new_alloc_size > alloc_size ) {
118da0: 39 7d 10 cmp %edi,0x10(%ebp)
118da3: 77 4b ja 118df0 <_Heap_Resize_block+0x110>
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
118da5: 89 4c 24 08 mov %ecx,0x8(%esp)
118da9: 8b 7d 10 mov 0x10(%ebp),%edi
118dac: 89 44 24 04 mov %eax,0x4(%esp)
118db0: 89 1c 24 mov %ebx,(%esp)
118db3: 89 7c 24 0c mov %edi,0xc(%esp)
118db7: e8 e4 c4 fe ff call 1052a0 <_Heap_Block_allocate>
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
118dbc: 8b 4d dc mov -0x24(%ebp),%ecx
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
118dbf: 8b 50 04 mov 0x4(%eax),%edx
118dc2: 01 c8 add %ecx,%eax
118dc4: 8b 4d 18 mov 0x18(%ebp),%ecx
118dc7: 83 e2 fe and $0xfffffffe,%edx
118dca: 01 d0 add %edx,%eax
return HEAP_RESIZE_SUCCESSFUL;
118dcc: 31 d2 xor %edx,%edx
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
118dce: 89 01 mov %eax,(%ecx)
++stats->resizes;
118dd0: ff 43 64 incl 0x64(%ebx)
}
118dd3: 8b 5d f4 mov -0xc(%ebp),%ebx
118dd6: 89 d0 mov %edx,%eax
118dd8: 8b 75 f8 mov -0x8(%ebp),%esi
118ddb: 8b 7d fc mov -0x4(%ebp),%edi
118dde: 89 ec mov %ebp,%esp
118de0: 5d pop %ebp
118de1: c3 ret
118de2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118de9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118df0: 8b 5d f4 mov -0xc(%ebp),%ebx
return HEAP_RESIZE_UNSATISFIED;
118df3: ba 01 00 00 00 mov $0x1,%edx
}
118df8: 8b 75 f8 mov -0x8(%ebp),%esi
118dfb: 89 d0 mov %edx,%eax
118dfd: 8b 7d fc mov -0x4(%ebp),%edi
118e00: 89 ec mov %ebp,%esp
118e02: 5d pop %ebp
118e03: c3 ret
118e04: 90 nop
118e05: 90 nop
118e06: 90 nop
118e07: 90 nop
118e08: 90 nop
118e09: 90 nop
118e0a: 90 nop
118e0b: 90 nop
118e0c: 90 nop
118e0d: 90 nop
118e0e: 90 nop
118e0f: 90 nop
00106000 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
106000: 55 push %ebp
return value - (value % alignment);
106001: 31 d2 xor %edx,%edx
106003: 89 e5 mov %esp,%ebp
106005: 83 ec 0c sub $0xc,%esp
106008: 89 5d f4 mov %ebx,-0xc(%ebp)
10600b: 8b 4d 0c mov 0xc(%ebp),%ecx
10600e: 89 75 f8 mov %esi,-0x8(%ebp)
106011: 8b 5d 08 mov 0x8(%ebp),%ebx
106014: 89 7d fc mov %edi,-0x4(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
106017: 8d 71 f8 lea -0x8(%ecx),%esi
return value - (value % alignment);
10601a: 89 c8 mov %ecx,%eax
10601c: f7 73 10 divl 0x10(%ebx)
- HEAP_BLOCK_HEADER_SIZE);
10601f: 89 f0 mov %esi,%eax
return (uintptr_t) block >= (uintptr_t) heap->first_block
106021: 8b 73 20 mov 0x20(%ebx),%esi
- HEAP_BLOCK_HEADER_SIZE);
106024: 29 d0 sub %edx,%eax
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;
106026: 31 d2 xor %edx,%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
106028: 39 c6 cmp %eax,%esi
10602a: 77 2a ja 106056 <_Heap_Size_of_alloc_area+0x56> <== NEVER TAKEN
10602c: 8b 5b 24 mov 0x24(%ebx),%ebx
10602f: 39 c3 cmp %eax,%ebx
106031: 72 23 jb 106056 <_Heap_Size_of_alloc_area+0x56> <== NEVER TAKEN
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
106033: 8b 78 04 mov 0x4(%eax),%edi
106036: 83 e7 fe and $0xfffffffe,%edi
return (Heap_Block *) ((uintptr_t) block + offset);
106039: 01 f8 add %edi,%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10603b: 39 c6 cmp %eax,%esi
10603d: 77 17 ja 106056 <_Heap_Size_of_alloc_area+0x56> <== NEVER TAKEN
10603f: 39 c3 cmp %eax,%ebx
106041: 72 13 jb 106056 <_Heap_Size_of_alloc_area+0x56> <== NEVER TAKEN
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
106043: 0f b6 50 04 movzbl 0x4(%eax),%edx
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
106047: 80 e2 01 and $0x1,%dl
10604a: 74 0a je 106056 <_Heap_Size_of_alloc_area+0x56> <== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
10604c: 29 c8 sub %ecx,%eax
10604e: 8d 48 04 lea 0x4(%eax),%ecx
106051: 8b 45 10 mov 0x10(%ebp),%eax
106054: 89 08 mov %ecx,(%eax)
return true;
}
106056: 8b 5d f4 mov -0xc(%ebp),%ebx
106059: 88 d0 mov %dl,%al
10605b: 8b 75 f8 mov -0x8(%ebp),%esi
10605e: 8b 7d fc mov -0x4(%ebp),%edi
106061: 89 ec mov %ebp,%esp
106063: 5d pop %ebp
106064: c3 ret
106065: 90 nop
106066: 90 nop
106067: 90 nop
106068: 90 nop
106069: 90 nop
10606a: 90 nop
10606b: 90 nop
10606c: 90 nop
10606d: 90 nop
10606e: 90 nop
10606f: 90 nop
00116250 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
116250: 55 push %ebp
116251: 89 e5 mov %esp,%ebp
116253: 57 push %edi
116254: 56 push %esi
116255: 53 push %ebx
116256: 83 ec 6c sub $0x6c,%esp
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
116259: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
11625d: c7 45 e0 00 62 11 00 movl $0x116200,-0x20(%ebp)
{
116264: 8b 75 08 mov 0x8(%ebp),%esi
_Heap_Walk_print : _Heap_Walk_print_nothing;
116267: 75 07 jne 116270 <_Heap_Walk+0x20>
116269: c7 45 e0 f0 61 11 00 movl $0x1161f0,-0x20(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
116270: 83 3d 00 a8 1a 00 02 cmpl $0x2,0x1aa800
116277: 74 17 je 116290 <_Heap_Walk+0x40>
return true;
116279: b2 01 mov $0x1,%dl
block = next_block;
} while ( block != first_block );
return true;
}
11627b: 83 c4 6c add $0x6c,%esp
11627e: 88 d0 mov %dl,%al
116280: 5b pop %ebx
116281: 5e pop %esi
116282: 5f pop %edi
116283: 5d pop %ebp
116284: c3 ret
116285: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11628c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
(*printer)(
116290: 8b 46 0c mov 0xc(%esi),%eax
uintptr_t const page_size = heap->page_size;
116293: 8b 4e 10 mov 0x10(%esi),%ecx
Heap_Block *const last_block = heap->last_block;
116296: 8b 7e 24 mov 0x24(%esi),%edi
uintptr_t const min_block_size = heap->min_block_size;
116299: 8b 56 14 mov 0x14(%esi),%edx
Heap_Block *const first_block = heap->first_block;
11629c: 8b 5e 20 mov 0x20(%esi),%ebx
(*printer)(
11629f: 89 44 24 28 mov %eax,0x28(%esp)
Heap_Block *const last_block = heap->last_block;
1162a3: 89 7d d8 mov %edi,-0x28(%ebp)
(*printer)(
1162a6: 8b 46 08 mov 0x8(%esi),%eax
1162a9: 89 7c 24 20 mov %edi,0x20(%esp)
1162ad: 89 cf mov %ecx,%edi
1162af: 89 5c 24 1c mov %ebx,0x1c(%esp)
uintptr_t const page_size = heap->page_size;
1162b3: 89 4d dc mov %ecx,-0x24(%ebp)
(*printer)(
1162b6: 89 44 24 24 mov %eax,0x24(%esp)
uintptr_t const min_block_size = heap->min_block_size;
1162ba: 89 55 d0 mov %edx,-0x30(%ebp)
(*printer)(
1162bd: 8b 46 1c mov 0x1c(%esi),%eax
1162c0: 89 44 24 18 mov %eax,0x18(%esp)
1162c4: 8b 46 18 mov 0x18(%esi),%eax
1162c7: 89 54 24 10 mov %edx,0x10(%esp)
1162cb: 89 4c 24 0c mov %ecx,0xc(%esp)
1162cf: 89 44 24 14 mov %eax,0x14(%esp)
1162d3: b8 10 18 19 00 mov $0x191810,%eax
1162d8: 89 44 24 08 mov %eax,0x8(%esp)
1162dc: 31 c0 xor %eax,%eax
1162de: 89 44 24 04 mov %eax,0x4(%esp)
1162e2: 8b 45 0c mov 0xc(%ebp),%eax
1162e5: 89 04 24 mov %eax,(%esp)
1162e8: 8b 45 e0 mov -0x20(%ebp),%eax
1162eb: ff d0 call *%eax
if ( page_size == 0 ) {
1162ed: 85 ff test %edi,%edi
1162ef: 0f 84 9b 00 00 00 je 116390 <_Heap_Walk+0x140>
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
1162f5: f6 45 dc 03 testb $0x3,-0x24(%ebp)
1162f9: 75 65 jne 116360 <_Heap_Walk+0x110>
return (value % alignment) == 0;
1162fb: 8b 45 d0 mov -0x30(%ebp),%eax
1162fe: 31 d2 xor %edx,%edx
116300: f7 75 dc divl -0x24(%ebp)
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
116303: 85 d2 test %edx,%edx
116305: 0f 85 e5 00 00 00 jne 1163f0 <_Heap_Walk+0x1a0>
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
11630b: 8d 43 08 lea 0x8(%ebx),%eax
return (value % alignment) == 0;
11630e: 31 d2 xor %edx,%edx
116310: f7 75 dc divl -0x24(%ebp)
if (
116313: 85 d2 test %edx,%edx
116315: 0f 85 f5 00 00 00 jne 116410 <_Heap_Walk+0x1c0>
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
11631b: 0f b6 53 04 movzbl 0x4(%ebx),%edx
if ( !_Heap_Is_prev_used( first_block ) ) {
11631f: 80 e2 01 and $0x1,%dl
116322: 0f 84 91 00 00 00 je 1163b9 <_Heap_Walk+0x169>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
116328: 8b 4d d8 mov -0x28(%ebp),%ecx
11632b: 8b 41 04 mov 0x4(%ecx),%eax
11632e: 89 45 e4 mov %eax,-0x1c(%ebp)
116331: 83 e0 fe and $0xfffffffe,%eax
return (Heap_Block *) ((uintptr_t) block + offset);
116334: 01 c8 add %ecx,%eax
116336: 89 45 d4 mov %eax,-0x2c(%ebp)
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
116339: 8b 48 04 mov 0x4(%eax),%ecx
11633c: 88 ca mov %cl,%dl
if ( _Heap_Is_free( last_block ) ) {
11633e: 80 e2 01 and $0x1,%dl
116341: 0f 84 db 00 00 00 je 116422 <_Heap_Walk+0x1d2>
if (
116347: 3b 5d d4 cmp -0x2c(%ebp),%ebx
11634a: 0f 84 e0 00 00 00 je 116430 <_Heap_Walk+0x1e0>
(*printer)(
116350: b8 2c 19 19 00 mov $0x19192c,%eax
116355: 89 44 24 08 mov %eax,0x8(%esp)
116359: eb 3e jmp 116399 <_Heap_Walk+0x149>
11635b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
11635f: 90 nop
(*printer)(
116360: 8b 45 dc mov -0x24(%ebp),%eax
116363: bb a7 17 19 00 mov $0x1917a7,%ebx
116368: 89 5c 24 08 mov %ebx,0x8(%esp)
11636c: 89 44 24 0c mov %eax,0xc(%esp)
(*printer)(
116370: 8b 45 0c mov 0xc(%ebp),%eax
116373: be 01 00 00 00 mov $0x1,%esi
116378: 89 74 24 04 mov %esi,0x4(%esp)
11637c: 89 04 24 mov %eax,(%esp)
11637f: 8b 45 e0 mov -0x20(%ebp),%eax
116382: ff d0 call *%eax
}
116384: 83 c4 6c add $0x6c,%esp
return false;
116387: 31 d2 xor %edx,%edx
}
116389: 5b pop %ebx
11638a: 88 d0 mov %dl,%al
11638c: 5e pop %esi
11638d: 5f pop %edi
11638e: 5d pop %ebp
11638f: c3 ret
(*printer)( source, true, "page size is zero\n" );
116390: be 94 17 19 00 mov $0x191794,%esi
116395: 89 74 24 08 mov %esi,0x8(%esp)
(*printer)(
116399: b8 01 00 00 00 mov $0x1,%eax
11639e: 89 44 24 04 mov %eax,0x4(%esp)
1163a2: 8b 45 0c mov 0xc(%ebp),%eax
1163a5: 89 04 24 mov %eax,(%esp)
1163a8: 8b 45 e0 mov -0x20(%ebp),%eax
1163ab: ff d0 call *%eax
}
1163ad: 83 c4 6c add $0x6c,%esp
return false;
1163b0: 31 d2 xor %edx,%edx
}
1163b2: 5b pop %ebx
1163b3: 88 d0 mov %dl,%al
1163b5: 5e pop %esi
1163b6: 5f pop %edi
1163b7: 5d pop %ebp
1163b8: c3 ret
1163b9: 88 55 e4 mov %dl,-0x1c(%ebp)
(*printer)(
1163bc: b8 fc 18 19 00 mov $0x1918fc,%eax
1163c1: 89 44 24 08 mov %eax,0x8(%esp)
(*printer)(
1163c5: b8 01 00 00 00 mov $0x1,%eax
1163ca: 89 44 24 04 mov %eax,0x4(%esp)
1163ce: 8b 45 0c mov 0xc(%ebp),%eax
1163d1: 89 04 24 mov %eax,(%esp)
1163d4: 8b 45 e0 mov -0x20(%ebp),%eax
1163d7: ff d0 call *%eax
return false;
1163d9: 0f b6 55 e4 movzbl -0x1c(%ebp),%edx
1163dd: e9 99 fe ff ff jmp 11627b <_Heap_Walk+0x2b>
1163e2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1163e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
(*printer)(
1163f0: 8b 45 d0 mov -0x30(%ebp),%eax
1163f3: b9 a4 18 19 00 mov $0x1918a4,%ecx
1163f8: 89 4c 24 08 mov %ecx,0x8(%esp)
1163fc: 89 44 24 0c mov %eax,0xc(%esp)
116400: e9 6b ff ff ff jmp 116370 <_Heap_Walk+0x120>
116405: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11640c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
(*printer)(
116410: 89 5c 24 0c mov %ebx,0xc(%esp)
116414: ba c8 18 19 00 mov $0x1918c8,%edx
116419: 89 54 24 08 mov %edx,0x8(%esp)
11641d: e9 4e ff ff ff jmp 116370 <_Heap_Walk+0x120>
116422: 88 55 e4 mov %dl,-0x1c(%ebp)
(*printer)(
116425: b8 c5 17 19 00 mov $0x1917c5,%eax
11642a: 89 44 24 08 mov %eax,0x8(%esp)
11642e: eb 95 jmp 1163c5 <_Heap_Walk+0x175>
uintptr_t const page_size = heap->page_size;
116430: 8b 46 10 mov 0x10(%esi),%eax
return _Heap_Free_list_head(heap)->next;
116433: 8b 5e 08 mov 0x8(%esi),%ebx
116436: 89 45 e4 mov %eax,-0x1c(%ebp)
return (uintptr_t) block >= (uintptr_t) heap->first_block
116439: 8b 46 20 mov 0x20(%esi),%eax
while ( free_block != free_list_tail ) {
11643c: 39 de cmp %ebx,%esi
11643e: 89 45 cc mov %eax,-0x34(%ebp)
116441: 0f 84 d2 03 00 00 je 116819 <_Heap_Walk+0x5c9> <== NEVER TAKEN
116447: 89 4d c8 mov %ecx,-0x38(%ebp)
11644a: 89 f7 mov %esi,%edi
11644c: 89 c1 mov %eax,%ecx
11644e: 66 90 xchg %ax,%ax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
116450: 39 cb cmp %ecx,%ebx
116452: 73 1c jae 116470 <_Heap_Walk+0x220>
(*printer)(
116454: 89 5c 24 0c mov %ebx,0xc(%esp)
116458: bf 1c 1b 19 00 mov $0x191b1c,%edi
11645d: 89 7c 24 08 mov %edi,0x8(%esp)
116461: e9 0a ff ff ff jmp 116370 <_Heap_Walk+0x120>
116466: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11646d: 8d 76 00 lea 0x0(%esi),%esi
116470: 39 5e 24 cmp %ebx,0x24(%esi)
116473: 72 df jb 116454 <_Heap_Walk+0x204> <== NEVER TAKEN
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
116475: 8d 43 08 lea 0x8(%ebx),%eax
return (value % alignment) == 0;
116478: 31 d2 xor %edx,%edx
11647a: f7 75 e4 divl -0x1c(%ebp)
if (
11647d: 85 d2 test %edx,%edx
11647f: 75 24 jne 1164a5 <_Heap_Walk+0x255>
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
116481: 8b 43 04 mov 0x4(%ebx),%eax
116484: 83 e0 fe and $0xfffffffe,%eax
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
116487: 0f b6 54 03 04 movzbl 0x4(%ebx,%eax,1),%edx
if ( _Heap_Is_used( free_block ) ) {
11648c: 80 e2 01 and $0x1,%dl
11648f: 75 26 jne 1164b7 <_Heap_Walk+0x267>
if ( free_block->prev != prev_block ) {
116491: 8b 43 0c mov 0xc(%ebx),%eax
116494: 39 f8 cmp %edi,%eax
116496: 75 31 jne 1164c9 <_Heap_Walk+0x279>
free_block = free_block->next;
116498: 8b 43 08 mov 0x8(%ebx),%eax
while ( free_block != free_list_tail ) {
11649b: 89 df mov %ebx,%edi
11649d: 39 c6 cmp %eax,%esi
11649f: 74 5c je 1164fd <_Heap_Walk+0x2ad>
1164a1: 89 c3 mov %eax,%ebx
1164a3: eb ab jmp 116450 <_Heap_Walk+0x200>
(*printer)(
1164a5: 89 5c 24 0c mov %ebx,0xc(%esp)
1164a9: bf 5c 19 19 00 mov $0x19195c,%edi
1164ae: 89 7c 24 08 mov %edi,0x8(%esp)
1164b2: e9 b9 fe ff ff jmp 116370 <_Heap_Walk+0x120>
(*printer)(
1164b7: 89 5c 24 0c mov %ebx,0xc(%esp)
1164bb: be da 17 19 00 mov $0x1917da,%esi
1164c0: 89 74 24 08 mov %esi,0x8(%esp)
1164c4: e9 a7 fe ff ff jmp 116370 <_Heap_Walk+0x120>
(*printer)(
1164c9: 89 5c 24 0c mov %ebx,0xc(%esp)
1164cd: bb 8c 19 19 00 mov $0x19198c,%ebx
1164d2: 88 55 e4 mov %dl,-0x1c(%ebp)
1164d5: 89 44 24 10 mov %eax,0x10(%esp)
1164d9: 89 5c 24 08 mov %ebx,0x8(%esp)
1164dd: 8d 76 00 lea 0x0(%esi),%esi
(*printer)(
1164e0: b8 01 00 00 00 mov $0x1,%eax
1164e5: 89 44 24 04 mov %eax,0x4(%esp)
1164e9: 8b 45 0c mov 0xc(%ebp),%eax
1164ec: 89 04 24 mov %eax,(%esp)
1164ef: 8b 45 e0 mov -0x20(%ebp),%eax
1164f2: ff d0 call *%eax
return false;
1164f4: 0f b6 55 e4 movzbl -0x1c(%ebp),%edx
1164f8: e9 7e fd ff ff jmp 11627b <_Heap_Walk+0x2b>
1164fd: 8b 4d c8 mov -0x38(%ebp),%ecx
116500: 89 75 08 mov %esi,0x8(%ebp)
116503: 8b 5d d4 mov -0x2c(%ebp),%ebx
116506: 8b 45 cc mov -0x34(%ebp),%eax
116509: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
116510: 88 4d e4 mov %cl,-0x1c(%ebp)
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
116513: 89 ce mov %ecx,%esi
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
116515: 80 65 e4 01 andb $0x1,-0x1c(%ebp)
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
116519: 83 e6 fe and $0xfffffffe,%esi
return (Heap_Block *) ((uintptr_t) block + offset);
11651c: 8d 3c 33 lea (%ebx,%esi,1),%edi
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11651f: 39 f8 cmp %edi,%eax
116521: 76 2d jbe 116550 <_Heap_Walk+0x300> <== ALWAYS TAKEN
(*printer)(
116523: 89 7c 24 10 mov %edi,0x10(%esp)
116527: ba 68 1b 19 00 mov $0x191b68,%edx
11652c: 89 5c 24 0c mov %ebx,0xc(%esp)
116530: 89 54 24 08 mov %edx,0x8(%esp)
116534: b8 01 00 00 00 mov $0x1,%eax
116539: 89 44 24 04 mov %eax,0x4(%esp)
11653d: 8b 45 0c mov 0xc(%ebp),%eax
116540: 89 04 24 mov %eax,(%esp)
116543: 8b 45 e0 mov -0x20(%ebp),%eax
116546: ff d0 call *%eax
return false;
116548: 31 d2 xor %edx,%edx
11654a: e9 2c fd ff ff jmp 11627b <_Heap_Walk+0x2b>
11654f: 90 nop
116550: 8b 45 08 mov 0x8(%ebp),%eax
116553: 39 78 24 cmp %edi,0x24(%eax)
116556: 72 cb jb 116523 <_Heap_Walk+0x2d3>
return (value % alignment) == 0;
116558: 31 d2 xor %edx,%edx
11655a: 89 f0 mov %esi,%eax
11655c: f7 75 dc divl -0x24(%ebp)
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
11655f: 85 d2 test %edx,%edx
116561: 74 5d je 1165c0 <_Heap_Walk+0x370>
116563: 3b 5d d8 cmp -0x28(%ebp),%ebx
116566: 0f 85 97 02 00 00 jne 116803 <_Heap_Walk+0x5b3> <== NEVER TAKEN
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
11656c: 0f b6 57 04 movzbl 0x4(%edi),%edx
if ( !_Heap_Is_prev_used( next_block ) ) {
116570: 80 e2 01 and $0x1,%dl
116573: 0f 84 b7 00 00 00 je 116630 <_Heap_Walk+0x3e0>
} else if (prev_used) {
116579: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp)
11657d: 0f 84 7d 00 00 00 je 116600 <_Heap_Walk+0x3b0>
(*printer)(
116583: 89 74 24 10 mov %esi,0x10(%esp)
116587: b8 f6 17 19 00 mov $0x1917f6,%eax
11658c: 89 44 24 08 mov %eax,0x8(%esp)
116590: 31 c0 xor %eax,%eax
116592: 89 44 24 04 mov %eax,0x4(%esp)
116596: 8b 45 0c mov 0xc(%ebp),%eax
116599: 89 5c 24 0c mov %ebx,0xc(%esp)
11659d: 89 04 24 mov %eax,(%esp)
1165a0: 8b 45 e0 mov -0x20(%ebp),%eax
1165a3: ff d0 call *%eax
} while ( block != first_block );
1165a5: 3b 7d d4 cmp -0x2c(%ebp),%edi
1165a8: 0f 84 cb fc ff ff je 116279 <_Heap_Walk+0x29>
return (uintptr_t) block >= (uintptr_t) heap->first_block
1165ae: 8b 45 08 mov 0x8(%ebp),%eax
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
1165b1: 89 fb mov %edi,%ebx
1165b3: 8b 4f 04 mov 0x4(%edi),%ecx
return (uintptr_t) block >= (uintptr_t) heap->first_block
1165b6: 8b 40 20 mov 0x20(%eax),%eax
1165b9: e9 52 ff ff ff jmp 116510 <_Heap_Walk+0x2c0>
1165be: 66 90 xchg %ax,%ax
bool const is_not_last_block = block != last_block;
1165c0: 3b 5d d8 cmp -0x28(%ebp),%ebx
1165c3: 0f 95 c0 setne %al
if ( block_size < min_block_size && is_not_last_block ) {
1165c6: 39 75 d0 cmp %esi,-0x30(%ebp)
1165c9: 0f 97 c2 seta %dl
1165cc: 20 c2 and %al,%dl
1165ce: 0f 85 fc 01 00 00 jne 1167d0 <_Heap_Walk+0x580>
if ( next_block_begin <= block_begin && is_not_last_block ) {
1165d4: 39 fb cmp %edi,%ebx
1165d6: 72 94 jb 11656c <_Heap_Walk+0x31c>
1165d8: 84 c0 test %al,%al
1165da: 74 90 je 11656c <_Heap_Walk+0x31c>
(*printer)(
1165dc: 88 55 e4 mov %dl,-0x1c(%ebp)
1165df: b8 1c 1a 19 00 mov $0x191a1c,%eax
1165e4: 89 7c 24 10 mov %edi,0x10(%esp)
1165e8: 89 5c 24 0c mov %ebx,0xc(%esp)
1165ec: 89 44 24 08 mov %eax,0x8(%esp)
1165f0: e9 eb fe ff ff jmp 1164e0 <_Heap_Walk+0x290>
1165f5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1165fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
(*printer)(
116600: 8b 03 mov (%ebx),%eax
116602: 89 74 24 10 mov %esi,0x10(%esp)
116606: 89 5c 24 0c mov %ebx,0xc(%esp)
11660a: 89 44 24 14 mov %eax,0x14(%esp)
11660e: b8 f4 1a 19 00 mov $0x191af4,%eax
116613: 89 44 24 08 mov %eax,0x8(%esp)
116617: 31 c0 xor %eax,%eax
116619: 89 44 24 04 mov %eax,0x4(%esp)
11661d: 8b 45 0c mov 0xc(%ebp),%eax
116620: 89 04 24 mov %eax,(%esp)
116623: 8b 45 e0 mov -0x20(%ebp),%eax
116626: ff d0 call *%eax
116628: e9 78 ff ff ff jmp 1165a5 <_Heap_Walk+0x355>
11662d: 8d 76 00 lea 0x0(%esi),%esi
return _Heap_Free_list_head(heap)->next;
116630: 8b 45 08 mov 0x8(%ebp),%eax
116633: 8b 40 08 mov 0x8(%eax),%eax
116636: 89 45 cc mov %eax,-0x34(%ebp)
block->next == last_free_block ?
116639: 8b 43 08 mov 0x8(%ebx),%eax
11663c: 89 45 c8 mov %eax,-0x38(%ebp)
11663f: 89 c1 mov %eax,%ecx
(*printer)(
116641: 8b 45 08 mov 0x8(%ebp),%eax
116644: 39 48 0c cmp %ecx,0xc(%eax)
116647: 0f 84 33 01 00 00 je 116780 <_Heap_Walk+0x530>
: (block->next == free_list_tail ? " (= tail)" : "")
11664d: 39 4d 08 cmp %ecx,0x8(%ebp)
116650: 0f 84 4a 01 00 00 je 1167a0 <_Heap_Walk+0x550>
116656: c7 45 c0 6f 78 19 00 movl $0x19786f,-0x40(%ebp)
block->prev == first_free_block ?
11665d: 8b 43 0c mov 0xc(%ebx),%eax
(*printer)(
116660: 39 45 cc cmp %eax,-0x34(%ebp)
block->prev == first_free_block ?
116663: 89 45 c4 mov %eax,-0x3c(%ebp)
(*printer)(
116666: 0f 84 04 01 00 00 je 116770 <_Heap_Walk+0x520>
: (block->prev == free_list_head ? " (= head)" : ""),
11666c: 39 45 08 cmp %eax,0x8(%ebp)
11666f: 0f 84 1b 01 00 00 je 116790 <_Heap_Walk+0x540>
116675: b9 6f 78 19 00 mov $0x19786f,%ecx <== NOT EXECUTED
(*printer)(
11667a: 89 4c 24 18 mov %ecx,0x18(%esp)
11667e: 8b 45 c0 mov -0x40(%ebp),%eax
116681: 89 74 24 10 mov %esi,0x10(%esp)
116685: 89 5c 24 0c mov %ebx,0xc(%esp)
116689: 88 55 cc mov %dl,-0x34(%ebp)
11668c: 89 44 24 20 mov %eax,0x20(%esp)
116690: 8b 45 c8 mov -0x38(%ebp),%eax
116693: 89 44 24 1c mov %eax,0x1c(%esp)
116697: 8b 45 c4 mov -0x3c(%ebp),%eax
11669a: 89 44 24 14 mov %eax,0x14(%esp)
11669e: b8 50 1a 19 00 mov $0x191a50,%eax
1166a3: 89 44 24 08 mov %eax,0x8(%esp)
1166a7: 31 c0 xor %eax,%eax
1166a9: 89 44 24 04 mov %eax,0x4(%esp)
1166ad: 8b 45 0c mov 0xc(%ebp),%eax
1166b0: 89 04 24 mov %eax,(%esp)
1166b3: 8b 45 e0 mov -0x20(%ebp),%eax
1166b6: ff d0 call *%eax
if ( block_size != next_block->prev_size ) {
1166b8: 8b 07 mov (%edi),%eax
1166ba: 0f b6 55 cc movzbl -0x34(%ebp),%edx
1166be: 39 c6 cmp %eax,%esi
1166c0: 74 3e je 116700 <_Heap_Walk+0x4b0>
(*printer)(
1166c2: 88 55 e4 mov %dl,-0x1c(%ebp)
1166c5: b9 01 00 00 00 mov $0x1,%ecx
1166ca: ba 88 1a 19 00 mov $0x191a88,%edx
1166cf: 89 4c 24 04 mov %ecx,0x4(%esp)
1166d3: 8b 4d 0c mov 0xc(%ebp),%ecx
1166d6: 89 7c 24 18 mov %edi,0x18(%esp)
1166da: 89 44 24 14 mov %eax,0x14(%esp)
1166de: 8b 45 e0 mov -0x20(%ebp),%eax
1166e1: 89 74 24 10 mov %esi,0x10(%esp)
1166e5: 89 5c 24 0c mov %ebx,0xc(%esp)
1166e9: 89 54 24 08 mov %edx,0x8(%esp)
1166ed: 89 0c 24 mov %ecx,(%esp)
1166f0: ff d0 call *%eax
return false;
1166f2: 0f b6 55 e4 movzbl -0x1c(%ebp),%edx
}
1166f6: 83 c4 6c add $0x6c,%esp
1166f9: 5b pop %ebx
1166fa: 5e pop %esi
1166fb: 88 d0 mov %dl,%al
1166fd: 5f pop %edi
1166fe: 5d pop %ebp
1166ff: c3 ret
if ( !prev_used ) {
116700: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp)
116704: 0f 84 a6 00 00 00 je 1167b0 <_Heap_Walk+0x560>
11670a: 8b 45 08 mov 0x8(%ebp),%eax
11670d: 8b 40 08 mov 0x8(%eax),%eax
while ( free_block != free_list_tail ) {
116710: 39 45 08 cmp %eax,0x8(%ebp)
116713: 74 2d je 116742 <_Heap_Walk+0x4f2> <== NEVER TAKEN
if ( free_block == block ) {
116715: 39 c3 cmp %eax,%ebx
116717: 8b 4d 08 mov 0x8(%ebp),%ecx
11671a: 75 1c jne 116738 <_Heap_Walk+0x4e8>
11671c: e9 84 fe ff ff jmp 1165a5 <_Heap_Walk+0x355>
116721: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
116728: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11672f: 90 nop
116730: 39 c3 cmp %eax,%ebx
116732: 0f 84 6d fe ff ff je 1165a5 <_Heap_Walk+0x355>
free_block = free_block->next;
116738: 8b 40 08 mov 0x8(%eax),%eax
while ( free_block != free_list_tail ) {
11673b: 39 c1 cmp %eax,%ecx
11673d: 8d 76 00 lea 0x0(%esi),%esi
116740: 75 ee jne 116730 <_Heap_Walk+0x4e0>
(*printer)(
116742: 89 5c 24 0c mov %ebx,0xc(%esp)
116746: 8b 45 0c mov 0xc(%ebp),%eax
116749: b9 3c 1b 19 00 mov $0x191b3c,%ecx
11674e: 89 4c 24 08 mov %ecx,0x8(%esp)
116752: bb 01 00 00 00 mov $0x1,%ebx
116757: 89 5c 24 04 mov %ebx,0x4(%esp)
11675b: 88 55 e4 mov %dl,-0x1c(%ebp)
11675e: 89 04 24 mov %eax,(%esp)
116761: 8b 45 e0 mov -0x20(%ebp),%eax
116764: ff d0 call *%eax
return false;
116766: 0f b6 55 e4 movzbl -0x1c(%ebp),%edx
11676a: e9 0c fb ff ff jmp 11627b <_Heap_Walk+0x2b>
11676f: 90 nop
(*printer)(
116770: b9 7a 17 19 00 mov $0x19177a,%ecx
116775: e9 00 ff ff ff jmp 11667a <_Heap_Walk+0x42a>
11677a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
116780: c7 45 c0 61 17 19 00 movl $0x191761,-0x40(%ebp)
116787: e9 d1 fe ff ff jmp 11665d <_Heap_Walk+0x40d>
11678c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
: (block->prev == free_list_head ? " (= head)" : ""),
116790: b9 8a 17 19 00 mov $0x19178a,%ecx
116795: e9 e0 fe ff ff jmp 11667a <_Heap_Walk+0x42a>
11679a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
: (block->next == free_list_tail ? " (= tail)" : "")
1167a0: c7 45 c0 70 17 19 00 movl $0x191770,-0x40(%ebp)
1167a7: e9 b1 fe ff ff jmp 11665d <_Heap_Walk+0x40d>
1167ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
(*printer)(
1167b0: 89 5c 24 0c mov %ebx,0xc(%esp)
1167b4: b8 c4 1a 19 00 mov $0x191ac4,%eax
1167b9: 89 44 24 08 mov %eax,0x8(%esp)
1167bd: e9 ae fb ff ff jmp 116370 <_Heap_Walk+0x120>
1167c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1167c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
(*printer)(
1167d0: 89 74 24 10 mov %esi,0x10(%esp)
1167d4: 8b 45 d0 mov -0x30(%ebp),%eax
1167d7: ba 01 00 00 00 mov $0x1,%edx
1167dc: 89 54 24 04 mov %edx,0x4(%esp)
1167e0: 89 5c 24 0c mov %ebx,0xc(%esp)
1167e4: 89 44 24 14 mov %eax,0x14(%esp)
1167e8: b8 f0 19 19 00 mov $0x1919f0,%eax
1167ed: 89 44 24 08 mov %eax,0x8(%esp)
1167f1: 8b 45 0c mov 0xc(%ebp),%eax
1167f4: 89 04 24 mov %eax,(%esp)
1167f7: 8b 45 e0 mov -0x20(%ebp),%eax
1167fa: ff d0 call *%eax
return false;
1167fc: 31 d2 xor %edx,%edx
1167fe: e9 78 fa ff ff jmp 11627b <_Heap_Walk+0x2b>
(*printer)(
116803: 89 74 24 10 mov %esi,0x10(%esp)
116807: b9 c0 19 19 00 mov $0x1919c0,%ecx
11680c: 89 5c 24 0c mov %ebx,0xc(%esp)
116810: 89 4c 24 08 mov %ecx,0x8(%esp)
116814: e9 1b fd ff ff jmp 116534 <_Heap_Walk+0x2e4>
while ( free_block != free_list_tail ) {
116819: 89 75 08 mov %esi,0x8(%ebp)
11681c: 8b 5d d4 mov -0x2c(%ebp),%ebx
11681f: 8b 45 cc mov -0x34(%ebp),%eax
116822: e9 e9 fc ff ff jmp 116510 <_Heap_Walk+0x2c0>
116827: 90 nop
116828: 90 nop
116829: 90 nop
11682a: 90 nop
11682b: 90 nop
11682c: 90 nop
11682d: 90 nop
11682e: 90 nop
11682f: 90 nop
0010c260 <_IO_Base64>:
}
int
_IO_Base64(IO_Put_char put_char, void *arg, const void *src, size_t srclen,
const char *wordbreak, int wordlen)
{
10c260: 55 push %ebp
10c261: 89 e5 mov %esp,%ebp
10c263: 57 push %edi
10c264: 56 push %esi
10c265: 53 push %ebx
10c266: 83 ec 2c sub $0x2c,%esp
10c269: 8b 45 1c mov 0x1c(%ebp),%eax
10c26c: 8b 5d 08 mov 0x8(%ebp),%ebx
10c26f: 8b 75 0c mov 0xc(%ebp),%esi
10c272: 8b 7d 10 mov 0x10(%ebp),%edi
unsigned int loops = 0;
const unsigned char *in = src;
int out = 0;
if (wordlen < 4) {
10c275: 89 45 dc mov %eax,-0x24(%ebp)
10c278: 83 f8 04 cmp $0x4,%eax
10c27b: 7d 07 jge 10c284 <_IO_Base64+0x24>
10c27d: c7 45 dc 04 00 00 00 movl $0x4,-0x24(%ebp)
wordlen = 4;
}
while (srclen > 2) {
10c284: 83 7d 14 02 cmpl $0x2,0x14(%ebp)
10c288: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
10c28f: 0f 86 bc 00 00 00 jbe 10c351 <_IO_Base64+0xf1>
10c295: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
10c29c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
(*put_char)(c, arg);
10c2a0: 89 74 24 04 mov %esi,0x4(%esp)
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
10c2a4: 0f b6 07 movzbl (%edi),%eax
10c2a7: c0 e8 02 shr $0x2,%al
10c2aa: 0f b6 c0 movzbl %al,%eax
10c2ad: 0f be 80 c0 c2 12 00 movsbl 0x12c2c0(%eax),%eax
10c2b4: 89 04 24 mov %eax,(%esp)
(*put_char)(c, arg);
10c2b7: ff d3 call *%ebx
10c2b9: 89 74 24 04 mov %esi,0x4(%esp)
_IO_Put(base64[((in[0]<<4)&0x30)|
10c2bd: 0f b6 07 movzbl (%edi),%eax
((in[1]>>4)&0x0f)], arg, put_char);
10c2c0: 0f b6 4f 01 movzbl 0x1(%edi),%ecx
_IO_Put(base64[((in[0]<<4)&0x30)|
10c2c4: c1 e0 04 shl $0x4,%eax
((in[1]>>4)&0x0f)], arg, put_char);
10c2c7: c0 e9 04 shr $0x4,%cl
_IO_Put(base64[((in[0]<<4)&0x30)|
10c2ca: 83 e0 30 and $0x30,%eax
((in[1]>>4)&0x0f)], arg, put_char);
10c2cd: 0f b6 c9 movzbl %cl,%ecx
_IO_Put(base64[((in[0]<<4)&0x30)|
10c2d0: 09 c1 or %eax,%ecx
10c2d2: 0f be 81 c0 c2 12 00 movsbl 0x12c2c0(%ecx),%eax
10c2d9: 89 04 24 mov %eax,(%esp)
(*put_char)(c, arg);
10c2dc: ff d3 call *%ebx
10c2de: 89 74 24 04 mov %esi,0x4(%esp)
_IO_Put(base64[((in[1]<<2)&0x3c)|
10c2e2: 0f b6 47 01 movzbl 0x1(%edi),%eax
((in[2]>>6)&0x03)], arg, put_char);
10c2e6: 0f b6 4f 02 movzbl 0x2(%edi),%ecx
_IO_Put(base64[((in[1]<<2)&0x3c)|
10c2ea: c1 e0 02 shl $0x2,%eax
((in[2]>>6)&0x03)], arg, put_char);
10c2ed: c0 e9 06 shr $0x6,%cl
_IO_Put(base64[((in[1]<<2)&0x3c)|
10c2f0: 83 e0 3c and $0x3c,%eax
((in[2]>>6)&0x03)], arg, put_char);
10c2f3: 0f b6 c9 movzbl %cl,%ecx
_IO_Put(base64[((in[1]<<2)&0x3c)|
10c2f6: 09 c1 or %eax,%ecx
10c2f8: 0f be 81 c0 c2 12 00 movsbl 0x12c2c0(%ecx),%eax
10c2ff: 89 04 24 mov %eax,(%esp)
(*put_char)(c, arg);
10c302: ff d3 call *%ebx
10c304: 89 74 24 04 mov %esi,0x4(%esp)
_IO_Put(base64[in[2]&0x3f], arg, put_char);
10c308: 0f b6 47 02 movzbl 0x2(%edi),%eax
10c30c: 83 e0 3f and $0x3f,%eax
10c30f: 0f be 80 c0 c2 12 00 movsbl 0x12c2c0(%eax),%eax
10c316: 89 04 24 mov %eax,(%esp)
(*put_char)(c, arg);
10c319: ff d3 call *%ebx
in += 3;
srclen -= 3;
out += 4;
10c31b: 8b 45 e4 mov -0x1c(%ebp),%eax
loops++;
if (srclen != 0 &&
10c31e: 83 6d 14 03 subl $0x3,0x14(%ebp)
out += 4;
10c322: 8d 48 04 lea 0x4(%eax),%ecx
if (srclen != 0 &&
10c325: 0f 84 9b 00 00 00 je 10c3c6 <_IO_Base64+0x166>
(int)((loops + 1) * 4) >= wordlen)
10c32b: 8b 45 e0 mov -0x20(%ebp),%eax
10c32e: 8d 04 85 08 00 00 00 lea 0x8(,%eax,4),%eax
if (srclen != 0 &&
10c335: 3b 45 dc cmp -0x24(%ebp),%eax
10c338: 0f 8d 92 00 00 00 jge 10c3d0 <_IO_Base64+0x170>
loops++;
10c33e: ff 45 e0 incl -0x20(%ebp)
out += 4;
10c341: 89 4d e4 mov %ecx,-0x1c(%ebp)
in += 3;
10c344: 83 c7 03 add $0x3,%edi
while (srclen > 2) {
10c347: 83 7d 14 02 cmpl $0x2,0x14(%ebp)
10c34b: 0f 87 4f ff ff ff ja 10c2a0 <_IO_Base64+0x40>
++w;
++out;
}
}
}
if (srclen == 2) {
10c351: 83 7d 14 02 cmpl $0x2,0x14(%ebp)
10c355: 0f 85 c5 00 00 00 jne 10c420 <_IO_Base64+0x1c0>
(*put_char)(c, arg);
10c35b: 89 74 24 04 mov %esi,0x4(%esp)
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
10c35f: 0f b6 07 movzbl (%edi),%eax
10c362: c0 e8 02 shr $0x2,%al
10c365: 0f b6 c0 movzbl %al,%eax
10c368: 0f be 80 c0 c2 12 00 movsbl 0x12c2c0(%eax),%eax
10c36f: 89 04 24 mov %eax,(%esp)
(*put_char)(c, arg);
10c372: ff d3 call *%ebx
10c374: 89 74 24 04 mov %esi,0x4(%esp)
_IO_Put(base64[((in[0]<<4)&0x30)|
10c378: 0f b6 07 movzbl (%edi),%eax
((in[1]>>4)&0x0f)], arg, put_char);
10c37b: 0f b6 4f 01 movzbl 0x1(%edi),%ecx
_IO_Put(base64[((in[0]<<4)&0x30)|
10c37f: c1 e0 04 shl $0x4,%eax
((in[1]>>4)&0x0f)], arg, put_char);
10c382: c0 e9 04 shr $0x4,%cl
_IO_Put(base64[((in[0]<<4)&0x30)|
10c385: 83 e0 30 and $0x30,%eax
((in[1]>>4)&0x0f)], arg, put_char);
10c388: 0f b6 c9 movzbl %cl,%ecx
_IO_Put(base64[((in[0]<<4)&0x30)|
10c38b: 09 c1 or %eax,%ecx
10c38d: 0f be 81 c0 c2 12 00 movsbl 0x12c2c0(%ecx),%eax
10c394: 89 04 24 mov %eax,(%esp)
(*put_char)(c, arg);
10c397: ff d3 call *%ebx
10c399: 89 74 24 04 mov %esi,0x4(%esp)
_IO_Put(base64[((in[1]<<2)&0x3c)], arg, put_char);
10c39d: 0f b6 47 01 movzbl 0x1(%edi),%eax
10c3a1: c1 e0 02 shl $0x2,%eax
10c3a4: 83 e0 3c and $0x3c,%eax
10c3a7: 0f be 80 c0 c2 12 00 movsbl 0x12c2c0(%eax),%eax
10c3ae: 89 04 24 mov %eax,(%esp)
(*put_char)(c, arg);
10c3b1: ff d3 call *%ebx
10c3b3: 89 74 24 04 mov %esi,0x4(%esp)
10c3b7: c7 04 24 3d 00 00 00 movl $0x3d,(%esp)
10c3be: ff d3 call *%ebx
} else if (srclen == 1) {
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
_IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char);
_IO_Put('=', arg, put_char);
_IO_Put('=', arg, put_char);
out += 4;
10c3c0: 8b 4d e4 mov -0x1c(%ebp),%ecx
10c3c3: 83 c1 04 add $0x4,%ecx
}
return out;
}
10c3c6: 83 c4 2c add $0x2c,%esp
10c3c9: 89 c8 mov %ecx,%eax
10c3cb: 5b pop %ebx
10c3cc: 5e pop %esi
10c3cd: 5f pop %edi
10c3ce: 5d pop %ebp
10c3cf: c3 ret
while (*w != '\0') {
10c3d0: 8b 45 18 mov 0x18(%ebp),%eax
10c3d3: 0f be 00 movsbl (%eax),%eax
10c3d6: 84 c0 test %al,%al
10c3d8: 0f 84 92 00 00 00 je 10c470 <_IO_Base64+0x210> <== NEVER TAKEN
10c3de: 89 7d 10 mov %edi,0x10(%ebp)
10c3e1: 8b 55 18 mov 0x18(%ebp),%edx
10c3e4: 89 cf mov %ecx,%edi
10c3e6: 2b 55 e4 sub -0x1c(%ebp),%edx
10c3e9: 89 55 e4 mov %edx,-0x1c(%ebp)
10c3ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
_IO_Put(*w, arg, put_char);
10c3f0: 89 04 24 mov %eax,(%esp)
++out;
10c3f3: 47 inc %edi
(*put_char)(c, arg);
10c3f4: 89 74 24 04 mov %esi,0x4(%esp)
10c3f8: ff d3 call *%ebx
while (*w != '\0') {
10c3fa: 8b 45 e4 mov -0x1c(%ebp),%eax
10c3fd: 0f be 44 38 fc movsbl -0x4(%eax,%edi,1),%eax
10c402: 84 c0 test %al,%al
10c404: 75 ea jne 10c3f0 <_IO_Base64+0x190> <== NEVER TAKEN
loops = 0;
10c406: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
++out;
10c40d: 89 f9 mov %edi,%ecx
10c40f: 8b 7d 10 mov 0x10(%ebp),%edi
10c412: 89 4d e4 mov %ecx,-0x1c(%ebp)
10c415: e9 2a ff ff ff jmp 10c344 <_IO_Base64+0xe4>
10c41a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
} else if (srclen == 1) {
10c420: 83 7d 14 01 cmpl $0x1,0x14(%ebp)
10c424: 75 59 jne 10c47f <_IO_Base64+0x21f>
(*put_char)(c, arg);
10c426: 89 74 24 04 mov %esi,0x4(%esp)
_IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char);
10c42a: 0f b6 07 movzbl (%edi),%eax
10c42d: c0 e8 02 shr $0x2,%al
10c430: 0f b6 c0 movzbl %al,%eax
10c433: 0f be 80 c0 c2 12 00 movsbl 0x12c2c0(%eax),%eax
10c43a: 89 04 24 mov %eax,(%esp)
(*put_char)(c, arg);
10c43d: ff d3 call *%ebx
10c43f: 89 74 24 04 mov %esi,0x4(%esp)
_IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char);
10c443: 0f b6 07 movzbl (%edi),%eax
10c446: c1 e0 04 shl $0x4,%eax
10c449: 83 e0 30 and $0x30,%eax
10c44c: 0f be 80 c0 c2 12 00 movsbl 0x12c2c0(%eax),%eax
10c453: 89 04 24 mov %eax,(%esp)
(*put_char)(c, arg);
10c456: ff d3 call *%ebx
10c458: 89 74 24 04 mov %esi,0x4(%esp)
10c45c: c7 04 24 3d 00 00 00 movl $0x3d,(%esp)
10c463: e9 49 ff ff ff jmp 10c3b1 <_IO_Base64+0x151>
10c468: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10c46f: 90 nop
out += 4;
10c470: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED
loops = 0;
10c473: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
10c47a: e9 c5 fe ff ff jmp 10c344 <_IO_Base64+0xe4> <== NOT EXECUTED
10c47f: 8b 4d e4 mov -0x1c(%ebp),%ecx
return out;
10c482: e9 3f ff ff ff jmp 10c3c6 <_IO_Base64+0x166>
10c487: 90 nop
10c488: 90 nop
10c489: 90 nop
10c48a: 90 nop
10c48b: 90 nop
10c48c: 90 nop
10c48d: 90 nop
10c48e: 90 nop
10c48f: 90 nop
00105440 <_IO_Vprintf>:
return (p);
}
int
_IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap)
{
105440: 55 push %ebp
105441: 89 e5 mov %esp,%ebp
105443: 57 push %edi
105444: 56 push %esi
105445: 53 push %ebx
105446: 81 ec 9c 00 00 00 sub $0x9c,%esp
char padc;
int stop = 0, retval = 0;
num = 0;
if (fmt == NULL)
10544c: 8b 45 10 mov 0x10(%ebp),%eax
{
10544f: 8b 5d 08 mov 0x8(%ebp),%ebx
if (fmt == NULL)
105452: 85 c0 test %eax,%eax
105454: 0f 84 d6 00 00 00 je 105530 <_IO_Vprintf+0xf0> <== NEVER TAKEN
fmt = "(fmt null)\n";
for (;;) {
padc = ' ';
width = 0;
while ((ch = (u_char)*fmt++) != '%' || stop) {
10545a: 8b 45 10 mov 0x10(%ebp),%eax
10545d: 0f b6 00 movzbl (%eax),%eax
width -= n;
if (!ladjust && width > 0)
while (width--)
PCHAR(padc);
while (n--)
105460: c7 45 b4 00 00 00 00 movl $0x0,-0x4c(%ebp)
105467: 31 d2 xor %edx,%edx
105469: 89 df mov %ebx,%edi
10546b: 89 d6 mov %edx,%esi
while ((ch = (u_char)*fmt++) != '%' || stop) {
10546d: 8b 4d 10 mov 0x10(%ebp),%ecx
105470: 29 ce sub %ecx,%esi
105472: eb 25 jmp 105499 <_IO_Vprintf+0x59>
105474: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10547b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10547f: 90 nop
if (ch == '\0')
105480: 85 d2 test %edx,%edx
105482: 0f 84 98 00 00 00 je 105520 <_IO_Vprintf+0xe0>
PCHAR(ch);
105488: 89 14 24 mov %edx,(%esp)
10548b: 8b 45 0c mov 0xc(%ebp),%eax
10548e: 89 44 24 04 mov %eax,0x4(%esp)
105492: ff d7 call *%edi
while ((ch = (u_char)*fmt++) != '%' || stop) {
105494: 0f b6 03 movzbl (%ebx),%eax
105497: 89 d9 mov %ebx,%ecx
105499: 8d 14 31 lea (%ecx,%esi,1),%edx
10549c: 3c 25 cmp $0x25,%al
10549e: 89 55 bc mov %edx,-0x44(%ebp)
1054a1: 8d 59 01 lea 0x1(%ecx),%ebx
1054a4: 0f b6 d0 movzbl %al,%edx
1054a7: 89 5d b8 mov %ebx,-0x48(%ebp)
1054aa: 75 d4 jne 105480 <_IO_Vprintf+0x40>
1054ac: 8b 45 b4 mov -0x4c(%ebp),%eax
1054af: 85 c0 test %eax,%eax
1054b1: 75 d5 jne 105488 <_IO_Vprintf+0x48> <== NEVER TAKEN
sign = 0; dot = 0; dwidth = 0; upper = 0;
1054b3: c7 45 90 00 00 00 00 movl $0x0,-0x70(%ebp)
1054ba: 89 f0 mov %esi,%eax
reswitch: switch (ch = (u_char)*fmt++) {
1054bc: 0f b6 51 01 movzbl 0x1(%ecx),%edx
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
1054c0: c7 45 9c 00 00 00 00 movl $0x0,-0x64(%ebp)
1054c7: 89 ce mov %ecx,%esi
1054c9: 89 c1 mov %eax,%ecx
1054cb: c7 45 a0 00 00 00 00 movl $0x0,-0x60(%ebp)
1054d2: c7 45 88 00 00 00 00 movl $0x0,-0x78(%ebp)
sign = 0; dot = 0; dwidth = 0; upper = 0;
1054d9: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp)
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
1054e0: c7 45 a8 00 00 00 00 movl $0x0,-0x58(%ebp)
1054e7: c7 45 98 00 00 00 00 movl $0x0,-0x68(%ebp)
width = 0;
1054ee: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
1054f5: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
padc = ' ';
1054fc: c6 45 87 20 movb $0x20,-0x79(%ebp)
reswitch: switch (ch = (u_char)*fmt++) {
105500: 8b 45 b8 mov -0x48(%ebp),%eax
105503: 40 inc %eax
105504: 89 45 10 mov %eax,0x10(%ebp)
105507: 0f b6 c2 movzbl %dl,%eax
10550a: 89 45 b0 mov %eax,-0x50(%ebp)
10550d: 88 d0 mov %dl,%al
10550f: 2c 23 sub $0x23,%al
105511: 3c 57 cmp $0x57,%al
105513: 77 4b ja 105560 <_IO_Vprintf+0x120> <== NEVER TAKEN
105515: 0f b6 c0 movzbl %al,%eax
105518: ff 24 85 d0 52 12 00 jmp *0x1252d0(,%eax,4)
10551f: 90 nop
stop = 1;
break;
}
}
#undef PCHAR
}
105520: 8b 45 bc mov -0x44(%ebp),%eax
105523: 81 c4 9c 00 00 00 add $0x9c,%esp
105529: 5b pop %ebx
10552a: 5e pop %esi
10552b: 5f pop %edi
10552c: 5d pop %ebp
10552d: c3 ret
10552e: 66 90 xchg %ax,%ax
fmt = "(fmt null)\n";
105530: c7 45 10 bb 52 12 00 movl $0x1252bb,0x10(%ebp) <== NOT EXECUTED
105537: b0 28 mov $0x28,%al <== NOT EXECUTED
105539: e9 22 ff ff ff jmp 105460 <_IO_Vprintf+0x20> <== NOT EXECUTED
zflag = 1;
10553e: c7 45 a4 01 00 00 00 movl $0x1,-0x5c(%ebp)
reswitch: switch (ch = (u_char)*fmt++) {
105545: 8b 45 b8 mov -0x48(%ebp),%eax
105548: 0f b6 50 01 movzbl 0x1(%eax),%edx
10554c: 8b 45 10 mov 0x10(%ebp),%eax
10554f: 89 45 b8 mov %eax,-0x48(%ebp)
goto reswitch;
105552: eb ac jmp 105500 <_IO_Vprintf+0xc0>
105554: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10555b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10555f: 90 nop
while (percent < fmt)
105560: 89 c8 mov %ecx,%eax
105562: 89 f1 mov %esi,%ecx
105564: 3b 4d 10 cmp 0x10(%ebp),%ecx
105567: 89 c6 mov %eax,%esi
105569: b8 25 00 00 00 mov $0x25,%eax
10556e: 0f 83 87 0a 00 00 jae 105ffb <_IO_Vprintf+0xbbb> <== NEVER TAKEN
105574: 89 75 bc mov %esi,-0x44(%ebp)
105577: 8b 75 0c mov 0xc(%ebp),%esi
10557a: eb 08 jmp 105584 <_IO_Vprintf+0x144>
10557c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
PCHAR(*percent++);
105580: 0f be 03 movsbl (%ebx),%eax
105583: 43 inc %ebx
105584: 89 74 24 04 mov %esi,0x4(%esp)
105588: 89 04 24 mov %eax,(%esp)
10558b: ff d7 call *%edi
while (percent < fmt)
10558d: 39 5d 10 cmp %ebx,0x10(%ebp)
105590: 75 ee jne 105580 <_IO_Vprintf+0x140>
stop = 1;
105592: c7 45 b4 01 00 00 00 movl $0x1,-0x4c(%ebp)
PCHAR(*percent++);
105599: 8b 75 bc mov -0x44(%ebp),%esi
10559c: 8b 45 10 mov 0x10(%ebp),%eax
10559f: 01 c6 add %eax,%esi
1055a1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1055a8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1055af: 90 nop
while ((ch = (u_char)*fmt++) != '%' || stop) {
1055b0: 8b 45 b8 mov -0x48(%ebp),%eax
1055b3: 0f b6 40 01 movzbl 0x1(%eax),%eax
1055b7: e9 b1 fe ff ff jmp 10546d <_IO_Vprintf+0x2d>
n = n * 10 + ch - '0';
1055bc: 8b 45 b0 mov -0x50(%ebp),%eax
1055bf: 83 e8 30 sub $0x30,%eax
1055c2: 89 45 b0 mov %eax,-0x50(%ebp)
ch = *fmt;
1055c5: 8b 45 b8 mov -0x48(%ebp),%eax
1055c8: 0f b6 50 01 movzbl 0x1(%eax),%edx
1055cc: 0f be c2 movsbl %dl,%eax
1055cf: 89 45 b8 mov %eax,-0x48(%ebp)
if (ch < '0' || ch > '9')
1055d2: 83 e8 30 sub $0x30,%eax
1055d5: 83 f8 09 cmp $0x9,%eax
1055d8: 0f 87 12 0a 00 00 ja 105ff0 <_IO_Vprintf+0xbb0>
reswitch: switch (ch = (u_char)*fmt++) {
1055de: 89 75 80 mov %esi,-0x80(%ebp)
1055e1: 8b 55 10 mov 0x10(%ebp),%edx
1055e4: 89 8d 7c ff ff ff mov %ecx,-0x84(%ebp)
1055ea: 8b 45 b0 mov -0x50(%ebp),%eax
1055ed: 89 7d 08 mov %edi,0x8(%ebp)
1055f0: 8b 75 b8 mov -0x48(%ebp),%esi
1055f3: 89 d1 mov %edx,%ecx
1055f5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1055fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ch = *fmt;
105600: 0f b6 51 01 movzbl 0x1(%ecx),%edx
n = n * 10 + ch - '0';
105604: 8d 04 80 lea (%eax,%eax,4),%eax
for (n = 0;; ++fmt) {
105607: 41 inc %ecx
n = n * 10 + ch - '0';
105608: 8d 44 46 d0 lea -0x30(%esi,%eax,2),%eax
ch = *fmt;
10560c: 0f be f2 movsbl %dl,%esi
if (ch < '0' || ch > '9')
10560f: 8d 7e d0 lea -0x30(%esi),%edi
105612: 83 ff 09 cmp $0x9,%edi
105615: 76 e9 jbe 105600 <_IO_Vprintf+0x1c0> <== NEVER TAKEN
105617: 89 4d b8 mov %ecx,-0x48(%ebp)
10561a: 8b 75 80 mov -0x80(%ebp),%esi
10561d: 89 45 b0 mov %eax,-0x50(%ebp)
105620: 8b 8d 7c ff ff ff mov -0x84(%ebp),%ecx
105626: 8b 7d 08 mov 0x8(%ebp),%edi
if (dot)
105629: 83 7d ac 00 cmpl $0x0,-0x54(%ebp)
10562d: 8b 45 b0 mov -0x50(%ebp),%eax
105630: 0f 85 6d 08 00 00 jne 105ea3 <_IO_Vprintf+0xa63>
105636: 89 45 94 mov %eax,-0x6c(%ebp)
105639: e9 c2 fe ff ff jmp 105500 <_IO_Vprintf+0xc0>
reswitch: switch (ch = (u_char)*fmt++) {
10563e: c7 45 b0 0a 00 00 00 movl $0xa,-0x50(%ebp)
base = 10;
105645: b9 0a 00 00 00 mov $0xa,%ecx
reswitch: switch (ch = (u_char)*fmt++) {
10564a: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp)
base = 10;
105651: 89 8d 7c ff ff ff mov %ecx,-0x84(%ebp)
if (jflag)
105657: 8b 55 9c mov -0x64(%ebp),%edx
num = va_arg(ap, intmax_t);
10565a: 8b 45 14 mov 0x14(%ebp),%eax
if (jflag)
10565d: 85 d2 test %edx,%edx
10565f: 0f 84 b7 07 00 00 je 105e1c <_IO_Vprintf+0x9dc>
num = va_arg(ap, intmax_t);
105665: 8b 75 14 mov 0x14(%ebp),%esi
105668: 8b 50 04 mov 0x4(%eax),%edx
10566b: 8b 00 mov (%eax),%eax
10566d: 83 c6 08 add $0x8,%esi
105670: 89 55 8c mov %edx,-0x74(%ebp)
105673: 89 45 88 mov %eax,-0x78(%ebp)
105676: 89 75 14 mov %esi,0x14(%ebp)
if (sharpflag && num != 0) {
105679: 0f b6 4d a8 movzbl -0x58(%ebp),%ecx
10567d: 80 e1 01 and $0x1,%cl
if (sign && (intmax_t)num < 0) {
105680: 85 d2 test %edx,%edx
if (sharpflag && num != 0) {
105682: 88 4d 80 mov %cl,-0x80(%ebp)
if (sign && (intmax_t)num < 0) {
105685: 0f 89 87 09 00 00 jns 106012 <_IO_Vprintf+0xbd2>
neg = 1;
10568b: c7 45 9c 01 00 00 00 movl $0x1,-0x64(%ebp)
num = -(intmax_t)num;
105692: f7 d8 neg %eax
105694: 89 45 88 mov %eax,-0x78(%ebp)
105697: 83 d2 00 adc $0x0,%edx
10569a: f7 da neg %edx
10569c: 89 55 8c mov %edx,-0x74(%ebp)
10569f: 31 d2 xor %edx,%edx
*p = '\0';
1056a1: 8b 4d 88 mov -0x78(%ebp),%ecx
*++p = hex2ascii_data[upper][num % base];
1056a4: 89 d0 mov %edx,%eax
1056a6: 89 7d 08 mov %edi,0x8(%ebp)
*p = '\0';
1056a9: 8b 5d 8c mov -0x74(%ebp),%ebx
*++p = hex2ascii_data[upper][num % base];
1056ac: c1 e0 04 shl $0x4,%eax
*p = '\0';
1056af: c6 45 d1 00 movb $0x0,-0x2f(%ebp)
*++p = hex2ascii_data[upper][num % base];
1056b3: 05 40 54 12 00 add $0x125440,%eax
1056b8: 89 45 a0 mov %eax,-0x60(%ebp)
*p = '\0';
1056bb: 89 ce mov %ecx,%esi
p = nbuf;
1056bd: 8d 4d d1 lea -0x2f(%ebp),%ecx
*++p = hex2ascii_data[upper][num % base];
1056c0: 89 cf mov %ecx,%edi
1056c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1056c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1056d0: 8d 45 c0 lea -0x40(%ebp),%eax
1056d3: 8b 4d ac mov -0x54(%ebp),%ecx
1056d6: 47 inc %edi
1056d7: 89 44 24 10 mov %eax,0x10(%esp)
1056db: 8b 45 b0 mov -0x50(%ebp),%eax
1056de: 89 34 24 mov %esi,(%esp)
1056e1: 89 5c 24 04 mov %ebx,0x4(%esp)
1056e5: 89 4c 24 0c mov %ecx,0xc(%esp)
1056e9: 89 44 24 08 mov %eax,0x8(%esp)
1056ed: e8 2e 28 01 00 call 117f20 <__udivmoddi4>
1056f2: 8b 4d a0 mov -0x60(%ebp),%ecx
1056f5: 03 4d c0 add -0x40(%ebp),%ecx
1056f8: 89 75 a8 mov %esi,-0x58(%ebp)
1056fb: 89 5d a4 mov %ebx,-0x5c(%ebp)
1056fe: 0f be 09 movsbl (%ecx),%ecx
} while (num /= base);
105701: 89 c6 mov %eax,%esi
105703: 8b 45 b0 mov -0x50(%ebp),%eax
105706: 89 d3 mov %edx,%ebx
105708: 39 45 a8 cmp %eax,-0x58(%ebp)
*++p = hex2ascii_data[upper][num % base];
10570b: 88 0f mov %cl,(%edi)
} while (num /= base);
10570d: 8b 55 a4 mov -0x5c(%ebp),%edx
105710: 1b 55 ac sbb -0x54(%ebp),%edx
105713: 73 bb jae 1056d0 <_IO_Vprintf+0x290>
*lenp = p - nbuf;
105715: 8d 45 d1 lea -0x2f(%ebp),%eax
105718: 89 fb mov %edi,%ebx
if (sharpflag && num != 0) {
10571a: 8b 55 8c mov -0x74(%ebp),%edx
*lenp = p - nbuf;
10571d: 89 7d b0 mov %edi,-0x50(%ebp)
105720: 29 c3 sub %eax,%ebx
if (sharpflag && num != 0) {
105722: 8b 45 88 mov -0x78(%ebp),%eax
*lenp = p - nbuf;
105725: 8b 7d 08 mov 0x8(%ebp),%edi
if (sharpflag && num != 0) {
105728: 89 c6 mov %eax,%esi
10572a: 09 d6 or %edx,%esi
10572c: 0f 95 c0 setne %al
tmp = 0;
10572f: 31 d2 xor %edx,%edx
if (sharpflag && num != 0) {
105731: 22 45 80 and -0x80(%ebp),%al
105734: 88 45 ac mov %al,-0x54(%ebp)
105737: 74 19 je 105752 <_IO_Vprintf+0x312>
if (base == 8)
105739: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
10573f: 83 f8 08 cmp $0x8,%eax
105742: 0f 84 99 06 00 00 je 105de1 <_IO_Vprintf+0x9a1> <== NEVER TAKEN
tmp = 0;
105748: 31 d2 xor %edx,%edx
10574a: 83 f8 10 cmp $0x10,%eax
10574d: 0f 94 c2 sete %dl
105750: 01 d2 add %edx,%edx
tmp++;
105752: 83 7d 9c 01 cmpl $0x1,-0x64(%ebp)
105756: 83 da ff sbb $0xffffffff,%edx
if (!ladjust && padc == '0')
105759: f6 45 98 01 testb $0x1,-0x68(%ebp)
10575d: 0f 85 9d 05 00 00 jne 105d00 <_IO_Vprintf+0x8c0> <== NEVER TAKEN
105763: 80 7d 87 30 cmpb $0x30,-0x79(%ebp)
105767: 0f 85 93 05 00 00 jne 105d00 <_IO_Vprintf+0x8c0>
dwidth = width - tmp;
10576d: 8b 75 94 mov -0x6c(%ebp),%esi
105770: 29 d6 sub %edx,%esi
static inline int imax(int a, int b) { return (a > b ? a : b); }
105772: 39 de cmp %ebx,%esi
105774: 89 f0 mov %esi,%eax
105776: 7d 02 jge 10577a <_IO_Vprintf+0x33a>
105778: 89 d8 mov %ebx,%eax
width -= tmp + imax(dwidth, n);
10577a: 01 c2 add %eax,%edx
10577c: 8b 45 94 mov -0x6c(%ebp),%eax
dwidth -= n;
10577f: 29 de sub %ebx,%esi
width -= tmp + imax(dwidth, n);
105781: 29 d0 sub %edx,%eax
105783: 89 45 a8 mov %eax,-0x58(%ebp)
while (width-- > 0)
105786: 8b 45 a8 mov -0x58(%ebp),%eax
105789: 8d 58 ff lea -0x1(%eax),%ebx
10578c: 85 c0 test %eax,%eax
10578e: 0f 8e 54 08 00 00 jle 105fe8 <_IO_Vprintf+0xba8>
105794: 89 5d a4 mov %ebx,-0x5c(%ebp)
105797: 89 75 a0 mov %esi,-0x60(%ebp)
10579a: 89 de mov %ebx,%esi
10579c: 8b 5d 0c mov 0xc(%ebp),%ebx
10579f: 88 4d a8 mov %cl,-0x58(%ebp)
1057a2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1057a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
PCHAR(' ');
1057b0: 89 5c 24 04 mov %ebx,0x4(%esp)
1057b4: c7 04 24 20 00 00 00 movl $0x20,(%esp)
1057bb: ff d7 call *%edi
while (width-- > 0)
1057bd: 83 ee 01 sub $0x1,%esi
1057c0: 73 ee jae 1057b0 <_IO_Vprintf+0x370>
PCHAR(' ');
1057c2: 8b 45 bc mov -0x44(%ebp),%eax
1057c5: 8b 5d a4 mov -0x5c(%ebp),%ebx
1057c8: 0f be 4d a8 movsbl -0x58(%ebp),%ecx
1057cc: 89 75 a8 mov %esi,-0x58(%ebp)
1057cf: 8b 75 a0 mov -0x60(%ebp),%esi
1057d2: 8d 44 03 01 lea 0x1(%ebx,%eax,1),%eax
1057d6: 89 45 bc mov %eax,-0x44(%ebp)
if (neg)
1057d9: 8b 5d 9c mov -0x64(%ebp),%ebx
1057dc: 85 db test %ebx,%ebx
1057de: 74 1a je 1057fa <_IO_Vprintf+0x3ba>
1057e0: 88 4d a4 mov %cl,-0x5c(%ebp)
PCHAR('-');
1057e3: 8b 45 0c mov 0xc(%ebp),%eax
1057e6: c7 04 24 2d 00 00 00 movl $0x2d,(%esp)
1057ed: 89 44 24 04 mov %eax,0x4(%esp)
1057f1: ff d7 call *%edi
1057f3: 0f be 4d a4 movsbl -0x5c(%ebp),%ecx
1057f7: ff 45 bc incl -0x44(%ebp)
if (sharpflag && num != 0) {
1057fa: 80 7d ac 00 cmpb $0x0,-0x54(%ebp)
1057fe: 74 50 je 105850 <_IO_Vprintf+0x410>
if (base == 8) {
105800: 83 bd 7c ff ff ff 08 cmpl $0x8,-0x84(%ebp)
105807: 0f 84 de 05 00 00 je 105deb <_IO_Vprintf+0x9ab> <== NEVER TAKEN
} else if (base == 16) {
10580d: 83 bd 7c ff ff ff 10 cmpl $0x10,-0x84(%ebp)
105814: 75 3a jne 105850 <_IO_Vprintf+0x410> <== NEVER TAKEN
105816: 88 4d ac mov %cl,-0x54(%ebp)
PCHAR('0');
105819: 8b 45 0c mov 0xc(%ebp),%eax
10581c: c7 04 24 30 00 00 00 movl $0x30,(%esp)
105823: 89 44 24 04 mov %eax,0x4(%esp)
105827: ff d7 call *%edi
PCHAR('x');
105829: 8b 45 0c mov 0xc(%ebp),%eax
10582c: c7 04 24 78 00 00 00 movl $0x78,(%esp)
105833: 89 44 24 04 mov %eax,0x4(%esp)
105837: ff d7 call *%edi
105839: 0f be 4d ac movsbl -0x54(%ebp),%ecx
10583d: 83 45 bc 02 addl $0x2,-0x44(%ebp)
105841: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105848: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10584f: 90 nop
while (dwidth-- > 0)
105850: 8d 5e ff lea -0x1(%esi),%ebx
105853: 85 f6 test %esi,%esi
105855: 7e 2c jle 105883 <_IO_Vprintf+0x443>
105857: 88 4d ac mov %cl,-0x54(%ebp)
10585a: 8b 75 0c mov 0xc(%ebp),%esi
10585d: 89 5d a4 mov %ebx,-0x5c(%ebp)
PCHAR('0');
105860: 89 74 24 04 mov %esi,0x4(%esp)
105864: c7 04 24 30 00 00 00 movl $0x30,(%esp)
10586b: ff d7 call *%edi
while (dwidth-- > 0)
10586d: 83 eb 01 sub $0x1,%ebx
105870: 73 ee jae 105860 <_IO_Vprintf+0x420>
PCHAR('0');
105872: 8b 45 bc mov -0x44(%ebp),%eax
105875: 8b 5d a4 mov -0x5c(%ebp),%ebx
105878: 0f be 4d ac movsbl -0x54(%ebp),%ecx
10587c: 8d 44 03 01 lea 0x1(%ebx,%eax,1),%eax
105880: 89 45 bc mov %eax,-0x44(%ebp)
while (*p)
105883: 84 c9 test %cl,%cl
105885: 0f 84 bb 05 00 00 je 105e46 <_IO_Vprintf+0xa06> <== NEVER TAKEN
*++p = hex2ascii_data[upper][num % base];
10588b: 8b 5d b0 mov -0x50(%ebp),%ebx
10588e: 8b 75 0c mov 0xc(%ebp),%esi
105891: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105898: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10589f: 90 nop
PCHAR(*p--);
1058a0: 89 0c 24 mov %ecx,(%esp)
1058a3: 4b dec %ebx
1058a4: 89 74 24 04 mov %esi,0x4(%esp)
1058a8: ff d7 call *%edi
1058aa: 8b 55 b0 mov -0x50(%ebp),%edx
1058ad: 8b 4d bc mov -0x44(%ebp),%ecx
1058b0: 29 da sub %ebx,%edx
1058b2: 01 ca add %ecx,%edx
while (*p)
1058b4: 0f be 0b movsbl (%ebx),%ecx
1058b7: 84 c9 test %cl,%cl
1058b9: 75 e5 jne 1058a0 <_IO_Vprintf+0x460>
1058bb: 89 d6 mov %edx,%esi
if (ladjust)
1058bd: 8b 55 98 mov -0x68(%ebp),%edx
1058c0: 85 d2 test %edx,%edx
1058c2: 0f 85 da 04 00 00 jne 105da2 <_IO_Vprintf+0x962> <== NEVER TAKEN
1058c8: c7 45 b4 00 00 00 00 movl $0x0,-0x4c(%ebp)
1058cf: e9 dc fc ff ff jmp 1055b0 <_IO_Vprintf+0x170>
if (!dot) {
1058d4: 8b 45 ac mov -0x54(%ebp),%eax
1058d7: 85 c0 test %eax,%eax
1058d9: 0f 85 d6 06 00 00 jne 105fb5 <_IO_Vprintf+0xb75> <== NEVER TAKEN
padc = '0';
1058df: 88 55 87 mov %dl,-0x79(%ebp)
reswitch: switch (ch = (u_char)*fmt++) {
1058e2: 8b 45 b8 mov -0x48(%ebp),%eax
1058e5: 0f b6 50 01 movzbl 0x1(%eax),%edx
1058e9: 8b 45 10 mov 0x10(%ebp),%eax
1058ec: 89 45 b8 mov %eax,-0x48(%ebp)
1058ef: e9 0c fc ff ff jmp 105500 <_IO_Vprintf+0xc0>
1058f4: 8b 45 b8 mov -0x48(%ebp),%eax
1058f7: 0f b6 50 01 movzbl 0x1(%eax),%edx
if (hflag) {
1058fb: 8b 45 a0 mov -0x60(%ebp),%eax
1058fe: 85 c0 test %eax,%eax
105900: 0f 85 a5 05 00 00 jne 105eab <_IO_Vprintf+0xa6b>
hflag = 1;
105906: c7 45 a0 01 00 00 00 movl $0x1,-0x60(%ebp)
reswitch: switch (ch = (u_char)*fmt++) {
10590d: 8b 45 10 mov 0x10(%ebp),%eax
105910: 89 45 b8 mov %eax,-0x48(%ebp)
105913: e9 e8 fb ff ff jmp 105500 <_IO_Vprintf+0xc0>
jflag = 1;
105918: c7 45 9c 01 00 00 00 movl $0x1,-0x64(%ebp)
reswitch: switch (ch = (u_char)*fmt++) {
10591f: 8b 45 b8 mov -0x48(%ebp),%eax
105922: 0f b6 50 01 movzbl 0x1(%eax),%edx
105926: 8b 45 10 mov 0x10(%ebp),%eax
105929: 89 45 b8 mov %eax,-0x48(%ebp)
goto reswitch;
10592c: e9 cf fb ff ff jmp 105500 <_IO_Vprintf+0xc0>
if (lflag) {
105931: 8b 45 a4 mov -0x5c(%ebp),%eax
105934: 85 c0 test %eax,%eax
105936: 0f 84 02 fc ff ff je 10553e <_IO_Vprintf+0xfe>
reswitch: switch (ch = (u_char)*fmt++) {
10593c: 8b 45 b8 mov -0x48(%ebp),%eax
10593f: 0f b6 50 01 movzbl 0x1(%eax),%edx
jflag = 1;
105943: 8b 45 a4 mov -0x5c(%ebp),%eax
105946: 89 45 9c mov %eax,-0x64(%ebp)
reswitch: switch (ch = (u_char)*fmt++) {
105949: 8b 45 10 mov 0x10(%ebp),%eax
10594c: 89 45 b8 mov %eax,-0x48(%ebp)
10594f: e9 ac fb ff ff jmp 105500 <_IO_Vprintf+0xc0>
105954: c7 45 b0 08 00 00 00 movl $0x8,-0x50(%ebp)
base = 8;
10595b: b8 08 00 00 00 mov $0x8,%eax
sign = 0; dot = 0; dwidth = 0; upper = 0;
105960: 31 d2 xor %edx,%edx
reswitch: switch (ch = (u_char)*fmt++) {
105962: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp)
base = 8;
105969: 89 85 7c ff ff ff mov %eax,-0x84(%ebp)
if (sharpflag && num != 0) {
10596f: 0f b6 45 a8 movzbl -0x58(%ebp),%eax
if (jflag)
105973: 8b 75 9c mov -0x64(%ebp),%esi
if (sharpflag && num != 0) {
105976: 24 01 and $0x1,%al
105978: 88 45 80 mov %al,-0x80(%ebp)
if (jflag)
10597b: 85 f6 test %esi,%esi
num = va_arg(ap, uintmax_t);
10597d: 8b 45 14 mov 0x14(%ebp),%eax
if (jflag)
105980: 0f 84 eb 03 00 00 je 105d71 <_IO_Vprintf+0x931>
num = va_arg(ap, uintmax_t);
105986: 8b 08 mov (%eax),%ecx
105988: 83 c0 08 add $0x8,%eax
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
10598b: c7 45 9c 00 00 00 00 movl $0x0,-0x64(%ebp)
num = va_arg(ap, uintmax_t);
105992: 8b 58 fc mov -0x4(%eax),%ebx
105995: 89 45 14 mov %eax,0x14(%ebp)
105998: 89 4d 88 mov %ecx,-0x78(%ebp)
10599b: 89 5d 8c mov %ebx,-0x74(%ebp)
10599e: e9 fe fc ff ff jmp 1056a1 <_IO_Vprintf+0x261>
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
1059a3: c7 45 9c 00 00 00 00 movl $0x0,-0x64(%ebp)
sharpflag = (width == 0);
1059aa: 8b 45 94 mov -0x6c(%ebp),%eax
goto number;
1059ad: c7 45 b0 10 00 00 00 movl $0x10,-0x50(%ebp)
1059b4: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp)
sharpflag = (width == 0);
1059bb: 85 c0 test %eax,%eax
num = (uintptr_t)va_arg(ap, void *);
1059bd: 8b 45 14 mov 0x14(%ebp),%eax
sharpflag = (width == 0);
1059c0: 0f 94 45 80 sete -0x80(%ebp)
num = (uintptr_t)va_arg(ap, void *);
1059c4: 31 d2 xor %edx,%edx
1059c6: 89 55 8c mov %edx,-0x74(%ebp)
sign = 0; dot = 0; dwidth = 0; upper = 0;
1059c9: 31 d2 xor %edx,%edx
num = (uintptr_t)va_arg(ap, void *);
1059cb: 8b 00 mov (%eax),%eax
1059cd: 89 45 88 mov %eax,-0x78(%ebp)
1059d0: 8b 45 14 mov 0x14(%ebp),%eax
1059d3: 83 c0 04 add $0x4,%eax
1059d6: 89 45 14 mov %eax,0x14(%ebp)
base = 16;
1059d9: b8 10 00 00 00 mov $0x10,%eax
1059de: 89 85 7c ff ff ff mov %eax,-0x84(%ebp)
goto number;
1059e4: e9 b8 fc ff ff jmp 1056a1 <_IO_Vprintf+0x261>
p = va_arg(ap, char *);
1059e9: 8b 45 14 mov 0x14(%ebp),%eax
1059ec: 83 c0 04 add $0x4,%eax
1059ef: 89 45 a4 mov %eax,-0x5c(%ebp)
1059f2: 8b 45 14 mov 0x14(%ebp),%eax
1059f5: 8b 18 mov (%eax),%ebx
if (p == NULL)
1059f7: 85 db test %ebx,%ebx
1059f9: 0f 84 ec 04 00 00 je 105eeb <_IO_Vprintf+0xaab>
if (!ladjust && width > 0)
1059ff: 0f b6 55 98 movzbl -0x68(%ebp),%edx
if (!dot)
105a03: 8b 45 ac mov -0x54(%ebp),%eax
if (!ladjust && width > 0)
105a06: 80 f2 01 xor $0x1,%dl
105a09: 80 e2 01 and $0x1,%dl
if (!dot)
105a0c: 85 c0 test %eax,%eax
105a0e: 0f 85 e1 04 00 00 jne 105ef5 <_IO_Vprintf+0xab5>
n = strlen (p);
105a14: 89 1c 24 mov %ebx,(%esp)
105a17: 88 55 b0 mov %dl,-0x50(%ebp)
105a1a: e8 21 41 01 00 call 119b40 <strlen>
105a1f: 0f b6 55 b0 movzbl -0x50(%ebp),%edx
105a23: 89 c1 mov %eax,%ecx
width -= n;
105a25: 29 4d 94 sub %ecx,-0x6c(%ebp)
while (n--)
105a28: 8d 71 ff lea -0x1(%ecx),%esi
105a2b: 89 75 b0 mov %esi,-0x50(%ebp)
width -= n;
105a2e: 8b 45 94 mov -0x6c(%ebp),%eax
if (!ladjust && width > 0)
105a31: 85 c0 test %eax,%eax
105a33: 0f 9f c0 setg %al
105a36: 84 c0 test %al,%al
105a38: 74 08 je 105a42 <_IO_Vprintf+0x602>
105a3a: 84 d2 test %dl,%dl
105a3c: 0f 85 eb 04 00 00 jne 105f2d <_IO_Vprintf+0xaed>
if (ladjust && width > 0)
105a42: 0f b6 55 98 movzbl -0x68(%ebp),%edx
105a46: 20 d0 and %dl,%al
while (n--)
105a48: 85 c9 test %ecx,%ecx
if (ladjust && width > 0)
105a4a: 88 45 a8 mov %al,-0x58(%ebp)
while (n--)
105a4d: 0f 84 b7 05 00 00 je 10600a <_IO_Vprintf+0xbca>
if (ladjust && width > 0)
105a53: 89 5d ac mov %ebx,-0x54(%ebp)
105a56: 8b 75 0c mov 0xc(%ebp),%esi
105a59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
PCHAR(*p++);
105a60: 89 74 24 04 mov %esi,0x4(%esp)
105a64: 43 inc %ebx
105a65: 0f be 53 ff movsbl -0x1(%ebx),%edx
105a69: 89 14 24 mov %edx,(%esp)
105a6c: ff d7 call *%edi
while (n--)
105a6e: 8b 4d ac mov -0x54(%ebp),%ecx
105a71: ba 01 00 00 00 mov $0x1,%edx
105a76: 29 da sub %ebx,%edx
105a78: 01 ca add %ecx,%edx
105a7a: 03 55 b0 add -0x50(%ebp),%edx
105a7d: 75 e1 jne 105a60 <_IO_Vprintf+0x620>
PCHAR(*p++);
105a7f: 8b 45 b0 mov -0x50(%ebp),%eax
105a82: 8b 75 bc mov -0x44(%ebp),%esi
105a85: 8d 74 30 01 lea 0x1(%eax,%esi,1),%esi
p = va_arg(ap, char *);
105a89: 8b 45 a4 mov -0x5c(%ebp),%eax
if (ladjust && width > 0)
105a8c: 80 7d a8 00 cmpb $0x0,-0x58(%ebp)
p = va_arg(ap, char *);
105a90: 89 45 14 mov %eax,0x14(%ebp)
if (ladjust && width > 0)
105a93: 0f 84 17 fb ff ff je 1055b0 <_IO_Vprintf+0x170>
while (width--)
105a99: 89 7d 08 mov %edi,0x8(%ebp)
105a9c: 8b 4d 94 mov -0x6c(%ebp),%ecx
105a9f: 89 f7 mov %esi,%edi
PCHAR(padc);
105aa1: 0f be 5d 87 movsbl -0x79(%ebp),%ebx
105aa5: 8b 75 08 mov 0x8(%ebp),%esi
105aa8: 89 4d bc mov %ecx,-0x44(%ebp)
while (width--)
105aab: 8d 41 ff lea -0x1(%ecx),%eax
105aae: 89 45 b0 mov %eax,-0x50(%ebp)
PCHAR(padc);
105ab1: 89 1c 24 mov %ebx,(%esp)
105ab4: 8b 45 0c mov 0xc(%ebp),%eax
105ab7: 89 44 24 04 mov %eax,0x4(%esp)
105abb: ff d6 call *%esi
while (width--)
105abd: ff 4d bc decl -0x44(%ebp)
105ac0: 75 ef jne 105ab1 <_IO_Vprintf+0x671>
PCHAR(padc);
105ac2: 89 75 08 mov %esi,0x8(%ebp)
105ac5: 8b 45 b0 mov -0x50(%ebp),%eax
105ac8: 89 fe mov %edi,%esi
105aca: 8b 7d 08 mov 0x8(%ebp),%edi
105acd: 8d 74 06 01 lea 0x1(%esi,%eax,1),%esi
p = va_arg(ap, char *);
105ad1: 8b 45 a4 mov -0x5c(%ebp),%eax
105ad4: 89 45 14 mov %eax,0x14(%ebp)
105ad7: e9 d4 fa ff ff jmp 1055b0 <_IO_Vprintf+0x170>
PCHAR(ch);
105adc: 8b 45 0c mov 0xc(%ebp),%eax
105adf: 89 44 24 04 mov %eax,0x4(%esp)
105ae3: 8b 45 b0 mov -0x50(%ebp),%eax
105ae6: 89 04 24 mov %eax,(%esp)
105ae9: ff d7 call *%edi
105aeb: 8b 75 bc mov -0x44(%ebp),%esi
105aee: 46 inc %esi
break;
105aef: e9 bc fa ff ff jmp 1055b0 <_IO_Vprintf+0x170>
dot = 1;
105af4: c7 45 ac 01 00 00 00 movl $0x1,-0x54(%ebp)
reswitch: switch (ch = (u_char)*fmt++) {
105afb: 8b 45 b8 mov -0x48(%ebp),%eax
105afe: 0f b6 50 01 movzbl 0x1(%eax),%edx
105b02: 8b 45 10 mov 0x10(%ebp),%eax
105b05: 89 45 b8 mov %eax,-0x48(%ebp)
105b08: e9 f3 f9 ff ff jmp 105500 <_IO_Vprintf+0xc0>
sharpflag = 1;
105b0d: c7 45 a8 01 00 00 00 movl $0x1,-0x58(%ebp) <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
105b14: 8b 45 b8 mov -0x48(%ebp),%eax <== NOT EXECUTED
105b17: 0f b6 50 01 movzbl 0x1(%eax),%edx <== NOT EXECUTED
105b1b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
105b1e: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED
goto reswitch;
105b21: e9 da f9 ff ff jmp 105500 <_IO_Vprintf+0xc0> <== NOT EXECUTED
ladjust = 1;
105b26: c7 45 98 01 00 00 00 movl $0x1,-0x68(%ebp)
reswitch: switch (ch = (u_char)*fmt++) {
105b2d: 8b 45 b8 mov -0x48(%ebp),%eax
105b30: 0f b6 50 01 movzbl 0x1(%eax),%edx
105b34: 8b 45 10 mov 0x10(%ebp),%eax
105b37: 89 45 b8 mov %eax,-0x48(%ebp)
goto reswitch;
105b3a: e9 c1 f9 ff ff jmp 105500 <_IO_Vprintf+0xc0>
reswitch: switch (ch = (u_char)*fmt++) {
105b3f: c7 45 b0 10 00 00 00 movl $0x10,-0x50(%ebp)
base = 16;
105b46: b8 10 00 00 00 mov $0x10,%eax
upper = 1;
105b4b: ba 01 00 00 00 mov $0x1,%edx
reswitch: switch (ch = (u_char)*fmt++) {
105b50: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp)
base = 16;
105b57: 89 85 7c ff ff ff mov %eax,-0x84(%ebp)
105b5d: e9 0d fe ff ff jmp 10596f <_IO_Vprintf+0x52f>
if (!ladjust && width > 0)
105b62: 8b 45 94 mov -0x6c(%ebp),%eax
width = va_arg(ap, int);
105b65: 8b 75 14 mov 0x14(%ebp),%esi
if (!ladjust && width > 0)
105b68: 83 f8 01 cmp $0x1,%eax
105b6b: 0f 9f c3 setg %bl
width = va_arg(ap, int);
105b6e: 83 c6 04 add $0x4,%esi
if (!ladjust && width > 0)
105b71: f6 45 98 01 testb $0x1,-0x68(%ebp)
width = va_arg(ap, int);
105b75: 89 75 b0 mov %esi,-0x50(%ebp)
if (!ladjust && width > 0)
105b78: 75 08 jne 105b82 <_IO_Vprintf+0x742> <== NEVER TAKEN
105b7a: 84 db test %bl,%bl
105b7c: 0f 85 cc 02 00 00 jne 105e4e <_IO_Vprintf+0xa0e> <== NEVER TAKEN
PCHAR(ch);
105b82: 8b 45 bc mov -0x44(%ebp),%eax
105b85: 8d 70 01 lea 0x1(%eax),%esi
PCHAR(va_arg(ap, int));
105b88: 8b 45 0c mov 0xc(%ebp),%eax
105b8b: 89 44 24 04 mov %eax,0x4(%esp)
105b8f: 8b 45 14 mov 0x14(%ebp),%eax
105b92: 8b 00 mov (%eax),%eax
105b94: 89 04 24 mov %eax,(%esp)
105b97: ff d7 call *%edi
if (ladjust && width > 0)
105b99: f6 45 98 01 testb $0x1,-0x68(%ebp)
105b9d: 0f 84 e4 02 00 00 je 105e87 <_IO_Vprintf+0xa47> <== ALWAYS TAKEN
105ba3: 84 db test %bl,%bl <== NOT EXECUTED
105ba5: 0f 84 dc 02 00 00 je 105e87 <_IO_Vprintf+0xa47> <== NOT EXECUTED
while (width--)
105bab: 8b 75 94 mov -0x6c(%ebp),%esi <== NOT EXECUTED
PCHAR(padc);
105bae: 0f be 5d 87 movsbl -0x79(%ebp),%ebx <== NOT EXECUTED
while (width--)
105bb2: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
105bb5: 89 75 ac mov %esi,-0x54(%ebp) <== NOT EXECUTED
PCHAR(padc);
105bb8: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105bbb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
105bbe: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
105bc2: ff d7 call *%edi <== NOT EXECUTED
while (width--)
105bc4: 83 ee 01 sub $0x1,%esi <== NOT EXECUTED
105bc7: 73 ef jae 105bb8 <_IO_Vprintf+0x778> <== NOT EXECUTED
PCHAR(padc);
105bc9: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED
105bcc: 8b 75 bc mov -0x44(%ebp),%esi <== NOT EXECUTED
105bcf: 8d 74 30 02 lea 0x2(%eax,%esi,1),%esi <== NOT EXECUTED
PCHAR(va_arg(ap, int));
105bd3: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED
105bd6: 89 45 14 mov %eax,0x14(%ebp) <== NOT EXECUTED
105bd9: e9 d2 f9 ff ff jmp 1055b0 <_IO_Vprintf+0x170> <== NOT EXECUTED
up = va_arg(ap, u_char *);
105bde: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
if (!width)
105be1: 8b 75 94 mov -0x6c(%ebp),%esi <== NOT EXECUTED
up = va_arg(ap, u_char *);
105be4: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
p = va_arg(ap, char *);
105be6: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
105be9: 89 45 a8 mov %eax,-0x58(%ebp) <== NOT EXECUTED
105bec: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
if (!width)
105bef: 85 f6 test %esi,%esi <== NOT EXECUTED
p = va_arg(ap, char *);
105bf1: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED
105bf4: 89 45 a4 mov %eax,-0x5c(%ebp) <== NOT EXECUTED
while(width--) {
105bf7: b8 0f 00 00 00 mov $0xf,%eax <== NOT EXECUTED
if (!width)
105bfc: 74 03 je 105c01 <_IO_Vprintf+0x7c1> <== NOT EXECUTED
while(width--) {
105bfe: 89 f0 mov %esi,%eax <== NOT EXECUTED
105c00: 48 dec %eax <== NOT EXECUTED
105c01: 89 5d b0 mov %ebx,-0x50(%ebp) <== NOT EXECUTED
105c04: 01 d8 add %ebx,%eax <== NOT EXECUTED
105c06: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
105c09: 89 45 ac mov %eax,-0x54(%ebp) <== NOT EXECUTED
PCHAR(hex2ascii(*up >> 4));
105c0c: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
105c10: 8b 75 b0 mov -0x50(%ebp),%esi <== NOT EXECUTED
105c13: 0f b6 06 movzbl (%esi),%eax <== NOT EXECUTED
105c16: c0 e8 04 shr $0x4,%al <== NOT EXECUTED
105c19: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
105c1c: 0f be 80 40 54 12 00 movsbl 0x125440(%eax),%eax <== NOT EXECUTED
105c23: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105c26: ff d7 call *%edi <== NOT EXECUTED
PCHAR(hex2ascii(*up & 0x0f));
105c28: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
105c2c: 89 75 b0 mov %esi,-0x50(%ebp) <== NOT EXECUTED
105c2f: 0f b6 06 movzbl (%esi),%eax <== NOT EXECUTED
105c32: 83 e0 0f and $0xf,%eax <== NOT EXECUTED
105c35: 0f be 80 40 54 12 00 movsbl 0x125440(%eax),%eax <== NOT EXECUTED
105c3c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105c3f: ff d7 call *%edi <== NOT EXECUTED
105c41: 8b 4d bc mov -0x44(%ebp),%ecx <== NOT EXECUTED
if (width)
105c44: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED
105c47: 3b 45 ac cmp -0x54(%ebp),%eax <== NOT EXECUTED
PCHAR(hex2ascii(*up & 0x0f));
105c4a: 8d 71 02 lea 0x2(%ecx),%esi <== NOT EXECUTED
if (width)
105c4d: 0f 85 dd 00 00 00 jne 105d30 <_IO_Vprintf+0x8f0> <== NOT EXECUTED
p = va_arg(ap, char *);
105c53: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED
105c56: 89 45 14 mov %eax,0x14(%ebp) <== NOT EXECUTED
105c59: e9 52 f9 ff ff jmp 1055b0 <_IO_Vprintf+0x170> <== NOT EXECUTED
width = va_arg(ap, int);
105c5e: 8b 45 14 mov 0x14(%ebp),%eax
105c61: 8b 55 14 mov 0x14(%ebp),%edx
105c64: 83 c0 04 add $0x4,%eax
if (!dot) {
105c67: 83 7d ac 00 cmpl $0x0,-0x54(%ebp)
width = va_arg(ap, int);
105c6b: 8b 12 mov (%edx),%edx
if (!dot) {
105c6d: 0f 85 70 02 00 00 jne 105ee3 <_IO_Vprintf+0xaa3> <== ALWAYS TAKEN
width = va_arg(ap, int);
105c73: 89 55 94 mov %edx,-0x6c(%ebp) <== NOT EXECUTED
if (width < 0) {
105c76: 85 d2 test %edx,%edx <== NOT EXECUTED
105c78: 79 07 jns 105c81 <_IO_Vprintf+0x841> <== NOT EXECUTED
width = -width;
105c7a: 83 75 98 01 xorl $0x1,-0x68(%ebp) <== NOT EXECUTED
105c7e: f7 5d 94 negl -0x6c(%ebp) <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
105c81: 8b 55 b8 mov -0x48(%ebp),%edx <== NOT EXECUTED
width = va_arg(ap, int);
105c84: 89 45 14 mov %eax,0x14(%ebp) <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
105c87: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
105c8a: 0f b6 52 01 movzbl 0x1(%edx),%edx <== NOT EXECUTED
105c8e: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED
105c91: e9 6a f8 ff ff jmp 105500 <_IO_Vprintf+0xc0> <== NOT EXECUTED
105c96: c7 45 b0 0a 00 00 00 movl $0xa,-0x50(%ebp)
base = 10;
105c9d: b8 0a 00 00 00 mov $0xa,%eax
sign = 0; dot = 0; dwidth = 0; upper = 0;
105ca2: 31 d2 xor %edx,%edx
reswitch: switch (ch = (u_char)*fmt++) {
105ca4: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp)
base = 10;
105cab: 89 85 7c ff ff ff mov %eax,-0x84(%ebp)
105cb1: e9 b9 fc ff ff jmp 10596f <_IO_Vprintf+0x52f>
reswitch: switch (ch = (u_char)*fmt++) {
105cb6: c7 45 b0 10 00 00 00 movl $0x10,-0x50(%ebp) <== NOT EXECUTED
105cbd: ba 10 00 00 00 mov $0x10,%edx <== NOT EXECUTED
105cc2: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp) <== NOT EXECUTED
105cc9: 89 95 7c ff ff ff mov %edx,-0x84(%ebp) <== NOT EXECUTED
105ccf: e9 83 f9 ff ff jmp 105657 <_IO_Vprintf+0x217> <== NOT EXECUTED
105cd4: c7 45 b0 10 00 00 00 movl $0x10,-0x50(%ebp)
105cdb: b8 10 00 00 00 mov $0x10,%eax
105ce0: 31 d2 xor %edx,%edx
105ce2: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp)
105ce9: 89 85 7c ff ff ff mov %eax,-0x84(%ebp)
105cef: e9 7b fc ff ff jmp 10596f <_IO_Vprintf+0x52f>
105cf4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105cfb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
105cff: 90 nop
static inline int imax(int a, int b) { return (a > b ? a : b); }
105d00: 8b 75 90 mov -0x70(%ebp),%esi
105d03: 39 de cmp %ebx,%esi
105d05: 89 f0 mov %esi,%eax
105d07: 7d 02 jge 105d0b <_IO_Vprintf+0x8cb>
105d09: 89 d8 mov %ebx,%eax
width -= tmp + imax(dwidth, n);
105d0b: 01 c2 add %eax,%edx
105d0d: 8b 45 94 mov -0x6c(%ebp),%eax
dwidth -= n;
105d10: 8b 75 90 mov -0x70(%ebp),%esi
width -= tmp + imax(dwidth, n);
105d13: 29 d0 sub %edx,%eax
105d15: 89 45 a8 mov %eax,-0x58(%ebp)
if (!ladjust)
105d18: 8b 45 98 mov -0x68(%ebp),%eax
dwidth -= n;
105d1b: 29 de sub %ebx,%esi
if (!ladjust)
105d1d: 85 c0 test %eax,%eax
105d1f: 0f 85 b4 fa ff ff jne 1057d9 <_IO_Vprintf+0x399> <== NEVER TAKEN
105d25: e9 5c fa ff ff jmp 105786 <_IO_Vprintf+0x346>
105d2a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for (q=p;*q;q++)
105d30: 8b 4d a4 mov -0x5c(%ebp),%ecx <== NOT EXECUTED
105d33: 0f be 01 movsbl (%ecx),%eax <== NOT EXECUTED
105d36: 84 c0 test %al,%al <== NOT EXECUTED
105d38: 74 2c je 105d66 <_IO_Vprintf+0x926> <== NOT EXECUTED
105d3a: 8b 55 bc mov -0x44(%ebp),%edx <== NOT EXECUTED
105d3d: 29 d1 sub %edx,%ecx <== NOT EXECUTED
105d3f: 89 4d bc mov %ecx,-0x44(%ebp) <== NOT EXECUTED
105d42: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
105d49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
PCHAR(*q);
105d50: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105d53: 46 inc %esi <== NOT EXECUTED
105d54: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
105d58: ff d7 call *%edi <== NOT EXECUTED
for (q=p;*q;q++)
105d5a: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED
105d5d: 0f be 44 30 fe movsbl -0x2(%eax,%esi,1),%eax <== NOT EXECUTED
105d62: 84 c0 test %al,%al <== NOT EXECUTED
105d64: 75 ea jne 105d50 <_IO_Vprintf+0x910> <== NOT EXECUTED
up++;
105d66: ff 45 b0 incl -0x50(%ebp) <== NOT EXECUTED
105d69: 89 75 bc mov %esi,-0x44(%ebp) <== NOT EXECUTED
105d6c: e9 9b fe ff ff jmp 105c0c <_IO_Vprintf+0x7cc> <== NOT EXECUTED
else if (lflag)
105d71: 8b 5d a4 mov -0x5c(%ebp),%ebx
width = va_arg(ap, int);
105d74: 8d 48 04 lea 0x4(%eax),%ecx
else if (lflag)
105d77: 85 db test %ebx,%ebx
105d79: 0f 85 8b 00 00 00 jne 105e0a <_IO_Vprintf+0x9ca>
else if (hflag)
105d7f: 8b 75 a0 mov -0x60(%ebp),%esi
num = (u_short)va_arg(ap, int);
105d82: 8b 45 14 mov 0x14(%ebp),%eax
else if (hflag)
105d85: 85 f6 test %esi,%esi
105d87: 0f 84 36 01 00 00 je 105ec3 <_IO_Vprintf+0xa83>
num = (u_short)va_arg(ap, int);
105d8d: c7 45 8c 00 00 00 00 movl $0x0,-0x74(%ebp)
105d94: 0f b7 00 movzwl (%eax),%eax
105d97: 89 4d 14 mov %ecx,0x14(%ebp)
105d9a: 89 45 88 mov %eax,-0x78(%ebp)
105d9d: e9 ff f8 ff ff jmp 1056a1 <_IO_Vprintf+0x261>
while (width-- > 0)
105da2: 8b 45 a8 mov -0x58(%ebp),%eax
105da5: 8d 58 ff lea -0x1(%eax),%ebx
105da8: 85 c0 test %eax,%eax
105daa: 89 5d bc mov %ebx,-0x44(%ebp)
105dad: 0f 8e fd f7 ff ff jle 1055b0 <_IO_Vprintf+0x170> <== NEVER TAKEN
105db3: 89 75 b0 mov %esi,-0x50(%ebp)
105db6: 89 de mov %ebx,%esi
105db8: 8b 5d 0c mov 0xc(%ebp),%ebx
105dbb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
105dbf: 90 nop
PCHAR(' ');
105dc0: 89 5c 24 04 mov %ebx,0x4(%esp)
105dc4: c7 04 24 20 00 00 00 movl $0x20,(%esp)
105dcb: ff d7 call *%edi
while (width-- > 0)
105dcd: 83 ee 01 sub $0x1,%esi
105dd0: 73 ee jae 105dc0 <_IO_Vprintf+0x980>
PCHAR(' ');
105dd2: 8b 75 b0 mov -0x50(%ebp),%esi
105dd5: 8b 45 bc mov -0x44(%ebp),%eax
105dd8: 8d 74 06 01 lea 0x1(%esi,%eax,1),%esi
105ddc: e9 cf f7 ff ff jmp 1055b0 <_IO_Vprintf+0x170>
tmp++;
105de1: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
105de6: e9 67 f9 ff ff jmp 105752 <_IO_Vprintf+0x312> <== NOT EXECUTED
105deb: 88 4d ac mov %cl,-0x54(%ebp) <== NOT EXECUTED
PCHAR('0');
105dee: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
105df1: c7 04 24 30 00 00 00 movl $0x30,(%esp) <== NOT EXECUTED
105df8: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
105dfc: ff d7 call *%edi <== NOT EXECUTED
105dfe: 0f be 4d ac movsbl -0x54(%ebp),%ecx <== NOT EXECUTED
105e02: ff 45 bc incl -0x44(%ebp) <== NOT EXECUTED
105e05: e9 46 fa ff ff jmp 105850 <_IO_Vprintf+0x410> <== NOT EXECUTED
num = va_arg(ap, u_int);
105e0a: 8b 18 mov (%eax),%ebx
105e0c: 31 f6 xor %esi,%esi
105e0e: 89 75 8c mov %esi,-0x74(%ebp)
105e11: 89 4d 14 mov %ecx,0x14(%ebp)
105e14: 89 5d 88 mov %ebx,-0x78(%ebp)
105e17: e9 85 f8 ff ff jmp 1056a1 <_IO_Vprintf+0x261>
else if (tflag)
105e1c: 8b 75 a4 mov -0x5c(%ebp),%esi
width = va_arg(ap, int);
105e1f: 8d 48 04 lea 0x4(%eax),%ecx
else if (tflag)
105e22: 85 f6 test %esi,%esi
105e24: 75 6c jne 105e92 <_IO_Vprintf+0xa52>
else if (hflag)
105e26: 8b 5d a0 mov -0x60(%ebp),%ebx
num = (short)va_arg(ap, int);
105e29: 8b 45 14 mov 0x14(%ebp),%eax
else if (hflag)
105e2c: 85 db test %ebx,%ebx
105e2e: 0f 84 64 01 00 00 je 105f98 <_IO_Vprintf+0xb58> <== ALWAYS TAKEN
num = (short)va_arg(ap, int);
105e34: 89 4d 14 mov %ecx,0x14(%ebp) <== NOT EXECUTED
105e37: 0f bf 00 movswl (%eax),%eax <== NOT EXECUTED
105e3a: 89 45 88 mov %eax,-0x78(%ebp) <== NOT EXECUTED
105e3d: 99 cltd <== NOT EXECUTED
105e3e: 89 55 8c mov %edx,-0x74(%ebp) <== NOT EXECUTED
105e41: e9 33 f8 ff ff jmp 105679 <_IO_Vprintf+0x239> <== NOT EXECUTED
while (*p)
105e46: 8b 75 bc mov -0x44(%ebp),%esi <== NOT EXECUTED
105e49: e9 6f fa ff ff jmp 1058bd <_IO_Vprintf+0x47d> <== NOT EXECUTED
PCHAR(padc);
105e4e: 0f be 5d 87 movsbl -0x79(%ebp),%ebx <== NOT EXECUTED
while (width--)
105e52: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED
105e55: 89 45 ac mov %eax,-0x54(%ebp) <== NOT EXECUTED
105e58: 89 c6 mov %eax,%esi <== NOT EXECUTED
PCHAR(padc);
105e5a: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
105e5d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
105e60: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
105e64: ff d7 call *%edi <== NOT EXECUTED
while (width--)
105e66: 83 ee 01 sub $0x1,%esi <== NOT EXECUTED
105e69: 73 ef jae 105e5a <_IO_Vprintf+0xa1a> <== NOT EXECUTED
105e6b: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED
105e6e: 8b 75 ac mov -0x54(%ebp),%esi <== NOT EXECUTED
105e71: 01 c6 add %eax,%esi <== NOT EXECUTED
PCHAR(va_arg(ap, int));
105e73: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
105e76: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
105e79: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
105e7d: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
105e80: 8b 00 mov (%eax),%eax <== NOT EXECUTED
105e82: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105e85: ff d7 call *%edi <== NOT EXECUTED
105e87: 8b 45 b0 mov -0x50(%ebp),%eax
105e8a: 89 45 14 mov %eax,0x14(%ebp)
105e8d: e9 1e f7 ff ff jmp 1055b0 <_IO_Vprintf+0x170>
num = va_arg(ap, int);
105e92: 8b 00 mov (%eax),%eax
105e94: 89 4d 14 mov %ecx,0x14(%ebp)
105e97: 89 45 88 mov %eax,-0x78(%ebp)
105e9a: 99 cltd
105e9b: 89 55 8c mov %edx,-0x74(%ebp)
105e9e: e9 d6 f7 ff ff jmp 105679 <_IO_Vprintf+0x239>
105ea3: 89 45 90 mov %eax,-0x70(%ebp)
105ea6: e9 55 f6 ff ff jmp 105500 <_IO_Vprintf+0xc0>
cflag = 1;
105eab: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED
hflag = 0;
105eae: c7 45 a0 00 00 00 00 movl $0x0,-0x60(%ebp) <== NOT EXECUTED
cflag = 1;
105eb5: 89 45 88 mov %eax,-0x78(%ebp) <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
105eb8: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
105ebb: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED
105ebe: e9 3d f6 ff ff jmp 105500 <_IO_Vprintf+0xc0> <== NOT EXECUTED
else if (cflag)
105ec3: 8b 5d 88 mov -0x78(%ebp),%ebx
105ec6: 85 db test %ebx,%ebx
105ec8: 0f 84 3c ff ff ff je 105e0a <_IO_Vprintf+0x9ca>
num = (u_char)va_arg(ap, int);
105ece: c7 45 8c 00 00 00 00 movl $0x0,-0x74(%ebp)
105ed5: 0f b6 00 movzbl (%eax),%eax
105ed8: 89 4d 14 mov %ecx,0x14(%ebp)
105edb: 89 45 88 mov %eax,-0x78(%ebp)
105ede: e9 be f7 ff ff jmp 1056a1 <_IO_Vprintf+0x261>
dwidth = va_arg(ap, int);
105ee3: 89 55 90 mov %edx,-0x70(%ebp)
105ee6: e9 96 fd ff ff jmp 105c81 <_IO_Vprintf+0x841>
p = "(null)";
105eeb: bb c7 52 12 00 mov $0x1252c7,%ebx
105ef0: e9 0a fb ff ff jmp 1059ff <_IO_Vprintf+0x5bf>
for (n = 0; n < dwidth && p[n]; n++)
105ef5: 8b 75 90 mov -0x70(%ebp),%esi
105ef8: 31 c9 xor %ecx,%ecx
105efa: 85 f6 test %esi,%esi
105efc: 0f 8e 40 01 00 00 jle 106042 <_IO_Vprintf+0xc02> <== NEVER TAKEN
105f02: 80 3c 0b 00 cmpb $0x0,(%ebx,%ecx,1)
105f06: 0f 84 19 fb ff ff je 105a25 <_IO_Vprintf+0x5e5> <== NEVER TAKEN
105f0c: 8d 41 01 lea 0x1(%ecx),%eax
105f0f: 3b 45 90 cmp -0x70(%ebp),%eax
105f12: 0f 84 08 01 00 00 je 106020 <_IO_Vprintf+0xbe0>
105f18: 89 c1 mov %eax,%ecx
105f1a: 80 3c 0b 00 cmpb $0x0,(%ebx,%ecx,1)
105f1e: 0f 84 01 fb ff ff je 105a25 <_IO_Vprintf+0x5e5>
105f24: eb e6 jmp 105f0c <_IO_Vprintf+0xacc>
if (!ladjust && width > 0)
105f26: c7 45 b0 ff ff ff ff movl $0xffffffff,-0x50(%ebp) <== NOT EXECUTED
while (width--)
105f2d: 89 7d 08 mov %edi,0x8(%ebp)
105f30: 8b 75 94 mov -0x6c(%ebp),%esi
105f33: 89 df mov %ebx,%edi
105f35: 89 4d a0 mov %ecx,-0x60(%ebp)
105f38: 8d 46 ff lea -0x1(%esi),%eax
105f3b: 89 f3 mov %esi,%ebx
105f3d: 8b 75 08 mov 0x8(%ebp),%esi
105f40: 89 45 a8 mov %eax,-0x58(%ebp)
PCHAR(padc);
105f43: 0f be 45 87 movsbl -0x79(%ebp),%eax
105f47: 89 45 ac mov %eax,-0x54(%ebp)
PCHAR(padc);
105f4a: 8b 45 0c mov 0xc(%ebp),%eax
105f4d: 89 44 24 04 mov %eax,0x4(%esp)
105f51: 8b 45 ac mov -0x54(%ebp),%eax
105f54: 89 04 24 mov %eax,(%esp)
105f57: ff d6 call *%esi
while (width--)
105f59: 4b dec %ebx
105f5a: 75 ee jne 105f4a <_IO_Vprintf+0xb0a>
PCHAR(padc);
105f5c: 8b 45 a8 mov -0x58(%ebp),%eax
105f5f: 89 fb mov %edi,%ebx
105f61: 89 f7 mov %esi,%edi
while (n--)
105f63: c6 45 a8 00 movb $0x0,-0x58(%ebp)
PCHAR(padc);
105f67: 8b 75 bc mov -0x44(%ebp),%esi
while (n--)
105f6a: c7 45 94 ff ff ff ff movl $0xffffffff,-0x6c(%ebp)
105f71: 8b 4d a0 mov -0x60(%ebp),%ecx
PCHAR(padc);
105f74: 8d 44 30 01 lea 0x1(%eax,%esi,1),%eax
105f78: 89 45 bc mov %eax,-0x44(%ebp)
while (n--)
105f7b: 85 c9 test %ecx,%ecx
105f7d: 0f 85 d0 fa ff ff jne 105a53 <_IO_Vprintf+0x613> <== ALWAYS TAKEN
105f83: c7 45 b4 00 00 00 00 movl $0x0,-0x4c(%ebp) <== NOT EXECUTED
p = va_arg(ap, char *);
105f8a: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED
PCHAR(padc);
105f8d: 8b 75 bc mov -0x44(%ebp),%esi <== NOT EXECUTED
p = va_arg(ap, char *);
105f90: 89 45 14 mov %eax,0x14(%ebp) <== NOT EXECUTED
105f93: e9 18 f6 ff ff jmp 1055b0 <_IO_Vprintf+0x170> <== NOT EXECUTED
else if (cflag)
105f98: 8b 55 88 mov -0x78(%ebp),%edx
105f9b: 85 d2 test %edx,%edx
105f9d: 0f 84 ef fe ff ff je 105e92 <_IO_Vprintf+0xa52> <== ALWAYS TAKEN
num = (char)va_arg(ap, int);
105fa3: 89 4d 14 mov %ecx,0x14(%ebp) <== NOT EXECUTED
105fa6: 0f be 00 movsbl (%eax),%eax <== NOT EXECUTED
105fa9: 89 45 88 mov %eax,-0x78(%ebp) <== NOT EXECUTED
105fac: 99 cltd <== NOT EXECUTED
105fad: 89 55 8c mov %edx,-0x74(%ebp) <== NOT EXECUTED
105fb0: e9 c4 f6 ff ff jmp 105679 <_IO_Vprintf+0x239> <== NOT EXECUTED
n = n * 10 + ch - '0';
105fb5: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED
105fb8: 83 e8 30 sub $0x30,%eax <== NOT EXECUTED
105fbb: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED
ch = *fmt;
105fbe: 8b 45 b8 mov -0x48(%ebp),%eax <== NOT EXECUTED
105fc1: 0f b6 50 01 movzbl 0x1(%eax),%edx <== NOT EXECUTED
105fc5: 0f be c2 movsbl %dl,%eax <== NOT EXECUTED
105fc8: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED
if (ch < '0' || ch > '9')
105fcb: 83 e8 30 sub $0x30,%eax <== NOT EXECUTED
105fce: 83 f8 09 cmp $0x9,%eax <== NOT EXECUTED
105fd1: 0f 86 07 f6 ff ff jbe 1055de <_IO_Vprintf+0x19e> <== NOT EXECUTED
n = n * 10 + ch - '0';
105fd7: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED
105fda: 89 45 90 mov %eax,-0x70(%ebp) <== NOT EXECUTED
reswitch: switch (ch = (u_char)*fmt++) {
105fdd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
105fe0: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED
105fe3: e9 18 f5 ff ff jmp 105500 <_IO_Vprintf+0xc0> <== NOT EXECUTED
while (width-- > 0)
105fe8: 89 5d a8 mov %ebx,-0x58(%ebp)
105feb: e9 e9 f7 ff ff jmp 1057d9 <_IO_Vprintf+0x399>
reswitch: switch (ch = (u_char)*fmt++) {
105ff0: 8b 45 10 mov 0x10(%ebp),%eax
105ff3: 89 45 b8 mov %eax,-0x48(%ebp)
105ff6: e9 2e f6 ff ff jmp 105629 <_IO_Vprintf+0x1e9>
stop = 1;
105ffb: c7 45 b4 01 00 00 00 movl $0x1,-0x4c(%ebp) <== NOT EXECUTED
while (percent < fmt)
106002: 8b 75 bc mov -0x44(%ebp),%esi <== NOT EXECUTED
106005: e9 a6 f5 ff ff jmp 1055b0 <_IO_Vprintf+0x170> <== NOT EXECUTED
while (n--)
10600a: 8b 75 bc mov -0x44(%ebp),%esi
10600d: e9 77 fa ff ff jmp 105a89 <_IO_Vprintf+0x649>
lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
106012: c7 45 9c 00 00 00 00 movl $0x0,-0x64(%ebp)
106019: 31 d2 xor %edx,%edx
10601b: e9 81 f6 ff ff jmp 1056a1 <_IO_Vprintf+0x261>
width -= n;
106020: 8b 75 90 mov -0x70(%ebp),%esi
106023: 29 75 94 sub %esi,-0x6c(%ebp)
106026: 8b 45 94 mov -0x6c(%ebp),%eax
if (!ladjust && width > 0)
106029: 85 c0 test %eax,%eax
10602b: 0f 9f c0 setg %al
10602e: 7e 04 jle 106034 <_IO_Vprintf+0xbf4> <== ALWAYS TAKEN
106030: 84 d2 test %dl,%dl <== NOT EXECUTED
106032: 75 2d jne 106061 <_IO_Vprintf+0xc21> <== NOT EXECUTED
if (ladjust && width > 0)
106034: 22 45 98 and -0x68(%ebp),%al
106037: 89 4d b0 mov %ecx,-0x50(%ebp)
10603a: 88 45 a8 mov %al,-0x58(%ebp)
10603d: e9 11 fa ff ff jmp 105a53 <_IO_Vprintf+0x613>
if (!ladjust && width > 0)
106042: 83 7d 94 00 cmpl $0x0,-0x6c(%ebp) <== NOT EXECUTED
106046: 0f 9f c0 setg %al <== NOT EXECUTED
106049: 7e 08 jle 106053 <_IO_Vprintf+0xc13> <== NOT EXECUTED
10604b: 84 d2 test %dl,%dl <== NOT EXECUTED
10604d: 0f 85 d3 fe ff ff jne 105f26 <_IO_Vprintf+0xae6> <== NOT EXECUTED
if (ladjust && width > 0)
106053: 22 45 98 and -0x68(%ebp),%al <== NOT EXECUTED
106056: 8b 75 bc mov -0x44(%ebp),%esi <== NOT EXECUTED
106059: 88 45 a8 mov %al,-0x58(%ebp) <== NOT EXECUTED
10605c: e9 28 fa ff ff jmp 105a89 <_IO_Vprintf+0x649> <== NOT EXECUTED
if (!ladjust && width > 0)
106061: 89 4d b0 mov %ecx,-0x50(%ebp) <== NOT EXECUTED
106064: 8b 4d 90 mov -0x70(%ebp),%ecx <== NOT EXECUTED
106067: e9 c1 fe ff ff jmp 105f2d <_IO_Vprintf+0xaed> <== NOT EXECUTED
10606c: 90 nop
10606d: 90 nop
10606e: 90 nop
10606f: 90 nop
00118b80 <_Memory_Allocate>:
void *_Memory_Allocate(
const Memory_Information *information,
uintptr_t size,
uintptr_t alignment
)
{
118b80: 55 push %ebp
118b81: 89 e5 mov %esp,%ebp
118b83: 57 push %edi
118b84: 8b 45 08 mov 0x8(%ebp),%eax
118b87: 56 push %esi
118b88: 53 push %ebx
118b89: 8b 5d 10 mov 0x10(%ebp),%ebx
Memory_Area *area;
const Memory_Area *end;
uintptr_t alignment_mask;
area = &information->areas[ 0 ];
118b8c: 8b 50 04 mov 0x4(%eax),%edx
end = &information->areas[ information->count ];
118b8f: 8b 00 mov (%eax),%eax
118b91: 8d 04 40 lea (%eax,%eax,2),%eax
118b94: 8d 34 82 lea (%edx,%eax,4),%esi
alignment_mask = alignment - 1;
while ( area != end ) {
118b97: 39 f2 cmp %esi,%edx
118b99: 74 45 je 118be0 <_Memory_Allocate+0x60> <== NEVER TAKEN
118b9b: 8d 7b ff lea -0x1(%ebx),%edi
118b9e: f7 db neg %ebx
118ba0: eb 15 jmp 118bb7 <_Memory_Allocate+0x37>
118ba2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118ba9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
area->free = (void *) alloc_end;
return (void *) alloc_begin;
}
++area;
118bb0: 83 c2 0c add $0xc,%edx <== NOT EXECUTED
while ( area != end ) {
118bb3: 39 d6 cmp %edx,%esi <== NOT EXECUTED
118bb5: 74 29 je 118be0 <_Memory_Allocate+0x60> <== NOT EXECUTED
alloc_begin += alignment_mask;
118bb7: 8b 42 04 mov 0x4(%edx),%eax
118bba: 01 f8 add %edi,%eax
alloc_begin &= ~alignment_mask;
118bbc: 21 d8 and %ebx,%eax
alloc_end = alloc_begin + size;
118bbe: 89 c1 mov %eax,%ecx
118bc0: 03 4d 0c add 0xc(%ebp),%ecx
118bc3: 72 eb jb 118bb0 <_Memory_Allocate+0x30> <== NEVER TAKEN
if ( alloc_begin <= alloc_end && alloc_end <= (uintptr_t) area->end ) {
118bc5: 39 4a 08 cmp %ecx,0x8(%edx)
118bc8: 72 e6 jb 118bb0 <_Memory_Allocate+0x30> <== NEVER TAKEN
area->free = (void *) alloc_end;
118bca: 89 4a 04 mov %ecx,0x4(%edx)
}
return NULL;
}
118bcd: 5b pop %ebx
118bce: 5e pop %esi
118bcf: 5f pop %edi
118bd0: 5d pop %ebp
118bd1: c3 ret
118bd2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118bd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118be0: 5b pop %ebx <== NOT EXECUTED
return NULL;
118be1: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
118be3: 5e pop %esi <== NOT EXECUTED
118be4: 5f pop %edi <== NOT EXECUTED
118be5: 5d pop %ebp <== NOT EXECUTED
118be6: c3 ret <== NOT EXECUTED
118be7: 90 nop
118be8: 90 nop
118be9: 90 nop
118bea: 90 nop
118beb: 90 nop
118bec: 90 nop
118bed: 90 nop
118bee: 90 nop
118bef: 90 nop
00105480 <_Memory_Fill>:
#include <rtems/score/memory.h>
#include <string.h>
void _Memory_Fill( const Memory_Information *information, int c )
{
105480: 55 push %ebp
105481: 89 e5 mov %esp,%ebp
105483: 57 push %edi
105484: 56 push %esi
105485: 53 push %ebx
105486: 83 ec 04 sub $0x4,%esp
105489: 8b 45 08 mov 0x8(%ebp),%eax
10548c: 8b 5d 0c mov 0xc(%ebp),%ebx
Memory_Area *area;
const Memory_Area *end;
area = &information->areas[ 0 ];
10548f: 8b 70 04 mov 0x4(%eax),%esi
end = &information->areas[ information->count ];
105492: 8b 00 mov (%eax),%eax
105494: 8d 04 40 lea (%eax,%eax,2),%eax
105497: 8d 04 86 lea (%esi,%eax,4),%eax
10549a: 89 45 f0 mov %eax,-0x10(%ebp)
while ( area != end ) {
10549d: 39 c6 cmp %eax,%esi
10549f: 74 35 je 1054d6 <_Memory_Fill+0x56> <== NEVER TAKEN
memset( _Memory_Get_free_begin( area ), c, _Memory_Get_free_size( area ) );
1054a1: 0f b6 c3 movzbl %bl,%eax
1054a4: 69 c0 01 01 01 01 imul $0x1010101,%eax,%eax
1054aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*
* @return The free memory area size in bytes of the memory area.
*/
RTEMS_INLINE_ROUTINE uintptr_t _Memory_Get_free_size( const Memory_Area *area )
{
return (uintptr_t) area->end - (uintptr_t) area->free;
1054b0: 8b 4e 04 mov 0x4(%esi),%ecx
1054b3: 8b 56 08 mov 0x8(%esi),%edx
1054b6: 89 cf mov %ecx,%edi
1054b8: 29 ca sub %ecx,%edx
1054ba: 83 fa 08 cmp $0x8,%edx
1054bd: 73 21 jae 1054e0 <_Memory_Fill+0x60> <== ALWAYS TAKEN
1054bf: 83 e2 07 and $0x7,%edx
1054c2: 74 0a je 1054ce <_Memory_Fill+0x4e> <== ALWAYS TAKEN
1054c4: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
1054c6: 88 1c 0f mov %bl,(%edi,%ecx,1) <== NOT EXECUTED
1054c9: 41 inc %ecx <== NOT EXECUTED
1054ca: 39 d1 cmp %edx,%ecx <== NOT EXECUTED
1054cc: 72 f8 jb 1054c6 <_Memory_Fill+0x46> <== NOT EXECUTED
++area;
1054ce: 83 c6 0c add $0xc,%esi
while ( area != end ) {
1054d1: 39 75 f0 cmp %esi,-0x10(%ebp)
1054d4: 75 da jne 1054b0 <_Memory_Fill+0x30> <== NEVER TAKEN
}
}
1054d6: 58 pop %eax
1054d7: 5b pop %ebx
1054d8: 5e pop %esi
1054d9: 5f pop %edi
1054da: 5d pop %ebp
1054db: c3 ret
1054dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
memset( _Memory_Get_free_begin( area ), c, _Memory_Get_free_size( area ) );
1054e0: f6 c1 01 test $0x1,%cl
1054e3: 75 2b jne 105510 <_Memory_Fill+0x90> <== NEVER TAKEN
1054e5: f7 c7 02 00 00 00 test $0x2,%edi
1054eb: 75 33 jne 105520 <_Memory_Fill+0xa0> <== NEVER TAKEN
1054ed: f7 c7 04 00 00 00 test $0x4,%edi
1054f3: 75 4b jne 105540 <_Memory_Fill+0xc0> <== NEVER TAKEN
1054f5: 89 d1 mov %edx,%ecx
1054f7: 83 e2 03 and $0x3,%edx
1054fa: c1 e9 02 shr $0x2,%ecx
1054fd: f3 ab rep stos %eax,%es:(%edi)
1054ff: eb be jmp 1054bf <_Memory_Fill+0x3f>
105501: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105508: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10550f: 90 nop
105510: 88 01 mov %al,(%ecx) <== NOT EXECUTED
105512: 47 inc %edi <== NOT EXECUTED
105513: 4a dec %edx <== NOT EXECUTED
105514: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
10551a: 74 d1 je 1054ed <_Memory_Fill+0x6d> <== NOT EXECUTED
10551c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
105520: 66 89 07 mov %ax,(%edi) <== NOT EXECUTED
105523: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
105526: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
105529: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
10552f: 74 c4 je 1054f5 <_Memory_Fill+0x75> <== NOT EXECUTED
105531: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
105538: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10553f: 90 nop <== NOT EXECUTED
105540: 89 07 mov %eax,(%edi) <== NOT EXECUTED
105542: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
105545: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
105548: eb ab jmp 1054f5 <_Memory_Fill+0x75> <== NOT EXECUTED
10554a: 90 nop
10554b: 90 nop
10554c: 90 nop
10554d: 90 nop
10554e: 90 nop
10554f: 90 nop
00107590 <_Mutex_Acquire_timed>:
int _Mutex_Acquire_timed(
struct _Mutex_Control *_mutex,
const struct timespec *abstime
)
{
107590: 55 push %ebp
107591: 89 e5 mov %esp,%ebp
107593: 83 ec 48 sub $0x48,%esp
107596: 89 5d fc mov %ebx,-0x4(%ebp)
107599: 8b 45 08 mov 0x8(%ebp),%eax
Thread_Control *executing;
Thread_Control *owner;
mutex = _Mutex_Get( _mutex );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
10759c: 9c pushf
10759d: fa cli
10759e: 5a pop %edx
executing = _Mutex_Queue_acquire_critical( mutex, &queue_context );
owner = mutex->Queue.Queue.owner;
if ( RTEMS_PREDICT_TRUE( owner == NULL ) ) {
10759f: 8b 48 0c mov 0xc(%eax),%ecx
1075a2: 8b 1d b8 b8 12 00 mov 0x12b8b8,%ebx
1075a8: 85 c9 test %ecx,%ecx
1075aa: 75 14 jne 1075c0 <_Mutex_Acquire_timed+0x30>
mutex->Queue.Queue.owner = executing;
1075ac: 89 58 0c mov %ebx,0xc(%eax)
_ISR_Local_enable( level );
1075af: 52 push %edx
1075b0: 9d popf
);
_Mutex_Acquire_slow( mutex, owner, executing, level, &queue_context );
return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
}
}
1075b1: 8b 5d fc mov -0x4(%ebp),%ebx
1075b4: 89 ec mov %ebp,%esp
return 0;
1075b6: 31 c0 xor %eax,%eax
}
1075b8: 5d pop %ebp
1075b9: c3 ret
1075ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1075c0: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED
queue_context->Timeout.arg = abstime;
1075c3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
_Thread_queue_Enqueue(
1075c6: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED
1075c9: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
1075cd: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
1075d0: ba c8 24 12 00 mov $0x1224c8,%edx <== NOT EXECUTED
1075d5: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
1075d9: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
1075dd: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1075e0: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
1075e3: c7 45 dc 30 97 10 00 movl $0x109730,-0x24(%ebp) <== NOT EXECUTED
queue_context->thread_state = thread_state;
1075ea: c7 45 d8 01 00 00 00 movl $0x1,-0x28(%ebp) <== NOT EXECUTED
queue_context->deadlock_callout = deadlock_callout;
1075f1: c7 45 f4 40 87 10 00 movl $0x108740,-0xc(%ebp) <== NOT EXECUTED
1075f8: e8 63 11 00 00 call 108760 <_Thread_queue_Enqueue> <== NOT EXECUTED
return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
1075fd: 8b 4b 4c mov 0x4c(%ebx),%ecx
}
107600: 8b 5d fc mov -0x4(%ebp),%ebx
107603: 89 ec mov %ebp,%esp
107605: 5d pop %ebp
return STATUS_GET_POSIX( _Thread_Wait_get_status( executing ) );
107606: 89 ca mov %ecx,%edx
107608: c1 fa 1f sar $0x1f,%edx
10760b: 0f b6 c2 movzbl %dl,%eax
10760e: 01 c8 add %ecx,%eax
107610: c1 f8 08 sar $0x8,%eax
}
107613: c3 ret
107614: 90 nop
107615: 90 nop
107616: 90 nop
107617: 90 nop
107618: 90 nop
107619: 90 nop
10761a: 90 nop
10761b: 90 nop
10761c: 90 nop
10761d: 90 nop
10761e: 90 nop
10761f: 90 nop
00109480 <_Objects_Extend_information>:
#include <string.h> /* for memcpy() */
Objects_Maximum _Objects_Extend_information(
Objects_Information *information
)
{
109480: 55 push %ebp
109481: 89 e5 mov %esp,%ebp
109483: 57 push %edi
109484: 56 push %esi
109485: 53 push %ebx
109486: 83 ec 4c sub $0x4c,%esp
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Extend_size(
const Objects_Information *information
)
{
return information->objects_per_block;
109489: 8b 45 08 mov 0x8(%ebp),%eax
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_maximum_index(
const Objects_Information *information
)
{
return _Objects_Get_index( information->maximum_id );
10948c: 8b 38 mov (%eax),%edi
return information->objects_per_block;
10948e: 0f b7 70 12 movzwl 0x12(%eax),%esi
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_index(
Objects_Id id
)
{
return
(Objects_Maximum)((id >> OBJECTS_INDEX_START_BIT) &
109492: 0f b7 c7 movzwl %di,%eax
109495: 89 45 d4 mov %eax,-0x2c(%ebp)
);
_Assert( _Objects_Is_auto_extend( information ) );
extend_count = _Objects_Extend_size( information );
old_maximum = _Objects_Get_maximum_index( information );
new_maximum = (uint32_t) old_maximum + extend_count;
109498: 8d 0c 06 lea (%esi,%eax,1),%ecx
10949b: 89 4d dc mov %ecx,-0x24(%ebp)
*/
do_extend = true;
index_base = extend_count;
block = 1;
if ( information->object_blocks == NULL ) {
10949e: 8b 4d 08 mov 0x8(%ebp),%ecx
1094a1: 8d 14 36 lea (%esi,%esi,1),%edx
1094a4: 89 55 e4 mov %edx,-0x1c(%ebp)
1094a7: 8b 49 28 mov 0x28(%ecx),%ecx
1094aa: 85 c9 test %ecx,%ecx
1094ac: 0f 84 2e 01 00 00 je 1095e0 <_Objects_Extend_information+0x160>
block_count = 1;
} else {
block_count = old_maximum / extend_count;
1094b2: 31 d2 xor %edx,%edx
1094b4: f7 f6 div %esi
1094b6: 89 45 d0 mov %eax,-0x30(%ebp)
for ( ; block < block_count; block++ ) {
1094b9: 83 f8 01 cmp $0x1,%eax
1094bc: 0f 86 0e 03 00 00 jbe 1097d0 <_Objects_Extend_information+0x350> <== NEVER TAKEN
block = 1;
1094c2: 89 7d e4 mov %edi,-0x1c(%ebp)
1094c5: bb 01 00 00 00 mov $0x1,%ebx
1094ca: 89 c7 mov %eax,%edi
1094cc: 89 f0 mov %esi,%eax
1094ce: eb 09 jmp 1094d9 <_Objects_Extend_information+0x59>
for ( ; block < block_count; block++ ) {
1094d0: 43 inc %ebx
1094d1: 39 df cmp %ebx,%edi
1094d3: 0f 84 e7 00 00 00 je 1095c0 <_Objects_Extend_information+0x140>
if ( information->object_blocks[ block ] == NULL ) {
1094d9: 89 c2 mov %eax,%edx
do_extend = false;
break;
} else
index_base += extend_count;
1094db: 01 f0 add %esi,%eax
if ( information->object_blocks[ block ] == NULL ) {
1094dd: 83 3c 99 00 cmpl $0x0,(%ecx,%ebx,4)
1094e1: 75 ed jne 1094d0 <_Objects_Extend_information+0x50>
do_extend = false;
1094e3: 89 55 d8 mov %edx,-0x28(%ebp)
1094e6: 8b 7d e4 mov -0x1c(%ebp),%edi
1094e9: 31 c9 xor %ecx,%ecx
1094eb: 89 45 e4 mov %eax,-0x1c(%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 ( new_maximum > OBJECTS_ID_FINAL_INDEX ) {
1094ee: 81 7d dc ff ff 00 00 cmpl $0xffff,-0x24(%ebp)
1094f5: 0f 87 b8 00 00 00 ja 1095b3 <_Objects_Extend_information+0x133>
1094fb: 88 4d cc mov %cl,-0x34(%ebp)
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
object_block_size = extend_count * information->object_size;
1094fe: 8b 45 08 mov 0x8(%ebp),%eax
109501: 0f b7 40 14 movzwl 0x14(%eax),%eax
109505: 0f af c6 imul %esi,%eax
new_object_block = _Workspace_Allocate( object_block_size );
109508: 89 04 24 mov %eax,(%esp)
10950b: e8 90 31 00 00 call 10c6a0 <_Workspace_Allocate>
if ( new_object_block == NULL ) {
109510: 85 c0 test %eax,%eax
new_object_block = _Workspace_Allocate( object_block_size );
109512: 89 c2 mov %eax,%edx
if ( new_object_block == NULL ) {
109514: 0f 84 99 00 00 00 je 1095b3 <_Objects_Extend_information+0x133> <== NEVER TAKEN
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
10951a: 0f b6 4d cc movzbl -0x34(%ebp),%ecx
api_class_and_node = information->maximum_id & ~OBJECTS_INDEX_MASK;
10951e: 81 e7 00 00 ff ff and $0xffff0000,%edi
109524: 89 7d e0 mov %edi,-0x20(%ebp)
if ( do_extend ) {
109527: 84 c9 test %cl,%cl
109529: 0f 85 d1 00 00 00 jne 109600 <_Objects_Extend_information+0x180>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
10952f: 8b 45 08 mov 0x8(%ebp),%eax
/*
* Append to inactive chain.
*/
the_object = new_object_block;
for ( index = index_base ; index < index_end ; ++index ) {
109532: 8b 75 e4 mov -0x1c(%ebp),%esi
information->object_blocks[ block ] = new_object_block;
109535: 8b 40 28 mov 0x28(%eax),%eax
109538: 89 14 98 mov %edx,(%eax,%ebx,4)
information->inactive_per_block[ block ] = information->objects_per_block;
10953b: 8b 45 08 mov 0x8(%ebp),%eax
10953e: 0f b7 48 12 movzwl 0x12(%eax),%ecx
109542: 8b 40 24 mov 0x24(%eax),%eax
109545: 66 89 0c 58 mov %cx,(%eax,%ebx,2)
information->inactive += information->objects_per_block;
109549: 8b 45 08 mov 0x8(%ebp),%eax
10954c: 0f b7 40 12 movzwl 0x12(%eax),%eax
109550: 66 89 45 dc mov %ax,-0x24(%ebp)
109554: 8b 45 08 mov 0x8(%ebp),%eax
109557: 8b 7d dc mov -0x24(%ebp),%edi
10955a: 66 01 78 10 add %di,0x10(%eax)
for ( index = index_base ; index < index_end ; ++index ) {
10955e: 39 75 d8 cmp %esi,-0x28(%ebp)
109561: 73 3d jae 1095a0 <_Objects_Extend_information+0x120> <== NEVER TAKEN
return &the_chain->Tail.Node;
109563: 89 5d dc mov %ebx,-0x24(%ebp)
| ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT );
_Chain_Initialize_node( &the_object->Node );
_Chain_Append_unprotected( &information->Inactive, &the_object->Node );
the_object = _Addresses_Add_offset( the_object, information->object_size );
109566: 8b 45 08 mov 0x8(%ebp),%eax
109569: 8b 7d 08 mov 0x8(%ebp),%edi
10956c: 0f b7 70 14 movzwl 0x14(%eax),%esi
109570: 8d 48 1c lea 0x1c(%eax),%ecx
109573: 8b 45 d8 mov -0x28(%ebp),%eax
109576: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10957d: 8d 76 00 lea 0x0(%esi),%esi
| ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT );
109580: 8b 5d e0 mov -0x20(%ebp),%ebx
109583: 40 inc %eax
109584: 09 c3 or %eax,%ebx
109586: 89 5a 08 mov %ebx,0x8(%edx)
old_last = tail->previous;
109589: 8b 5f 20 mov 0x20(%edi),%ebx
the_node->next = tail;
10958c: 89 0a mov %ecx,(%edx)
tail->previous = the_node;
10958e: 89 57 20 mov %edx,0x20(%edi)
old_last->next = the_node;
109591: 89 13 mov %edx,(%ebx)
the_node->previous = old_last;
109593: 89 5a 04 mov %ebx,0x4(%edx)
109596: 01 f2 add %esi,%edx
for ( index = index_base ; index < index_end ; ++index ) {
109598: 3b 45 e4 cmp -0x1c(%ebp),%eax
10959b: 75 e3 jne 109580 <_Objects_Extend_information+0x100>
10959d: 8b 5d dc mov -0x24(%ebp),%ebx
}
return block;
}
1095a0: 83 c4 4c add $0x4c,%esp
return block;
1095a3: 0f b7 c3 movzwl %bx,%eax
}
1095a6: 5b pop %ebx
1095a7: 5e pop %esi
1095a8: 5f pop %edi
1095a9: 5d pop %ebp
1095aa: c3 ret
_Workspace_Free( new_object_block );
1095ab: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
1095ae: e8 1d 31 00 00 call 10c6d0 <_Workspace_Free> <== NOT EXECUTED
}
1095b3: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
return 0;
1095b6: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
1095b8: 5b pop %ebx <== NOT EXECUTED
1095b9: 5e pop %esi <== NOT EXECUTED
1095ba: 5f pop %edi <== NOT EXECUTED
1095bb: 5d pop %ebp <== NOT EXECUTED
1095bc: c3 ret <== NOT EXECUTED
1095bd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
index_base += extend_count;
1095c0: 89 45 d8 mov %eax,-0x28(%ebp)
index_end = index_base + extend_count;
1095c3: 01 f0 add %esi,%eax
index_base += extend_count;
1095c5: 8b 7d e4 mov -0x1c(%ebp),%edi
index_end = index_base + extend_count;
1095c8: 89 45 e4 mov %eax,-0x1c(%ebp)
do_extend = true;
1095cb: b1 01 mov $0x1,%cl
1095cd: e9 1c ff ff ff jmp 1094ee <_Objects_Extend_information+0x6e>
1095d2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1095d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
index_base = extend_count;
1095e0: 89 75 d8 mov %esi,-0x28(%ebp)
do_extend = true;
1095e3: b1 01 mov $0x1,%cl
block = 1;
1095e5: bb 01 00 00 00 mov $0x1,%ebx
block_count = 1;
1095ea: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
1095f1: e9 f8 fe ff ff jmp 1094ee <_Objects_Extend_information+0x6e>
1095f6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1095fd: 8d 76 00 lea 0x0(%esi),%esi
109600: 89 45 c8 mov %eax,-0x38(%ebp)
block_count++;
109603: 8b 45 d0 mov -0x30(%ebp),%eax
109606: 40 inc %eax
object_blocks_size = block_count * sizeof( *object_blocks );
109607: 8d 3c 85 00 00 00 00 lea 0x0(,%eax,4),%edi
10960e: 89 7d c0 mov %edi,-0x40(%ebp)
local_table_size = new_maximum * sizeof( *local_table );
109611: 8b 7d dc mov -0x24(%ebp),%edi
table_size = object_blocks_size
109614: 8d 04 40 lea (%eax,%eax,2),%eax
local_table_size = new_maximum * sizeof( *local_table );
109617: c1 e7 02 shl $0x2,%edi
table_size = object_blocks_size
10961a: 8d 04 47 lea (%edi,%eax,2),%eax
object_blocks = _Workspace_Allocate( table_size );
10961d: 89 04 24 mov %eax,(%esp)
109620: e8 7b 30 00 00 call 10c6a0 <_Workspace_Allocate>
if ( object_blocks == NULL ) {
109625: 8b 55 c8 mov -0x38(%ebp),%edx
object_blocks = _Workspace_Allocate( table_size );
109628: 89 45 cc mov %eax,-0x34(%ebp)
if ( object_blocks == NULL ) {
10962b: 85 c0 test %eax,%eax
10962d: 0f 84 78 ff ff ff je 1095ab <_Objects_Extend_information+0x12b> <== NEVER TAKEN
109633: 8b 45 cc mov -0x34(%ebp),%eax
109636: 8b 4d c0 mov -0x40(%ebp),%ecx
109639: 01 c8 add %ecx,%eax
10963b: 89 45 c8 mov %eax,-0x38(%ebp)
10963e: 01 c7 add %eax,%edi
if ( old_maximum > extend_count ) {
109640: 3b 75 d4 cmp -0x2c(%ebp),%esi
109643: 89 7d c4 mov %edi,-0x3c(%ebp)
109646: 0f 82 1d 01 00 00 jb 109769 <_Objects_Extend_information+0x2e9>
object_blocks[ 0 ] = NULL;
10964c: 8b 45 cc mov -0x34(%ebp),%eax
10964f: c7 00 00 00 00 00 movl $0x0,(%eax)
inactive_per_block[ 0 ] = 0;
109655: 8b 45 c4 mov -0x3c(%ebp),%eax
109658: 66 c7 00 00 00 movw $0x0,(%eax)
memcpy(
10965d: 8b 4d d4 mov -0x2c(%ebp),%ecx
109660: 8b 45 c8 mov -0x38(%ebp),%eax
109663: 8b 75 08 mov 0x8(%ebp),%esi
109666: c1 e1 02 shl $0x2,%ecx
109669: 83 f9 08 cmp $0x8,%ecx
10966c: 89 c7 mov %eax,%edi
10966e: 8b 76 04 mov 0x4(%esi),%esi
109671: 0f 83 8a 00 00 00 jae 109701 <_Objects_Extend_information+0x281>
109677: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
for ( index = index_base ; index < index_end ; ++index ) {
109679: 8b 7d e4 mov -0x1c(%ebp),%edi
10967c: 39 7d d8 cmp %edi,-0x28(%ebp)
10967f: 73 43 jae 1096c4 <_Objects_Extend_information+0x244> <== NEVER TAKEN
local_table[ index ] = NULL;
109681: 8b 45 d8 mov -0x28(%ebp),%eax
109684: 8b 75 e4 mov -0x1c(%ebp),%esi
109687: 8b 4d c8 mov -0x38(%ebp),%ecx
10968a: 29 c6 sub %eax,%esi
10968c: c1 e6 02 shl $0x2,%esi
10968f: 8d 3c 81 lea (%ecx,%eax,4),%edi
109692: 83 fe 08 cmp $0x8,%esi
109695: 0f 83 99 00 00 00 jae 109734 <_Objects_Extend_information+0x2b4>
10969b: f7 c6 04 00 00 00 test $0x4,%esi
1096a1: 74 09 je 1096ac <_Objects_Extend_information+0x22c>
1096a3: c7 07 00 00 00 00 movl $0x0,(%edi)
1096a9: 83 c7 04 add $0x4,%edi
1096ac: f7 c6 02 00 00 00 test $0x2,%esi
1096b2: 74 08 je 1096bc <_Objects_Extend_information+0x23c> <== ALWAYS TAKEN
1096b4: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
1096b9: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1096bc: 83 e6 01 and $0x1,%esi
1096bf: 74 03 je 1096c4 <_Objects_Extend_information+0x244> <== ALWAYS TAKEN
1096c1: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
1096c4: 89 55 d4 mov %edx,-0x2c(%ebp)
_ISR_lock_ISR_disable( &lock_context );
1096c7: 9c pushf
1096c8: fa cli
1096c9: 59 pop %ecx
information->object_blocks = object_blocks;
1096ca: 8b 7d 08 mov 0x8(%ebp),%edi
1096cd: 8b 75 cc mov -0x34(%ebp),%esi
old_tables = information->object_blocks;
1096d0: 8b 45 08 mov 0x8(%ebp),%eax
| (new_maximum << OBJECTS_INDEX_START_BIT);
1096d3: 8b 55 e0 mov -0x20(%ebp),%edx
old_tables = information->object_blocks;
1096d6: 8b 40 28 mov 0x28(%eax),%eax
information->object_blocks = object_blocks;
1096d9: 89 77 28 mov %esi,0x28(%edi)
information->inactive_per_block = inactive_per_block;
1096dc: 8b 75 c4 mov -0x3c(%ebp),%esi
1096df: 89 77 24 mov %esi,0x24(%edi)
information->local_table = local_table;
1096e2: 8b 75 c8 mov -0x38(%ebp),%esi
1096e5: 89 77 04 mov %esi,0x4(%edi)
| (new_maximum << OBJECTS_INDEX_START_BIT);
1096e8: 8b 75 dc mov -0x24(%ebp),%esi
1096eb: 09 d6 or %edx,%esi
1096ed: 89 37 mov %esi,(%edi)
_ISR_lock_ISR_enable( &lock_context );
1096ef: 51 push %ecx
1096f0: 9d popf
_Workspace_Free( old_tables );
1096f1: 89 04 24 mov %eax,(%esp)
1096f4: e8 d7 2f 00 00 call 10c6d0 <_Workspace_Free>
block_count++;
1096f9: 8b 55 d4 mov -0x2c(%ebp),%edx
1096fc: e9 2e fe ff ff jmp 10952f <_Objects_Extend_information+0xaf>
memcpy(
109701: a8 01 test $0x1,%al
109703: 0f 85 1a 01 00 00 jne 109823 <_Objects_Extend_information+0x3a3> <== NEVER TAKEN
109709: f7 c7 02 00 00 00 test $0x2,%edi
10970f: 0f 85 f9 00 00 00 jne 10980e <_Objects_Extend_information+0x38e> <== NEVER TAKEN
109715: f7 c7 04 00 00 00 test $0x4,%edi
10971b: 0f 84 56 ff ff ff je 109677 <_Objects_Extend_information+0x1f7>
109721: 8b 06 mov (%esi),%eax
109723: 83 c7 04 add $0x4,%edi
109726: 83 c6 04 add $0x4,%esi
109729: 83 e9 04 sub $0x4,%ecx
10972c: 89 47 fc mov %eax,-0x4(%edi)
10972f: e9 43 ff ff ff jmp 109677 <_Objects_Extend_information+0x1f7>
local_table[ index ] = NULL;
109734: f7 c7 01 00 00 00 test $0x1,%edi
10973a: 0f 85 12 01 00 00 jne 109852 <_Objects_Extend_information+0x3d2> <== NEVER TAKEN
109740: f7 c7 02 00 00 00 test $0x2,%edi
109746: 0f 85 f6 00 00 00 jne 109842 <_Objects_Extend_information+0x3c2> <== NEVER TAKEN
10974c: f7 c7 04 00 00 00 test $0x4,%edi
109752: 0f 85 d9 00 00 00 jne 109831 <_Objects_Extend_information+0x3b1>
109758: 89 f1 mov %esi,%ecx
10975a: 31 c0 xor %eax,%eax
10975c: c1 e9 02 shr $0x2,%ecx
10975f: 83 e6 03 and $0x3,%esi
109762: f3 ab rep stos %eax,%es:(%edi)
109764: e9 32 ff ff ff jmp 10969b <_Objects_Extend_information+0x21b>
memcpy(
109769: 8b 45 c0 mov -0x40(%ebp),%eax
10976c: 8b 75 08 mov 0x8(%ebp),%esi
10976f: 8d 48 fc lea -0x4(%eax),%ecx
109772: 8b 45 cc mov -0x34(%ebp),%eax
109775: 83 f9 08 cmp $0x8,%ecx
109778: 8b 76 28 mov 0x28(%esi),%esi
10977b: 89 c7 mov %eax,%edi
10977d: 73 60 jae 1097df <_Objects_Extend_information+0x35f> <== ALWAYS TAKEN
10977f: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(
109781: 8b 4d d0 mov -0x30(%ebp),%ecx
109784: 8b 45 c4 mov -0x3c(%ebp),%eax
109787: 8b 75 08 mov 0x8(%ebp),%esi
10978a: 01 c9 add %ecx,%ecx
10978c: 83 f9 08 cmp $0x8,%ecx
10978f: 89 c7 mov %eax,%edi
109791: 8b 76 24 mov 0x24(%esi),%esi
109794: 73 07 jae 10979d <_Objects_Extend_information+0x31d>
109796: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
109798: e9 c0 fe ff ff jmp 10965d <_Objects_Extend_information+0x1dd>
10979d: a8 01 test $0x1,%al
10979f: 0f 85 cc 00 00 00 jne 109871 <_Objects_Extend_information+0x3f1> <== NEVER TAKEN
1097a5: f7 c7 02 00 00 00 test $0x2,%edi
1097ab: 0f 85 ab 00 00 00 jne 10985c <_Objects_Extend_information+0x3dc> <== NEVER TAKEN
1097b1: f7 c7 04 00 00 00 test $0x4,%edi
1097b7: 74 dd je 109796 <_Objects_Extend_information+0x316>
1097b9: 8b 06 mov (%esi),%eax
1097bb: 83 c7 04 add $0x4,%edi
1097be: 83 c6 04 add $0x4,%esi
1097c1: 83 e9 04 sub $0x4,%ecx
1097c4: 89 47 fc mov %eax,-0x4(%edi)
1097c7: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
1097c9: e9 8f fe ff ff jmp 10965d <_Objects_Extend_information+0x1dd>
1097ce: 66 90 xchg %ax,%ax
index_base = extend_count;
1097d0: 89 75 d8 mov %esi,-0x28(%ebp) <== NOT EXECUTED
do_extend = true;
1097d3: b1 01 mov $0x1,%cl <== NOT EXECUTED
block = 1;
1097d5: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
1097da: e9 0f fd ff ff jmp 1094ee <_Objects_Extend_information+0x6e> <== NOT EXECUTED
memcpy(
1097df: a8 01 test $0x1,%al
1097e1: 0f 85 ad 00 00 00 jne 109894 <_Objects_Extend_information+0x414> <== NEVER TAKEN
1097e7: f7 c7 02 00 00 00 test $0x2,%edi
1097ed: 0f 85 8c 00 00 00 jne 10987f <_Objects_Extend_information+0x3ff> <== NEVER TAKEN
1097f3: f7 c7 04 00 00 00 test $0x4,%edi
1097f9: 74 84 je 10977f <_Objects_Extend_information+0x2ff>
1097fb: 8b 06 mov (%esi),%eax
1097fd: 83 c7 04 add $0x4,%edi
109800: 83 c6 04 add $0x4,%esi
109803: 83 e9 04 sub $0x4,%ecx
109806: 89 47 fc mov %eax,-0x4(%edi)
109809: e9 71 ff ff ff jmp 10977f <_Objects_Extend_information+0x2ff>
memcpy(
10980e: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
109811: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
109814: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
109817: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
10981a: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
10981e: e9 f2 fe ff ff jmp 109715 <_Objects_Extend_information+0x295> <== NOT EXECUTED
109823: 0f b6 06 movzbl (%esi),%eax <== NOT EXECUTED
109826: 47 inc %edi <== NOT EXECUTED
109827: 46 inc %esi <== NOT EXECUTED
109828: 49 dec %ecx <== NOT EXECUTED
109829: 88 47 ff mov %al,-0x1(%edi) <== NOT EXECUTED
10982c: e9 d8 fe ff ff jmp 109709 <_Objects_Extend_information+0x289> <== NOT EXECUTED
local_table[ index ] = NULL;
109831: c7 07 00 00 00 00 movl $0x0,(%edi)
109837: 83 ee 04 sub $0x4,%esi
10983a: 83 c7 04 add $0x4,%edi
10983d: e9 16 ff ff ff jmp 109758 <_Objects_Extend_information+0x2d8>
109842: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
109847: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
10984a: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10984d: e9 fa fe ff ff jmp 10974c <_Objects_Extend_information+0x2cc> <== NOT EXECUTED
109852: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
109855: 4e dec %esi <== NOT EXECUTED
109856: 47 inc %edi <== NOT EXECUTED
109857: e9 e4 fe ff ff jmp 109740 <_Objects_Extend_information+0x2c0> <== NOT EXECUTED
memcpy(
10985c: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
10985f: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
109862: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
109865: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
109868: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
10986c: e9 40 ff ff ff jmp 1097b1 <_Objects_Extend_information+0x331> <== NOT EXECUTED
109871: 0f b6 06 movzbl (%esi),%eax <== NOT EXECUTED
109874: 47 inc %edi <== NOT EXECUTED
109875: 46 inc %esi <== NOT EXECUTED
109876: 49 dec %ecx <== NOT EXECUTED
109877: 88 47 ff mov %al,-0x1(%edi) <== NOT EXECUTED
10987a: e9 26 ff ff ff jmp 1097a5 <_Objects_Extend_information+0x325> <== NOT EXECUTED
memcpy(
10987f: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
109882: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
109885: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
109888: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
10988b: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
10988f: e9 5f ff ff ff jmp 1097f3 <_Objects_Extend_information+0x373> <== NOT EXECUTED
109894: 0f b6 06 movzbl (%esi),%eax <== NOT EXECUTED
109897: 47 inc %edi <== NOT EXECUTED
109898: 46 inc %esi <== NOT EXECUTED
109899: 88 47 ff mov %al,-0x1(%edi) <== NOT EXECUTED
10989c: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10989f: 83 e9 05 sub $0x5,%ecx <== NOT EXECUTED
1098a2: e9 40 ff ff ff jmp 1097e7 <_Objects_Extend_information+0x367> <== NOT EXECUTED
1098a7: 90 nop
1098a8: 90 nop
1098a9: 90 nop
1098aa: 90 nop
1098ab: 90 nop
1098ac: 90 nop
1098ad: 90 nop
1098ae: 90 nop
1098af: 90 nop
00109940 <_Objects_Free_objects_block>:
void _Objects_Free_objects_block(
Objects_Information *information,
Objects_Maximum block
)
{
109940: 55 push %ebp
109941: 89 e5 mov %esp,%ebp
109943: 57 push %edi
109944: 56 push %esi
109945: 53 push %ebx
109946: 83 ec 2c sub $0x2c,%esp
109949: 8b 7d 08 mov 0x8(%ebp),%edi
10994c: 0f b7 75 0c movzwl 0xc(%ebp),%esi
Objects_Maximum index_base;
Objects_Maximum index_end;
Chain_Node *node;
const Chain_Node *tail;
objects_per_block = information->objects_per_block;
109950: 0f b7 47 12 movzwl 0x12(%edi),%eax
{
109954: 89 75 dc mov %esi,-0x24(%ebp)
objects_per_block = information->objects_per_block;
109957: 89 45 e0 mov %eax,-0x20(%ebp)
_Assert( block >= 1 );
_Assert(
block < _Objects_Get_maximum_index( information ) / objects_per_block
);
index_base = block * objects_per_block;
10995a: 89 c1 mov %eax,%ecx
10995c: 0f af ce imul %esi,%ecx
return &the_chain->Tail.Node;
10995f: 8d 77 1c lea 0x1c(%edi),%esi
109962: 0f b7 c9 movzwl %cx,%ecx
index_end = index_base + objects_per_block;
109965: 01 c8 add %ecx,%eax
109967: 0f b7 c0 movzwl %ax,%eax
10996a: 89 45 e4 mov %eax,-0x1c(%ebp)
return _Chain_Immutable_head( the_chain )->next;
10996d: 8b 47 18 mov 0x18(%edi),%eax
node = _Chain_First( &information->Inactive );
tail = _Chain_Immutable_tail( &information->Inactive );
while ( node != tail ) {
109970: 39 f0 cmp %esi,%eax
109972: 74 1e je 109992 <_Objects_Free_objects_block+0x52>
Objects_Control *object;
uint32_t index;
object = (Objects_Control *) node;
index = _Objects_Get_index( object->id ) - OBJECTS_INDEX_MINIMUM;
109974: 0f b7 50 08 movzwl 0x8(%eax),%edx
109978: 89 c3 mov %eax,%ebx
return the_node->next;
10997a: 8b 00 mov (%eax),%eax
10997c: 4a dec %edx
/*
* Get the next node before the node is extracted
*/
node = _Chain_Next( node );
if ( index >= index_base && index < index_end ) {
10997d: 39 ca cmp %ecx,%edx
10997f: 72 ef jb 109970 <_Objects_Free_objects_block+0x30>
109981: 39 55 e4 cmp %edx,-0x1c(%ebp)
109984: 76 ea jbe 109970 <_Objects_Free_objects_block+0x30>
previous = the_node->previous;
109986: 8b 53 04 mov 0x4(%ebx),%edx
while ( node != tail ) {
109989: 39 f0 cmp %esi,%eax
next->previous = previous;
10998b: 89 50 04 mov %edx,0x4(%eax)
previous->next = next;
10998e: 89 02 mov %eax,(%edx)
109990: 75 e2 jne 109974 <_Objects_Free_objects_block+0x34> <== ALWAYS TAKEN
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
109992: 8b 75 dc mov -0x24(%ebp),%esi
109995: 8b 47 28 mov 0x28(%edi),%eax
109998: 8d 1c b5 00 00 00 00 lea 0x0(,%esi,4),%ebx
10999f: 8b 04 18 mov (%eax,%ebx,1),%eax
1099a2: 89 04 24 mov %eax,(%esp)
1099a5: e8 26 2d 00 00 call 10c6d0 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
1099aa: 8b 47 28 mov 0x28(%edi),%eax
1099ad: c7 04 18 00 00 00 00 movl $0x0,(%eax,%ebx,1)
information->inactive_per_block[ block ] = 0;
1099b4: 8b 47 24 mov 0x24(%edi),%eax
1099b7: 66 c7 04 70 00 00 movw $0x0,(%eax,%esi,2)
information->inactive -= objects_per_block;
1099bd: 8b 45 e0 mov -0x20(%ebp),%eax
1099c0: 66 29 47 10 sub %ax,0x10(%edi)
}
1099c4: 83 c4 2c add $0x2c,%esp
1099c7: 5b pop %ebx
1099c8: 5e pop %esi
1099c9: 5f pop %edi
1099ca: 5d pop %ebp
1099cb: c3 ret
1099cc: 90 nop
1099cd: 90 nop
1099ce: 90 nop
1099cf: 90 nop
001098b0 <_Objects_Free_unlimited>:
void _Objects_Free_unlimited(
Objects_Information *information,
Objects_Control *the_object
)
{
1098b0: 55 push %ebp
1098b1: 89 e5 mov %esp,%ebp
1098b3: 53 push %ebx
1098b4: 8b 4d 08 mov 0x8(%ebp),%ecx
1098b7: 8b 45 0c mov 0xc(%ebp),%eax
return &the_chain->Tail.Node;
1098ba: 8d 59 1c lea 0x1c(%ecx),%ebx
old_last = tail->previous;
1098bd: 8b 51 20 mov 0x20(%ecx),%edx
return &the_chain->Tail.Node;
1098c0: 89 18 mov %ebx,(%eax)
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Is_auto_extend(
const Objects_Information *information
)
{
return information->objects_per_block != 0;
1098c2: 0f b7 59 12 movzwl 0x12(%ecx),%ebx
tail->previous = the_node;
1098c6: 89 41 20 mov %eax,0x20(%ecx)
old_last->next = the_node;
1098c9: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
1098cb: 89 50 04 mov %edx,0x4(%eax)
_Chain_Append_unprotected( &information->Inactive, &the_object->Node );
if ( _Objects_Is_auto_extend( information ) ) {
1098ce: 85 db test %ebx,%ebx
1098d0: 74 2c je 1098fe <_Objects_Free_unlimited+0x4e> <== NEVER TAKEN
1098d2: 8b 40 08 mov 0x8(%eax),%eax
Objects_Maximum objects_per_block;
Objects_Maximum block;
Objects_Maximum inactive;
objects_per_block = information->objects_per_block;
block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM;
1098d5: 48 dec %eax
1098d6: 0f b7 c0 movzwl %ax,%eax
if ( block > objects_per_block ) {
1098d9: 39 c3 cmp %eax,%ebx
1098db: 73 21 jae 1098fe <_Objects_Free_unlimited+0x4e>
block /= objects_per_block;
++information->inactive_per_block[ block ];
1098dd: 31 d2 xor %edx,%edx
1098df: f7 f3 div %ebx
1098e1: 8b 51 24 mov 0x24(%ecx),%edx
1098e4: 66 ff 04 42 incw (%edx,%eax,2)
/*
* Check if the threshold level has been met of
* 1.5 x objects_per_block are free.
*/
if ( inactive > ( objects_per_block + ( objects_per_block >> 1 ) ) ) {
1098e8: 89 da mov %ebx,%edx
1098ea: d1 ea shr %edx
1098ec: 01 d3 add %edx,%ebx
inactive = information->inactive;
1098ee: 0f b7 41 10 movzwl 0x10(%ecx),%eax
++inactive;
1098f2: 40 inc %eax
1098f3: 0f b7 c0 movzwl %ax,%eax
information->inactive = inactive;
1098f6: 66 89 41 10 mov %ax,0x10(%ecx)
if ( inactive > ( objects_per_block + ( objects_per_block >> 1 ) ) ) {
1098fa: 39 d8 cmp %ebx,%eax
1098fc: 7f 12 jg 109910 <_Objects_Free_unlimited+0x60>
_Objects_Shrink_information( information );
}
}
}
}
1098fe: 5b pop %ebx
1098ff: 5d pop %ebp
109900: c3 ret
109901: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109908: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10990f: 90 nop
109910: 5b pop %ebx
109911: 5d pop %ebp
_Objects_Shrink_information( information );
109912: e9 b9 00 00 00 jmp 1099d0 <_Objects_Shrink_information>
109917: 90 nop
109918: 90 nop
109919: 90 nop
10991a: 90 nop
10991b: 90 nop
10991c: 90 nop
10991d: 90 nop
10991e: 90 nop
10991f: 90 nop
0010c810 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10c810: 55 push %ebp
10c811: 89 e5 mov %esp,%ebp
10c813: 83 ec 18 sub $0x18,%esp
10c816: 89 75 fc mov %esi,-0x4(%ebp)
10c819: 0f b7 75 0c movzwl 0xc(%ebp),%esi
10c81d: 89 5d f8 mov %ebx,-0x8(%ebp)
10c820: 8b 5d 08 mov 0x8(%ebp),%ebx
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10c823: 85 f6 test %esi,%esi
10c825: 74 29 je 10c850 <_Objects_Get_information+0x40>
/*
* 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 );
10c827: 89 1c 24 mov %ebx,(%esp)
10c82a: e8 41 06 00 00 call 10ce70 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10c82f: 85 c0 test %eax,%eax
10c831: 74 1d je 10c850 <_Objects_Get_information+0x40>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10c833: 39 f0 cmp %esi,%eax
10c835: 72 19 jb 10c850 <_Objects_Get_information+0x40>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10c837: 8b 04 9d 50 57 12 00 mov 0x125750(,%ebx,4),%eax
10c83e: 85 c0 test %eax,%eax
10c840: 74 0e je 10c850 <_Objects_Get_information+0x40> <== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10c842: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !info )
10c845: 85 c0 test %eax,%eax
10c847: 74 07 je 10c850 <_Objects_Get_information+0x40>
* 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 ( _Objects_Get_maximum_index( info ) == 0 )
10c849: 66 83 38 00 cmpw $0x0,(%eax)
10c84d: 75 03 jne 10c852 <_Objects_Get_information+0x42>
10c84f: 90 nop
return NULL;
10c850: 31 c0 xor %eax,%eax
#endif
return info;
}
10c852: 8b 5d f8 mov -0x8(%ebp),%ebx
10c855: 8b 75 fc mov -0x4(%ebp),%esi
10c858: 89 ec mov %ebp,%esp
10c85a: 5d pop %ebp
10c85b: c3 ret
10c85c: 90 nop
10c85d: 90 nop
10c85e: 90 nop
10c85f: 90 nop
00109040 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
109040: 55 push %ebp
109041: 89 e5 mov %esp,%ebp
109043: 83 ec 38 sub $0x38,%esp
109046: 89 5d f4 mov %ebx,-0xc(%ebp)
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
109049: 8b 45 0c mov 0xc(%ebp),%eax
{
10904c: 89 7d fc mov %edi,-0x4(%ebp)
10904f: 8b 5d 10 mov 0x10(%ebp),%ebx
109052: 89 75 f8 mov %esi,-0x8(%ebp)
109055: 8b 7d 08 mov 0x8(%ebp),%edi
if ( name == NULL )
109058: 85 c0 test %eax,%eax
10905a: 74 7a je 1090d6 <_Objects_Get_name_as_string+0x96>
10905c: 85 db test %ebx,%ebx
10905e: 74 76 je 1090d6 <_Objects_Get_name_as_string+0x96>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
109060: 85 ff test %edi,%edi
109062: 74 5c je 1090c0 <_Objects_Get_name_as_string+0x80>
information = _Objects_Get_information_id( tmpId );
109064: 89 3c 24 mov %edi,(%esp)
109067: e8 b4 64 00 00 call 10f520 <_Objects_Get_information_id>
if ( !information )
10906c: 85 c0 test %eax,%eax
information = _Objects_Get_information_id( tmpId );
10906e: 89 c6 mov %eax,%esi
if ( !information )
109070: 74 64 je 1090d6 <_Objects_Get_name_as_string+0x96>
return NULL;
the_object = _Objects_Get( tmpId, &lock_context, information );
109072: 89 44 24 08 mov %eax,0x8(%esp)
109076: 8d 45 e4 lea -0x1c(%ebp),%eax
109079: 89 44 24 04 mov %eax,0x4(%esp)
10907d: 89 3c 24 mov %edi,(%esp)
109080: e8 bb fe ff ff call 108f40 <_Objects_Get>
if ( the_object == NULL ) {
109085: 85 c0 test %eax,%eax
109087: 74 4d je 1090d6 <_Objects_Get_name_as_string+0x96>
return NULL;
}
_Objects_Name_to_string(
109089: 89 5c 24 08 mov %ebx,0x8(%esp)
10908d: 8b 4d 0c mov 0xc(%ebp),%ecx
return information->name_length > 0;
109090: 31 d2 xor %edx,%edx
109092: 89 4c 24 0c mov %ecx,0xc(%esp)
109096: 66 83 7e 16 00 cmpw $0x0,0x16(%esi)
10909b: 0f 95 c2 setne %dl
10909e: 89 54 24 04 mov %edx,0x4(%esp)
1090a2: 8b 40 0c mov 0xc(%eax),%eax
1090a5: 89 04 24 mov %eax,(%esp)
1090a8: e8 03 ff ff ff call 108fb0 <_Objects_Name_to_string>
_Objects_Has_string_name( information ),
name,
length
);
_ISR_lock_ISR_enable( &lock_context );
1090ad: ff 75 e4 push -0x1c(%ebp)
1090b0: 9d popf
return name;
}
1090b1: 8b 75 f8 mov -0x8(%ebp),%esi
return name;
1090b4: 89 d8 mov %ebx,%eax
}
1090b6: 8b 5d f4 mov -0xc(%ebp),%ebx
1090b9: 8b 7d fc mov -0x4(%ebp),%edi
1090bc: 89 ec mov %ebp,%esp
1090be: 5d pop %ebp
1090bf: c3 ret
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
1090c0: a1 98 31 13 00 mov 0x133198,%eax
1090c5: 8b 78 08 mov 0x8(%eax),%edi
information = _Objects_Get_information_id( tmpId );
1090c8: 89 3c 24 mov %edi,(%esp)
1090cb: e8 50 64 00 00 call 10f520 <_Objects_Get_information_id>
if ( !information )
1090d0: 85 c0 test %eax,%eax
information = _Objects_Get_information_id( tmpId );
1090d2: 89 c6 mov %eax,%esi
if ( !information )
1090d4: 75 9c jne 109072 <_Objects_Get_name_as_string+0x32> <== ALWAYS TAKEN
}
1090d6: 8b 5d f4 mov -0xc(%ebp),%ebx
return NULL;
1090d9: 31 c0 xor %eax,%eax
}
1090db: 8b 75 f8 mov -0x8(%ebp),%esi
1090de: 8b 7d fc mov -0x4(%ebp),%edi
1090e1: 89 ec mov %ebp,%esp
1090e3: 5d pop %ebp
1090e4: c3 ret
1090e5: 90 nop
1090e6: 90 nop
1090e7: 90 nop
1090e8: 90 nop
1090e9: 90 nop
1090ea: 90 nop
1090eb: 90 nop
1090ec: 90 nop
1090ed: 90 nop
1090ee: 90 nop
1090ef: 90 nop
001090f0 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
1090f0: 55 push %ebp
1090f1: 89 e5 mov %esp,%ebp
1090f3: 83 ec 28 sub $0x28,%esp
1090f6: 89 5d fc mov %ebx,-0x4(%ebp)
1090f9: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id;
1090fc: 85 db test %ebx,%ebx
1090fe: 75 08 jne 109108 <_Objects_Id_to_name+0x18>
109100: a1 98 31 13 00 mov 0x133198,%eax
109105: 8b 58 08 mov 0x8(%eax),%ebx
information = _Objects_Get_information_id( tmpId );
109108: 89 1c 24 mov %ebx,(%esp)
10910b: e8 10 64 00 00 call 10f520 <_Objects_Get_information_id>
if ( !information )
109110: 85 c0 test %eax,%eax
109112: 74 3c je 109150 <_Objects_Id_to_name+0x60>
return OBJECTS_INVALID_ID;
if ( _Objects_Has_string_name( information ) )
109114: 66 83 78 16 00 cmpw $0x0,0x16(%eax)
109119: 75 35 jne 109150 <_Objects_Id_to_name+0x60> <== NEVER TAKEN
return OBJECTS_INVALID_ID;
the_object = _Objects_Get(
10911b: 89 44 24 08 mov %eax,0x8(%esp)
10911f: 8d 45 f4 lea -0xc(%ebp),%eax
109122: 89 44 24 04 mov %eax,0x4(%esp)
109126: 89 1c 24 mov %ebx,(%esp)
109129: e8 12 fe ff ff call 108f40 <_Objects_Get>
tmpId,
&lock_context,
information
);
if ( !the_object )
10912e: 85 c0 test %eax,%eax
109130: 74 1e je 109150 <_Objects_Id_to_name+0x60>
return OBJECTS_INVALID_ID;
*name = the_object->name;
109132: 8b 50 0c mov 0xc(%eax),%edx
109135: 8b 45 0c mov 0xc(%ebp),%eax
109138: 89 10 mov %edx,(%eax)
_ISR_lock_ISR_enable( &lock_context );
10913a: ff 75 f4 push -0xc(%ebp)
10913d: 9d popf
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
10913e: 8b 5d fc mov -0x4(%ebp),%ebx
109141: 89 ec mov %ebp,%esp
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
109143: 31 c0 xor %eax,%eax
}
109145: 5d pop %ebp
109146: c3 ret
109147: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10914e: 66 90 xchg %ax,%ax
109150: 8b 5d fc mov -0x4(%ebp),%ebx
109153: 89 ec mov %ebp,%esp
return OBJECTS_INVALID_ID;
109155: b8 03 00 00 00 mov $0x3,%eax
}
10915a: 5d pop %ebp
10915b: c3 ret
10915c: 90 nop
10915d: 90 nop
10915e: 90 nop
10915f: 90 nop
00118f10 <_Objects_Name_to_string>:
Objects_Name name,
bool is_string,
char *buffer,
size_t buffer_size
)
{
118f10: 55 push %ebp
118f11: 89 e5 mov %esp,%ebp
118f13: 57 push %edi
118f14: 56 push %esi
118f15: 53 push %ebx
118f16: 83 ec 10 sub $0x10,%esp
char lname[ 5 ];
const char *s;
char *d;
size_t i;
if ( is_string ) {
118f19: 80 7d 0c 00 cmpb $0x0,0xc(%ebp)
{
118f1d: 8b 45 08 mov 0x8(%ebp),%eax
118f20: 8b 4d 10 mov 0x10(%ebp),%ecx
118f23: 8b 7d 14 mov 0x14(%ebp),%edi
if ( is_string ) {
118f26: 74 58 je 118f80 <_Objects_Name_to_string+0x70> <== ALWAYS TAKEN
}
d = buffer;
i = 1;
if ( s != NULL ) {
118f28: 85 c0 test %eax,%eax <== NOT EXECUTED
118f2a: 75 14 jne 118f40 <_Objects_Name_to_string+0x30> <== NOT EXECUTED
while ( *s != '\0' ) {
if ( i < buffer_size ) {
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
118f2c: 31 d2 xor %edx,%edx
++s;
++i;
}
}
if ( buffer_size > 0 ) {
118f2e: 85 ff test %edi,%edi
118f30: 74 03 je 118f35 <_Objects_Name_to_string+0x25>
*d = '\0';
118f32: c6 01 00 movb $0x0,(%ecx)
}
return i - 1;
}
118f35: 83 c4 10 add $0x10,%esp
118f38: 89 d0 mov %edx,%eax
118f3a: 5b pop %ebx
118f3b: 5e pop %esi
118f3c: 5f pop %edi
118f3d: 5d pop %ebp
118f3e: c3 ret
118f3f: 90 nop
s = name.name_p;
118f40: 89 c6 mov %eax,%esi <== NOT EXECUTED
while ( *s != '\0' ) {
118f42: 0f b6 00 movzbl (%eax),%eax <== NOT EXECUTED
118f45: 84 c0 test %al,%al
118f47: 74 e3 je 118f2c <_Objects_Name_to_string+0x1c>
118f49: ba 01 00 00 00 mov $0x1,%edx
118f4e: eb 02 jmp 118f52 <_Objects_Name_to_string+0x42>
++i;
118f50: 89 da mov %ebx,%edx
if ( i < buffer_size ) {
118f52: 39 d7 cmp %edx,%edi
118f54: 76 0f jbe 118f65 <_Objects_Name_to_string+0x55>
return uc >= ' ' && uc <= '~';
118f56: 88 c3 mov %al,%bl
118f58: 80 eb 20 sub $0x20,%bl
*d = _Objects_Name_char_is_printable(*s) ? *s : '*';
118f5b: 80 fb 5e cmp $0x5e,%bl
118f5e: 76 02 jbe 118f62 <_Objects_Name_to_string+0x52>
118f60: b0 2a mov $0x2a,%al
118f62: 88 01 mov %al,(%ecx)
++d;
118f64: 41 inc %ecx
++i;
118f65: 8d 5a 01 lea 0x1(%edx),%ebx
while ( *s != '\0' ) {
118f68: 0f b6 44 1e ff movzbl -0x1(%esi,%ebx,1),%eax
118f6d: 84 c0 test %al,%al
118f6f: 75 df jne 118f50 <_Objects_Name_to_string+0x40>
118f71: eb bb jmp 118f2e <_Objects_Name_to_string+0x1e>
118f73: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
118f7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
lname[ 4 ] = '\0';
118f80: c6 45 f3 00 movb $0x0,-0xd(%ebp)
s = lname;
118f84: 8d 75 ef lea -0x11(%ebp),%esi
118f87: 89 c2 mov %eax,%edx
118f89: 0f ca bswap %edx
lname[ 0 ] = (name.name_u32 >> 24) & 0xff;
118f8b: 89 55 ef mov %edx,-0x11(%ebp)
118f8e: c1 e8 18 shr $0x18,%eax
if ( s != NULL ) {
118f91: eb b2 jmp 118f45 <_Objects_Name_to_string+0x35>
118f93: 90 nop
118f94: 90 nop
118f95: 90 nop
118f96: 90 nop
118f97: 90 nop
118f98: 90 nop
118f99: 90 nop
118f9a: 90 nop
118f9b: 90 nop
118f9c: 90 nop
118f9d: 90 nop
118f9e: 90 nop
118f9f: 90 nop
001056c0 <_Objects_Set_name>:
Status_Control _Objects_Set_name(
const Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
1056c0: 55 push %ebp
1056c1: 89 e5 mov %esp,%ebp
1056c3: 56 push %esi
1056c4: 53 push %ebx
1056c5: 83 ec 20 sub $0x20,%esp
1056c8: 8b 45 08 mov 0x8(%ebp),%eax
1056cb: 8b 5d 0c mov 0xc(%ebp),%ebx
1056ce: 8b 75 10 mov 0x10(%ebp),%esi
1056d1: 0f b7 40 16 movzwl 0x16(%eax),%eax
if ( _Objects_Has_string_name( information ) ) {
1056d5: 85 c0 test %eax,%eax
1056d7: 74 37 je 105710 <_Objects_Set_name+0x50>
size_t length;
char *dup;
length = strnlen( name, information->name_length );
1056d9: 89 34 24 mov %esi,(%esp)
1056dc: 89 44 24 04 mov %eax,0x4(%esp)
1056e0: e8 5b 3f 01 00 call 119640 <strnlen>
dup = _Workspace_String_duplicate( name, length );
1056e5: 89 34 24 mov %esi,(%esp)
1056e8: 89 44 24 04 mov %eax,0x4(%esp)
1056ec: e8 4f 27 00 00 call 107e40 <_Workspace_String_duplicate>
if ( dup == NULL ) {
1056f1: 85 c0 test %eax,%eax
dup = _Workspace_String_duplicate( name, length );
1056f3: 89 c6 mov %eax,%esi
if ( dup == NULL ) {
1056f5: 74 69 je 105760 <_Objects_Set_name+0xa0> <== ALWAYS TAKEN
return STATUS_NO_MEMORY;
}
_Workspace_Free( RTEMS_DECONST( char *, the_object->name.name_p ) );
1056f7: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
1056fa: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1056fd: e8 1e 27 00 00 call 107e20 <_Workspace_Free> <== NOT EXECUTED
the_object->name.name_u32 =
_Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] );
}
return STATUS_SUCCESSFUL;
105702: 31 c0 xor %eax,%eax <== NOT EXECUTED
the_object->name.name_p = dup;
105704: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED
}
105707: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
10570a: 5b pop %ebx <== NOT EXECUTED
10570b: 5e pop %esi <== NOT EXECUTED
10570c: 5d pop %ebp <== NOT EXECUTED
10570d: c3 ret <== NOT EXECUTED
10570e: 66 90 xchg %ax,%ax <== NOT EXECUTED
memset( c, ' ', sizeof( c ) );
105710: c7 45 f4 20 20 20 20 movl $0x20202020,-0xc(%ebp)
for ( i = 0; i < 4; ++i ) {
105717: 31 c0 xor %eax,%eax
if ( name[ i ] == '\0') {
105719: 0f b6 14 06 movzbl (%esi,%eax,1),%edx
10571d: 84 d2 test %dl,%dl
10571f: 74 0a je 10572b <_Objects_Set_name+0x6b>
c[ i ] = name[ i ];
105721: 88 54 05 f4 mov %dl,-0xc(%ebp,%eax,1)
for ( i = 0; i < 4; ++i ) {
105725: 40 inc %eax
105726: 83 f8 04 cmp $0x4,%eax
105729: 75 ee jne 105719 <_Objects_Set_name+0x59>
_Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] );
10572b: 0f be 45 f4 movsbl -0xc(%ebp),%eax
10572f: 0f be 55 f5 movsbl -0xb(%ebp),%edx
105733: c1 e0 18 shl $0x18,%eax
105736: c1 e2 10 shl $0x10,%edx
105739: 09 d0 or %edx,%eax
10573b: 0f be 55 f7 movsbl -0x9(%ebp),%edx
10573f: 09 d0 or %edx,%eax
105741: 0f be 55 f6 movsbl -0xa(%ebp),%edx
105745: c1 e2 08 shl $0x8,%edx
105748: 09 d0 or %edx,%eax
10574a: 89 43 0c mov %eax,0xc(%ebx)
return STATUS_SUCCESSFUL;
10574d: 31 c0 xor %eax,%eax
}
10574f: 83 c4 20 add $0x20,%esp
105752: 5b pop %ebx
105753: 5e pop %esi
105754: 5d pop %ebp
105755: c3 ret
105756: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10575d: 8d 76 00 lea 0x0(%esi),%esi
return STATUS_NO_MEMORY;
105760: b8 1a 16 00 00 mov $0x161a,%eax
105765: eb e8 jmp 10574f <_Objects_Set_name+0x8f>
105767: 90 nop
105768: 90 nop
105769: 90 nop
10576a: 90 nop
10576b: 90 nop
10576c: 90 nop
10576d: 90 nop
10576e: 90 nop
10576f: 90 nop
001099d0 <_Objects_Shrink_information>:
void _Objects_Shrink_information(
Objects_Information *information
)
{
1099d0: 55 push %ebp
/*
* Search the list to find block or chunk with all objects inactive.
*/
objects_per_block = information->objects_per_block;
block_count = _Objects_Get_maximum_index( information ) / objects_per_block;
1099d1: 31 d2 xor %edx,%edx
{
1099d3: 89 e5 mov %esp,%ebp
1099d5: 57 push %edi
1099d6: 56 push %esi
1099d7: 53 push %ebx
1099d8: 83 ec 1c sub $0x1c,%esp
1099db: 8b 75 08 mov 0x8(%ebp),%esi
objects_per_block = information->objects_per_block;
1099de: 0f b7 5e 12 movzwl 0x12(%esi),%ebx
block_count = _Objects_Get_maximum_index( information ) / objects_per_block;
1099e2: 0f b7 06 movzwl (%esi),%eax
1099e5: f7 f3 div %ebx
for ( block = 1; block < block_count; block++ ) {
1099e7: 83 f8 01 cmp $0x1,%eax
1099ea: 76 30 jbe 109a1c <_Objects_Shrink_information+0x4c> <== NEVER TAKEN
if ( information->inactive_per_block[ block ] == objects_per_block ) {
1099ec: 8b 7e 24 mov 0x24(%esi),%edi
1099ef: ba 01 00 00 00 mov $0x1,%edx
1099f4: eb 12 jmp 109a08 <_Objects_Shrink_information+0x38>
1099f6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1099fd: 8d 76 00 lea 0x0(%esi),%esi
for ( block = 1; block < block_count; block++ ) {
109a00: 42 inc %edx
109a01: 0f b7 ca movzwl %dx,%ecx
109a04: 39 c8 cmp %ecx,%eax
109a06: 76 14 jbe 109a1c <_Objects_Shrink_information+0x4c> <== NEVER TAKEN
if ( information->inactive_per_block[ block ] == objects_per_block ) {
109a08: 0f b7 0c 57 movzwl (%edi,%edx,2),%ecx
109a0c: 39 d9 cmp %ebx,%ecx
109a0e: 75 f0 jne 109a00 <_Objects_Shrink_information+0x30>
_Objects_Free_objects_block( information, block );
109a10: 89 54 24 04 mov %edx,0x4(%esp)
109a14: 89 34 24 mov %esi,(%esp)
109a17: e8 24 ff ff ff call 109940 <_Objects_Free_objects_block>
return;
}
}
}
109a1c: 83 c4 1c add $0x1c,%esp
109a1f: 5b pop %ebx
109a20: 5e pop %esi
109a21: 5f pop %edi
109a22: 5d pop %ebp
109a23: c3 ret
109a24: 90 nop
109a25: 90 nop
109a26: 90 nop
109a27: 90 nop
109a28: 90 nop
109a29: 90 nop
109a2a: 90 nop
109a2b: 90 nop
109a2c: 90 nop
109a2d: 90 nop
109a2e: 90 nop
109a2f: 90 nop
00106820 <_Once>:
.Mutex = RTEMS_MUTEX_INITIALIZER( "_Once" ),
.State = RTEMS_CONDITION_VARIABLE_INITIALIZER( "_Once" )
};
int _Once( unsigned char *once_state, void ( *init_routine )( void ) )
{
106820: 55 push %ebp
106821: 89 e5 mov %esp,%ebp
106823: 83 ec 18 sub $0x18,%esp
106826: 89 5d f8 mov %ebx,-0x8(%ebp)
106829: 8b 5d 08 mov 0x8(%ebp),%ebx
10682c: 89 75 fc mov %esi,-0x4(%ebp)
_Atomic_Fence( ATOMIC_ORDER_ACQUIRE );
if ( RTEMS_PREDICT_FALSE( *once_state != ONCE_STATE_COMPLETE ) ) {
10682f: 80 3b 02 cmpb $0x2,(%ebx)
106832: 75 0c jne 106840 <_Once+0x20>
_Once_Unlock( thread_life_state );
}
return 0;
}
106834: 8b 5d f8 mov -0x8(%ebp),%ebx
106837: 31 c0 xor %eax,%eax
106839: 8b 75 fc mov -0x4(%ebp),%esi
10683c: 89 ec mov %ebp,%esp
10683e: 5d pop %ebp
10683f: c3 ret
Thread_Life_state _Once_Lock( void )
{
Thread_Life_state thread_life_state;
thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
106840: c7 04 24 01 00 00 00 movl $0x1,(%esp)
106847: e8 14 1e 00 00 call 108660 <_Thread_Set_life_protection>
mutex->_Queue._name = name;
}
static __inline void rtems_mutex_lock( rtems_mutex *mutex )
{
_Mutex_Acquire( mutex );
10684c: c7 04 24 c0 a3 12 00 movl $0x12a3c0,(%esp)
106853: 89 c6 mov %eax,%esi
106855: e8 96 fd ff ff call 1065f0 <_Mutex_Acquire>
if ( *once_state == ONCE_STATE_INIT ) {
10685a: 0f b6 03 movzbl (%ebx),%eax
10685d: 84 c0 test %al,%al
10685f: 74 4f je 1068b0 <_Once+0x90> <== ALWAYS TAKEN
while ( *once_state != ONCE_STATE_COMPLETE ) {
106861: 3c 02 cmp $0x2,%al <== NOT EXECUTED
106863: 74 25 je 10688a <_Once+0x6a> <== NOT EXECUTED
106865: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10686c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
static __inline void rtems_condition_variable_wait(
rtems_condition_variable *condition_variable,
rtems_mutex *mutex
)
{
_Condition_Wait( condition_variable, mutex );
106870: c7 04 24 d4 a3 12 00 movl $0x12a3d4,(%esp) <== NOT EXECUTED
106877: b8 c0 a3 12 00 mov $0x12a3c0,%eax <== NOT EXECUTED
10687c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106880: e8 5b 3d 00 00 call 10a5e0 <_Condition_Wait> <== NOT EXECUTED
106885: 80 3b 02 cmpb $0x2,(%ebx) <== NOT EXECUTED
106888: 75 e6 jne 106870 <_Once+0x50> <== NOT EXECUTED
_Mutex_Release( mutex );
10688a: c7 04 24 c0 a3 12 00 movl $0x12a3c0,(%esp)
106891: e8 ca fd ff ff call 106660 <_Mutex_Release>
}
void _Once_Unlock( Thread_Life_state thread_life_state )
{
rtems_mutex_unlock( &_Once_Information.Mutex );
_Thread_Set_life_protection( thread_life_state );
106896: 89 34 24 mov %esi,(%esp)
106899: e8 c2 1d 00 00 call 108660 <_Thread_Set_life_protection>
}
10689e: 8b 5d f8 mov -0x8(%ebp),%ebx
1068a1: 31 c0 xor %eax,%eax
1068a3: 8b 75 fc mov -0x4(%ebp),%esi
1068a6: 89 ec mov %ebp,%esp
1068a8: 5d pop %ebp
1068a9: c3 ret
1068aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*once_state = ONCE_STATE_RUNNING;
1068b0: c6 03 01 movb $0x1,(%ebx)
1068b3: c7 04 24 c0 a3 12 00 movl $0x12a3c0,(%esp)
1068ba: e8 a1 fd ff ff call 106660 <_Mutex_Release>
_Thread_Set_life_protection( thread_life_state );
1068bf: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1068c6: e8 95 1d 00 00 call 108660 <_Thread_Set_life_protection>
( *init_routine )();
1068cb: ff 55 0c call *0xc(%ebp)
thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
1068ce: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1068d5: e8 86 1d 00 00 call 108660 <_Thread_Set_life_protection>
_Mutex_Acquire( mutex );
1068da: c7 04 24 c0 a3 12 00 movl $0x12a3c0,(%esp)
1068e1: e8 0a fd ff ff call 1065f0 <_Mutex_Acquire>
*once_state = ONCE_STATE_COMPLETE;
1068e6: c6 03 02 movb $0x2,(%ebx)
static __inline void rtems_condition_variable_broadcast(
rtems_condition_variable *condition_variable
)
{
_Condition_Broadcast( condition_variable );
1068e9: c7 04 24 d4 a3 12 00 movl $0x12a3d4,(%esp)
1068f0: e8 4b 3d 00 00 call 10a640 <_Condition_Broadcast>
}
1068f5: eb 93 jmp 10688a <_Once+0x6a>
1068f7: 90 nop
1068f8: 90 nop
1068f9: 90 nop
1068fa: 90 nop
1068fb: 90 nop
1068fc: 90 nop
1068fd: 90 nop
1068fe: 90 nop
1068ff: 90 nop
0010e0d0 <_Processor_mask_Copy>:
long *dst,
size_t dst_size,
const long *src,
size_t src_size
)
{
10e0d0: 55 push %ebp
10e0d1: 89 e5 mov %esp,%ebp
10e0d3: 57 push %edi
10e0d4: 56 push %esi
10e0d5: 53 push %ebx
10e0d6: 83 ec 04 sub $0x4,%esp
10e0d9: 8b 5d 0c mov 0xc(%ebp),%ebx
10e0dc: 8b 4d 14 mov 0x14(%ebp),%ecx
10e0df: 8b 55 08 mov 0x8(%ebp),%edx
10e0e2: 8b 45 10 mov 0x10(%ebp),%eax
long inclusive = 0;
long exclusive = 0;
if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) {
10e0e5: 89 de mov %ebx,%esi
10e0e7: 09 ce or %ecx,%esi
10e0e9: 83 e6 03 and $0x3,%esi
10e0ec: 89 75 f0 mov %esi,-0x10(%ebp)
10e0ef: 75 7f jne 10e170 <_Processor_mask_Copy+0xa0>
long inclusive = 0;
10e0f1: 31 ff xor %edi,%edi
return PROCESSOR_MASK_COPY_INVALID_SIZE;
}
while ( dst_size > 0 && src_size > 0 ) {
10e0f3: 85 c9 test %ecx,%ecx
10e0f5: 74 22 je 10e119 <_Processor_mask_Copy+0x49>
10e0f7: 85 db test %ebx,%ebx
10e0f9: 74 1e je 10e119 <_Processor_mask_Copy+0x49>
10e0fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10e0ff: 90 nop
long bits = *src;
10e100: 8b 30 mov (%eax),%esi
inclusive |= bits;
*dst = bits;
++dst;
10e102: 83 c2 04 add $0x4,%edx
++src;
10e105: 83 c0 04 add $0x4,%eax
dst_size -= sizeof( long );
src_size -= sizeof( long );
10e108: 83 e9 04 sub $0x4,%ecx
*dst = bits;
10e10b: 89 72 fc mov %esi,-0x4(%edx)
inclusive |= bits;
10e10e: 09 f7 or %esi,%edi
while ( dst_size > 0 && src_size > 0 ) {
10e110: 83 eb 04 sub $0x4,%ebx
10e113: 74 18 je 10e12d <_Processor_mask_Copy+0x5d>
10e115: 85 c9 test %ecx,%ecx
10e117: 75 e7 jne 10e100 <_Processor_mask_Copy+0x30> <== NEVER TAKEN
}
while ( dst_size > 0 ) {
10e119: 85 db test %ebx,%ebx
10e11b: 74 10 je 10e12d <_Processor_mask_Copy+0x5d>
10e11d: 01 d3 add %edx,%ebx
10e11f: 90 nop
*dst = 0;
10e120: c7 02 00 00 00 00 movl $0x0,(%edx)
++dst;
10e126: 83 c2 04 add $0x4,%edx
while ( dst_size > 0 ) {
10e129: 39 da cmp %ebx,%edx
10e12b: 75 f3 jne 10e120 <_Processor_mask_Copy+0x50> <== NEVER TAKEN
dst_size -= sizeof( long );
}
while ( src_size > 0 ) {
10e12d: 85 c9 test %ecx,%ecx
10e12f: 74 4f je 10e180 <_Processor_mask_Copy+0xb0>
long exclusive = 0;
10e131: 31 d2 xor %edx,%edx
10e133: 01 c1 add %eax,%ecx
10e135: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10e13c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
exclusive |= *src;
10e140: 8b 18 mov (%eax),%ebx
++src;
10e142: 83 c0 04 add $0x4,%eax
exclusive |= *src;
10e145: 09 da or %ebx,%edx
while ( src_size > 0 ) {
10e147: 39 c8 cmp %ecx,%eax
10e149: 75 f5 jne 10e140 <_Processor_mask_Copy+0x70> <== NEVER TAKEN
src_size -= sizeof( long );
}
if ( exclusive != 0 ) {
10e14b: 85 d2 test %edx,%edx
10e14d: 74 0e je 10e15d <_Processor_mask_Copy+0x8d>
if ( inclusive != 0 ) {
return PROCESSOR_MASK_COPY_PARTIAL_LOSS;
} else {
return PROCESSOR_MASK_COPY_COMPLETE_LOSS;
10e14f: 83 ff 01 cmp $0x1,%edi
10e152: b8 01 00 00 00 mov $0x1,%eax
10e157: 83 d0 00 adc $0x0,%eax
10e15a: 89 45 f0 mov %eax,-0x10(%ebp)
}
}
return PROCESSOR_MASK_COPY_LOSSLESS;
}
10e15d: 8b 45 f0 mov -0x10(%ebp),%eax
10e160: 5a pop %edx
10e161: 5b pop %ebx
10e162: 5e pop %esi
10e163: 5f pop %edi
10e164: 5d pop %ebp
10e165: c3 ret
10e166: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10e16d: 8d 76 00 lea 0x0(%esi),%esi
return PROCESSOR_MASK_COPY_INVALID_SIZE;
10e170: c7 45 f0 03 00 00 00 movl $0x3,-0x10(%ebp)
}
10e177: 8b 45 f0 mov -0x10(%ebp),%eax
10e17a: 5a pop %edx
10e17b: 5b pop %ebx
10e17c: 5e pop %esi
10e17d: 5f pop %edi
10e17e: 5d pop %ebp
10e17f: c3 ret
return PROCESSOR_MASK_COPY_LOSSLESS;
10e180: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
10e187: eb d4 jmp 10e15d <_Processor_mask_Copy+0x8d>
10e189: 90 nop
10e18a: 90 nop
10e18b: 90 nop
10e18c: 90 nop
10e18d: 90 nop
10e18e: 90 nop
10e18f: 90 nop
0010acb0 <_RBTree_Extract>:
void _RBTree_Extract(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
10acb0: 55 push %ebp
10acb1: 89 e5 mov %esp,%ebp
10acb3: 57 push %edi
10acb4: 56 push %esi
10acb5: 53 push %ebx
10acb6: 83 ec 04 sub $0x4,%esp
10acb9: 8b 4d 0c mov 0xc(%ebp),%ecx
10acbc: 8b 75 08 mov 0x8(%ebp),%esi
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10acbf: 8b 19 mov (%ecx),%ebx
10acc1: 8b 41 04 mov 0x4(%ecx),%eax
10acc4: 85 db test %ebx,%ebx
10acc6: 0f 84 14 02 00 00 je 10aee0 <_RBTree_Extract+0x230>
10accc: 85 c0 test %eax,%eax
10acce: 0f 84 9c 00 00 00 je 10ad70 <_RBTree_Extract+0xc0>
10acd4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10acdb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10acdf: 90 nop
10ace0: 89 c3 mov %eax,%ebx
10ace2: 8b 00 mov (%eax),%eax
10ace4: 85 c0 test %eax,%eax
10ace6: 75 f8 jne 10ace0 <_RBTree_Extract+0x30>
10ace8: 8b 43 04 mov 0x4(%ebx),%eax
10aceb: 8b 7b 0c mov 0xc(%ebx),%edi
10acee: 8b 53 08 mov 0x8(%ebx),%edx
10acf1: 85 c0 test %eax,%eax
10acf3: 89 7d f0 mov %edi,-0x10(%ebp)
10acf6: 0f 84 d4 02 00 00 je 10afd0 <_RBTree_Extract+0x320>
10acfc: 89 50 08 mov %edx,0x8(%eax)
10acff: 8b 7b 08 mov 0x8(%ebx),%edi
10ad02: 85 d2 test %edx,%edx
10ad04: 0f 84 a6 02 00 00 je 10afb0 <_RBTree_Extract+0x300> <== NEVER TAKEN
10ad0a: 3b 1a cmp (%edx),%ebx
10ad0c: 0f 84 6e 02 00 00 je 10af80 <_RBTree_Extract+0x2d0>
10ad12: 89 42 04 mov %eax,0x4(%edx)
10ad15: 39 f9 cmp %edi,%ecx
10ad17: 0f 84 9d 02 00 00 je 10afba <_RBTree_Extract+0x30a>
10ad1d: 8b 39 mov (%ecx),%edi
10ad1f: 89 3b mov %edi,(%ebx)
10ad21: 8b 79 04 mov 0x4(%ecx),%edi
10ad24: 89 7b 04 mov %edi,0x4(%ebx)
10ad27: 8b 79 08 mov 0x8(%ecx),%edi
10ad2a: 89 7b 08 mov %edi,0x8(%ebx)
10ad2d: 8b 79 0c mov 0xc(%ecx),%edi
10ad30: 89 7b 0c mov %edi,0xc(%ebx)
10ad33: 8b 79 08 mov 0x8(%ecx),%edi
10ad36: 85 ff test %edi,%edi
10ad38: 0f 84 a2 02 00 00 je 10afe0 <_RBTree_Extract+0x330>
10ad3e: 3b 0f cmp (%edi),%ecx
10ad40: 0f 84 ba 02 00 00 je 10b000 <_RBTree_Extract+0x350>
10ad46: 89 5f 04 mov %ebx,0x4(%edi)
10ad49: 8b 39 mov (%ecx),%edi
10ad4b: 8b 49 04 mov 0x4(%ecx),%ecx
10ad4e: 89 5f 08 mov %ebx,0x8(%edi)
10ad51: 85 c9 test %ecx,%ecx
10ad53: 74 03 je 10ad58 <_RBTree_Extract+0xa8>
10ad55: 89 59 08 mov %ebx,0x8(%ecx)
10ad58: 85 d2 test %edx,%edx
10ad5a: 74 35 je 10ad91 <_RBTree_Extract+0xe1> <== NEVER TAKEN
10ad5c: 89 d1 mov %edx,%ecx
10ad5e: 66 90 xchg %ax,%ax
10ad60: 8b 49 08 mov 0x8(%ecx),%ecx
10ad63: 85 c9 test %ecx,%ecx
10ad65: 75 f9 jne 10ad60 <_RBTree_Extract+0xb0>
10ad67: eb 28 jmp 10ad91 <_RBTree_Extract+0xe1>
10ad69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10ad70: 8b 41 0c mov 0xc(%ecx),%eax
10ad73: 8b 51 08 mov 0x8(%ecx),%edx
10ad76: 89 45 f0 mov %eax,-0x10(%ebp)
10ad79: 89 d8 mov %ebx,%eax
10ad7b: 89 50 08 mov %edx,0x8(%eax)
10ad7e: 85 d2 test %edx,%edx
10ad80: 0f 84 73 01 00 00 je 10aef9 <_RBTree_Extract+0x249>
10ad86: 3b 0a cmp (%edx),%ecx
10ad88: 0f 84 12 02 00 00 je 10afa0 <_RBTree_Extract+0x2f0>
10ad8e: 89 42 04 mov %eax,0x4(%edx)
10ad91: 8b 7d f0 mov -0x10(%ebp),%edi
10ad94: 85 ff test %edi,%edi
10ad96: 74 43 je 10addb <_RBTree_Extract+0x12b>
_Assert( _RBTree_Find_root( the_node ) == _RBTree_Root( the_rbtree ) );
RB_REMOVE( RBTree_Control, the_rbtree, the_node );
_RBTree_Initialize_node( the_node );
}
10ad98: 58 pop %eax
10ad99: 5b pop %ebx
10ad9a: 5e pop %esi
10ad9b: 5f pop %edi
10ad9c: 5d pop %ebp
10ad9d: c3 ret
10ad9e: 66 90 xchg %ax,%ax
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10ada0: 83 79 0c 01 cmpl $0x1,0xc(%ecx)
10ada4: 0f 84 96 00 00 00 je 10ae40 <_RBTree_Extract+0x190>
10adaa: 8b 01 mov (%ecx),%eax
10adac: 85 c0 test %eax,%eax
10adae: 74 0b je 10adbb <_RBTree_Extract+0x10b>
10adb0: 8b 58 0c mov 0xc(%eax),%ebx
10adb3: 85 db test %ebx,%ebx
10adb5: 0f 85 61 01 00 00 jne 10af1c <_RBTree_Extract+0x26c>
10adbb: 8b 59 04 mov 0x4(%ecx),%ebx
10adbe: 85 db test %ebx,%ebx
10adc0: 74 0b je 10adcd <_RBTree_Extract+0x11d>
10adc2: 8b 7b 0c mov 0xc(%ebx),%edi
10adc5: 85 ff test %edi,%edi
10adc7: 0f 85 3c 01 00 00 jne 10af09 <_RBTree_Extract+0x259>
10adcd: c7 41 0c 01 00 00 00 movl $0x1,0xc(%ecx)
10add4: 8b 4a 08 mov 0x8(%edx),%ecx
10add7: 89 d0 mov %edx,%eax
10add9: 89 ca mov %ecx,%edx
10addb: 85 c0 test %eax,%eax
10addd: 74 0b je 10adea <_RBTree_Extract+0x13a>
10addf: 8b 48 0c mov 0xc(%eax),%ecx
10ade2: 85 c9 test %ecx,%ecx
10ade4: 0f 85 26 02 00 00 jne 10b010 <_RBTree_Extract+0x360>
10adea: 8b 0e mov (%esi),%ecx
10adec: 39 c8 cmp %ecx,%eax
10adee: 0f 84 6e 01 00 00 je 10af62 <_RBTree_Extract+0x2b2>
10adf4: 8b 0a mov (%edx),%ecx
10adf6: 39 c1 cmp %eax,%ecx
10adf8: 75 a6 jne 10ada0 <_RBTree_Extract+0xf0>
10adfa: 8b 42 04 mov 0x4(%edx),%eax
10adfd: 83 78 0c 01 cmpl $0x1,0xc(%eax)
10ae01: 8b 08 mov (%eax),%ecx
10ae03: 74 7b je 10ae80 <_RBTree_Extract+0x1d0>
10ae05: 85 c9 test %ecx,%ecx
10ae07: 74 0b je 10ae14 <_RBTree_Extract+0x164>
10ae09: 8b 59 0c mov 0xc(%ecx),%ebx
10ae0c: 85 db test %ebx,%ebx
10ae0e: 0f 85 62 02 00 00 jne 10b076 <_RBTree_Extract+0x3c6>
10ae14: 8b 58 04 mov 0x4(%eax),%ebx
10ae17: 85 db test %ebx,%ebx
10ae19: 74 0b je 10ae26 <_RBTree_Extract+0x176>
10ae1b: 8b 7b 0c mov 0xc(%ebx),%edi
10ae1e: 85 ff test %edi,%edi
10ae20: 0f 85 5e 02 00 00 jne 10b084 <_RBTree_Extract+0x3d4>
10ae26: c7 40 0c 01 00 00 00 movl $0x1,0xc(%eax)
10ae2d: 8b 4a 08 mov 0x8(%edx),%ecx
10ae30: eb a5 jmp 10add7 <_RBTree_Extract+0x127>
10ae32: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10ae39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10ae40: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx)
10ae47: 8b 41 04 mov 0x4(%ecx),%eax
10ae4a: c7 42 0c 01 00 00 00 movl $0x1,0xc(%edx)
10ae51: 89 02 mov %eax,(%edx)
10ae53: 85 c0 test %eax,%eax
10ae55: 74 03 je 10ae5a <_RBTree_Extract+0x1aa> <== NEVER TAKEN
10ae57: 89 50 08 mov %edx,0x8(%eax)
10ae5a: 8b 5a 08 mov 0x8(%edx),%ebx
10ae5d: 89 59 08 mov %ebx,0x8(%ecx)
10ae60: 85 db test %ebx,%ebx
10ae62: 74 6c je 10aed0 <_RBTree_Extract+0x220>
10ae64: 3b 13 cmp (%ebx),%edx
10ae66: 0f 84 94 00 00 00 je 10af00 <_RBTree_Extract+0x250>
10ae6c: 89 4b 04 mov %ecx,0x4(%ebx)
10ae6f: 89 51 04 mov %edx,0x4(%ecx)
10ae72: 89 4a 08 mov %ecx,0x8(%edx)
10ae75: 89 c1 mov %eax,%ecx
10ae77: e9 2e ff ff ff jmp 10adaa <_RBTree_Extract+0xfa>
10ae7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10ae80: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
10ae87: 85 c9 test %ecx,%ecx
10ae89: c7 42 0c 01 00 00 00 movl $0x1,0xc(%edx)
10ae90: 89 4a 04 mov %ecx,0x4(%edx)
10ae93: 74 03 je 10ae98 <_RBTree_Extract+0x1e8> <== NEVER TAKEN
10ae95: 89 51 08 mov %edx,0x8(%ecx)
10ae98: 8b 5a 08 mov 0x8(%edx),%ebx
10ae9b: 89 58 08 mov %ebx,0x8(%eax)
10ae9e: 85 db test %ebx,%ebx
10aea0: 0f 84 ea 00 00 00 je 10af90 <_RBTree_Extract+0x2e0>
10aea6: 3b 13 cmp (%ebx),%edx
10aea8: 0f 84 42 01 00 00 je 10aff0 <_RBTree_Extract+0x340>
10aeae: 89 43 04 mov %eax,0x4(%ebx)
10aeb1: 8b 5a 04 mov 0x4(%edx),%ebx
10aeb4: 89 10 mov %edx,(%eax)
10aeb6: 89 42 08 mov %eax,0x8(%edx)
10aeb9: 8b 0b mov (%ebx),%ecx
10aebb: 89 d8 mov %ebx,%eax
10aebd: e9 43 ff ff ff jmp 10ae05 <_RBTree_Extract+0x155>
10aec2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10aec9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10aed0: 89 0e mov %ecx,(%esi)
10aed2: eb 9b jmp 10ae6f <_RBTree_Extract+0x1bf>
10aed4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10aedb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10aedf: 90 nop
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10aee0: 8b 79 0c mov 0xc(%ecx),%edi
10aee3: 85 c0 test %eax,%eax
10aee5: 8b 51 08 mov 0x8(%ecx),%edx
10aee8: 89 7d f0 mov %edi,-0x10(%ebp)
10aeeb: 0f 85 8a fe ff ff jne 10ad7b <_RBTree_Extract+0xcb>
10aef1: 85 d2 test %edx,%edx
10aef3: 0f 85 8d fe ff ff jne 10ad86 <_RBTree_Extract+0xd6>
10aef9: 89 06 mov %eax,(%esi)
10aefb: e9 91 fe ff ff jmp 10ad91 <_RBTree_Extract+0xe1>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10af00: 89 0b mov %ecx,(%ebx)
10af02: 8b 02 mov (%edx),%eax
10af04: e9 66 ff ff ff jmp 10ae6f <_RBTree_Extract+0x1bf>
10af09: 85 c0 test %eax,%eax
10af0b: 0f 84 06 01 00 00 je 10b017 <_RBTree_Extract+0x367>
10af11: 8b 78 0c mov 0xc(%eax),%edi
10af14: 85 ff test %edi,%edi
10af16: 0f 84 fb 00 00 00 je 10b017 <_RBTree_Extract+0x367> <== ALWAYS TAKEN
10af1c: 8b 7a 0c mov 0xc(%edx),%edi
10af1f: 8b 1a mov (%edx),%ebx
10af21: 89 79 0c mov %edi,0xc(%ecx)
10af24: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
10af2b: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
10af32: 8b 43 04 mov 0x4(%ebx),%eax
10af35: 89 02 mov %eax,(%edx)
10af37: 85 c0 test %eax,%eax
10af39: 74 03 je 10af3e <_RBTree_Extract+0x28e>
10af3b: 89 50 08 mov %edx,0x8(%eax)
10af3e: 8b 42 08 mov 0x8(%edx),%eax
10af41: 89 43 08 mov %eax,0x8(%ebx)
10af44: 85 c0 test %eax,%eax
10af46: 0f 84 21 01 00 00 je 10b06d <_RBTree_Extract+0x3bd>
10af4c: 8b 4a 08 mov 0x8(%edx),%ecx
10af4f: 3b 11 cmp (%ecx),%edx
10af51: 0f 84 b7 01 00 00 je 10b10e <_RBTree_Extract+0x45e>
10af57: 89 58 04 mov %ebx,0x4(%eax)
10af5a: 8b 0e mov (%esi),%ecx
10af5c: 89 53 04 mov %edx,0x4(%ebx)
10af5f: 89 5a 08 mov %ebx,0x8(%edx)
10af62: 85 c9 test %ecx,%ecx
10af64: 0f 84 2e fe ff ff je 10ad98 <_RBTree_Extract+0xe8>
10af6a: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx)
}
10af71: 58 pop %eax
10af72: 5b pop %ebx
10af73: 5e pop %esi
10af74: 5f pop %edi
10af75: 5d pop %ebp
10af76: c3 ret
10af77: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10af7e: 66 90 xchg %ax,%ax
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10af80: 89 02 mov %eax,(%edx)
10af82: e9 8e fd ff ff jmp 10ad15 <_RBTree_Extract+0x65>
10af87: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10af8e: 66 90 xchg %ax,%ax
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10af90: 89 06 mov %eax,(%esi)
10af92: 89 cb mov %ecx,%ebx
10af94: e9 1b ff ff ff jmp 10aeb4 <_RBTree_Extract+0x204>
10af99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10afa0: 89 02 mov %eax,(%edx)
10afa2: e9 ea fd ff ff jmp 10ad91 <_RBTree_Extract+0xe1>
10afa7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10afae: 66 90 xchg %ax,%ax
10afb0: 89 06 mov %eax,(%esi) <== NOT EXECUTED
10afb2: 39 f9 cmp %edi,%ecx <== NOT EXECUTED
10afb4: 0f 85 63 fd ff ff jne 10ad1d <_RBTree_Extract+0x6d> <== NOT EXECUTED
10afba: 89 da mov %ebx,%edx
10afbc: e9 5c fd ff ff jmp 10ad1d <_RBTree_Extract+0x6d>
10afc1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10afc8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10afcf: 90 nop
10afd0: 89 d7 mov %edx,%edi
10afd2: e9 2b fd ff ff jmp 10ad02 <_RBTree_Extract+0x52>
10afd7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10afde: 66 90 xchg %ax,%ax
10afe0: 89 1e mov %ebx,(%esi)
10afe2: e9 62 fd ff ff jmp 10ad49 <_RBTree_Extract+0x99>
10afe7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10afee: 66 90 xchg %ax,%ax
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10aff0: 89 03 mov %eax,(%ebx)
10aff2: 89 cb mov %ecx,%ebx
10aff4: e9 bb fe ff ff jmp 10aeb4 <_RBTree_Extract+0x204>
10aff9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static )
10b000: 89 1f mov %ebx,(%edi)
10b002: e9 42 fd ff ff jmp 10ad49 <_RBTree_Extract+0x99>
10b007: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b00e: 66 90 xchg %ax,%ax
10b010: 89 c1 mov %eax,%ecx
10b012: e9 53 ff ff ff jmp 10af6a <_RBTree_Extract+0x2ba>
RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static )
10b017: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
10b01e: 8b 03 mov (%ebx),%eax
10b020: c7 41 0c 01 00 00 00 movl $0x1,0xc(%ecx)
10b027: 89 41 04 mov %eax,0x4(%ecx)
10b02a: 85 c0 test %eax,%eax
10b02c: 74 03 je 10b031 <_RBTree_Extract+0x381>
10b02e: 89 48 08 mov %ecx,0x8(%eax)
10b031: 8b 41 08 mov 0x8(%ecx),%eax
10b034: 89 43 08 mov %eax,0x8(%ebx)
10b037: 85 c0 test %eax,%eax
10b039: 74 2e je 10b069 <_RBTree_Extract+0x3b9> <== NEVER TAKEN
10b03b: 3b 08 cmp (%eax),%ecx
10b03d: 0f 84 d4 00 00 00 je 10b117 <_RBTree_Extract+0x467> <== ALWAYS TAKEN
10b043: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED
10b046: 89 0b mov %ecx,(%ebx)
10b048: 89 59 08 mov %ebx,0x8(%ecx)
10b04b: 8b 1a mov (%edx),%ebx
10b04d: 8b 4a 0c mov 0xc(%edx),%ecx
10b050: 8b 03 mov (%ebx),%eax
10b052: 89 4b 0c mov %ecx,0xc(%ebx)
10b055: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
10b05c: 85 c0 test %eax,%eax
10b05e: 0f 84 ce fe ff ff je 10af32 <_RBTree_Extract+0x282> <== NEVER TAKEN
10b064: e9 c2 fe ff ff jmp 10af2b <_RBTree_Extract+0x27b>
10b069: 89 1e mov %ebx,(%esi) <== NOT EXECUTED
10b06b: eb d9 jmp 10b046 <_RBTree_Extract+0x396> <== NOT EXECUTED
10b06d: 89 1e mov %ebx,(%esi)
10b06f: 89 d9 mov %ebx,%ecx
10b071: e9 e6 fe ff ff jmp 10af5c <_RBTree_Extract+0x2ac>
10b076: 8b 58 04 mov 0x4(%eax),%ebx
10b079: 85 db test %ebx,%ebx
10b07b: 74 47 je 10b0c4 <_RBTree_Extract+0x414>
10b07d: 8b 7b 0c mov 0xc(%ebx),%edi
10b080: 85 ff test %edi,%edi
10b082: 74 40 je 10b0c4 <_RBTree_Extract+0x414>
10b084: 8b 4a 0c mov 0xc(%edx),%ecx
10b087: 8b 7a 04 mov 0x4(%edx),%edi
10b08a: 89 48 0c mov %ecx,0xc(%eax)
10b08d: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
10b094: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
10b09b: 8b 07 mov (%edi),%eax
10b09d: 89 42 04 mov %eax,0x4(%edx)
10b0a0: 85 c0 test %eax,%eax
10b0a2: 74 03 je 10b0a7 <_RBTree_Extract+0x3f7>
10b0a4: 89 50 08 mov %edx,0x8(%eax)
10b0a7: 8b 42 08 mov 0x8(%edx),%eax
10b0aa: 89 47 08 mov %eax,0x8(%edi)
10b0ad: 85 c0 test %eax,%eax
10b0af: 74 6d je 10b11e <_RBTree_Extract+0x46e>
10b0b1: 3b 10 cmp (%eax),%edx
10b0b3: 74 6f je 10b124 <_RBTree_Extract+0x474>
10b0b5: 89 78 04 mov %edi,0x4(%eax)
10b0b8: 8b 0e mov (%esi),%ecx
10b0ba: 89 17 mov %edx,(%edi)
10b0bc: 89 7a 08 mov %edi,0x8(%edx)
10b0bf: e9 9e fe ff ff jmp 10af62 <_RBTree_Extract+0x2b2>
10b0c4: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx)
10b0cb: 8b 59 04 mov 0x4(%ecx),%ebx
10b0ce: c7 40 0c 01 00 00 00 movl $0x1,0xc(%eax)
10b0d5: 89 18 mov %ebx,(%eax)
10b0d7: 85 db test %ebx,%ebx
10b0d9: 74 03 je 10b0de <_RBTree_Extract+0x42e>
10b0db: 89 43 08 mov %eax,0x8(%ebx)
10b0de: 8b 58 08 mov 0x8(%eax),%ebx
10b0e1: 89 59 08 mov %ebx,0x8(%ecx)
10b0e4: 85 db test %ebx,%ebx
10b0e6: 74 42 je 10b12a <_RBTree_Extract+0x47a> <== NEVER TAKEN
10b0e8: 3b 03 cmp (%ebx),%eax
10b0ea: 74 42 je 10b12e <_RBTree_Extract+0x47e> <== NEVER TAKEN
10b0ec: 89 4b 04 mov %ecx,0x4(%ebx)
10b0ef: 89 41 04 mov %eax,0x4(%ecx)
10b0f2: 89 48 08 mov %ecx,0x8(%eax)
10b0f5: 8b 7a 04 mov 0x4(%edx),%edi
10b0f8: 8b 42 0c mov 0xc(%edx),%eax
10b0fb: 8b 5f 04 mov 0x4(%edi),%ebx
10b0fe: 89 47 0c mov %eax,0xc(%edi)
10b101: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
10b108: 85 db test %ebx,%ebx
10b10a: 74 8f je 10b09b <_RBTree_Extract+0x3eb> <== NEVER TAKEN
10b10c: eb 86 jmp 10b094 <_RBTree_Extract+0x3e4>
10b10e: 89 18 mov %ebx,(%eax)
10b110: 8b 0e mov (%esi),%ecx
10b112: e9 45 fe ff ff jmp 10af5c <_RBTree_Extract+0x2ac>
10b117: 89 18 mov %ebx,(%eax)
10b119: e9 28 ff ff ff jmp 10b046 <_RBTree_Extract+0x396>
10b11e: 89 3e mov %edi,(%esi)
10b120: 89 f9 mov %edi,%ecx
10b122: eb 96 jmp 10b0ba <_RBTree_Extract+0x40a>
10b124: 89 38 mov %edi,(%eax)
10b126: 8b 0e mov (%esi),%ecx
10b128: eb 90 jmp 10b0ba <_RBTree_Extract+0x40a>
10b12a: 89 0e mov %ecx,(%esi) <== NOT EXECUTED
10b12c: eb c1 jmp 10b0ef <_RBTree_Extract+0x43f> <== NOT EXECUTED
10b12e: 89 0b mov %ecx,(%ebx) <== NOT EXECUTED
10b130: eb bd jmp 10b0ef <_RBTree_Extract+0x43f> <== NOT EXECUTED
10b132: 90 nop
10b133: 90 nop
10b134: 90 nop
10b135: 90 nop
10b136: 90 nop
10b137: 90 nop
10b138: 90 nop
10b139: 90 nop
10b13a: 90 nop
10b13b: 90 nop
10b13c: 90 nop
10b13d: 90 nop
10b13e: 90 nop
10b13f: 90 nop
0010b140 <_RBTree_Insert_color>:
void _RBTree_Insert_color(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
10b140: 55 push %ebp
10b141: 89 e5 mov %esp,%ebp
10b143: 57 push %edi
10b144: 8b 4d 0c mov 0xc(%ebp),%ecx
10b147: 56 push %esi
10b148: 8b 75 08 mov 0x8(%ebp),%esi
10b14b: 53 push %ebx
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
10b14c: 8b 41 08 mov 0x8(%ecx),%eax
10b14f: 85 c0 test %eax,%eax
10b151: 74 67 je 10b1ba <_RBTree_Insert_color+0x7a>
10b153: 83 78 0c 01 cmpl $0x1,0xc(%eax)
10b157: 75 61 jne 10b1ba <_RBTree_Insert_color+0x7a>
10b159: 8b 50 08 mov 0x8(%eax),%edx
10b15c: 8b 1a mov (%edx),%ebx
10b15e: 39 c3 cmp %eax,%ebx
10b160: 74 6e je 10b1d0 <_RBTree_Insert_color+0x90>
10b162: 85 db test %ebx,%ebx
10b164: 74 0a je 10b170 <_RBTree_Insert_color+0x30>
10b166: 83 7b 0c 01 cmpl $0x1,0xc(%ebx)
10b16a: 0f 84 10 01 00 00 je 10b280 <_RBTree_Insert_color+0x140>
10b170: 39 08 cmp %ecx,(%eax)
10b172: 0f 84 c8 00 00 00 je 10b240 <_RBTree_Insert_color+0x100>
10b178: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
10b17f: 8b 42 04 mov 0x4(%edx),%eax
10b182: c7 42 0c 01 00 00 00 movl $0x1,0xc(%edx)
10b189: 8b 18 mov (%eax),%ebx
10b18b: 89 5a 04 mov %ebx,0x4(%edx)
10b18e: 85 db test %ebx,%ebx
10b190: 74 03 je 10b195 <_RBTree_Insert_color+0x55>
10b192: 89 53 08 mov %edx,0x8(%ebx)
10b195: 8b 5a 08 mov 0x8(%edx),%ebx
10b198: 89 58 08 mov %ebx,0x8(%eax)
10b19b: 85 db test %ebx,%ebx
10b19d: 0f 84 8d 00 00 00 je 10b230 <_RBTree_Insert_color+0xf0>
10b1a3: 3b 13 cmp (%ebx),%edx
10b1a5: 0f 84 f5 00 00 00 je 10b2a0 <_RBTree_Insert_color+0x160>
10b1ab: 89 43 04 mov %eax,0x4(%ebx)
10b1ae: 89 10 mov %edx,(%eax)
10b1b0: 89 42 08 mov %eax,0x8(%edx)
10b1b3: 8b 41 08 mov 0x8(%ecx),%eax
10b1b6: 85 c0 test %eax,%eax
10b1b8: 75 99 jne 10b153 <_RBTree_Insert_color+0x13> <== ALWAYS TAKEN
10b1ba: 8b 06 mov (%esi),%eax
10b1bc: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
RBTree_Control_RB_INSERT_COLOR( the_rbtree, the_node );
}
10b1c3: 5b pop %ebx
10b1c4: 5e pop %esi
10b1c5: 5f pop %edi
10b1c6: 5d pop %ebp
10b1c7: c3 ret
10b1c8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b1cf: 90 nop
RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline )
10b1d0: 8b 5a 04 mov 0x4(%edx),%ebx
10b1d3: 85 db test %ebx,%ebx
10b1d5: 74 0a je 10b1e1 <_RBTree_Insert_color+0xa1>
10b1d7: 83 7b 0c 01 cmpl $0x1,0xc(%ebx)
10b1db: 0f 84 9f 00 00 00 je 10b280 <_RBTree_Insert_color+0x140>
10b1e1: 39 48 04 cmp %ecx,0x4(%eax)
10b1e4: 89 c3 mov %eax,%ebx
10b1e6: 0f 84 c4 00 00 00 je 10b2b0 <_RBTree_Insert_color+0x170>
10b1ec: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
10b1f3: 8b 43 04 mov 0x4(%ebx),%eax
10b1f6: c7 42 0c 01 00 00 00 movl $0x1,0xc(%edx)
10b1fd: 89 02 mov %eax,(%edx)
10b1ff: 85 c0 test %eax,%eax
10b201: 74 03 je 10b206 <_RBTree_Insert_color+0xc6>
10b203: 89 50 08 mov %edx,0x8(%eax)
10b206: 8b 42 08 mov 0x8(%edx),%eax
10b209: 89 43 08 mov %eax,0x8(%ebx)
10b20c: 85 c0 test %eax,%eax
10b20e: 0f 84 cc 00 00 00 je 10b2e0 <_RBTree_Insert_color+0x1a0>
10b214: 3b 10 cmp (%eax),%edx
10b216: 0f 84 d4 00 00 00 je 10b2f0 <_RBTree_Insert_color+0x1b0>
10b21c: 89 58 04 mov %ebx,0x4(%eax)
10b21f: 89 53 04 mov %edx,0x4(%ebx)
10b222: 89 5a 08 mov %ebx,0x8(%edx)
10b225: e9 22 ff ff ff jmp 10b14c <_RBTree_Insert_color+0xc>
10b22a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
10b230: 89 06 mov %eax,(%esi)
10b232: e9 77 ff ff ff jmp 10b1ae <_RBTree_Insert_color+0x6e>
10b237: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b23e: 66 90 xchg %ax,%ax
10b240: 8b 59 04 mov 0x4(%ecx),%ebx
10b243: 89 18 mov %ebx,(%eax)
10b245: 85 db test %ebx,%ebx
10b247: 0f 84 c3 00 00 00 je 10b310 <_RBTree_Insert_color+0x1d0>
10b24d: 89 43 08 mov %eax,0x8(%ebx)
10b250: 8b 58 08 mov 0x8(%eax),%ebx
10b253: 89 59 08 mov %ebx,0x8(%ecx)
10b256: 85 db test %ebx,%ebx
10b258: 0f 84 a2 00 00 00 je 10b300 <_RBTree_Insert_color+0x1c0> <== NEVER TAKEN
10b25e: 39 03 cmp %eax,(%ebx)
10b260: 0f 84 b7 00 00 00 je 10b31d <_RBTree_Insert_color+0x1dd> <== NEVER TAKEN
10b266: 89 4b 04 mov %ecx,0x4(%ebx)
10b269: 89 41 04 mov %eax,0x4(%ecx)
10b26c: 89 cb mov %ecx,%ebx
10b26e: 89 48 08 mov %ecx,0x8(%eax)
10b271: 89 c1 mov %eax,%ecx
10b273: 89 d8 mov %ebx,%eax
10b275: e9 fe fe ff ff jmp 10b178 <_RBTree_Insert_color+0x38>
10b27a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
10b280: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
10b287: 89 d1 mov %edx,%ecx
10b289: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
10b290: c7 42 0c 01 00 00 00 movl $0x1,0xc(%edx)
10b297: e9 b0 fe ff ff jmp 10b14c <_RBTree_Insert_color+0xc>
10b29c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10b2a0: 89 03 mov %eax,(%ebx)
10b2a2: e9 07 ff ff ff jmp 10b1ae <_RBTree_Insert_color+0x6e>
10b2a7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b2ae: 66 90 xchg %ax,%ax
10b2b0: 8b 19 mov (%ecx),%ebx
10b2b2: 89 58 04 mov %ebx,0x4(%eax)
10b2b5: 85 db test %ebx,%ebx
10b2b7: 74 77 je 10b330 <_RBTree_Insert_color+0x1f0>
10b2b9: 89 43 08 mov %eax,0x8(%ebx)
10b2bc: 8b 58 08 mov 0x8(%eax),%ebx
10b2bf: 89 59 08 mov %ebx,0x8(%ecx)
10b2c2: 85 db test %ebx,%ebx
10b2c4: 74 7a je 10b340 <_RBTree_Insert_color+0x200> <== NEVER TAKEN
10b2c6: 39 03 cmp %eax,(%ebx)
10b2c8: 74 6b je 10b335 <_RBTree_Insert_color+0x1f5> <== ALWAYS TAKEN
10b2ca: 89 4b 04 mov %ecx,0x4(%ebx) <== NOT EXECUTED
10b2cd: 89 01 mov %eax,(%ecx)
10b2cf: 89 cf mov %ecx,%edi
10b2d1: 89 48 08 mov %ecx,0x8(%eax)
10b2d4: 8b 1a mov (%edx),%ebx
10b2d6: 89 c1 mov %eax,%ecx
10b2d8: 89 f8 mov %edi,%eax
10b2da: e9 0d ff ff ff jmp 10b1ec <_RBTree_Insert_color+0xac>
10b2df: 90 nop
10b2e0: 89 1e mov %ebx,(%esi)
10b2e2: e9 38 ff ff ff jmp 10b21f <_RBTree_Insert_color+0xdf>
10b2e7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b2ee: 66 90 xchg %ax,%ax
10b2f0: 89 18 mov %ebx,(%eax)
10b2f2: e9 28 ff ff ff jmp 10b21f <_RBTree_Insert_color+0xdf>
10b2f7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b2fe: 66 90 xchg %ax,%ax
10b300: 89 0e mov %ecx,(%esi) <== NOT EXECUTED
10b302: e9 62 ff ff ff jmp 10b269 <_RBTree_Insert_color+0x129> <== NOT EXECUTED
10b307: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10b30e: 66 90 xchg %ax,%ax <== NOT EXECUTED
10b310: 89 51 08 mov %edx,0x8(%ecx)
10b313: 89 d3 mov %edx,%ebx
10b315: 39 03 cmp %eax,(%ebx)
10b317: 0f 85 49 ff ff ff jne 10b266 <_RBTree_Insert_color+0x126> <== ALWAYS TAKEN
10b31d: 89 0b mov %ecx,(%ebx) <== NOT EXECUTED
10b31f: e9 45 ff ff ff jmp 10b269 <_RBTree_Insert_color+0x129> <== NOT EXECUTED
10b324: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10b32b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10b32f: 90 nop <== NOT EXECUTED
10b330: 89 51 08 mov %edx,0x8(%ecx)
10b333: 89 d3 mov %edx,%ebx
10b335: 89 0b mov %ecx,(%ebx)
10b337: eb 94 jmp 10b2cd <_RBTree_Insert_color+0x18d>
10b339: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b340: 89 0e mov %ecx,(%esi) <== NOT EXECUTED
10b342: eb 89 jmp 10b2cd <_RBTree_Insert_color+0x18d> <== NOT EXECUTED
10b344: 90 nop
10b345: 90 nop
10b346: 90 nop
10b347: 90 nop
10b348: 90 nop
10b349: 90 nop
10b34a: 90 nop
10b34b: 90 nop
10b34c: 90 nop
10b34d: 90 nop
10b34e: 90 nop
10b34f: 90 nop
001067e0 <_RBTree_Iterate>:
void _RBTree_Iterate(
const RBTree_Control *rbtree,
RBTree_Visitor visitor,
void *visitor_arg
)
{
1067e0: 55 push %ebp
1067e1: 89 e5 mov %esp,%ebp
1067e3: 57 push %edi
1067e4: 56 push %esi
1067e5: 53 push %ebx
1067e6: 83 ec 1c sub $0x1c,%esp
const RBTree_Node *current = _RBTree_Minimum( rbtree );
1067e9: 8b 45 08 mov 0x8(%ebp),%eax
{
1067ec: 8b 7d 0c mov 0xc(%ebp),%edi
const RBTree_Node *current = _RBTree_Minimum( rbtree );
1067ef: 89 04 24 mov %eax,(%esp)
1067f2: e8 39 00 00 00 call 106830 <_RBTree_Minimum>
bool stop = false;
while ( !stop && current != NULL ) {
1067f7: 85 c0 test %eax,%eax
1067f9: 74 25 je 106820 <_RBTree_Iterate+0x40>
1067fb: 89 c6 mov %eax,%esi
1067fd: 8d 76 00 lea 0x0(%esi),%esi
stop = ( *visitor )( current, visitor_arg );
106800: 89 34 24 mov %esi,(%esp)
106803: 8b 45 10 mov 0x10(%ebp),%eax
106806: 89 44 24 04 mov %eax,0x4(%esp)
10680a: ff d7 call *%edi
current = _RBTree_Successor( current );
10680c: 89 34 24 mov %esi,(%esp)
stop = ( *visitor )( current, visitor_arg );
10680f: 88 c3 mov %al,%bl
current = _RBTree_Successor( current );
106811: e8 4a 00 00 00 call 106860 <_RBTree_Successor>
while ( !stop && current != NULL ) {
106816: fe cb dec %bl
current = _RBTree_Successor( current );
106818: 89 c6 mov %eax,%esi
while ( !stop && current != NULL ) {
10681a: 74 04 je 106820 <_RBTree_Iterate+0x40> <== NEVER TAKEN
10681c: 85 c0 test %eax,%eax
10681e: 75 e0 jne 106800 <_RBTree_Iterate+0x20>
}
}
106820: 83 c4 1c add $0x1c,%esp
106823: 5b pop %ebx
106824: 5e pop %esi
106825: 5f pop %edi
106826: 5d pop %ebp
106827: c3 ret
106828: 90 nop
106829: 90 nop
10682a: 90 nop
10682b: 90 nop
10682c: 90 nop
10682d: 90 nop
10682e: 90 nop
10682f: 90 nop
00115b10 <_RBTree_Predecessor>:
RBTree_Node *_RBTree_Predecessor( const RBTree_Node *node )
{
115b10: 55 push %ebp
115b11: 89 e5 mov %esp,%ebp
115b13: 8b 4d 08 mov 0x8(%ebp),%ecx
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
115b16: 8b 01 mov (%ecx),%eax
115b18: 85 c0 test %eax,%eax
115b1a: 74 14 je 115b30 <_RBTree_Predecessor+0x20>
115b1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
115b20: 89 c2 mov %eax,%edx
115b22: 8b 40 04 mov 0x4(%eax),%eax
115b25: 85 c0 test %eax,%eax
115b27: 75 f7 jne 115b20 <_RBTree_Predecessor+0x10>
return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
}
115b29: 5d pop %ebp
115b2a: 89 d0 mov %edx,%eax
115b2c: c3 ret
115b2d: 8d 76 00 lea 0x0(%esi),%esi
RB_GENERATE_PREV( RBTree_Control, RBTree_Node, Node, static )
115b30: 8b 51 08 mov 0x8(%ecx),%edx
115b33: 85 d2 test %edx,%edx
115b35: 74 f2 je 115b29 <_RBTree_Predecessor+0x19>
115b37: 3b 4a 04 cmp 0x4(%edx),%ecx
115b3a: 74 ed je 115b29 <_RBTree_Predecessor+0x19>
115b3c: 39 0a cmp %ecx,(%edx)
115b3e: 75 e9 jne 115b29 <_RBTree_Predecessor+0x19> <== NEVER TAKEN
115b40: 8b 42 08 mov 0x8(%edx),%eax
115b43: 89 d1 mov %edx,%ecx
115b45: 85 c0 test %eax,%eax
115b47: 74 0a je 115b53 <_RBTree_Predecessor+0x43>
115b49: 89 c2 mov %eax,%edx
115b4b: 39 0a cmp %ecx,(%edx)
115b4d: 74 f1 je 115b40 <_RBTree_Predecessor+0x30>
}
115b4f: 5d pop %ebp
115b50: 89 d0 mov %edx,%eax
115b52: c3 ret
115b53: 31 d2 xor %edx,%edx
return RB_PREV( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
115b55: eb d2 jmp 115b29 <_RBTree_Predecessor+0x19>
115b57: 90 nop
115b58: 90 nop
115b59: 90 nop
115b5a: 90 nop
115b5b: 90 nop
115b5c: 90 nop
115b5d: 90 nop
115b5e: 90 nop
115b5f: 90 nop
00115ac0 <_RBTree_Successor>:
RBTree_Node *_RBTree_Successor( const RBTree_Node *node )
{
115ac0: 55 push %ebp
115ac1: 89 e5 mov %esp,%ebp
115ac3: 8b 4d 08 mov 0x8(%ebp),%ecx
RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
115ac6: 8b 41 04 mov 0x4(%ecx),%eax
115ac9: 85 c0 test %eax,%eax
115acb: 74 13 je 115ae0 <_RBTree_Successor+0x20>
115acd: 8d 76 00 lea 0x0(%esi),%esi
115ad0: 89 c2 mov %eax,%edx
115ad2: 8b 00 mov (%eax),%eax
115ad4: 85 c0 test %eax,%eax
115ad6: 75 f8 jne 115ad0 <_RBTree_Successor+0x10>
return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
}
115ad8: 5d pop %ebp
115ad9: 89 d0 mov %edx,%eax
115adb: c3 ret
115adc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
RB_GENERATE_NEXT( RBTree_Control, RBTree_Node, Node, static )
115ae0: 8b 51 08 mov 0x8(%ecx),%edx
115ae3: 85 d2 test %edx,%edx
115ae5: 74 f1 je 115ad8 <_RBTree_Successor+0x18>
115ae7: 3b 0a cmp (%edx),%ecx
115ae9: 74 ed je 115ad8 <_RBTree_Successor+0x18>
115aeb: 39 4a 04 cmp %ecx,0x4(%edx)
115aee: 75 e8 jne 115ad8 <_RBTree_Successor+0x18> <== NEVER TAKEN
115af0: 8b 42 08 mov 0x8(%edx),%eax
115af3: 89 d1 mov %edx,%ecx
115af5: 85 c0 test %eax,%eax
115af7: 74 0b je 115b04 <_RBTree_Successor+0x44>
115af9: 89 c2 mov %eax,%edx
115afb: 39 4a 04 cmp %ecx,0x4(%edx)
115afe: 74 f0 je 115af0 <_RBTree_Successor+0x30>
}
115b00: 5d pop %ebp
115b01: 89 d0 mov %edx,%eax
115b03: c3 ret
115b04: 31 d2 xor %edx,%edx
return RB_NEXT( RBTree_Control, NULL, RTEMS_DECONST( RBTree_Node *, node ) );
115b06: eb d0 jmp 115ad8 <_RBTree_Successor+0x18>
115b08: 90 nop
115b09: 90 nop
115b0a: 90 nop
115b0b: 90 nop
115b0c: 90 nop
115b0d: 90 nop
115b0e: 90 nop
115b0f: 90 nop
00119070 <_SMP_barrier_Wait>:
bool _SMP_barrier_Wait(
SMP_barrier_Control *control,
SMP_barrier_State *state,
unsigned int count
)
{
119070: 55 push %ebp
119071: 89 e5 mov %esp,%ebp
119073: 53 push %ebx
119074: 8b 45 0c mov 0xc(%ebp),%eax
119077: 8b 4d 08 mov 0x8(%ebp),%ecx
unsigned int sense = ~state->sense;
11907a: 8b 10 mov (%eax),%edx
11907c: f7 d2 not %edx
unsigned int previous_value;
bool performed_release;
state->sense = sense;
11907e: 89 10 mov %edx,(%eax)
_ISR_Local_disable( level );
119080: 9c pushf
119081: fa cli
119082: 5b pop %ebx
*obj = val + arg;
119083: 8b 01 mov (%ecx),%eax
119085: 40 inc %eax
119086: 89 01 mov %eax,(%ecx)
_ISR_Local_enable( level );
119088: 53 push %ebx
119089: 9d popf
&control->value,
1U,
ATOMIC_ORDER_RELAXED
);
if ( previous_value + 1U == count ) {
11908a: 39 45 10 cmp %eax,0x10(%ebp)
11908d: 74 11 je 1190a0 <_SMP_barrier_Wait+0x30> <== ALWAYS TAKEN
11908f: 90 nop
val = *obj;
119090: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
_Atomic_Store_uint( &control->value, 0U, ATOMIC_ORDER_RELAXED );
_Atomic_Store_uint( &control->sense, sense, ATOMIC_ORDER_RELEASE );
performed_release = true;
} else {
while (
119093: 39 c2 cmp %eax,%edx <== NOT EXECUTED
119095: 75 f9 jne 119090 <_SMP_barrier_Wait+0x20> <== NOT EXECUTED
performed_release = false;
}
return performed_release;
}
119097: 5b pop %ebx <== NOT EXECUTED
performed_release = false;
119098: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
11909a: 5d pop %ebp <== NOT EXECUTED
11909b: c3 ret <== NOT EXECUTED
11909c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
*obj = desired;
1190a0: c7 01 00 00 00 00 movl $0x0,(%ecx)
1190a6: 89 51 04 mov %edx,0x4(%ecx)
performed_release = true;
1190a9: b0 01 mov $0x1,%al
}
1190ab: 5b pop %ebx
1190ac: 5d pop %ebp
1190ad: c3 ret
1190ae: 90 nop
1190af: 90 nop
00106cd0 <_Scheduler_CBS_Attach_thread>:
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
106cd0: 55 push %ebp
106cd1: 89 e5 mov %esp,%ebp
106cd3: 83 ec 38 sub $0x38,%esp
106cd6: 89 75 f8 mov %esi,-0x8(%ebp)
106cd9: 8b 45 08 mov 0x8(%ebp),%eax
Scheduler_CBS_Server *server;
ISR_lock_Context lock_context;
Thread_Control *the_thread;
Scheduler_CBS_Node *node;
if ( server_id >= _Scheduler_CBS_Maximum_servers ) {
106cdc: 39 05 48 23 12 00 cmp %eax,0x122348
{
106ce2: 89 5d f4 mov %ebx,-0xc(%ebp)
106ce5: 8b 75 0c mov 0xc(%ebp),%esi
106ce8: 89 7d fc mov %edi,-0x4(%ebp)
if ( server_id >= _Scheduler_CBS_Maximum_servers ) {
106ceb: 0f 86 9f 00 00 00 jbe 106d90 <_Scheduler_CBS_Attach_thread+0xc0>
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
server = &_Scheduler_CBS_Server_list[ server_id ];
106cf1: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
106cf8: 29 c3 sub %eax,%ebx
106cfa: c1 e3 02 shl $0x2,%ebx
if ( !server->initialized ) {
106cfd: 80 bb 38 ad 12 00 00 cmpb $0x0,0x12ad38(%ebx)
server = &_Scheduler_CBS_Server_list[ server_id ];
106d04: 8d bb 20 ad 12 00 lea 0x12ad20(%ebx),%edi
if ( !server->initialized ) {
106d0a: 0f 84 90 00 00 00 je 106da0 <_Scheduler_CBS_Attach_thread+0xd0>
return SCHEDULER_CBS_ERROR_NOSERVER;
}
if ( server->task_id != -1 ) {
106d10: 83 bb 20 ad 12 00 ff cmpl $0xffffffff,0x12ad20(%ebx)
106d17: 75 57 jne 106d70 <_Scheduler_CBS_Attach_thread+0xa0>
return SCHEDULER_CBS_ERROR_FULL;
}
the_thread = _Thread_Get( task_id, &lock_context );
106d19: 89 34 24 mov %esi,(%esp)
106d1c: 8d 45 e4 lea -0x1c(%ebp),%eax
106d1f: 89 44 24 04 mov %eax,0x4(%esp)
106d23: e8 88 16 00 00 call 1083b0 <_Thread_Get>
if ( the_thread == NULL ) {
106d28: 85 c0 test %eax,%eax
106d2a: 74 64 je 106d90 <_Scheduler_CBS_Attach_thread+0xc0>
return the_thread->Scheduler.nodes;
106d2c: 8b 50 38 mov 0x38(%eax),%edx
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
}
node = _Scheduler_CBS_Thread_get_node( the_thread );
if ( node->cbs_server != NULL ) {
106d2f: 8b 4a 48 mov 0x48(%edx),%ecx
106d32: 85 c9 test %ecx,%ecx
106d34: 75 4a jne 106d80 <_Scheduler_CBS_Attach_thread+0xb0> <== NEVER TAKEN
_ISR_lock_ISR_enable( &lock_context );
return SCHEDULER_CBS_ERROR_FULL;
}
node->cbs_server = server;
106d36: 89 7a 48 mov %edi,0x48(%edx)
server->task_id = task_id;
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
106d39: b9 03 00 00 00 mov $0x3,%ecx
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
106d3e: ba b0 6d 10 00 mov $0x106db0,%edx
server->task_id = task_id;
106d43: 89 b3 20 ad 12 00 mov %esi,0x12ad20(%ebx)
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
106d49: 89 90 8c 00 00 00 mov %edx,0x8c(%eax)
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
106d4f: 89 88 88 00 00 00 mov %ecx,0x88(%eax)
the_thread->is_preemptible = true;
106d55: c6 80 81 00 00 00 01 movb $0x1,0x81(%eax)
_ISR_lock_ISR_enable( &lock_context );
106d5c: ff 75 e4 push -0x1c(%ebp)
106d5f: 9d popf
return SCHEDULER_CBS_OK;
106d60: 31 c0 xor %eax,%eax
}
106d62: 8b 5d f4 mov -0xc(%ebp),%ebx
106d65: 8b 75 f8 mov -0x8(%ebp),%esi
106d68: 8b 7d fc mov -0x4(%ebp),%edi
106d6b: 89 ec mov %ebp,%esp
106d6d: 5d pop %ebp
106d6e: c3 ret
106d6f: 90 nop
return SCHEDULER_CBS_ERROR_FULL;
106d70: b8 e6 ff ff ff mov $0xffffffe6,%eax
106d75: eb eb jmp 106d62 <_Scheduler_CBS_Attach_thread+0x92>
106d77: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106d7e: 66 90 xchg %ax,%ax
_ISR_lock_ISR_enable( &lock_context );
106d80: ff 75 e4 push -0x1c(%ebp) <== NOT EXECUTED
106d83: 9d popf <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
106d84: b8 e6 ff ff ff mov $0xffffffe6,%eax <== NOT EXECUTED
106d89: eb d7 jmp 106d62 <_Scheduler_CBS_Attach_thread+0x92> <== NOT EXECUTED
106d8b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106d8f: 90 nop <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
106d90: b8 ee ff ff ff mov $0xffffffee,%eax
106d95: eb cb jmp 106d62 <_Scheduler_CBS_Attach_thread+0x92>
106d97: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106d9e: 66 90 xchg %ax,%ax
return SCHEDULER_CBS_ERROR_NOSERVER;
106da0: b8 e7 ff ff ff mov $0xffffffe7,%eax
106da5: eb bb jmp 106d62 <_Scheduler_CBS_Attach_thread+0x92>
106da7: 90 nop
106da8: 90 nop
106da9: 90 nop
106daa: 90 nop
106dab: 90 nop
106dac: 90 nop
106dad: 90 nop
106dae: 90 nop
106daf: 90 nop
00106db0 <_Scheduler_CBS_Budget_callout>:
#include <rtems/score/schedulercbsimpl.h>
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
106db0: 55 push %ebp
106db1: 89 e5 mov %esp,%ebp
106db3: 83 ec 48 sub $0x48,%esp
106db6: 89 5d f8 mov %ebx,-0x8(%ebp)
106db9: 8b 45 08 mov 0x8(%ebp),%eax
106dbc: 89 75 fc mov %esi,-0x4(%ebp)
node = _Scheduler_CBS_Thread_get_node( the_thread );
/* Put violating task to background until the end of period. */
_Thread_queue_Context_clear_priority_updates( &queue_context );
_Scheduler_CBS_Cancel_job(
106dbf: 8d 75 d4 lea -0x2c(%ebp),%esi
queue_context->Priority.update_count = 0;
106dc2: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
106dc9: 8b 58 38 mov 0x38(%eax),%ebx
106dcc: 89 74 24 0c mov %esi,0xc(%esp)
106dd0: 8b 53 4c mov 0x4c(%ebx),%edx
106dd3: 89 44 24 04 mov %eax,0x4(%esp)
106dd7: c7 04 24 00 00 00 00 movl $0x0,(%esp)
106dde: 89 54 24 08 mov %edx,0x8(%esp)
106de2: e8 39 06 00 00 call 107420 <_Scheduler_CBS_Cancel_job>
NULL,
the_thread,
node->deadline_node,
&queue_context
);
_Thread_Priority_update( &queue_context );
106de7: 89 34 24 mov %esi,(%esp)
106dea: e8 d1 12 00 00 call 1080c0 <_Thread_Priority_update>
/* Invoke callback function if any. */
if ( node->cbs_server->cbs_budget_overrun ) {
106def: 8b 43 48 mov 0x48(%ebx),%eax
106df2: 8b 50 14 mov 0x14(%eax),%edx
106df5: 85 d2 test %edx,%edx
106df7: 74 1d je 106e16 <_Scheduler_CBS_Budget_callout+0x66> <== NEVER TAKEN
_Scheduler_CBS_Get_server_id(
106df9: 8d 55 d0 lea -0x30(%ebp),%edx
106dfc: 89 54 24 04 mov %edx,0x4(%esp)
106e00: 8b 00 mov (%eax),%eax
106e02: 89 04 24 mov %eax,(%esp)
106e05: e8 06 05 00 00 call 107310 <_Scheduler_CBS_Get_server_id>
node->cbs_server->task_id,
&server_id
);
node->cbs_server->cbs_budget_overrun( server_id );
106e0a: 8b 55 d0 mov -0x30(%ebp),%edx
106e0d: 8b 43 48 mov 0x48(%ebx),%eax
106e10: 89 14 24 mov %edx,(%esp)
106e13: ff 50 14 call *0x14(%eax)
}
}
106e16: 8b 5d f8 mov -0x8(%ebp),%ebx
106e19: 8b 75 fc mov -0x4(%ebp),%esi
106e1c: 89 ec mov %ebp,%esp
106e1e: 5d pop %ebp
106e1f: c3 ret
00106e30 <_Scheduler_CBS_Cleanup>:
#include <rtems/score/schedulercbs.h>
#include <rtems/score/wkspace.h>
int _Scheduler_CBS_Cleanup (void)
{
106e30: 55 push %ebp
106e31: 89 e5 mov %esp,%ebp
106e33: 57 push %edi
106e34: 56 push %esi
106e35: 53 push %ebx
106e36: 83 ec 1c sub $0x1c,%esp
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
106e39: 8b 3d 48 23 12 00 mov 0x122348,%edi
106e3f: 85 ff test %edi,%edi
106e41: 74 2a je 106e6d <_Scheduler_CBS_Cleanup+0x3d> <== NEVER TAKEN
106e43: be 38 ad 12 00 mov $0x12ad38,%esi
106e48: 31 db xor %ebx,%ebx
106e4a: eb 0c jmp 106e58 <_Scheduler_CBS_Cleanup+0x28>
106e4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106e50: 43 inc %ebx
106e51: 83 c6 1c add $0x1c,%esi
106e54: 39 fb cmp %edi,%ebx
106e56: 74 15 je 106e6d <_Scheduler_CBS_Cleanup+0x3d>
if ( _Scheduler_CBS_Server_list[ i ].initialized )
106e58: 80 3e 00 cmpb $0x0,(%esi)
106e5b: 74 f3 je 106e50 <_Scheduler_CBS_Cleanup+0x20>
_Scheduler_CBS_Destroy_server( i );
106e5d: 89 1c 24 mov %ebx,(%esp)
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
106e60: 43 inc %ebx
106e61: 83 c6 1c add $0x1c,%esi
_Scheduler_CBS_Destroy_server( i );
106e64: e8 d7 00 00 00 call 106f40 <_Scheduler_CBS_Destroy_server>
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
106e69: 39 fb cmp %edi,%ebx
106e6b: 75 eb jne 106e58 <_Scheduler_CBS_Cleanup+0x28> <== ALWAYS TAKEN
}
return SCHEDULER_CBS_OK;
}
106e6d: 83 c4 1c add $0x1c,%esp
106e70: 31 c0 xor %eax,%eax
106e72: 5b pop %ebx
106e73: 5e pop %esi
106e74: 5f pop %edi
106e75: 5d pop %ebp
106e76: c3 ret
106e77: 90 nop
106e78: 90 nop
106e79: 90 nop
106e7a: 90 nop
106e7b: 90 nop
106e7c: 90 nop
106e7d: 90 nop
106e7e: 90 nop
106e7f: 90 nop
00106e80 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
106e80: 55 push %ebp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
106e81: 31 c0 xor %eax,%eax
{
106e83: 89 e5 mov %esp,%ebp
if ( params->budget <= 0 ||
106e85: 89 c1 mov %eax,%ecx
{
106e87: 53 push %ebx
106e88: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( params->budget <= 0 ||
106e8b: 3b 43 08 cmp 0x8(%ebx),%eax
106e8e: 1b 4b 0c sbb 0xc(%ebx),%ecx
106e91: 0f 8d a1 00 00 00 jge 106f38 <_Scheduler_CBS_Create_server+0xb8>
106e97: 3b 03 cmp (%ebx),%eax
106e99: 1b 43 04 sbb 0x4(%ebx),%eax
106e9c: 0f 8d 96 00 00 00 jge 106f38 <_Scheduler_CBS_Create_server+0xb8>
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++ ) {
106ea2: 8b 0d 48 23 12 00 mov 0x122348,%ecx
106ea8: 85 c9 test %ecx,%ecx
106eaa: 0f 84 80 00 00 00 je 106f30 <_Scheduler_CBS_Create_server+0xb0> <== NEVER TAKEN
106eb0: ba 38 ad 12 00 mov $0x12ad38,%edx
106eb5: 31 c0 xor %eax,%eax
106eb7: eb 0f jmp 106ec8 <_Scheduler_CBS_Create_server+0x48>
106eb9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106ec0: 40 inc %eax
106ec1: 83 c2 1c add $0x1c,%edx
106ec4: 39 c1 cmp %eax,%ecx
106ec6: 74 68 je 106f30 <_Scheduler_CBS_Create_server+0xb0>
if ( !_Scheduler_CBS_Server_list[i].initialized )
106ec8: 80 3a 00 cmpb $0x0,(%edx)
106ecb: 75 f3 jne 106ec0 <_Scheduler_CBS_Create_server+0x40>
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
106ecd: 8b 55 10 mov 0x10(%ebp),%edx
the_server = &_Scheduler_CBS_Server_list[*server_id];
the_server->parameters = *params;
106ed0: 8b 0b mov (%ebx),%ecx
*server_id = i;
106ed2: 89 02 mov %eax,(%edx)
the_server->parameters = *params;
106ed4: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
106edb: 29 c2 sub %eax,%edx
106edd: c1 e2 02 shl $0x2,%edx
106ee0: 89 8a 24 ad 12 00 mov %ecx,0x12ad24(%edx)
106ee6: 8d 82 20 ad 12 00 lea 0x12ad20(%edx),%eax
106eec: 8b 4b 04 mov 0x4(%ebx),%ecx
106eef: 89 8a 28 ad 12 00 mov %ecx,0x12ad28(%edx)
106ef5: 8b 4b 08 mov 0x8(%ebx),%ecx
106ef8: 89 8a 2c ad 12 00 mov %ecx,0x12ad2c(%edx)
106efe: 8b 4b 0c mov 0xc(%ebx),%ecx
106f01: 89 8a 30 ad 12 00 mov %ecx,0x12ad30(%edx)
the_server->task_id = -1;
106f07: b9 ff ff ff ff mov $0xffffffff,%ecx
106f0c: 89 8a 20 ad 12 00 mov %ecx,0x12ad20(%edx)
the_server->cbs_budget_overrun = budget_overrun_callback;
106f12: 8b 55 0c mov 0xc(%ebp),%edx
the_server->initialized = true;
106f15: c6 40 18 01 movb $0x1,0x18(%eax)
the_server->cbs_budget_overrun = budget_overrun_callback;
106f19: 89 50 14 mov %edx,0x14(%eax)
return SCHEDULER_CBS_OK;
106f1c: 31 c0 xor %eax,%eax
}
106f1e: 5b pop %ebx
106f1f: 5d pop %ebp
106f20: c3 ret
106f21: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106f28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106f2f: 90 nop
106f30: 5b pop %ebx
return SCHEDULER_CBS_ERROR_FULL;
106f31: b8 e6 ff ff ff mov $0xffffffe6,%eax
}
106f36: 5d pop %ebp
106f37: c3 ret
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
106f38: b8 ee ff ff ff mov $0xffffffee,%eax
106f3d: eb df jmp 106f1e <_Scheduler_CBS_Create_server+0x9e>
106f3f: 90 nop
00107310 <_Scheduler_CBS_Get_server_id>:
int _Scheduler_CBS_Get_server_id (
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
107310: 55 push %ebp
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
107311: 8b 0d 48 23 12 00 mov 0x122348,%ecx
{
107317: 89 e5 mov %esp,%ebp
107319: 53 push %ebx
10731a: 8b 5d 08 mov 0x8(%ebp),%ebx
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
10731d: 85 c9 test %ecx,%ecx
10731f: 74 21 je 107342 <_Scheduler_CBS_Get_server_id+0x32> <== NEVER TAKEN
107321: b8 20 ad 12 00 mov $0x12ad20,%eax
107326: 31 d2 xor %edx,%edx
107328: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10732f: 90 nop
if ( _Scheduler_CBS_Server_list[i].initialized &&
107330: 80 78 18 00 cmpb $0x0,0x18(%eax)
107334: 74 04 je 10733a <_Scheduler_CBS_Get_server_id+0x2a>
107336: 39 18 cmp %ebx,(%eax)
107338: 74 16 je 107350 <_Scheduler_CBS_Get_server_id+0x40>
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
10733a: 42 inc %edx
10733b: 83 c0 1c add $0x1c,%eax
10733e: 39 ca cmp %ecx,%edx
107340: 75 ee jne 107330 <_Scheduler_CBS_Get_server_id+0x20>
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
}
107342: 5b pop %ebx
return SCHEDULER_CBS_ERROR_NOSERVER;
107343: b8 e7 ff ff ff mov $0xffffffe7,%eax
}
107348: 5d pop %ebp
107349: c3 ret
10734a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*server_id = i;
107350: 8b 45 0c mov 0xc(%ebp),%eax
107353: 89 10 mov %edx,(%eax)
return SCHEDULER_CBS_OK;
107355: 31 c0 xor %eax,%eax
}
107357: 5b pop %ebx
107358: 5d pop %ebp
107359: c3 ret
10735a: 90 nop
10735b: 90 nop
10735c: 90 nop
10735d: 90 nop
10735e: 90 nop
10735f: 90 nop
001064b0 <_Scheduler_CBS_Unblock>:
void _Scheduler_CBS_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
1064b0: 55 push %ebp
1064b1: 89 e5 mov %esp,%ebp
1064b3: 83 ec 68 sub $0x68,%esp
1064b6: 89 5d f4 mov %ebx,-0xc(%ebp)
1064b9: 8b 45 08 mov 0x8(%ebp),%eax
1064bc: 89 75 f8 mov %esi,-0x8(%ebp)
1064bf: 8b 5d 10 mov 0x10(%ebp),%ebx
1064c2: 89 7d fc mov %edi,-0x4(%ebp)
1064c5: 8b 75 0c mov 0xc(%ebp),%esi
1064c8: 89 45 b0 mov %eax,-0x50(%ebp)
Scheduler_CBS_Node *the_node;
Scheduler_CBS_Server *serv_info;
Priority_Control priority;
the_node = _Scheduler_CBS_Node_downcast( node );
serv_info = the_node->cbs_server;
1064cb: 8b 4b 48 mov 0x48(%ebx),%ecx
{
1064ce: 89 75 b4 mov %esi,-0x4c(%ebp)
priority = _Scheduler_Node_get_priority( &the_node->Base.Base );
priority = SCHEDULER_PRIORITY_PURIFY( priority );
1064d1: 8b 43 28 mov 0x28(%ebx),%eax
1064d4: 8b 7b 2c mov 0x2c(%ebx),%edi
1064d7: 83 e0 fe and $0xfffffffe,%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 != NULL && ( priority & SCHEDULER_EDF_PRIO_MSB ) == 0 ) {
1064da: 85 c9 test %ecx,%ecx
1064dc: 74 77 je 106555 <_Scheduler_CBS_Unblock+0xa5>
1064de: 89 c6 mov %eax,%esi
1064e0: 89 f8 mov %edi,%eax
1064e2: f7 d0 not %eax
1064e4: c1 e8 1f shr $0x1f,%eax
1064e7: 84 c0 test %al,%al
1064e9: 74 6a je 106555 <_Scheduler_CBS_Unblock+0xa5>
time_t deadline = serv_info->parameters.deadline;
time_t budget = serv_info->parameters.budget;
uint32_t deadline_left = the_thread->cpu_time_budget;
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
1064eb: c7 45 ac 00 00 00 00 movl $0x0,-0x54(%ebp)
1064f2: a1 b8 9c 12 00 mov 0x129cb8,%eax
1064f7: 89 fa mov %edi,%edx
1064f9: 89 45 a8 mov %eax,-0x58(%ebp)
1064fc: 89 f0 mov %esi,%eax
if ( deadline * budget_left > budget * deadline_left ) {
1064fe: 8b 71 08 mov 0x8(%ecx),%esi
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
106501: 2b 45 a8 sub -0x58(%ebp),%eax
106504: 1b 55 ac sbb -0x54(%ebp),%edx
106507: 89 45 a8 mov %eax,-0x58(%ebp)
if ( deadline * budget_left > budget * deadline_left ) {
10650a: 8b 41 04 mov 0x4(%ecx),%eax
Priority_Control budget_left = priority - _Watchdog_Ticks_since_boot;
10650d: 89 55 ac mov %edx,-0x54(%ebp)
if ( deadline * budget_left > budget * deadline_left ) {
106510: 8b 55 a8 mov -0x58(%ebp),%edx
106513: 8b 7d ac mov -0x54(%ebp),%edi
106516: 0f af d6 imul %esi,%edx
106519: 8b 75 b4 mov -0x4c(%ebp),%esi
10651c: 0f af f8 imul %eax,%edi
10651f: 8b 45 a8 mov -0x58(%ebp),%eax
106522: 01 d7 add %edx,%edi
106524: f7 61 04 mull 0x4(%ecx)
106527: 89 55 ac mov %edx,-0x54(%ebp)
10652a: 8b 96 84 00 00 00 mov 0x84(%esi),%edx
106530: 01 7d ac add %edi,-0x54(%ebp)
106533: 8b 79 10 mov 0x10(%ecx),%edi
106536: 89 45 a8 mov %eax,-0x58(%ebp)
106539: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10653f: 8b 75 a8 mov -0x58(%ebp),%esi
106542: 0f af fa imul %edx,%edi
106545: f7 61 0c mull 0xc(%ecx)
106548: 01 fa add %edi,%edx
10654a: 8b 7d ac mov -0x54(%ebp),%edi
10654d: 39 f0 cmp %esi,%eax
10654f: 89 d0 mov %edx,%eax
106551: 19 f8 sbb %edi,%eax
106553: 72 2b jb 106580 <_Scheduler_CBS_Unblock+0xd0> <== ALWAYS TAKEN
&queue_context
);
}
}
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
106555: 89 5d 10 mov %ebx,0x10(%ebp)
106558: 8b 45 b4 mov -0x4c(%ebp),%eax
}
10655b: 8b 5d f4 mov -0xc(%ebp),%ebx
10655e: 8b 75 f8 mov -0x8(%ebp),%esi
106561: 8b 7d fc mov -0x4(%ebp),%edi
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
106564: 89 45 0c mov %eax,0xc(%ebp)
106567: 8b 45 b0 mov -0x50(%ebp),%eax
10656a: 89 45 08 mov %eax,0x8(%ebp)
}
10656d: 89 ec mov %ebp,%esp
10656f: 5d pop %ebp
_Scheduler_EDF_Unblock( scheduler, the_thread, &the_node->Base.Base );
106570: e9 bb 04 00 00 jmp 106a30 <_Scheduler_EDF_Unblock>
106575: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10657c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*/
RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates(
Thread_queue_Context *queue_context
)
{
queue_context->Priority.update_count = 0;
106580: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
_Scheduler_CBS_Cancel_job(
106587: 8d 45 c4 lea -0x3c(%ebp),%eax
10658a: 89 44 24 0c mov %eax,0xc(%esp)
10658e: 8b 43 4c mov 0x4c(%ebx),%eax
106591: 89 44 24 08 mov %eax,0x8(%esp)
106595: 8b 45 b4 mov -0x4c(%ebp),%eax
106598: 89 44 24 04 mov %eax,0x4(%esp)
10659c: 8b 45 b0 mov -0x50(%ebp),%eax
10659f: 89 04 24 mov %eax,(%esp)
1065a2: e8 c9 fe ff ff call 106470 <_Scheduler_CBS_Cancel_job>
1065a7: eb ac jmp 106555 <_Scheduler_CBS_Unblock+0xa5>
1065a9: 90 nop
1065aa: 90 nop
1065ab: 90 nop
1065ac: 90 nop
1065ad: 90 nop
1065ae: 90 nop
1065af: 90 nop
00106670 <_Scheduler_EDF_Block>:
void _Scheduler_EDF_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
106670: 55 push %ebp
106671: 89 e5 mov %esp,%ebp
106673: 83 ec 38 sub $0x38,%esp
106676: 89 75 f8 mov %esi,-0x8(%ebp)
RTEMS_INLINE_ROUTINE void _Scheduler_EDF_Extract(
Scheduler_EDF_Context *context,
Scheduler_EDF_Node *node
)
{
_RBTree_Extract( &context->Ready, &node->Node );
106679: 8b 45 10 mov 0x10(%ebp),%eax
10667c: 89 5d f4 mov %ebx,-0xc(%ebp)
10667f: 8b 75 08 mov 0x8(%ebp),%esi
106682: 89 7d fc mov %edi,-0x4(%ebp)
106685: 8b 5d 0c mov 0xc(%ebp),%ebx
106688: 83 c0 30 add $0x30,%eax
10668b: 89 44 24 04 mov %eax,0x4(%esp)
10668f: 8b 06 mov (%esi),%eax
106691: 89 04 24 mov %eax,(%esp)
106694: e8 b7 4a 00 00 call 10b150 <_RBTree_Extract>
{
( *extract )( scheduler, the_thread, node );
/* TODO: flash critical section? */
if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) {
106699: 3b 1d 78 9c 12 00 cmp 0x129c78,%ebx
10669f: 74 1f je 1066c0 <_Scheduler_EDF_Block+0x50>
1066a1: 3b 1d 7c 9c 12 00 cmp 0x129c7c,%ebx
1066a7: 74 17 je 1066c0 <_Scheduler_EDF_Block+0x50> <== NEVER TAKEN
the_thread,
node,
_Scheduler_EDF_Extract_body,
_Scheduler_EDF_Schedule_body
);
}
1066a9: 8b 5d f4 mov -0xc(%ebp),%ebx
1066ac: 8b 75 f8 mov -0x8(%ebp),%esi
1066af: 8b 7d fc mov -0x4(%ebp),%edi
1066b2: 89 ec mov %ebp,%esp
1066b4: 5d pop %ebp
1066b5: c3 ret
1066b6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1066bd: 8d 76 00 lea 0x0(%esi),%esi
Scheduler_EDF_Node *node;
(void) the_thread;
context = _Scheduler_EDF_Get_context( scheduler );
first = _RBTree_Minimum( &context->Ready );
1066c0: 8b 06 mov (%esi),%eax
1066c2: 89 04 24 mov %eax,(%esp)
1066c5: e8 26 51 00 00 call 10b7f0 <_RBTree_Minimum>
RTEMS_INLINE_ROUTINE void _Scheduler_Update_heir(
Thread_Control *new_heir,
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
1066ca: 8b 1d 7c 9c 12 00 mov 0x129c7c,%ebx
node = RTEMS_CONTAINER_OF( first, Scheduler_EDF_Node, Node );
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
1066d0: 8b 48 d0 mov -0x30(%eax),%ecx
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
1066d3: 89 4d e4 mov %ecx,-0x1c(%ebp)
1066d6: 39 d9 cmp %ebx,%ecx
1066d8: 74 cf je 1066a9 <_Scheduler_EDF_Block+0x39> <== NEVER TAKEN
last = cpu->cpu_usage_timestamp;
1066da: 8b 35 80 9c 12 00 mov 0x129c80,%esi
1066e0: 8b 3d 84 9c 12 00 mov 0x129c84,%edi
*time = _Timecounter_Sbinuptime();
1066e6: e8 45 f8 ff ff call 105f30 <_Timecounter_Sbinuptime>
*/
heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED;
new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED;
#endif
_Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) );
_Thread_Heir = new_heir;
1066eb: 8b 4d e4 mov -0x1c(%ebp),%ecx
1066ee: a3 80 9c 12 00 mov %eax,0x129c80
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
1066f3: 29 f0 sub %esi,%eax
1066f5: 8b 75 f8 mov -0x8(%ebp),%esi
1066f8: 89 15 84 9c 12 00 mov %edx,0x129c84
1066fe: 19 fa sbb %edi,%edx
106700: 8b 7d fc mov -0x4(%ebp),%edi
*_time += *_add;
106703: 01 83 90 00 00 00 add %eax,0x90(%ebx)
_Thread_Dispatch_necessary = true;
106709: b0 01 mov $0x1,%al
10670b: 11 93 94 00 00 00 adc %edx,0x94(%ebx)
106711: 8b 5d f4 mov -0xc(%ebp),%ebx
_Thread_Heir = new_heir;
106714: 89 0d 7c 9c 12 00 mov %ecx,0x129c7c
_Thread_Dispatch_necessary = true;
10671a: a2 74 9c 12 00 mov %al,0x129c74
10671f: 89 ec mov %ebp,%esp
106721: 5d pop %ebp
106722: c3 ret
106723: 90 nop
106724: 90 nop
106725: 90 nop
106726: 90 nop
106727: 90 nop
106728: 90 nop
106729: 90 nop
10672a: 90 nop
10672b: 90 nop
10672c: 90 nop
10672d: 90 nop
10672e: 90 nop
10672f: 90 nop
001069a0 <_Scheduler_EDF_Schedule>:
void _Scheduler_EDF_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
1069a0: 55 push %ebp
1069a1: 89 e5 mov %esp,%ebp
1069a3: 83 ec 38 sub $0x38,%esp
1069a6: 89 5d f4 mov %ebx,-0xc(%ebp)
first = _RBTree_Minimum( &context->Ready );
1069a9: 8b 45 08 mov 0x8(%ebp),%eax
1069ac: 89 75 f8 mov %esi,-0x8(%ebp)
1069af: 89 7d fc mov %edi,-0x4(%ebp)
1069b2: 8b 00 mov (%eax),%eax
1069b4: 89 04 24 mov %eax,(%esp)
1069b7: e8 34 4e 00 00 call 10b7f0 <_RBTree_Minimum>
Thread_Control *heir = _Thread_Heir;
1069bc: 8b 1d 7c 9c 12 00 mov 0x129c7c,%ebx
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
1069c2: 8b 48 d0 mov -0x30(%eax),%ecx
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
1069c5: 39 d9 cmp %ebx,%ecx
1069c7: 74 09 je 1069d2 <_Scheduler_EDF_Schedule+0x32> <== ALWAYS TAKEN
1069c9: 80 bb 81 00 00 00 00 cmpb $0x0,0x81(%ebx) <== NOT EXECUTED
1069d0: 75 0e jne 1069e0 <_Scheduler_EDF_Schedule+0x40> <== NOT EXECUTED
_Scheduler_EDF_Schedule_body( scheduler, the_thread, false );
}
1069d2: 8b 5d f4 mov -0xc(%ebp),%ebx
1069d5: 8b 75 f8 mov -0x8(%ebp),%esi
1069d8: 8b 7d fc mov -0x4(%ebp),%edi
1069db: 89 ec mov %ebp,%esp
1069dd: 5d pop %ebp
1069de: c3 ret
1069df: 90 nop
1069e0: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED
1069e3: 8b 35 80 9c 12 00 mov 0x129c80,%esi <== NOT EXECUTED
1069e9: 8b 3d 84 9c 12 00 mov 0x129c84,%edi <== NOT EXECUTED
1069ef: e8 3c f5 ff ff call 105f30 <_Timecounter_Sbinuptime> <== NOT EXECUTED
_Thread_Heir = new_heir;
1069f4: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
1069f7: a3 80 9c 12 00 mov %eax,0x129c80 <== NOT EXECUTED
*_result = *_end - *_start;
1069fc: 29 f0 sub %esi,%eax <== NOT EXECUTED
1069fe: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
106a01: 89 15 84 9c 12 00 mov %edx,0x129c84 <== NOT EXECUTED
106a07: 19 fa sbb %edi,%edx <== NOT EXECUTED
106a09: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
*_time += *_add;
106a0c: 01 83 90 00 00 00 add %eax,0x90(%ebx) <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
106a12: b0 01 mov $0x1,%al <== NOT EXECUTED
106a14: 11 93 94 00 00 00 adc %edx,0x94(%ebx) <== NOT EXECUTED
106a1a: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
_Thread_Heir = new_heir;
106a1d: 89 0d 7c 9c 12 00 mov %ecx,0x129c7c <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
106a23: a2 74 9c 12 00 mov %al,0x129c74 <== NOT EXECUTED
106a28: 89 ec mov %ebp,%esp <== NOT EXECUTED
106a2a: 5d pop %ebp <== NOT EXECUTED
106a2b: c3 ret <== NOT EXECUTED
106a2c: 90 nop
106a2d: 90 nop
106a2e: 90 nop
106a2f: 90 nop
00106a30 <_Scheduler_EDF_Unblock>:
void _Scheduler_EDF_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
106a30: 55 push %ebp
106a31: 89 e5 mov %esp,%ebp
106a33: 57 push %edi
106a34: 56 push %esi
106a35: 53 push %ebx
106a36: 83 ec 2c sub $0x2c,%esp
106a39: 8b 7d 10 mov 0x10(%ebp),%edi
return scheduler->context;
106a3c: 8b 45 08 mov 0x8(%ebp),%eax
Priority_Control insert_priority;
context = _Scheduler_EDF_Get_context( scheduler );
the_node = _Scheduler_EDF_Node_downcast( node );
priority = _Scheduler_Node_get_priority( &the_node->Base );
priority = SCHEDULER_PRIORITY_PURIFY( priority );
106a3f: 8b 5f 28 mov 0x28(%edi),%ebx
106a42: 8b 08 mov (%eax),%ecx
106a44: 8b 77 2c mov 0x2c(%edi),%esi
106a47: 89 d8 mov %ebx,%eax
insert_priority = SCHEDULER_PRIORITY_APPEND( priority );
106a49: 83 cb 01 or $0x1,%ebx
106a4c: 89 4d e0 mov %ecx,-0x20(%ebp)
priority = SCHEDULER_PRIORITY_PURIFY( priority );
106a4f: 83 e0 fe and $0xfffffffe,%eax
106a52: 89 45 e4 mov %eax,-0x1c(%ebp)
the_node->priority = priority;
106a55: 89 47 40 mov %eax,0x40(%edi)
_RBTree_Insert_inline(
106a58: 8d 47 30 lea 0x30(%edi),%eax
106a5b: 89 45 dc mov %eax,-0x24(%ebp)
while ( *link != NULL ) {
106a5e: 8b 01 mov (%ecx),%eax
106a60: 89 77 44 mov %esi,0x44(%edi)
106a63: 85 c0 test %eax,%eax
106a65: 75 0b jne 106a72 <_Scheduler_EDF_Unblock+0x42>
106a67: e9 d4 00 00 00 jmp 106b40 <_Scheduler_EDF_Unblock+0x110>
106a6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106a70: 89 d0 mov %edx,%eax
if ( ( *less )( key, parent ) ) {
106a72: 8b 50 14 mov 0x14(%eax),%edx
return &RB_LEFT( the_node, Node );
106a75: 89 c1 mov %eax,%ecx
if ( ( *less )( key, parent ) ) {
106a77: 39 58 10 cmp %ebx,0x10(%eax)
106a7a: 19 f2 sbb %esi,%edx
106a7c: 73 03 jae 106a81 <_Scheduler_EDF_Unblock+0x51>
return &RB_RIGHT( the_node, Node );
106a7e: 8d 48 04 lea 0x4(%eax),%ecx
while ( *link != NULL ) {
106a81: 8b 11 mov (%ecx),%edx
106a83: 85 d2 test %edx,%edx
106a85: 75 e9 jne 106a70 <_Scheduler_EDF_Unblock+0x40>
RB_SET( child, parent, Node );
106a87: 89 47 38 mov %eax,0x38(%edi)
*link = child;
106a8a: 8b 45 dc mov -0x24(%ebp),%eax
RB_SET( child, parent, Node );
106a8d: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
106a94: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi)
106a9b: c7 47 3c 01 00 00 00 movl $0x1,0x3c(%edi)
*link = child;
106aa2: 89 01 mov %eax,(%ecx)
_RBTree_Insert_color( the_rbtree, the_node );
106aa4: 89 44 24 04 mov %eax,0x4(%esp)
106aa8: 8b 45 e0 mov -0x20(%ebp),%eax
106aab: 89 04 24 mov %eax,(%esp)
106aae: e8 2d 4b 00 00 call 10b5e0 <_RBTree_Insert_color>
* 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 ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
106ab3: 8b 1d 7c 9c 12 00 mov 0x129c7c,%ebx
106ab9: 8b 7d e4 mov -0x1c(%ebp),%edi
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
106abc: 8b 43 38 mov 0x38(%ebx),%eax
106abf: 3b 78 14 cmp 0x14(%eax),%edi
106ac2: 89 f7 mov %esi,%edi
106ac4: 1b 78 18 sbb 0x18(%eax),%edi
106ac7: 72 17 jb 106ae0 <_Scheduler_EDF_Unblock+0xb0>
_Scheduler_Update_heir(
the_thread,
priority == ( SCHEDULER_EDF_PRIO_MSB | PRIORITY_PSEUDO_ISR )
);
}
}
106ac9: 83 c4 2c add $0x2c,%esp
106acc: 5b pop %ebx
106acd: 5e pop %esi
106ace: 5f pop %edi
106acf: 5d pop %ebp
106ad0: c3 ret
106ad1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106ad8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106adf: 90 nop
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
106ae0: 3b 5d 0c cmp 0xc(%ebp),%ebx
106ae3: 74 e4 je 106ac9 <_Scheduler_EDF_Unblock+0x99> <== NEVER TAKEN
106ae5: 8b 45 e4 mov -0x1c(%ebp),%eax
_Scheduler_Update_heir(
106ae8: 81 c6 00 00 00 80 add $0x80000000,%esi
106aee: 09 f0 or %esi,%eax
106af0: 74 09 je 106afb <_Scheduler_EDF_Unblock+0xcb> <== NEVER TAKEN
106af2: 80 bb 81 00 00 00 00 cmpb $0x0,0x81(%ebx)
106af9: 74 ce je 106ac9 <_Scheduler_EDF_Unblock+0x99>
106afb: 8b 35 80 9c 12 00 mov 0x129c80,%esi
106b01: 8b 3d 84 9c 12 00 mov 0x129c84,%edi
106b07: e8 24 f4 ff ff call 105f30 <_Timecounter_Sbinuptime>
106b0c: a3 80 9c 12 00 mov %eax,0x129c80
*_result = *_end - *_start;
106b11: 29 f0 sub %esi,%eax
106b13: 89 15 84 9c 12 00 mov %edx,0x129c84
106b19: 19 fa sbb %edi,%edx
*_time += *_add;
106b1b: 01 83 90 00 00 00 add %eax,0x90(%ebx)
_Thread_Heir = new_heir;
106b21: 8b 45 0c mov 0xc(%ebp),%eax
106b24: 11 93 94 00 00 00 adc %edx,0x94(%ebx)
106b2a: a3 7c 9c 12 00 mov %eax,0x129c7c
_Thread_Dispatch_necessary = true;
106b2f: b0 01 mov $0x1,%al
106b31: a2 74 9c 12 00 mov %al,0x129c74
}
106b36: eb 91 jmp 106ac9 <_Scheduler_EDF_Unblock+0x99>
106b38: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106b3f: 90 nop
link = _RBTree_Root_reference( the_rbtree );
106b40: 8b 4d e0 mov -0x20(%ebp),%ecx
106b43: e9 3f ff ff ff jmp 106a87 <_Scheduler_EDF_Unblock+0x57>
106b48: 90 nop
106b49: 90 nop
106b4a: 90 nop
106b4b: 90 nop
106b4c: 90 nop
106b4d: 90 nop
106b4e: 90 nop
106b4f: 90 nop
001068d0 <_Scheduler_EDF_Unmap_priority>:
Priority_Control _Scheduler_EDF_Unmap_priority(
const Scheduler_Control *scheduler,
Priority_Control priority
)
{
1068d0: 55 push %ebp <== NOT EXECUTED
1068d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1068d3: 53 push %ebx <== NOT EXECUTED
return SCHEDULER_PRIORITY_UNMAP( priority & ~SCHEDULER_EDF_PRIO_MSB );
1068d4: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
1068d7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
}
1068da: 5b pop %ebx <== NOT EXECUTED
return SCHEDULER_PRIORITY_UNMAP( priority & ~SCHEDULER_EDF_PRIO_MSB );
1068db: 0f ac d0 01 shrd $0x1,%edx,%eax <== NOT EXECUTED
1068df: d1 ea shr %edx <== NOT EXECUTED
1068e1: 89 c1 mov %eax,%ecx <== NOT EXECUTED
1068e3: 81 e2 ff ff ff 3f and $0x3fffffff,%edx <== NOT EXECUTED
}
1068e9: 89 c8 mov %ecx,%eax <== NOT EXECUTED
1068eb: 5d pop %ebp <== NOT EXECUTED
1068ec: c3 ret <== NOT EXECUTED
1068ed: 90 nop
1068ee: 90 nop
1068ef: 90 nop
00106740 <_Scheduler_EDF_Update_priority>:
void _Scheduler_EDF_Update_priority(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
106740: 55 push %ebp
106741: 89 e5 mov %esp,%ebp
106743: 57 push %edi
106744: 56 push %esi
106745: 53 push %ebx
106746: 83 ec 2c sub $0x2c,%esp
Scheduler_EDF_Context *context;
Scheduler_EDF_Node *the_node;
Priority_Control priority;
Priority_Control insert_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
106749: 8b 45 0c mov 0xc(%ebp),%eax
{
10674c: 8b 5d 10 mov 0x10(%ebp),%ebx
if ( !_Thread_Is_ready( the_thread ) ) {
10674f: 8b 50 1c mov 0x1c(%eax),%edx
106752: 85 d2 test %edx,%edx
106754: 0f 85 bc 00 00 00 jne 106816 <_Scheduler_EDF_Update_priority+0xd6>
do {
seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock );
#endif
priority = node->Priority.value;
10675a: 8b 7b 28 mov 0x28(%ebx),%edi
10675d: 8b 73 2c mov 0x2c(%ebx),%esi
the_node = _Scheduler_EDF_Node_downcast( node );
insert_priority = _Scheduler_Node_get_priority( &the_node->Base );
priority = SCHEDULER_PRIORITY_PURIFY( insert_priority );
if ( priority == the_node->priority ) {
106760: 8b 53 40 mov 0x40(%ebx),%edx
106763: 8b 4b 44 mov 0x44(%ebx),%ecx
priority = SCHEDULER_PRIORITY_PURIFY( insert_priority );
106766: 89 f8 mov %edi,%eax
106768: 83 e0 fe and $0xfffffffe,%eax
if ( priority == the_node->priority ) {
10676b: 31 c2 xor %eax,%edx
10676d: 31 f1 xor %esi,%ecx
10676f: 09 d1 or %edx,%ecx
106771: 0f 84 9f 00 00 00 je 106816 <_Scheduler_EDF_Update_priority+0xd6> <== NEVER TAKEN
/* Nothing to do */
return;
}
the_node->priority = priority;
106777: 89 43 40 mov %eax,0x40(%ebx)
return scheduler->context;
10677a: 8b 45 08 mov 0x8(%ebp),%eax
_RBTree_Extract( &context->Ready, &node->Node );
10677d: 8d 4b 30 lea 0x30(%ebx),%ecx
106780: 89 73 44 mov %esi,0x44(%ebx)
106783: 89 4d e0 mov %ecx,-0x20(%ebp)
106786: 8b 00 mov (%eax),%eax
106788: 89 4c 24 04 mov %ecx,0x4(%esp)
10678c: 89 04 24 mov %eax,(%esp)
10678f: 89 45 e4 mov %eax,-0x1c(%ebp)
106792: e8 b9 49 00 00 call 10b150 <_RBTree_Extract>
link = _RBTree_Root_reference( the_rbtree );
parent = NULL;
is_new_minimum = true;
while ( *link != NULL ) {
106797: 8b 45 e4 mov -0x1c(%ebp),%eax
10679a: 8b 00 mov (%eax),%eax
10679c: 85 c0 test %eax,%eax
10679e: 75 12 jne 1067b2 <_Scheduler_EDF_Update_priority+0x72> <== ALWAYS TAKEN
1067a0: e9 cb 00 00 00 jmp 106870 <_Scheduler_EDF_Update_priority+0x130> <== NOT EXECUTED
1067a5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1067ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1067b0: 89 d0 mov %edx,%eax
parent = *link;
if ( ( *less )( key, parent ) ) {
1067b2: 8b 50 14 mov 0x14(%eax),%edx
return &RB_LEFT( the_node, Node );
1067b5: 89 c1 mov %eax,%ecx
if ( ( *less )( key, parent ) ) {
1067b7: 39 78 10 cmp %edi,0x10(%eax)
1067ba: 19 f2 sbb %esi,%edx
1067bc: 73 03 jae 1067c1 <_Scheduler_EDF_Update_priority+0x81>
return &RB_RIGHT( the_node, Node );
1067be: 8d 48 04 lea 0x4(%eax),%ecx
while ( *link != NULL ) {
1067c1: 8b 11 mov (%ecx),%edx
1067c3: 85 d2 test %edx,%edx
1067c5: 75 e9 jne 1067b0 <_Scheduler_EDF_Update_priority+0x70>
RB_SET( child, parent, Node );
1067c7: 89 43 38 mov %eax,0x38(%ebx)
*link = child;
1067ca: 8b 45 e0 mov -0x20(%ebp),%eax
RB_SET( child, parent, Node );
1067cd: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
1067d4: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx)
1067db: c7 43 3c 01 00 00 00 movl $0x1,0x3c(%ebx)
*link = child;
1067e2: 89 01 mov %eax,(%ecx)
is_new_minimum = false;
}
}
_RBTree_Add_child( the_node, parent, link );
_RBTree_Insert_color( the_rbtree, the_node );
1067e4: 89 44 24 04 mov %eax,0x4(%esp)
1067e8: 8b 45 e4 mov -0x1c(%ebp),%eax
1067eb: 89 04 24 mov %eax,(%esp)
1067ee: e8 ed 4d 00 00 call 10b5e0 <_RBTree_Insert_color>
first = _RBTree_Minimum( &context->Ready );
1067f3: 8b 45 08 mov 0x8(%ebp),%eax
1067f6: 8b 00 mov (%eax),%eax
1067f8: 89 04 24 mov %eax,(%esp)
1067fb: e8 f0 4f 00 00 call 10b7f0 <_RBTree_Minimum>
Thread_Control *heir = _Thread_Heir;
106800: 8b 1d 7c 9c 12 00 mov 0x129c7c,%ebx
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
106806: 8b 48 d0 mov -0x30(%eax),%ecx
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
106809: 39 d9 cmp %ebx,%ecx
10680b: 74 09 je 106816 <_Scheduler_EDF_Update_priority+0xd6>
10680d: 80 bb 81 00 00 00 00 cmpb $0x0,0x81(%ebx)
106814: 75 0a jne 106820 <_Scheduler_EDF_Update_priority+0xe0> <== ALWAYS TAKEN
context = _Scheduler_EDF_Get_context( scheduler );
_Scheduler_EDF_Extract( context, the_node );
_Scheduler_EDF_Enqueue( context, the_node, insert_priority );
_Scheduler_EDF_Schedule_body( scheduler, the_thread, false );
}
106816: 83 c4 2c add $0x2c,%esp
106819: 5b pop %ebx
10681a: 5e pop %esi
10681b: 5f pop %edi
10681c: 5d pop %ebp
10681d: c3 ret
10681e: 66 90 xchg %ax,%ax
106820: 89 4d e4 mov %ecx,-0x1c(%ebp)
106823: 8b 35 80 9c 12 00 mov 0x129c80,%esi
106829: 8b 3d 84 9c 12 00 mov 0x129c84,%edi
10682f: e8 fc f6 ff ff call 105f30 <_Timecounter_Sbinuptime>
_Thread_Heir = new_heir;
106834: 8b 4d e4 mov -0x1c(%ebp),%ecx
106837: a3 80 9c 12 00 mov %eax,0x129c80
*_result = *_end - *_start;
10683c: 29 f0 sub %esi,%eax
10683e: 89 15 84 9c 12 00 mov %edx,0x129c84
106844: 19 fa sbb %edi,%edx
*_time += *_add;
106846: 01 83 90 00 00 00 add %eax,0x90(%ebx)
_Thread_Dispatch_necessary = true;
10684c: b0 01 mov $0x1,%al
10684e: 11 93 94 00 00 00 adc %edx,0x94(%ebx)
_Thread_Heir = new_heir;
106854: 89 0d 7c 9c 12 00 mov %ecx,0x129c7c
_Thread_Dispatch_necessary = true;
10685a: a2 74 9c 12 00 mov %al,0x129c74
10685f: eb b5 jmp 106816 <_Scheduler_EDF_Update_priority+0xd6>
106861: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106868: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10686f: 90 nop
link = _RBTree_Root_reference( the_rbtree );
106870: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
106873: e9 4f ff ff ff jmp 1067c7 <_Scheduler_EDF_Update_priority+0x87> <== NOT EXECUTED
106878: 90 nop
106879: 90 nop
10687a: 90 nop
10687b: 90 nop
10687c: 90 nop
10687d: 90 nop
10687e: 90 nop
10687f: 90 nop
00106b50 <_Scheduler_EDF_Yield>:
void _Scheduler_EDF_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
106b50: 55 push %ebp
106b51: 89 e5 mov %esp,%ebp
106b53: 57 push %edi
106b54: 56 push %esi
106b55: 53 push %ebx
106b56: 83 ec 2c sub $0x2c,%esp
return scheduler->context;
106b59: 8b 45 08 mov 0x8(%ebp),%eax
106b5c: 8b 7d 10 mov 0x10(%ebp),%edi
106b5f: 8b 00 mov (%eax),%eax
_RBTree_Extract( &context->Ready, &node->Node );
106b61: 8d 77 30 lea 0x30(%edi),%esi
106b64: 89 74 24 04 mov %esi,0x4(%esp)
106b68: 89 75 e0 mov %esi,-0x20(%ebp)
106b6b: 89 04 24 mov %eax,(%esp)
106b6e: 89 45 e4 mov %eax,-0x1c(%ebp)
106b71: e8 da 45 00 00 call 10b150 <_RBTree_Extract>
while ( *link != NULL ) {
106b76: 8b 45 e4 mov -0x1c(%ebp),%eax
context = _Scheduler_EDF_Get_context( scheduler );
the_node = _Scheduler_EDF_Node_downcast( node );
_Scheduler_EDF_Extract( context, the_node );
_Scheduler_EDF_Enqueue( context, the_node, the_node->priority );
106b79: 8b 77 40 mov 0x40(%edi),%esi
106b7c: 8b 5f 44 mov 0x44(%edi),%ebx
106b7f: 8b 00 mov (%eax),%eax
106b81: 85 c0 test %eax,%eax
106b83: 75 0d jne 106b92 <_Scheduler_EDF_Yield+0x42> <== ALWAYS TAKEN
106b85: e9 b6 00 00 00 jmp 106c40 <_Scheduler_EDF_Yield+0xf0> <== NOT EXECUTED
106b8a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
106b90: 89 d0 mov %edx,%eax
if ( ( *less )( key, parent ) ) {
106b92: 8b 50 14 mov 0x14(%eax),%edx
return &RB_LEFT( the_node, Node );
106b95: 89 c1 mov %eax,%ecx
if ( ( *less )( key, parent ) ) {
106b97: 39 70 10 cmp %esi,0x10(%eax)
106b9a: 19 da sbb %ebx,%edx
106b9c: 73 03 jae 106ba1 <_Scheduler_EDF_Yield+0x51>
return &RB_RIGHT( the_node, Node );
106b9e: 8d 48 04 lea 0x4(%eax),%ecx
while ( *link != NULL ) {
106ba1: 8b 11 mov (%ecx),%edx
106ba3: 85 d2 test %edx,%edx
106ba5: 75 e9 jne 106b90 <_Scheduler_EDF_Yield+0x40>
RB_SET( child, parent, Node );
106ba7: 89 47 38 mov %eax,0x38(%edi) <== NOT EXECUTED
*link = child;
106baa: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
RB_SET( child, parent, Node );
106bad: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) <== NOT EXECUTED
106bb4: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi) <== NOT EXECUTED
106bbb: c7 47 3c 01 00 00 00 movl $0x1,0x3c(%edi) <== NOT EXECUTED
*link = child;
106bc2: 89 01 mov %eax,(%ecx) <== NOT EXECUTED
_RBTree_Insert_color( the_rbtree, the_node );
106bc4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106bc8: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
106bcb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106bce: e8 0d 4a 00 00 call 10b5e0 <_RBTree_Insert_color> <== NOT EXECUTED
first = _RBTree_Minimum( &context->Ready );
106bd3: 8b 45 08 mov 0x8(%ebp),%eax
106bd6: 8b 00 mov (%eax),%eax
106bd8: 89 04 24 mov %eax,(%esp)
106bdb: e8 10 4c 00 00 call 10b7f0 <_RBTree_Minimum>
Thread_Control *heir = _Thread_Heir;
106be0: 8b 1d 7c 9c 12 00 mov 0x129c7c,%ebx
_Scheduler_Update_heir( node->Base.owner, force_dispatch );
106be6: 8b 48 d0 mov -0x30(%eax),%ecx
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
106be9: 89 4d e4 mov %ecx,-0x1c(%ebp)
106bec: 39 d9 cmp %ebx,%ecx
106bee: 74 3c je 106c2c <_Scheduler_EDF_Yield+0xdc> <== NEVER TAKEN
106bf0: 8b 35 80 9c 12 00 mov 0x129c80,%esi
106bf6: 8b 3d 84 9c 12 00 mov 0x129c84,%edi
106bfc: e8 2f f3 ff ff call 105f30 <_Timecounter_Sbinuptime>
_Thread_Heir = new_heir;
106c01: 8b 4d e4 mov -0x1c(%ebp),%ecx
106c04: a3 80 9c 12 00 mov %eax,0x129c80
*_result = *_end - *_start;
106c09: 29 f0 sub %esi,%eax
106c0b: 89 15 84 9c 12 00 mov %edx,0x129c84
106c11: 19 fa sbb %edi,%edx
*_time += *_add;
106c13: 01 83 90 00 00 00 add %eax,0x90(%ebx)
_Thread_Dispatch_necessary = true;
106c19: b0 01 mov $0x1,%al
106c1b: 11 93 94 00 00 00 adc %edx,0x94(%ebx)
_Thread_Heir = new_heir;
106c21: 89 0d 7c 9c 12 00 mov %ecx,0x129c7c
_Thread_Dispatch_necessary = true;
106c27: a2 74 9c 12 00 mov %al,0x129c74
_Scheduler_EDF_Schedule_body( scheduler, the_thread, true );
}
106c2c: 83 c4 2c add $0x2c,%esp
106c2f: 5b pop %ebx
106c30: 5e pop %esi
106c31: 5f pop %edi
106c32: 5d pop %ebp
106c33: c3 ret
106c34: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106c3b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106c3f: 90 nop
link = _RBTree_Root_reference( the_rbtree );
106c40: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
106c43: e9 5f ff ff ff jmp 106ba7 <_Scheduler_EDF_Yield+0x57> <== NOT EXECUTED
106c48: 90 nop
106c49: 90 nop
106c4a: 90 nop
106c4b: 90 nop
106c4c: 90 nop
106c4d: 90 nop
106c4e: 90 nop
106c4f: 90 nop
00109220 <_Scheduler_Set_affinity>:
bool _Scheduler_Set_affinity(
Thread_Control *the_thread,
size_t cpusetsize,
const cpu_set_t *cpuset
)
{
109220: 55 push %ebp
109221: 89 e5 mov %esp,%ebp
109223: 83 ec 28 sub $0x28,%esp
Processor_mask *dst,
size_t src_size,
const cpu_set_t *src
)
{
return _Processor_mask_Copy(
109226: 8b 45 0c mov 0xc(%ebp),%eax
109229: 89 44 24 0c mov %eax,0xc(%esp)
10922d: 8b 45 10 mov 0x10(%ebp),%eax
109230: 89 44 24 08 mov %eax,0x8(%esp)
109234: b8 04 00 00 00 mov $0x4,%eax
109239: 89 44 24 04 mov %eax,0x4(%esp)
10923d: 8d 45 f4 lea -0xc(%ebp),%eax
109240: 89 04 24 mov %eax,(%esp)
109243: e8 88 4e 00 00 call 10e0d0 <_Processor_mask_Copy>
109248: 89 c2 mov %eax,%edx
return (unsigned int) status <= PROCESSOR_MASK_COPY_PARTIAL_LOSS;
10924a: 31 c0 xor %eax,%eax
Scheduler_Node *node;
ISR_lock_Context lock_context;
bool ok;
status = _Processor_mask_From_cpu_set_t( &affinity, cpusetsize, cpuset );
if ( !_Processor_mask_Is_at_most_partial_loss( status ) ) {
10924c: 83 fa 01 cmp $0x1,%edx
10924f: 77 0f ja 109260 <_Scheduler_Set_affinity+0x40> <== NEVER TAKEN
BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c );
109251: a1 c4 7d 18 00 mov 0x187dc4,%eax
109256: 8b 55 f4 mov -0xc(%ebp),%edx
109259: 21 c2 and %eax,%edx
return BIT_SUBSET( CPU_MAXIMUM_PROCESSORS, big, small );
10925b: 39 c2 cmp %eax,%edx
10925d: 0f 94 c0 sete %al
);
#endif
_Scheduler_Release_critical( scheduler, &lock_context );
return ok;
}
109260: 89 ec mov %ebp,%esp
109262: 5d pop %ebp
109263: c3 ret
109264: 90 nop
109265: 90 nop
109266: 90 nop
109267: 90 nop
109268: 90 nop
109269: 90 nop
10926a: 90 nop
10926b: 90 nop
10926c: 90 nop
10926d: 90 nop
10926e: 90 nop
10926f: 90 nop
00106990 <_Scheduler_default_Tick>:
void _Scheduler_default_Tick(
const Scheduler_Control *scheduler,
Thread_Control *executing
)
{
106990: 55 push %ebp
106991: 89 e5 mov %esp,%ebp
106993: 83 ec 18 sub $0x18,%esp
106996: 89 5d fc mov %ebx,-0x4(%ebp)
106999: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10699c: 80 bb 81 00 00 00 00 cmpb $0x0,0x81(%ebx)
1069a3: 74 16 je 1069bb <_Scheduler_default_Tick+0x2b>
return;
if ( !_States_Is_ready( executing->current_state ) )
1069a5: 8b 43 1c mov 0x1c(%ebx),%eax
1069a8: 85 c0 test %eax,%eax
1069aa: 75 0f jne 1069bb <_Scheduler_default_Tick+0x2b>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
1069ac: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
1069b2: 83 f8 02 cmp $0x2,%eax
1069b5: 77 19 ja 1069d0 <_Scheduler_default_Tick+0x40>
1069b7: 85 c0 test %eax,%eax
1069b9: 75 35 jne 1069f0 <_Scheduler_default_Tick+0x60>
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
#endif
}
}
1069bb: 8b 5d fc mov -0x4(%ebp),%ebx
1069be: 89 ec mov %ebp,%esp
1069c0: 5d pop %ebp
1069c1: c3 ret
1069c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1069c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
switch ( executing->budget_algorithm ) {
1069d0: 83 f8 03 cmp $0x3,%eax
1069d3: 75 e6 jne 1069bb <_Scheduler_default_Tick+0x2b> <== NEVER TAKEN
if ( --executing->cpu_time_budget == 0 )
1069d5: ff 8b 84 00 00 00 decl 0x84(%ebx)
1069db: 75 de jne 1069bb <_Scheduler_default_Tick+0x2b>
(*executing->budget_callout)( executing );
1069dd: 89 5d 08 mov %ebx,0x8(%ebp)
1069e0: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
}
1069e6: 8b 5d fc mov -0x4(%ebp),%ebx
1069e9: 89 ec mov %ebp,%esp
1069eb: 5d pop %ebp
(*executing->budget_callout)( executing );
1069ec: ff e0 jmp *%eax
1069ee: 66 90 xchg %ax,%ax
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
1069f0: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
1069f6: 48 dec %eax
1069f7: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
1069fd: 85 c0 test %eax,%eax
1069ff: 7f ba jg 1069bb <_Scheduler_default_Tick+0x2b>
_Thread_Yield( executing );
106a01: 89 1c 24 mov %ebx,(%esp)
106a04: e8 77 1f 00 00 call 108980 <_Thread_Yield>
executing->cpu_time_budget =
106a09: a1 bc 54 12 00 mov 0x1254bc,%eax
106a0e: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
106a14: eb a5 jmp 1069bb <_Scheduler_default_Tick+0x2b>
106a16: 90 nop
106a17: 90 nop
106a18: 90 nop
106a19: 90 nop
106a1a: 90 nop
106a1b: 90 nop
106a1c: 90 nop
106a1d: 90 nop
106a1e: 90 nop
106a1f: 90 nop
00106b40 <_Scheduler_priority_Initialize>:
#endif
#include <rtems/score/schedulerpriorityimpl.h>
void _Scheduler_priority_Initialize( const Scheduler_Control *scheduler )
{
106b40: 55 push %ebp
memset( bit_map, 0, sizeof( *bit_map ) );
106b41: 31 c9 xor %ecx,%ecx
106b43: 89 e5 mov %esp,%ebp
106b45: 57 push %edi
return scheduler->context;
106b46: 8b 45 08 mov 0x8(%ebp),%eax
106b49: 56 push %esi
106b4a: be 22 00 00 00 mov $0x22,%esi
106b4f: 53 push %ebx
106b50: 8b 18 mov (%eax),%ebx
106b52: f6 c3 01 test $0x1,%bl
106b55: 89 da mov %ebx,%edx
106b57: 0f 85 c3 00 00 00 jne 106c20 <_Scheduler_priority_Initialize+0xe0> <== NEVER TAKEN
106b5d: f6 c2 02 test $0x2,%dl
106b60: 0f 85 aa 00 00 00 jne 106c10 <_Scheduler_priority_Initialize+0xd0> <== NEVER TAKEN
106b66: 89 f7 mov %esi,%edi
106b68: 31 c0 xor %eax,%eax
106b6a: 83 e7 f8 and $0xfffffff8,%edi
106b6d: 89 0c 02 mov %ecx,(%edx,%eax,1)
106b70: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
106b74: 83 c0 08 add $0x8,%eax
106b77: 39 f8 cmp %edi,%eax
106b79: 72 f2 jb 106b6d <_Scheduler_priority_Initialize+0x2d>
106b7b: 01 c2 add %eax,%edx
106b7d: f7 c6 04 00 00 00 test $0x4,%esi
106b83: 75 6b jne 106bf0 <_Scheduler_priority_Initialize+0xb0> <== NEVER TAKEN
106b85: f7 c6 02 00 00 00 test $0x2,%esi
106b8b: 75 53 jne 106be0 <_Scheduler_priority_Initialize+0xa0> <== ALWAYS TAKEN
106b8d: 83 e6 01 and $0x1,%esi <== NOT EXECUTED
106b90: 75 3e jne 106bd0 <_Scheduler_priority_Initialize+0x90> <== NOT EXECUTED
Scheduler_priority_Context *context =
_Scheduler_priority_Get_context( scheduler );
_Priority_bit_map_Initialize( &context->Bit_map );
_Scheduler_priority_Ready_queue_initialize(
106b92: 8b 75 08 mov 0x8(%ebp),%esi
106b95: 8d 43 24 lea 0x24(%ebx),%eax
for ( index = 0 ; index <= (size_t) maximum_priority ; ++index ) {
106b98: 8b 56 3c mov 0x3c(%esi),%edx
106b9b: 8d 14 52 lea (%edx,%edx,2),%edx
106b9e: 8d 4c 93 24 lea 0x24(%ebx,%edx,4),%ecx
106ba2: eb 0f jmp 106bb3 <_Scheduler_priority_Initialize+0x73>
106ba4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106bab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106baf: 90 nop
106bb0: 83 c0 0c add $0xc,%eax
head->previous = NULL;
106bb3: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
head->next = tail;
106bba: 8d 50 04 lea 0x4(%eax),%edx
106bbd: 39 c8 cmp %ecx,%eax
106bbf: 89 10 mov %edx,(%eax)
tail->previous = head;
106bc1: 89 40 08 mov %eax,0x8(%eax)
106bc4: 75 ea jne 106bb0 <_Scheduler_priority_Initialize+0x70>
&context->Ready[ 0 ],
scheduler->maximum_priority
);
}
106bc6: 5b pop %ebx
106bc7: 5e pop %esi
106bc8: 5f pop %edi
106bc9: 5d pop %ebp
106bca: c3 ret
106bcb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106bcf: 90 nop
106bd0: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
106bd3: eb bd jmp 106b92 <_Scheduler_priority_Initialize+0x52> <== NOT EXECUTED
106bd5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106bdc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106be0: 66 c7 02 00 00 movw $0x0,(%edx)
106be5: 83 c2 02 add $0x2,%edx
106be8: 83 e6 01 and $0x1,%esi
106beb: 74 a5 je 106b92 <_Scheduler_priority_Initialize+0x52> <== ALWAYS TAKEN
106bed: eb e1 jmp 106bd0 <_Scheduler_priority_Initialize+0x90> <== NOT EXECUTED
106bef: 90 nop <== NOT EXECUTED
106bf0: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
106bf6: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
106bf9: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED
106bff: 74 8c je 106b8d <_Scheduler_priority_Initialize+0x4d> <== NOT EXECUTED
106c01: eb dd jmp 106be0 <_Scheduler_priority_Initialize+0xa0> <== NOT EXECUTED
106c03: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106c0a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
106c10: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
106c15: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
106c18: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
106c1b: e9 46 ff ff ff jmp 106b66 <_Scheduler_priority_Initialize+0x26> <== NOT EXECUTED
106c20: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED
106c23: 8d 53 01 lea 0x1(%ebx),%edx <== NOT EXECUTED
106c26: be 21 00 00 00 mov $0x21,%esi <== NOT EXECUTED
106c2b: e9 2d ff ff ff jmp 106b5d <_Scheduler_priority_Initialize+0x1d> <== NOT EXECUTED
00106e90 <_Scheduler_priority_Schedule>:
void _Scheduler_priority_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
106e90: 55 push %ebp
_CPU_Bitfield_Find_first_bit( value, bit_number );
106e91: 31 d2 xor %edx,%edx
106e93: 89 e5 mov %esp,%ebp
106e95: 83 ec 28 sub $0x28,%esp
106e98: 89 5d f4 mov %ebx,-0xc(%ebp)
106e9b: 8b 45 08 mov 0x8(%ebp),%eax
106e9e: 89 75 f8 mov %esi,-0x8(%ebp)
106ea1: 89 7d fc mov %edi,-0x4(%ebp)
106ea4: 8b 08 mov (%eax),%ecx
106ea6: 89 d0 mov %edx,%eax
106ea8: 0f b7 19 movzwl (%ecx),%ebx
106eab: 66 0f bc c3 bsf %bx,%ax
106eaf: 0f b7 c0 movzwl %ax,%eax
106eb2: 0f b7 5c 41 02 movzwl 0x2(%ecx,%eax,2),%ebx
106eb7: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
106ebb: c1 e0 04 shl $0x4,%eax
_CPU_Bitfield_Find_first_bit( value, bit_number );
106ebe: 0f b7 d2 movzwl %dx,%edx
Thread_Control *heir = _Thread_Heir;
106ec1: 8b 1d fc 03 13 00 mov 0x1303fc,%ebx
Chain_Node *first = _Chain_First( &ready_queues[ index ] );
106ec7: 01 d0 add %edx,%eax
return _Chain_Immutable_head( the_chain )->next;
106ec9: 8d 04 40 lea (%eax,%eax,2),%eax
106ecc: 8b 4c 81 24 mov 0x24(%ecx,%eax,4),%ecx
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
106ed0: 39 d9 cmp %ebx,%ecx
106ed2: 74 09 je 106edd <_Scheduler_priority_Schedule+0x4d>
106ed4: 80 bb 81 00 00 00 00 cmpb $0x0,0x81(%ebx)
106edb: 75 13 jne 106ef0 <_Scheduler_priority_Schedule+0x60> <== ALWAYS TAKEN
_Scheduler_priority_Schedule_body( scheduler, the_thread, false );
}
106edd: 8b 5d f4 mov -0xc(%ebp),%ebx
106ee0: 8b 75 f8 mov -0x8(%ebp),%esi
106ee3: 8b 7d fc mov -0x4(%ebp),%edi
106ee6: 89 ec mov %ebp,%esp
106ee8: 5d pop %ebp
106ee9: c3 ret
106eea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
106ef0: 89 4d e4 mov %ecx,-0x1c(%ebp)
106ef3: 8b 35 00 04 13 00 mov 0x130400,%esi
106ef9: 8b 3d 04 04 13 00 mov 0x130404,%edi
106eff: e8 4c f4 ff ff call 106350 <_Timecounter_Sbinuptime>
_Thread_Heir = new_heir;
106f04: 8b 4d e4 mov -0x1c(%ebp),%ecx
106f07: a3 00 04 13 00 mov %eax,0x130400
*_result = *_end - *_start;
106f0c: 29 f0 sub %esi,%eax
106f0e: 8b 75 f8 mov -0x8(%ebp),%esi
106f11: 89 15 04 04 13 00 mov %edx,0x130404
106f17: 19 fa sbb %edi,%edx
106f19: 8b 7d fc mov -0x4(%ebp),%edi
*_time += *_add;
106f1c: 01 83 90 00 00 00 add %eax,0x90(%ebx)
_Thread_Dispatch_necessary = true;
106f22: b0 01 mov $0x1,%al
106f24: 11 93 94 00 00 00 adc %edx,0x94(%ebx)
106f2a: 8b 5d f4 mov -0xc(%ebp),%ebx
_Thread_Heir = new_heir;
106f2d: 89 0d fc 03 13 00 mov %ecx,0x1303fc
_Thread_Dispatch_necessary = true;
106f33: a2 f4 03 13 00 mov %al,0x1303f4
106f38: 89 ec mov %ebp,%esp
106f3a: 5d pop %ebp
106f3b: c3 ret
106f3c: 90 nop
106f3d: 90 nop
106f3e: 90 nop
106f3f: 90 nop
00106f40 <_Scheduler_priority_Unblock>:
void _Scheduler_priority_Unblock (
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
106f40: 55 push %ebp
106f41: 89 e5 mov %esp,%ebp
106f43: 57 push %edi
106f44: 56 push %esi
106f45: 53 push %ebx
106f46: 83 ec 1c sub $0x1c,%esp
return scheduler->context;
106f49: 8b 55 08 mov 0x8(%ebp),%edx
106f4c: 8b 45 10 mov 0x10(%ebp),%eax
106f4f: 8b 3a mov (%edx),%edi
106f51: 89 7d e0 mov %edi,-0x20(%ebp)
do {
seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock );
#endif
priority = node->Priority.value;
106f54: 8b 78 28 mov 0x28(%eax),%edi
106f57: 89 7d e4 mov %edi,-0x1c(%ebp)
unsigned int unmapped_priority;
context = _Scheduler_priority_Get_context( scheduler );
the_node = _Scheduler_priority_Node_downcast( node );
priority = (unsigned int ) _Scheduler_Node_get_priority( &the_node->Base );
unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority );
106f5a: 89 fa mov %edi,%edx
106f5c: d1 ea shr %edx
if ( unmapped_priority != the_node->Ready_queue.current_priority ) {
106f5e: 39 50 30 cmp %edx,0x30(%eax)
106f61: 75 5d jne 106fc0 <_Scheduler_priority_Unblock+0x80>
*bit_map_info->minor |= bit_map_info->ready_minor;
106f63: 8b 70 38 mov 0x38(%eax),%esi
Chain_Control *ready_chain = ready_queue->ready_chain;
106f66: 8b 58 34 mov 0x34(%eax),%ebx
106f69: 0f b7 50 3e movzwl 0x3e(%eax),%edx
106f6d: 89 75 dc mov %esi,-0x24(%ebp)
return &the_chain->Tail.Node;
106f70: 8b 75 0c mov 0xc(%ebp),%esi
106f73: 8d 7b 04 lea 0x4(%ebx),%edi
old_last = tail->previous;
106f76: 8b 4b 08 mov 0x8(%ebx),%ecx
return &the_chain->Tail.Node;
106f79: 89 3e mov %edi,(%esi)
tail->previous = the_node;
106f7b: 89 73 08 mov %esi,0x8(%ebx)
106f7e: 8b 5d dc mov -0x24(%ebp),%ebx
old_last->next = the_node;
106f81: 89 31 mov %esi,(%ecx)
the_node->previous = old_last;
106f83: 89 4e 04 mov %ecx,0x4(%esi)
bit_map->major_bit_map |= bit_map_info->ready_major;
106f86: 8b 75 e0 mov -0x20(%ebp),%esi
*bit_map_info->minor |= bit_map_info->ready_minor;
106f89: 0f b7 0b movzwl (%ebx),%ecx
106f8c: 09 ca or %ecx,%edx
106f8e: 66 89 13 mov %dx,(%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 ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
106f91: 8b 1d fc 03 13 00 mov 0x1303fc,%ebx
bit_map->major_bit_map |= bit_map_info->ready_major;
106f97: 0f b7 16 movzwl (%esi),%edx
106f9a: 8b 40 3c mov 0x3c(%eax),%eax
106f9d: 09 d0 or %edx,%eax
106f9f: ba 00 00 00 00 mov $0x0,%edx
106fa4: 66 89 06 mov %ax,(%esi)
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
106fa7: 8b 43 38 mov 0x38(%ebx),%eax
106faa: 8b 75 e4 mov -0x1c(%ebp),%esi
106fad: 3b 70 14 cmp 0x14(%eax),%esi
106fb0: 1b 50 18 sbb 0x18(%eax),%edx
106fb3: 72 6b jb 107020 <_Scheduler_priority_Unblock+0xe0>
_Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR );
}
}
106fb5: 83 c4 1c add $0x1c,%esp
106fb8: 5b pop %ebx
106fb9: 5e pop %esi
106fba: 5f pop %edi
106fbb: 5d pop %ebp
106fbc: c3 ret
106fbd: 8d 76 00 lea 0x0(%esi),%esi
ready_queue->current_priority = new_priority;
106fc0: 89 50 30 mov %edx,0x30(%eax)
ready_queue->ready_chain = &ready_queues[ new_priority ];
106fc3: 8b 7d e0 mov -0x20(%ebp),%edi
106fc6: 8d 0c 52 lea (%edx,%edx,2),%ecx
106fc9: 8d 5c 8f 24 lea 0x24(%edi,%ecx,4),%ebx
return the_priority / 16;
106fcd: 8b 4d e4 mov -0x1c(%ebp),%ecx
106fd0: 89 58 34 mov %ebx,0x34(%eax)
106fd3: c1 e9 05 shr $0x5,%ecx
bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ];
106fd6: 8d 7c 4f 02 lea 0x2(%edi,%ecx,2),%edi
106fda: 89 7d dc mov %edi,-0x24(%ebp)
106fdd: 89 78 38 mov %edi,0x38(%eax)
return _CPU_Priority_Mask( bit_number );
106fe0: bf 01 00 00 00 mov $0x1,%edi
106fe5: 89 fe mov %edi,%esi
106fe7: d3 e6 shl %cl,%esi
106fe9: 0f b7 ce movzwl %si,%ecx
bit_map_info->ready_major = mask;
106fec: 66 89 48 3c mov %cx,0x3c(%eax)
bit_map_info->block_major = (Priority_bit_map_Word) ~mask;
106ff0: f7 d1 not %ecx
106ff2: 66 89 48 40 mov %cx,0x40(%eax)
return the_priority % 16;
106ff6: 89 d1 mov %edx,%ecx
106ff8: 83 e1 0f and $0xf,%ecx
return _CPU_Priority_Mask( bit_number );
106ffb: d3 e7 shl %cl,%edi
106ffd: 0f b7 d7 movzwl %di,%edx
bit_map_info->ready_minor = mask;
107000: 66 89 50 3e mov %dx,0x3e(%eax)
bit_map_info->block_minor = (Priority_bit_map_Word) ~mask;
107004: 89 d1 mov %edx,%ecx
107006: f7 d1 not %ecx
107008: 66 89 48 42 mov %cx,0x42(%eax)
_Priority_bit_map_Initialize_information(
bit_map,
&ready_queue->Priority_map,
new_priority
);
}
10700c: e9 5f ff ff ff jmp 106f70 <_Scheduler_priority_Unblock+0x30>
107011: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107018: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10701f: 90 nop
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
107020: 3b 5d 0c cmp 0xc(%ebp),%ebx
107023: 74 90 je 106fb5 <_Scheduler_priority_Unblock+0x75> <== NEVER TAKEN
107025: 85 f6 test %esi,%esi
107027: 74 09 je 107032 <_Scheduler_priority_Unblock+0xf2>
107029: 80 bb 81 00 00 00 00 cmpb $0x0,0x81(%ebx)
107030: 74 83 je 106fb5 <_Scheduler_priority_Unblock+0x75>
107032: 8b 35 00 04 13 00 mov 0x130400,%esi
107038: 8b 3d 04 04 13 00 mov 0x130404,%edi
10703e: e8 0d f3 ff ff call 106350 <_Timecounter_Sbinuptime>
107043: a3 00 04 13 00 mov %eax,0x130400
*_result = *_end - *_start;
107048: 29 f0 sub %esi,%eax
10704a: 89 15 04 04 13 00 mov %edx,0x130404
107050: 19 fa sbb %edi,%edx
*_time += *_add;
107052: 01 83 90 00 00 00 add %eax,0x90(%ebx)
_Thread_Heir = new_heir;
107058: 8b 45 0c mov 0xc(%ebp),%eax
10705b: 11 93 94 00 00 00 adc %edx,0x94(%ebx)
107061: a3 fc 03 13 00 mov %eax,0x1303fc
_Thread_Dispatch_necessary = true;
107066: b0 01 mov $0x1,%al
107068: a2 f4 03 13 00 mov %al,0x1303f4
10706d: e9 43 ff ff ff jmp 106fb5 <_Scheduler_priority_Unblock+0x75>
107072: 90 nop
107073: 90 nop
107074: 90 nop
107075: 90 nop
107076: 90 nop
107077: 90 nop
107078: 90 nop
107079: 90 nop
10707a: 90 nop
10707b: 90 nop
10707c: 90 nop
10707d: 90 nop
10707e: 90 nop
10707f: 90 nop
00106370 <_Scheduler_simple_Block>:
void _Scheduler_simple_Block(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
106370: 55 push %ebp
106371: 89 e5 mov %esp,%ebp
106373: 83 ec 28 sub $0x28,%esp
106376: 89 5d f4 mov %ebx,-0xc(%ebp)
106379: 8b 45 0c mov 0xc(%ebp),%eax
{
( *extract )( scheduler, the_thread, node );
/* TODO: flash critical section? */
if ( _Thread_Is_executing( the_thread ) || _Thread_Is_heir( the_thread ) ) {
10637c: 3b 05 d8 a0 12 00 cmp 0x12a0d8,%eax
106382: 89 75 f8 mov %esi,-0x8(%ebp)
return ( the_thread == _Thread_Heir );
106385: 8b 1d dc a0 12 00 mov 0x12a0dc,%ebx
10638b: 89 7d fc mov %edi,-0x4(%ebp)
next = the_node->next;
10638e: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
106390: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
106393: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
106396: 89 0a mov %ecx,(%edx)
106398: 74 16 je 1063b0 <_Scheduler_simple_Block+0x40>
10639a: 39 d8 cmp %ebx,%eax
10639c: 74 12 je 1063b0 <_Scheduler_simple_Block+0x40> <== NEVER TAKEN
the_thread,
node,
_Scheduler_simple_Extract,
_Scheduler_simple_Schedule_body
);
}
10639e: 8b 5d f4 mov -0xc(%ebp),%ebx
1063a1: 8b 75 f8 mov -0x8(%ebp),%esi
1063a4: 8b 7d fc mov -0x4(%ebp),%edi
1063a7: 89 ec mov %ebp,%esp
1063a9: 5d pop %ebp
1063aa: c3 ret
1063ab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1063af: 90 nop
return _Chain_Immutable_head( the_chain )->next;
1063b0: 8b 45 08 mov 0x8(%ebp),%eax
1063b3: 8b 00 mov (%eax),%eax
1063b5: 8b 08 mov (%eax),%ecx
bool force_dispatch
)
{
Thread_Control *heir = _Thread_Heir;
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
1063b7: 89 4d e4 mov %ecx,-0x1c(%ebp)
1063ba: 39 d9 cmp %ebx,%ecx
1063bc: 74 e0 je 10639e <_Scheduler_simple_Block+0x2e> <== NEVER TAKEN
last = cpu->cpu_usage_timestamp;
1063be: 8b 35 e0 a0 12 00 mov 0x12a0e0,%esi
1063c4: 8b 3d e4 a0 12 00 mov 0x12a0e4,%edi
*time = _Timecounter_Sbinuptime();
1063ca: e8 e1 f9 ff ff call 105db0 <_Timecounter_Sbinuptime>
*/
heir->Scheduler.state = THREAD_SCHEDULER_BLOCKED;
new_heir->Scheduler.state = THREAD_SCHEDULER_SCHEDULED;
#endif
_Thread_Update_CPU_time_used( heir, _Thread_Get_CPU( heir ) );
_Thread_Heir = new_heir;
1063cf: 8b 4d e4 mov -0x1c(%ebp),%ecx
1063d2: a3 e0 a0 12 00 mov %eax,0x12a0e0
const Timestamp_Control *_start,
const Timestamp_Control *_end,
Timestamp_Control *_result
)
{
*_result = *_end - *_start;
1063d7: 29 f0 sub %esi,%eax
1063d9: 8b 75 f8 mov -0x8(%ebp),%esi
1063dc: 89 15 e4 a0 12 00 mov %edx,0x12a0e4
1063e2: 19 fa sbb %edi,%edx
1063e4: 8b 7d fc mov -0x4(%ebp),%edi
*_time += *_add;
1063e7: 01 83 90 00 00 00 add %eax,0x90(%ebx)
_Thread_Dispatch_necessary = true;
1063ed: b0 01 mov $0x1,%al
1063ef: 11 93 94 00 00 00 adc %edx,0x94(%ebx)
1063f5: 8b 5d f4 mov -0xc(%ebp),%ebx
_Thread_Heir = new_heir;
1063f8: 89 0d dc a0 12 00 mov %ecx,0x12a0dc
_Thread_Dispatch_necessary = true;
1063fe: a2 d4 a0 12 00 mov %al,0x12a0d4
106403: 89 ec mov %ebp,%esp
106405: 5d pop %ebp
106406: c3 ret
106407: 90 nop
106408: 90 nop
106409: 90 nop
10640a: 90 nop
10640b: 90 nop
10640c: 90 nop
10640d: 90 nop
10640e: 90 nop
10640f: 90 nop
00106510 <_Scheduler_simple_Schedule>:
void _Scheduler_simple_Schedule(
const Scheduler_Control *scheduler,
Thread_Control *the_thread
)
{
106510: 55 push %ebp <== NOT EXECUTED
106511: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106513: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED
106516: 89 5d f4 mov %ebx,-0xc(%ebp) <== NOT EXECUTED
106519: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10651c: 89 75 f8 mov %esi,-0x8(%ebp) <== NOT EXECUTED
Thread_Control *heir = _Thread_Heir;
10651f: 8b 1d dc a0 12 00 mov 0x12a0dc,%ebx <== NOT EXECUTED
106525: 89 7d fc mov %edi,-0x4(%ebp) <== NOT EXECUTED
106528: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10652a: 8b 08 mov (%eax),%ecx <== NOT EXECUTED
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
10652c: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED
10652e: 74 09 je 106539 <_Scheduler_simple_Schedule+0x29> <== NOT EXECUTED
106530: 80 bb 81 00 00 00 00 cmpb $0x0,0x81(%ebx) <== NOT EXECUTED
106537: 75 17 jne 106550 <_Scheduler_simple_Schedule+0x40> <== NOT EXECUTED
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
106539: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
10653c: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
10653f: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
106542: 89 ec mov %ebp,%esp <== NOT EXECUTED
106544: 5d pop %ebp <== NOT EXECUTED
106545: c3 ret <== NOT EXECUTED
106546: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10654d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
106550: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED
106553: 8b 35 e0 a0 12 00 mov 0x12a0e0,%esi <== NOT EXECUTED
106559: 8b 3d e4 a0 12 00 mov 0x12a0e4,%edi <== NOT EXECUTED
10655f: e8 4c f8 ff ff call 105db0 <_Timecounter_Sbinuptime> <== NOT EXECUTED
_Thread_Heir = new_heir;
106564: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
106567: a3 e0 a0 12 00 mov %eax,0x12a0e0 <== NOT EXECUTED
*_result = *_end - *_start;
10656c: 29 f0 sub %esi,%eax <== NOT EXECUTED
10656e: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
106571: 89 15 e4 a0 12 00 mov %edx,0x12a0e4 <== NOT EXECUTED
106577: 19 fa sbb %edi,%edx <== NOT EXECUTED
106579: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
*_time += *_add;
10657c: 01 83 90 00 00 00 add %eax,0x90(%ebx) <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
106582: b0 01 mov $0x1,%al <== NOT EXECUTED
106584: 11 93 94 00 00 00 adc %edx,0x94(%ebx) <== NOT EXECUTED
10658a: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
_Thread_Heir = new_heir;
10658d: 89 0d dc a0 12 00 mov %ecx,0x12a0dc <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
106593: a2 d4 a0 12 00 mov %al,0x12a0d4 <== NOT EXECUTED
106598: 89 ec mov %ebp,%esp <== NOT EXECUTED
10659a: 5d pop %ebp <== NOT EXECUTED
10659b: c3 ret <== NOT EXECUTED
10659c: 90 nop
10659d: 90 nop
10659e: 90 nop
10659f: 90 nop
001065a0 <_Scheduler_simple_Unblock>:
void _Scheduler_simple_Unblock(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
1065a0: 55 push %ebp
1065a1: 89 e5 mov %esp,%ebp
1065a3: 57 push %edi
1065a4: 56 push %esi
1065a5: 53 push %ebx
1065a6: 83 ec 1c sub $0x1c,%esp
1065a9: 8b 7d 0c mov 0xc(%ebp),%edi
return scheduler->context;
1065ac: 8b 45 08 mov 0x8(%ebp),%eax
1065af: 8b 57 38 mov 0x38(%edi),%edx
1065b2: 8b 00 mov (%eax),%eax
1065b4: 8b 7a 14 mov 0x14(%edx),%edi
return &the_chain->Tail.Node;
1065b7: 8d 58 04 lea 0x4(%eax),%ebx
return _Chain_Immutable_head( the_chain )->next;
1065ba: 8b 00 mov (%eax),%eax
1065bc: 89 7d e0 mov %edi,-0x20(%ebp)
(void) node;
context = _Scheduler_simple_Get_context( scheduler );
priority = _Thread_Get_priority( the_thread );
insert_priority = SCHEDULER_PRIORITY_APPEND( priority );
1065bf: 89 fa mov %edi,%edx
1065c1: 83 ca 01 or $0x1,%edx
while ( next != tail && !( *order )( left, next ) ) {
1065c4: 39 c3 cmp %eax,%ebx
1065c6: 74 1b je 1065e3 <_Scheduler_simple_Unblock+0x43>
const Thread_Control *thread_next;
priority_to_insert = (const unsigned int *) to_insert;
thread_next = (const Thread_Control *) next;
return *priority_to_insert <= _Thread_Get_priority( thread_next );
1065c8: 89 d6 mov %edx,%esi
1065ca: 31 ff xor %edi,%edi
1065cc: eb 08 jmp 1065d6 <_Scheduler_simple_Unblock+0x36>
1065ce: 66 90 xchg %ax,%ax
return the_node->next;
1065d0: 8b 00 mov (%eax),%eax
while ( next != tail && !( *order )( left, next ) ) {
1065d2: 39 c3 cmp %eax,%ebx
1065d4: 74 0d je 1065e3 <_Scheduler_simple_Unblock+0x43>
1065d6: 8b 50 38 mov 0x38(%eax),%edx
1065d9: 8b 4a 18 mov 0x18(%edx),%ecx
1065dc: 39 72 14 cmp %esi,0x14(%edx)
1065df: 19 f9 sbb %edi,%ecx
1065e1: 72 ed jb 1065d0 <_Scheduler_simple_Unblock+0x30>
return the_node->previous;
1065e3: 8b 40 04 mov 0x4(%eax),%eax
the_node->previous = after_node;
1065e6: 8b 7d 0c mov 0xc(%ebp),%edi
* 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 ( priority < _Thread_Get_priority( _Thread_Heir ) ) {
1065e9: 8b 35 dc a0 12 00 mov 0x12a0dc,%esi
before_node = after_node->next;
1065ef: 8b 10 mov (%eax),%edx
the_node->previous = after_node;
1065f1: 89 47 04 mov %eax,0x4(%edi)
after_node->next = the_node;
1065f4: 89 38 mov %edi,(%eax)
1065f6: 8b 46 38 mov 0x38(%esi),%eax
the_node->next = before_node;
1065f9: 89 17 mov %edx,(%edi)
before_node->previous = the_node;
1065fb: 89 7a 04 mov %edi,0x4(%edx)
1065fe: 8b 7d e0 mov -0x20(%ebp),%edi
106601: ba 00 00 00 00 mov $0x0,%edx
106606: 3b 78 14 cmp 0x14(%eax),%edi
106609: 1b 50 18 sbb 0x18(%eax),%edx
10660c: 72 12 jb 106620 <_Scheduler_simple_Unblock+0x80>
_Scheduler_Update_heir(
the_thread,
priority == PRIORITY_PSEUDO_ISR
);
}
}
10660e: 83 c4 1c add $0x1c,%esp
106611: 5b pop %ebx
106612: 5e pop %esi
106613: 5f pop %edi
106614: 5d pop %ebp
106615: c3 ret
106616: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10661d: 8d 76 00 lea 0x0(%esi),%esi
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
106620: 3b 75 0c cmp 0xc(%ebp),%esi
106623: 74 e9 je 10660e <_Scheduler_simple_Unblock+0x6e> <== NEVER TAKEN
106625: 85 ff test %edi,%edi
106627: 74 09 je 106632 <_Scheduler_simple_Unblock+0x92>
106629: 80 be 81 00 00 00 00 cmpb $0x0,0x81(%esi)
106630: 74 dc je 10660e <_Scheduler_simple_Unblock+0x6e>
106632: a1 e0 a0 12 00 mov 0x12a0e0,%eax
106637: 8b 15 e4 a0 12 00 mov 0x12a0e4,%edx
10663d: 89 45 e0 mov %eax,-0x20(%ebp)
106640: 89 55 e4 mov %edx,-0x1c(%ebp)
106643: e8 68 f7 ff ff call 105db0 <_Timecounter_Sbinuptime>
106648: a3 e0 a0 12 00 mov %eax,0x12a0e0
*_result = *_end - *_start;
10664d: 2b 45 e0 sub -0x20(%ebp),%eax
106650: 89 15 e4 a0 12 00 mov %edx,0x12a0e4
106656: 1b 55 e4 sbb -0x1c(%ebp),%edx
*_time += *_add;
106659: 01 86 90 00 00 00 add %eax,0x90(%esi)
_Thread_Heir = new_heir;
10665f: 8b 45 0c mov 0xc(%ebp),%eax
106662: 11 96 94 00 00 00 adc %edx,0x94(%esi)
106668: a3 dc a0 12 00 mov %eax,0x12a0dc
_Thread_Dispatch_necessary = true;
10666d: b0 01 mov $0x1,%al
10666f: a2 d4 a0 12 00 mov %al,0x12a0d4
106674: eb 98 jmp 10660e <_Scheduler_simple_Unblock+0x6e>
106676: 90 nop
106677: 90 nop
106678: 90 nop
106679: 90 nop
10667a: 90 nop
10667b: 90 nop
10667c: 90 nop
10667d: 90 nop
10667e: 90 nop
10667f: 90 nop
00106430 <_Scheduler_simple_Update_priority>:
void _Scheduler_simple_Update_priority(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
106430: 55 push %ebp
106431: 89 e5 mov %esp,%ebp
106433: 57 push %edi
106434: 56 push %esi
106435: 53 push %ebx
106436: 83 ec 1c sub $0x1c,%esp
Scheduler_simple_Context *context;
unsigned int new_priority;
if ( !_Thread_Is_ready( the_thread ) ) {
106439: 8b 45 0c mov 0xc(%ebp),%eax
10643c: 8b 50 1c mov 0x1c(%eax),%edx
10643f: 85 d2 test %edx,%edx
106441: 74 0d je 106450 <_Scheduler_simple_Update_priority+0x20><== ALWAYS TAKEN
new_priority = (unsigned int ) _Scheduler_Node_get_priority( node );
_Scheduler_simple_Extract( scheduler, the_thread, node );
_Scheduler_simple_Insert( &context->Ready, the_thread, new_priority );
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
106443: 83 c4 1c add $0x1c,%esp
106446: 5b pop %ebx
106447: 5e pop %esi
106448: 5f pop %edi
106449: 5d pop %ebp
10644a: c3 ret
10644b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10644f: 90 nop
106450: 8b 45 08 mov 0x8(%ebp),%eax
106453: 8b 38 mov (%eax),%edi
do {
seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock );
#endif
priority = node->Priority.value;
106455: 8b 45 10 mov 0x10(%ebp),%eax
106458: 89 7d e4 mov %edi,-0x1c(%ebp)
return &the_chain->Tail.Node;
10645b: 8d 5f 04 lea 0x4(%edi),%ebx
10645e: 8b 70 28 mov 0x28(%eax),%esi
next = the_node->next;
106461: 8b 45 0c mov 0xc(%ebp),%eax
106464: 8b 10 mov (%eax),%edx
previous = the_node->previous;
106466: 8b 40 04 mov 0x4(%eax),%eax
next->previous = previous;
106469: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
10646c: 89 10 mov %edx,(%eax)
return _Chain_Immutable_head( the_chain )->next;
10646e: 8b 07 mov (%edi),%eax
)
{
const Chain_Node *tail = _Chain_Immutable_tail( the_chain );
Chain_Node *next = _Chain_First( the_chain );
while ( next != tail && !( *order )( left, next ) ) {
106470: 39 c3 cmp %eax,%ebx
106472: 74 1f je 106493 <_Scheduler_simple_Update_priority+0x63><== NEVER TAKEN
106474: 31 ff xor %edi,%edi
106476: eb 0e jmp 106486 <_Scheduler_simple_Update_priority+0x56>
106478: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10647f: 90 nop
return the_node->next;
106480: 8b 00 mov (%eax),%eax
while ( next != tail && !( *order )( left, next ) ) {
106482: 39 c3 cmp %eax,%ebx
106484: 74 0d je 106493 <_Scheduler_simple_Update_priority+0x63>
return aggregation->Node.priority;
106486: 8b 50 38 mov 0x38(%eax),%edx
106489: 8b 4a 18 mov 0x18(%edx),%ecx
10648c: 39 72 14 cmp %esi,0x14(%edx)
10648f: 19 f9 sbb %edi,%ecx
106491: 72 ed jb 106480 <_Scheduler_simple_Update_priority+0x50>
return the_node->previous;
106493: 8b 40 04 mov 0x4(%eax),%eax
the_node->previous = after_node;
106496: 8b 75 0c mov 0xc(%ebp),%esi
Thread_Control *heir = _Thread_Heir;
106499: 8b 1d dc a0 12 00 mov 0x12a0dc,%ebx
before_node = after_node->next;
10649f: 8b 10 mov (%eax),%edx
the_node->previous = after_node;
1064a1: 89 46 04 mov %eax,0x4(%esi)
after_node->next = the_node;
1064a4: 89 30 mov %esi,(%eax)
return _Chain_Immutable_head( the_chain )->next;
1064a6: 8b 45 e4 mov -0x1c(%ebp),%eax
the_node->next = before_node;
1064a9: 89 16 mov %edx,(%esi)
before_node->previous = the_node;
1064ab: 89 72 04 mov %esi,0x4(%edx)
return _Chain_Immutable_head( the_chain )->next;
1064ae: 8b 08 mov (%eax),%ecx
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
1064b0: 39 d9 cmp %ebx,%ecx
1064b2: 74 8f je 106443 <_Scheduler_simple_Update_priority+0x13>
1064b4: 80 bb 81 00 00 00 00 cmpb $0x0,0x81(%ebx)
1064bb: 74 86 je 106443 <_Scheduler_simple_Update_priority+0x13><== ALWAYS TAKEN
1064bd: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED
1064c0: 8b 35 e0 a0 12 00 mov 0x12a0e0,%esi <== NOT EXECUTED
1064c6: 8b 3d e4 a0 12 00 mov 0x12a0e4,%edi <== NOT EXECUTED
1064cc: e8 df f8 ff ff call 105db0 <_Timecounter_Sbinuptime> <== NOT EXECUTED
_Thread_Heir = new_heir;
1064d1: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
1064d4: a3 e0 a0 12 00 mov %eax,0x12a0e0 <== NOT EXECUTED
*_result = *_end - *_start;
1064d9: 29 f0 sub %esi,%eax <== NOT EXECUTED
1064db: 89 15 e4 a0 12 00 mov %edx,0x12a0e4 <== NOT EXECUTED
1064e1: 19 fa sbb %edi,%edx <== NOT EXECUTED
*_time += *_add;
1064e3: 01 83 90 00 00 00 add %eax,0x90(%ebx) <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
1064e9: b0 01 mov $0x1,%al <== NOT EXECUTED
1064eb: 11 93 94 00 00 00 adc %edx,0x94(%ebx) <== NOT EXECUTED
_Thread_Heir = new_heir;
1064f1: 89 0d dc a0 12 00 mov %ecx,0x12a0dc <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
1064f7: a2 d4 a0 12 00 mov %al,0x12a0d4 <== NOT EXECUTED
1064fc: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED
1064ff: 5b pop %ebx <== NOT EXECUTED
106500: 5e pop %esi <== NOT EXECUTED
106501: 5f pop %edi <== NOT EXECUTED
106502: 5d pop %ebp <== NOT EXECUTED
106503: c3 ret <== NOT EXECUTED
106504: 90 nop
106505: 90 nop
106506: 90 nop
106507: 90 nop
106508: 90 nop
106509: 90 nop
10650a: 90 nop
10650b: 90 nop
10650c: 90 nop
10650d: 90 nop
10650e: 90 nop
10650f: 90 nop
00106680 <_Scheduler_simple_Yield>:
void _Scheduler_simple_Yield(
const Scheduler_Control *scheduler,
Thread_Control *the_thread,
Scheduler_Node *node
)
{
106680: 55 push %ebp
106681: 89 e5 mov %esp,%ebp
106683: 57 push %edi
106684: 56 push %esi
106685: 53 push %ebx
106686: 83 ec 1c sub $0x1c,%esp
return scheduler->context;
106689: 8b 45 08 mov 0x8(%ebp),%eax
10668c: 8b 38 mov (%eax),%edi
next = the_node->next;
10668e: 8b 45 0c mov 0xc(%ebp),%eax
106691: 89 7d e4 mov %edi,-0x1c(%ebp)
return &the_chain->Tail.Node;
106694: 8d 5f 04 lea 0x4(%edi),%ebx
next = the_node->next;
106697: 8b 10 mov (%eax),%edx
previous = the_node->previous;
106699: 8b 40 04 mov 0x4(%eax),%eax
next->previous = previous;
10669c: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
10669f: 89 10 mov %edx,(%eax)
1066a1: 8b 45 0c mov 0xc(%ebp),%eax
1066a4: 8b 40 38 mov 0x38(%eax),%eax
context = _Scheduler_simple_Get_context( scheduler );
(void) node;
_Chain_Extract_unprotected( &the_thread->Object.Node );
insert_priority = (unsigned int) _Thread_Get_priority( the_thread );
1066a7: 8b 40 14 mov 0x14(%eax),%eax
insert_priority = SCHEDULER_PRIORITY_APPEND( insert_priority );
1066aa: 83 c8 01 or $0x1,%eax
1066ad: 89 c2 mov %eax,%edx
return _Chain_Immutable_head( the_chain )->next;
1066af: 8b 07 mov (%edi),%eax
while ( next != tail && !( *order )( left, next ) ) {
1066b1: 39 c3 cmp %eax,%ebx
1066b3: 74 1e je 1066d3 <_Scheduler_simple_Yield+0x53> <== NEVER TAKEN
1066b5: 89 d6 mov %edx,%esi
1066b7: 31 ff xor %edi,%edi
1066b9: eb 0b jmp 1066c6 <_Scheduler_simple_Yield+0x46>
1066bb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1066bf: 90 nop
return the_node->next;
1066c0: 8b 00 mov (%eax),%eax
while ( next != tail && !( *order )( left, next ) ) {
1066c2: 39 c3 cmp %eax,%ebx
1066c4: 74 0d je 1066d3 <_Scheduler_simple_Yield+0x53> <== NEVER TAKEN
1066c6: 8b 50 38 mov 0x38(%eax),%edx
1066c9: 8b 4a 18 mov 0x18(%edx),%ecx
1066cc: 39 72 14 cmp %esi,0x14(%edx)
1066cf: 19 f9 sbb %edi,%ecx
1066d1: 72 ed jb 1066c0 <_Scheduler_simple_Yield+0x40>
return the_node->previous;
1066d3: 8b 40 04 mov 0x4(%eax),%eax
the_node->previous = after_node;
1066d6: 8b 7d 0c mov 0xc(%ebp),%edi
Thread_Control *heir = _Thread_Heir;
1066d9: 8b 1d dc a0 12 00 mov 0x12a0dc,%ebx
before_node = after_node->next;
1066df: 8b 10 mov (%eax),%edx
the_node->previous = after_node;
1066e1: 89 47 04 mov %eax,0x4(%edi)
after_node->next = the_node;
1066e4: 89 38 mov %edi,(%eax)
return _Chain_Immutable_head( the_chain )->next;
1066e6: 8b 45 e4 mov -0x1c(%ebp),%eax
the_node->next = before_node;
1066e9: 89 17 mov %edx,(%edi)
before_node->previous = the_node;
1066eb: 89 7a 04 mov %edi,0x4(%edx)
return _Chain_Immutable_head( the_chain )->next;
1066ee: 8b 08 mov (%eax),%ecx
if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) {
1066f0: 39 d9 cmp %ebx,%ecx
1066f2: 74 09 je 1066fd <_Scheduler_simple_Yield+0x7d>
1066f4: 80 bb 81 00 00 00 00 cmpb $0x0,0x81(%ebx)
1066fb: 75 13 jne 106710 <_Scheduler_simple_Yield+0x90> <== NEVER TAKEN
_Scheduler_simple_Insert( &context->Ready, the_thread, insert_priority );
_Scheduler_simple_Schedule_body( scheduler, the_thread, false );
}
1066fd: 83 c4 1c add $0x1c,%esp
106700: 5b pop %ebx
106701: 5e pop %esi
106702: 5f pop %edi
106703: 5d pop %ebp
106704: c3 ret
106705: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10670c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106710: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED
106713: 8b 35 e0 a0 12 00 mov 0x12a0e0,%esi <== NOT EXECUTED
106719: 8b 3d e4 a0 12 00 mov 0x12a0e4,%edi <== NOT EXECUTED
10671f: e8 8c f6 ff ff call 105db0 <_Timecounter_Sbinuptime> <== NOT EXECUTED
_Thread_Heir = new_heir;
106724: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
106727: a3 e0 a0 12 00 mov %eax,0x12a0e0 <== NOT EXECUTED
*_result = *_end - *_start;
10672c: 29 f0 sub %esi,%eax <== NOT EXECUTED
10672e: 89 15 e4 a0 12 00 mov %edx,0x12a0e4 <== NOT EXECUTED
106734: 19 fa sbb %edi,%edx <== NOT EXECUTED
*_time += *_add;
106736: 01 83 90 00 00 00 add %eax,0x90(%ebx) <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
10673c: b0 01 mov $0x1,%al <== NOT EXECUTED
10673e: 11 93 94 00 00 00 adc %edx,0x94(%ebx) <== NOT EXECUTED
_Thread_Heir = new_heir;
106744: 89 0d dc a0 12 00 mov %ecx,0x12a0dc <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
10674a: a2 d4 a0 12 00 mov %al,0x12a0d4 <== NOT EXECUTED
10674f: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED
106752: 5b pop %ebx <== NOT EXECUTED
106753: 5e pop %esi <== NOT EXECUTED
106754: 5f pop %edi <== NOT EXECUTED
106755: 5d pop %ebp <== NOT EXECUTED
106756: c3 ret <== NOT EXECUTED
106757: 90 nop
106758: 90 nop
106759: 90 nop
10675a: 90 nop
10675b: 90 nop
10675c: 90 nop
10675d: 90 nop
10675e: 90 nop
10675f: 90 nop
0010bea0 <_TLS_Get_allocation_size>:
size = (uintptr_t) _TLS_Size;
10bea0: b8 00 00 00 00 mov $0x0,%eax
RTEMS_OBFUSCATE_VARIABLE( size );
10bea5: 89 c2 mov %eax,%edx
uintptr_t allocation_size;
uintptr_t alignment;
size = _TLS_Get_size();
if ( size == 0 ) {
10bea7: 85 d2 test %edx,%edx
10bea9: 89 d0 mov %edx,%eax
10beab: 74 3c je 10bee9 <_TLS_Get_allocation_size+0x49>
return 0;
}
allocation_size = _TLS_Allocation_size;
10bead: a1 94 05 13 00 mov 0x130594,%eax
if ( allocation_size == 0 ) {
10beb2: 85 c0 test %eax,%eax
10beb4: 75 33 jne 10bee9 <_TLS_Get_allocation_size+0x49>
return (val + msk) & ~msk;
10beb6: 8d 42 03 lea 0x3(%edx),%eax
10beb9: 83 e0 fc and $0xfffffffc,%eax
10bebc: 89 c2 mov %eax,%edx
10bebe: b8 04 00 00 00 mov $0x4,%eax
10bec3: 83 e0 fc and $0xfffffffc,%eax
/*
* The stack allocator does not support aligned allocations. Allocate
* enough to do the alignment manually.
*/
if ( alignment > CPU_HEAP_ALIGNMENT ) {
10bec6: 83 f8 04 cmp $0x4,%eax
10bec9: 76 02 jbe 10becd <_TLS_Get_allocation_size+0x2d>
allocation_size += alignment;
10becb: 01 c2 add %eax,%edx
sizeof(TLS_Thread_control_block) : alignment;
10becd: 83 f8 04 cmp $0x4,%eax
10bed0: 72 1e jb 10bef0 <_TLS_Get_allocation_size+0x50> <== NEVER TAKEN
}
allocation_size += _TLS_Get_thread_control_block_area_size( alignment );
10bed2: 01 d0 add %edx,%eax
#ifndef __i386__
allocation_size += sizeof(TLS_Dynamic_thread_vector);
#endif
if ( _Thread_Maximum_TLS_size != 0 ) {
10bed4: 8b 15 a8 48 12 00 mov 0x1248a8,%edx
10beda: 85 d2 test %edx,%edx
10bedc: 74 06 je 10bee4 <_TLS_Get_allocation_size+0x44>
if ( allocation_size <= _Thread_Maximum_TLS_size ) {
10bede: 39 c2 cmp %eax,%edx
10bee0: 72 21 jb 10bf03 <_TLS_Get_allocation_size+0x63>
10bee2: 89 d0 mov %edx,%eax
} else {
_Internal_error( INTERNAL_ERROR_TOO_LARGE_TLS_SIZE );
}
}
_TLS_Allocation_size = allocation_size;
10bee4: a3 94 05 13 00 mov %eax,0x130594
}
return allocation_size;
}
10bee9: c3 ret
10beea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
10bef0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
allocation_size += _TLS_Get_thread_control_block_area_size( alignment );
10bef5: 01 d0 add %edx,%eax <== NOT EXECUTED
if ( _Thread_Maximum_TLS_size != 0 ) {
10bef7: 8b 15 a8 48 12 00 mov 0x1248a8,%edx <== NOT EXECUTED
10befd: 85 d2 test %edx,%edx <== NOT EXECUTED
10beff: 74 e3 je 10bee4 <_TLS_Get_allocation_size+0x44> <== NOT EXECUTED
10bf01: eb db jmp 10bede <_TLS_Get_allocation_size+0x3e> <== NOT EXECUTED
{
10bf03: 55 push %ebp
10bf04: 89 e5 mov %esp,%ebp
10bf06: 83 ec 18 sub $0x18,%esp
_Internal_error( INTERNAL_ERROR_TOO_LARGE_TLS_SIZE );
10bf09: c7 04 24 29 00 00 00 movl $0x29,(%esp)
10bf10: e8 0b 95 ff ff call 105420 <_Internal_error>
10bf15: 90 nop
10bf16: 90 nop
10bf17: 90 nop
10bf18: 90 nop
10bf19: 90 nop
10bf1a: 90 nop
10bf1b: 90 nop
10bf1c: 90 nop
10bf1d: 90 nop
10bf1e: 90 nop
10bf1f: 90 nop
0010b410 <_TOD_Hook_Run>:
Status_Control _TOD_Hook_Run(
TOD_Action action,
const struct timespec *tod
)
{
10b410: 55 push %ebp
10b411: 89 e5 mov %esp,%ebp
10b413: 57 push %edi
10b414: 56 push %esi
10b415: 53 push %ebx
10b416: 83 ec 1c sub $0x1c,%esp
return _Chain_Immutable_head( the_chain )->next;
10b419: 8b 3d f8 76 12 00 mov 0x1276f8,%edi
10b41f: 8b 75 08 mov 0x8(%ebp),%esi
10b422: 8b 5d 0c mov 0xc(%ebp),%ebx
* This is assumed to be called only from _TOD_Set() which is supposed
* to be called only while holding the TOD lock.
*/
_Assert( _TOD_Is_owner() );
for (
10b425: 81 ff fc 76 12 00 cmp $0x1276fc,%edi
10b42b: 75 0d jne 10b43a <_TOD_Hook_Run+0x2a>
10b42d: eb 21 jmp 10b450 <_TOD_Hook_Run+0x40>
10b42f: 90 nop
return the_node->next;
10b430: 8b 3f mov (%edi),%edi
10b432: 81 ff fc 76 12 00 cmp $0x1276fc,%edi
10b438: 74 16 je 10b450 <_TOD_Hook_Run+0x40>
the_node = _Chain_Immutable_next( the_node )
) {
const TOD_Hook *the_hook;
the_hook = (const TOD_Hook *) the_node;
status = ( *the_hook->handler )( action, tod );
10b43a: 89 5c 24 04 mov %ebx,0x4(%esp)
10b43e: 89 34 24 mov %esi,(%esp)
10b441: ff 57 08 call *0x8(%edi)
if ( status != STATUS_SUCCESSFUL ) {
10b444: 85 c0 test %eax,%eax
10b446: 74 e8 je 10b430 <_TOD_Hook_Run+0x20>
break;
}
}
return status;
}
10b448: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED
10b44b: 5b pop %ebx <== NOT EXECUTED
10b44c: 5e pop %esi <== NOT EXECUTED
10b44d: 5f pop %edi <== NOT EXECUTED
10b44e: 5d pop %ebp <== NOT EXECUTED
10b44f: c3 ret <== NOT EXECUTED
10b450: 83 c4 1c add $0x1c,%esp
{
10b453: 31 c0 xor %eax,%eax
}
10b455: 5b pop %ebx
10b456: 5e pop %esi
10b457: 5f pop %edi
10b458: 5d pop %ebp
10b459: c3 ret
10b45a: 90 nop
10b45b: 90 nop
10b45c: 90 nop
10b45d: 90 nop
10b45e: 90 nop
10b45f: 90 nop
00105ad0 <_TOD_Set>:
Status_Control _TOD_Set(
const struct timespec *tod,
ISR_lock_Context *lock_context
)
{
105ad0: 55 push %ebp
105ad1: 89 e5 mov %esp,%ebp
105ad3: 83 ec 68 sub $0x68,%esp
105ad6: 89 75 f8 mov %esi,-0x8(%ebp)
105ad9: 8b 75 08 mov 0x8(%ebp),%esi
105adc: 89 5d f4 mov %ebx,-0xc(%ebp)
105adf: 89 7d fc mov %edi,-0x4(%ebp)
&& (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND;
105ae2: 85 f6 test %esi,%esi
105ae4: 74 09 je 105aef <_TOD_Set+0x1f> <== NEVER TAKEN
105ae6: 81 7e 08 ff c9 9a 3b cmpl $0x3b9ac9ff,0x8(%esi)
105aed: 76 21 jbe 105b10 <_TOD_Set+0x40>
return STATUS_INVALID_NUMBER;
105aef: bb 0a 16 00 00 mov $0x160a,%ebx
_Timecounter_Release( lock_context );
105af4: 8b 45 0c mov 0xc(%ebp),%eax
105af7: ff 30 push (%eax)
105af9: 9d popf
}
_TOD.is_set = true;
return STATUS_SUCCESSFUL;
}
105afa: 8b 75 f8 mov -0x8(%ebp),%esi
105afd: 89 d8 mov %ebx,%eax
105aff: 8b 5d f4 mov -0xc(%ebp),%ebx
105b02: 8b 7d fc mov -0x4(%ebp),%edi
105b05: 89 ec mov %ebp,%esp
105b07: 5d pop %ebp
105b08: c3 ret
105b09: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if ( _Watchdog_Is_far_future_timespec( tod ) ) {
105b10: 8b 06 mov (%esi),%eax
105b12: b9 ff 1a 25 de mov $0xde251aff,%ecx
105b17: 8b 56 04 mov 0x4(%esi),%edx
105b1a: 05 00 1b 25 de add $0xde251b00,%eax
105b1f: 89 45 c0 mov %eax,-0x40(%ebp)
105b22: 83 d2 ff adc $0xffffffff,%edx
105b25: b8 03 00 00 00 mov $0x3,%eax
105b2a: 3b 4d c0 cmp -0x40(%ebp),%ecx
105b2d: 89 55 c4 mov %edx,-0x3c(%ebp)
105b30: 1b 45 c4 sbb -0x3c(%ebp),%eax
105b33: 72 ba jb 105aef <_TOD_Set+0x1f>
return _TOD_Hook_Run( TOD_ACTION_SET_CLOCK, tod );
105b35: 89 74 24 04 mov %esi,0x4(%esp)
105b39: c7 04 24 00 00 00 00 movl $0x0,(%esp)
105b40: e8 cb 58 00 00 call 10b410 <_TOD_Hook_Run>
if ( status != STATUS_SUCCESSFUL ) {
105b45: 85 c0 test %eax,%eax
return _TOD_Hook_Run( TOD_ACTION_SET_CLOCK, tod );
105b47: 89 c3 mov %eax,%ebx
if ( status != STATUS_SUCCESSFUL ) {
105b49: 75 a9 jne 105af4 <_TOD_Set+0x24>
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
105b4b: 8b 7e 08 mov 0x8(%esi),%edi
_bt->sec = _ts->tv_sec;
105b4e: 8b 06 mov (%esi),%eax
105b50: 8b 56 04 mov 0x4(%esi),%edx
105b53: 89 45 d8 mov %eax,-0x28(%ebp)
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
105b56: 89 f8 mov %edi,%eax
_bt->sec = _ts->tv_sec;
105b58: 89 55 dc mov %edx,-0x24(%ebp)
_bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL;
105b5b: 99 cltd
105b5c: 69 c2 09 fa 82 4b imul $0x4b82fa09,%edx,%eax
105b62: 8d 0c b8 lea (%eax,%edi,4),%ecx
105b65: b8 09 fa 82 4b mov $0x4b82fa09,%eax
105b6a: f7 e7 mul %edi
105b6c: 89 45 e0 mov %eax,-0x20(%ebp)
_Timecounter_Set_clock( &tod_as_bintime, lock_context );
105b6f: 8b 45 0c mov 0xc(%ebp),%eax
105b72: 01 ca add %ecx,%edx
105b74: 89 55 e4 mov %edx,-0x1c(%ebp)
105b77: 89 44 24 04 mov %eax,0x4(%esp)
105b7b: 8d 45 d8 lea -0x28(%ebp),%eax
105b7e: 89 04 24 mov %eax,(%esp)
105b81: e8 fa 12 00 00 call 106e80 <_Timecounter_Set_clock>
ticks = (uint64_t) ts->tv_sec;
105b86: 8b 06 mov (%esi),%eax
105b88: 8b 56 04 mov 0x4(%esi),%edx
ticks |= (uint32_t) ts->tv_nsec;
105b8b: 8b 76 08 mov 0x8(%esi),%esi
_ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context );
105b8e: 9c pushf
105b8f: fa cli
105b90: 59 pop %ecx
105b91: 89 4d d4 mov %ecx,-0x2c(%ebp)
return (Watchdog_Control *) header->first;
105b94: 8b 0d 3c bd 12 00 mov 0x12bd3c,%ecx
if ( first != NULL ) {
105b9a: 85 c9 test %ecx,%ecx
105b9c: 74 28 je 105bc6 <_TOD_Set+0xf6>
_Watchdog_Tickle(
105b9e: 89 4c 24 04 mov %ecx,0x4(%esp)
ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS;
105ba2: 0f a4 c2 1e shld $0x1e,%eax,%edx
105ba6: 89 54 24 0c mov %edx,0xc(%esp)
105baa: c1 e0 1e shl $0x1e,%eax
105bad: c7 04 24 38 bd 12 00 movl $0x12bd38,(%esp)
105bb4: 8d 7d d4 lea -0x2c(%ebp),%edi
ticks |= (uint32_t) ts->tv_nsec;
105bb7: 09 c6 or %eax,%esi
105bb9: 89 7c 24 10 mov %edi,0x10(%esp)
105bbd: 89 74 24 08 mov %esi,0x8(%esp)
105bc1: e8 0a 3d 00 00 call 1098d0 <_Watchdog_Do_tickle>
_ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context );
105bc6: ff 75 d4 push -0x2c(%ebp)
105bc9: 9d popf
_TOD.is_set = true;
105bca: b0 01 mov $0x1,%al
}
105bcc: 8b 75 f8 mov -0x8(%ebp),%esi
_TOD.is_set = true;
105bcf: a2 f0 bc 12 00 mov %al,0x12bcf0
}
105bd4: 8b 7d fc mov -0x4(%ebp),%edi
105bd7: 89 d8 mov %ebx,%eax
105bd9: 8b 5d f4 mov -0xc(%ebp),%ebx
105bdc: 89 ec mov %ebp,%esp
105bde: 5d pop %ebp
105bdf: c3 ret
001053c0 <_Terminate>:
void _Terminate(
Internal_errors_Source the_source,
Internal_errors_t the_error
)
{
1053c0: 55 push %ebp
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, error };
_User_extensions_Iterate(
1053c1: 31 c0 xor %eax,%eax
1053c3: 89 e5 mov %esp,%ebp
1053c5: ba 20 8b 10 00 mov $0x108b20,%edx
1053ca: 56 push %esi
1053cb: 53 push %ebx
1053cc: 83 ec 20 sub $0x20,%esp
1053cf: 89 44 24 08 mov %eax,0x8(%esp)
1053d3: 8b 5d 08 mov 0x8(%ebp),%ebx
1053d6: 8d 45 f0 lea -0x10(%ebp),%eax
1053d9: 89 54 24 04 mov %edx,0x4(%esp)
1053dd: 8b 75 0c mov 0xc(%ebp),%esi
1053e0: 89 04 24 mov %eax,(%esp)
User_extensions_Fatal_context ctx = { source, error };
1053e3: 89 5d f0 mov %ebx,-0x10(%ebp)
1053e6: 89 75 f4 mov %esi,-0xc(%ebp)
_User_extensions_Iterate(
1053e9: e8 92 37 00 00 call 108b80 <_User_extensions_Iterate>
_System_state_Current = state;
1053ee: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_TERMINATED );
_SMP_Request_shutdown();
_CPU_Fatal_halt( the_source, the_error );
1053f3: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
1053f7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
_Internal_errors_What_happened.the_source = the_source;
1053fa: 89 1d cc 03 13 00 mov %ebx,0x1303cc <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
105400: 89 35 d0 03 13 00 mov %esi,0x1303d0 <== NOT EXECUTED
105406: 89 0d d4 03 13 00 mov %ecx,0x1303d4 <== NOT EXECUTED
_CPU_Fatal_halt( the_source, the_error );
10540c: e8 ff 7f 00 00 call 10d410 <_CPU_Fatal_halt> <== NOT EXECUTED
105411: 90 nop
105412: 90 nop
105413: 90 nop
105414: 90 nop
105415: 90 nop
105416: 90 nop
105417: 90 nop
105418: 90 nop
105419: 90 nop
10541a: 90 nop
10541b: 90 nop
10541c: 90 nop
10541d: 90 nop
10541e: 90 nop
10541f: 90 nop
0010a2a0 <_Thread_Allocate_unlimited>:
}
}
}
Objects_Control *_Thread_Allocate_unlimited( Objects_Information *information )
{
10a2a0: 55 push %ebp
10a2a1: 89 e5 mov %esp,%ebp
10a2a3: 83 ec 38 sub $0x38,%esp
10a2a6: 89 5d f4 mov %ebx,-0xc(%ebp)
10a2a9: 8b 5d 08 mov 0x8(%ebp),%ebx
10a2ac: 89 75 f8 mov %esi,-0x8(%ebp)
10a2af: 89 7d fc mov %edi,-0x4(%ebp)
return _Chain_Immutable_head( the_chain )->next;
10a2b2: 8b 4b 18 mov 0x18(%ebx),%ecx
return &the_chain->Tail.Node;
10a2b5: 8d 73 1c lea 0x1c(%ebx),%esi
10a2b8: 8d 7b 18 lea 0x18(%ebx),%edi
if ( !_Chain_Is_empty(the_chain))
10a2bb: 39 f1 cmp %esi,%ecx
10a2bd: 74 41 je 10a300 <_Thread_Allocate_unlimited+0x60>
new_first = old_first->next;
10a2bf: 8b 01 mov (%ecx),%eax
Objects_Maximum objects_per_block;
Objects_Maximum block;
_Assert( _Objects_Is_auto_extend( information ) );
objects_per_block = information->objects_per_block;
10a2c1: 0f b7 73 12 movzwl 0x12(%ebx),%esi
head->next = new_first;
10a2c5: 89 43 18 mov %eax,0x18(%ebx)
return &the_chain->Head.Node;
10a2c8: 89 78 04 mov %edi,0x4(%eax)
block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM;
10a2cb: 8b 41 08 mov 0x8(%ecx),%eax
10a2ce: 48 dec %eax
10a2cf: 0f b7 c0 movzwl %ax,%eax
if ( block > objects_per_block ) {
10a2d2: 39 c6 cmp %eax,%esi
10a2d4: 73 0f jae 10a2e5 <_Thread_Allocate_unlimited+0x45>
block /= objects_per_block;
information->inactive_per_block[ block ]--;
10a2d6: 31 d2 xor %edx,%edx
10a2d8: f7 f6 div %esi
10a2da: 8b 53 24 mov 0x24(%ebx),%edx
10a2dd: 66 ff 0c 42 decw (%edx,%eax,2)
information->inactive--;
10a2e1: 66 ff 4b 10 decw 0x10(%ebx)
return _Objects_Allocate_with_extend(
information,
_Thread_Extend_information
);
}
10a2e5: 8b 5d f4 mov -0xc(%ebp),%ebx
10a2e8: 89 c8 mov %ecx,%eax
10a2ea: 8b 75 f8 mov -0x8(%ebp),%esi
10a2ed: 8b 7d fc mov -0x4(%ebp),%edi
10a2f0: 89 ec mov %ebp,%esp
10a2f2: 5d pop %ebp
10a2f3: c3 ret
10a2f4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a2fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10a2ff: 90 nop
block = _Objects_Extend_information( &information->Objects );
10a300: 89 1c 24 mov %ebx,(%esp)
10a303: e8 78 f1 ff ff call 109480 <_Objects_Extend_information>
10a308: 0f b7 d0 movzwl %ax,%edx
if ( block > 0 ) {
10a30b: 85 d2 test %edx,%edx
10a30d: 75 11 jne 10a320 <_Thread_Allocate_unlimited+0x80> <== ALWAYS TAKEN
return _Chain_Immutable_head( the_chain )->next;
10a30f: 8b 4b 18 mov 0x18(%ebx),%ecx
if ( !_Chain_Is_empty(the_chain))
10a312: 39 ce cmp %ecx,%esi
10a314: 75 a9 jne 10a2bf <_Thread_Allocate_unlimited+0x1f> <== ALWAYS TAKEN
return NULL;
10a316: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10a318: eb cb jmp 10a2e5 <_Thread_Allocate_unlimited+0x45> <== NOT EXECUTED
10a31a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
10a320: 89 55 e4 mov %edx,-0x1c(%ebp)
new_heads = _Freechain_Extend(
10a323: b8 3c 00 00 00 mov $0x3c,%eax
10a328: ba a0 c6 10 00 mov $0x10c6a0,%edx
10a32d: 89 44 24 0c mov %eax,0xc(%esp)
10a331: 0f b7 43 12 movzwl 0x12(%ebx),%eax
10a335: 89 54 24 04 mov %edx,0x4(%esp)
10a339: 89 44 24 08 mov %eax,0x8(%esp)
10a33d: 8d 43 30 lea 0x30(%ebx),%eax
10a340: 89 04 24 mov %eax,(%esp)
10a343: e8 28 9f 00 00 call 114270 <_Freechain_Extend>
if ( new_heads == NULL ) {
10a348: 8b 55 e4 mov -0x1c(%ebp),%edx
10a34b: 85 c0 test %eax,%eax
10a34d: 75 c0 jne 10a30f <_Thread_Allocate_unlimited+0x6f> <== ALWAYS TAKEN
_Objects_Free_objects_block( &information->Objects, block );
10a34f: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10a353: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a356: e8 e5 f5 ff ff call 109940 <_Objects_Free_objects_block> <== NOT EXECUTED
10a35b: eb b2 jmp 10a30f <_Thread_Allocate_unlimited+0x6f> <== NOT EXECUTED
10a35d: 90 nop
10a35e: 90 nop
10a35f: 90 nop
0010bf90 <_Thread_Cancel>:
void _Thread_Cancel(
Thread_Control *the_thread,
Thread_Control *executing,
void *exit_value
)
{
10bf90: 55 push %ebp
10bf91: 89 e5 mov %esp,%ebp
10bf93: 57 push %edi
10bf94: 56 push %esi
10bf95: 53 push %ebx
10bf96: 83 ec 2c sub $0x2c,%esp
10bf99: 8b 5d 08 mov 0x8(%ebp),%ebx
10bf9c: 8b 4d 0c mov 0xc(%ebp),%ecx
10bf9f: 8b 45 10 mov 0x10(%ebp),%eax
_ISR_lock_ISR_disable( lock_context );
10bfa2: 9c pushf
10bfa3: fa cli
10bfa4: 5a pop %edx
the_thread->Life.exit_value = exit_value;
10bfa5: 89 83 28 01 00 00 mov %eax,0x128(%ebx)
previous = the_thread->Life.state;
10bfab: 8b 83 20 01 00 00 mov 0x120(%ebx),%eax
state |= set;
10bfb1: 89 c6 mov %eax,%esi
10bfb3: 83 ce 04 or $0x4,%esi
if (
10bfb6: a8 09 test $0x9,%al
state |= set;
10bfb8: 89 b3 20 01 00 00 mov %esi,0x120(%ebx)
if (
10bfbe: 0f 85 ac 00 00 00 jne 10c070 <_Thread_Cancel+0xe0>
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10bfc4: 0f b6 83 a4 00 00 00 movzbl 0xa4(%ebx),%eax
if ( _Chain_Is_node_off_chain( the_node ) ) {
10bfcb: 8b b3 14 01 00 00 mov 0x114(%ebx),%esi
10bfd1: 88 83 81 00 00 00 mov %al,0x81(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10bfd7: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
10bfdd: 85 f6 test %esi,%esi
10bfdf: 89 83 88 00 00 00 mov %eax,0x88(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
10bfe5: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
10bfeb: 89 83 8c 00 00 00 mov %eax,0x8c(%ebx)
action->handler = handler;
10bff1: b8 40 bd 10 00 mov $0x10bd40,%eax
10bff6: 89 83 1c 01 00 00 mov %eax,0x11c(%ebx)
cpu_self->dispatch_necessary = true;
10bffc: b0 01 mov $0x1,%al
10bffe: a2 54 48 13 00 mov %al,0x134854
10c003: 0f 84 f7 00 00 00 je 10c100 <_Thread_Cancel+0x170>
disable_level = cpu_self->thread_dispatch_disable_level;
10c009: a1 50 48 13 00 mov 0x134850,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10c00e: 40 inc %eax
10c00f: a3 50 48 13 00 mov %eax,0x134850
return aggregation->Node.priority;
10c014: 8b 41 38 mov 0x38(%ecx),%eax
10c017: 8b 70 14 mov 0x14(%eax),%esi
10c01a: 8b 78 18 mov 0x18(%eax),%edi
);
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
priority = _Thread_Get_priority( executing );
if ( _States_Is_dormant( the_thread->current_state ) ) {
10c01d: 8b 43 1c mov 0x1c(%ebx),%eax
10c020: 85 c0 test %eax,%eax
10c022: 0f 88 c8 00 00 00 js 10c0f0 <_Thread_Cancel+0x160>
pending_requests = the_thread->Life.pending_life_change_requests;
10c028: 8b 83 24 01 00 00 mov 0x124(%ebx),%eax
the_thread->Life.pending_life_change_requests = pending_requests + 1;
10c02e: 8d 48 01 lea 0x1(%eax),%ecx
if ( pending_requests == 0 ) {
10c031: 85 c0 test %eax,%eax
the_thread->Life.pending_life_change_requests = pending_requests + 1;
10c033: 89 8b 24 01 00 00 mov %ecx,0x124(%ebx)
if ( pending_requests == 0 ) {
10c039: 0f 84 11 01 00 00 je 10c150 <_Thread_Cancel+0x1c0> <== ALWAYS TAKEN
_ISR_lock_ISR_enable( lock_context );
10c03f: 52 push %edx
10c040: 9d popf
_Thread_queue_Extract_with_proxy( the_thread );
10c041: 89 1c 24 mov %ebx,(%esp)
10c044: e8 77 6b 00 00 call 112bc0 <_Thread_queue_Extract_with_proxy>
_ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock, &lock_context );
10c049: 9c pushf
10c04a: fa cli
10c04b: 8f 45 e4 pop -0x1c(%ebp)
_Watchdog_Per_CPU_remove(
10c04e: 8d 43 64 lea 0x64(%ebx),%eax
10c051: 89 44 24 04 mov %eax,0x4(%esp)
10c055: 8b 43 60 mov 0x60(%ebx),%eax
10c058: 89 04 24 mov %eax,(%esp)
10c05b: e8 80 09 00 00 call 10c9e0 <_Watchdog_Remove>
_ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock, &lock_context );
10c060: ff 75 e4 push -0x1c(%ebp)
10c063: 9d popf
_Thread_Raise_real_priority( the_thread, priority );
10c064: eb 55 jmp 10c0bb <_Thread_Cancel+0x12b>
10c066: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10c06d: 8d 76 00 lea 0x0(%esi),%esi
disable_level = cpu_self->thread_dispatch_disable_level;
10c070: a1 50 48 13 00 mov 0x134850,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10c075: 40 inc %eax
10c076: a3 50 48 13 00 mov %eax,0x134850
if ( _States_Is_dormant( the_thread->current_state ) ) {
10c07b: 8b 73 1c mov 0x1c(%ebx),%esi
10c07e: 85 f6 test %esi,%esi
10c080: 78 6e js 10c0f0 <_Thread_Cancel+0x160> <== NEVER TAKEN
10c082: 8b 41 38 mov 0x38(%ecx),%eax
10c085: 8b 70 14 mov 0x14(%eax),%esi
10c088: 8b 78 18 mov 0x18(%eax),%edi
pending_requests = the_thread->Life.pending_life_change_requests;
10c08b: 8b 83 24 01 00 00 mov 0x124(%ebx),%eax
the_thread->Life.pending_life_change_requests = pending_requests + 1;
10c091: 8d 48 01 lea 0x1(%eax),%ecx
if ( pending_requests == 0 ) {
10c094: 85 c0 test %eax,%eax
the_thread->Life.pending_life_change_requests = pending_requests + 1;
10c096: 89 8b 24 01 00 00 mov %ecx,0x124(%ebx)
if ( pending_requests == 0 ) {
10c09c: 0f 84 ce 00 00 00 je 10c170 <_Thread_Cancel+0x1e0> <== ALWAYS TAKEN
_Thread_State_release( the_thread, &lock_context );
_Thread_Finalize_life_change( the_thread, priority );
} else {
_Thread_Add_life_change_request( the_thread );
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
10c0a2: 89 1c 24 mov %ebx,(%esp)
10c0a5: b8 00 80 00 00 mov $0x8000,%eax
10c0aa: 89 44 24 04 mov %eax,0x4(%esp)
10c0ae: 89 55 e4 mov %edx,-0x1c(%ebp)
10c0b1: e8 5a 65 00 00 call 112610 <_Thread_Clear_state_locked>
_ISR_lock_ISR_enable( lock_context );
10c0b6: 8b 55 e4 mov -0x1c(%ebp),%edx
10c0b9: 52 push %edx
10c0ba: 9d popf
_Thread_State_release( the_thread, &lock_context );
_Thread_Raise_real_priority( the_thread, priority );
10c0bb: 89 f2 mov %esi,%edx
10c0bd: 89 f9 mov %edi,%ecx
10c0bf: 89 d8 mov %ebx,%eax
10c0c1: e8 aa fa ff ff call 10bb70 <_Thread_Raise_real_priority>
_ISR_lock_ISR_disable( lock_context );
10c0c6: 9c pushf
10c0c7: fa cli
10c0c8: 5e pop %esi
pending_requests = the_thread->Life.pending_life_change_requests;
10c0c9: 8b 83 24 01 00 00 mov 0x124(%ebx),%eax
the_thread->Life.pending_life_change_requests = pending_requests - 1;
10c0cf: 8d 50 ff lea -0x1(%eax),%edx
if ( pending_requests == 1 ) {
10c0d2: 48 dec %eax
the_thread->Life.pending_life_change_requests = pending_requests - 1;
10c0d3: 89 93 24 01 00 00 mov %edx,0x124(%ebx)
if ( pending_requests == 1 ) {
10c0d9: 74 55 je 10c130 <_Thread_Cancel+0x1a0> <== ALWAYS TAKEN
_ISR_lock_ISR_enable( lock_context );
10c0db: 56 push %esi
10c0dc: 9d popf
_Thread_Remove_life_change_request( the_thread );
}
_Thread_Dispatch_enable( cpu_self );
10c0dd: c7 45 08 40 48 13 00 movl $0x134840,0x8(%ebp)
}
10c0e4: 83 c4 2c add $0x2c,%esp
10c0e7: 5b pop %ebx
10c0e8: 5e pop %esi
10c0e9: 5f pop %edi
10c0ea: 5d pop %ebp
_Thread_Dispatch_enable( cpu_self );
10c0eb: e9 a0 ea ff ff jmp 10ab90 <_Thread_Dispatch_enable>
10c0f0: 52 push %edx
10c0f1: 9d popf
_Thread_Make_zombie( the_thread );
10c0f2: 89 d8 mov %ebx,%eax
10c0f4: e8 97 fb ff ff call 10bc90 <_Thread_Make_zombie>
10c0f9: eb e2 jmp 10c0dd <_Thread_Cancel+0x14d>
10c0fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10c0ff: 90 nop
old_last = tail->previous;
10c100: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax
_Chain_Append_if_is_off_chain_unprotected(
10c106: 8d b3 14 01 00 00 lea 0x114(%ebx),%esi
tail->previous = the_node;
10c10c: 89 b3 d8 00 00 00 mov %esi,0xd8(%ebx)
return &the_chain->Tail.Node;
10c112: 8d bb d4 00 00 00 lea 0xd4(%ebx),%edi
10c118: 89 bb 14 01 00 00 mov %edi,0x114(%ebx)
old_last->next = the_node;
10c11e: 89 30 mov %esi,(%eax)
the_node->previous = old_last;
10c120: 89 83 18 01 00 00 mov %eax,0x118(%ebx)
}
10c126: e9 de fe ff ff jmp 10c009 <_Thread_Cancel+0x79>
10c12b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10c12f: 90 nop
_Thread_Clear_state_locked(
10c130: 89 1c 24 mov %ebx,(%esp)
10c133: bf 0c 83 02 30 mov $0x3002830c,%edi
10c138: 89 7c 24 04 mov %edi,0x4(%esp)
10c13c: e8 cf 64 00 00 call 112610 <_Thread_Clear_state_locked>
10c141: eb 98 jmp 10c0db <_Thread_Cancel+0x14b>
10c143: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10c14a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
10c150: 89 1c 24 mov %ebx,(%esp)
10c153: b8 00 00 02 00 mov $0x20000,%eax
10c158: 89 44 24 04 mov %eax,0x4(%esp)
10c15c: 89 55 e4 mov %edx,-0x1c(%ebp)
10c15f: e8 2c 02 00 00 call 10c390 <_Thread_Set_state_locked>
10c164: 8b 55 e4 mov -0x1c(%ebp),%edx
10c167: e9 d3 fe ff ff jmp 10c03f <_Thread_Cancel+0xaf>
10c16c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10c170: 89 1c 24 mov %ebx,(%esp)
10c173: b8 00 00 02 00 mov $0x20000,%eax
10c178: 89 44 24 04 mov %eax,0x4(%esp)
10c17c: 89 55 e4 mov %edx,-0x1c(%ebp)
10c17f: e8 0c 02 00 00 call 10c390 <_Thread_Set_state_locked>
10c184: 8b 55 e4 mov -0x1c(%ebp),%edx
10c187: e9 16 ff ff ff jmp 10c0a2 <_Thread_Cancel+0x112>
10c18c: 90 nop
10c18d: 90 nop
10c18e: 90 nop
10c18f: 90 nop
0010a350 <_Thread_Change_life>:
Thread_Life_state _Thread_Change_life(
Thread_Life_state clear,
Thread_Life_state set,
Thread_Life_state ignore
)
{
10a350: 55 push %ebp
10a351: 89 e5 mov %esp,%ebp
10a353: 83 ec 28 sub $0x28,%esp
10a356: 89 5d f4 mov %ebx,-0xc(%ebp)
10a359: 89 75 f8 mov %esi,-0x8(%ebp)
10a35c: 89 7d fc mov %edi,-0x4(%ebp)
_ISR_lock_ISR_disable( lock_context );
10a35f: 9c pushf
10a360: fa cli
10a361: 59 pop %ecx
10a362: 8b 15 d8 d0 12 00 mov 0x12d0d8,%edx
state &= ~clear;
10a368: 8b 45 08 mov 0x8(%ebp),%eax
state |= set;
10a36b: 8b 75 0c mov 0xc(%ebp),%esi
previous = the_thread->Life.state;
10a36e: 8b 9a 20 01 00 00 mov 0x120(%edx),%ebx
state &= ~clear;
10a374: f7 d0 not %eax
10a376: 21 d8 and %ebx,%eax
state |= set;
10a378: 09 f0 or %esi,%eax
state &= ~ignore;
10a37a: 8b 75 10 mov 0x10(%ebp),%esi
the_thread->Life.state = state;
10a37d: 89 82 20 01 00 00 mov %eax,0x120(%edx)
state &= ~ignore;
10a383: f7 d6 not %esi
10a385: 21 f0 and %esi,%eax
if (
10a387: a8 09 test $0x9,%al
10a389: 75 45 jne 10a3d0 <_Thread_Change_life+0x80>
&& _Thread_Is_life_changing( state )
10a38b: a8 06 test $0x6,%al
10a38d: 74 41 je 10a3d0 <_Thread_Change_life+0x80>
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10a38f: 0f b6 82 a4 00 00 00 movzbl 0xa4(%edx),%eax
10a396: 88 82 81 00 00 00 mov %al,0x81(%edx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10a39c: 8b 82 a8 00 00 00 mov 0xa8(%edx),%eax
10a3a2: 89 82 88 00 00 00 mov %eax,0x88(%edx)
the_thread->budget_callout = the_thread->Start.budget_callout;
10a3a8: 8b 82 ac 00 00 00 mov 0xac(%edx),%eax
10a3ae: 89 82 8c 00 00 00 mov %eax,0x8c(%edx)
action->handler = handler;
10a3b4: b8 20 9e 10 00 mov $0x109e20,%eax
10a3b9: 89 82 1c 01 00 00 mov %eax,0x11c(%edx)
10a3bf: b0 01 mov $0x1,%al
10a3c1: a2 d4 d0 12 00 mov %al,0x12d0d4
if ( _Chain_Is_node_off_chain( the_node ) ) {
10a3c6: 8b 82 14 01 00 00 mov 0x114(%edx),%eax
10a3cc: 85 c0 test %eax,%eax
10a3ce: 74 30 je 10a400 <_Thread_Change_life+0xb0> <== ALWAYS TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
10a3d0: a1 d0 d0 12 00 mov 0x12d0d0,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
10a3d5: 40 inc %eax
10a3d6: a3 d0 d0 12 00 mov %eax,0x12d0d0
_ISR_lock_ISR_enable( lock_context );
10a3db: 51 push %ecx
10a3dc: 9d popf
previous = _Thread_Change_life_locked( executing, clear, set, ignore );
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_Thread_State_release( executing, &lock_context );
_Thread_Dispatch_enable( cpu_self );
10a3dd: c7 04 24 c0 d0 12 00 movl $0x12d0c0,(%esp)
10a3e4: e8 27 e4 ff ff call 108810 <_Thread_Dispatch_enable>
return previous;
}
10a3e9: 8b 75 f8 mov -0x8(%ebp),%esi
10a3ec: 89 d8 mov %ebx,%eax
10a3ee: 8b 7d fc mov -0x4(%ebp),%edi
10a3f1: 8b 5d f4 mov -0xc(%ebp),%ebx
10a3f4: 89 ec mov %ebp,%esp
10a3f6: 5d pop %ebp
10a3f7: c3 ret
10a3f8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a3ff: 90 nop
old_last = tail->previous;
10a400: 8b 82 d8 00 00 00 mov 0xd8(%edx),%eax
_Chain_Append_if_is_off_chain_unprotected(
10a406: 8d b2 14 01 00 00 lea 0x114(%edx),%esi
tail->previous = the_node;
10a40c: 89 b2 d8 00 00 00 mov %esi,0xd8(%edx)
return &the_chain->Tail.Node;
10a412: 8d ba d4 00 00 00 lea 0xd4(%edx),%edi
10a418: 89 ba 14 01 00 00 mov %edi,0x114(%edx)
old_last->next = the_node;
10a41e: 89 30 mov %esi,(%eax)
the_node->previous = old_last;
10a420: 89 82 18 01 00 00 mov %eax,0x118(%edx)
}
10a426: eb a8 jmp 10a3d0 <_Thread_Change_life+0x80>
10a428: 90 nop
10a429: 90 nop
10a42a: 90 nop
10a42b: 90 nop
10a42c: 90 nop
10a42d: 90 nop
10a42e: 90 nop
10a42f: 90 nop
0010b740 <_Thread_Clear_state_locked>:
States_Control _Thread_Clear_state_locked(
Thread_Control *the_thread,
States_Control state
)
{
10b740: 55 push %ebp
10b741: 89 e5 mov %esp,%ebp
10b743: 83 ec 18 sub $0x18,%esp
10b746: 89 5d fc mov %ebx,-0x4(%ebp)
10b749: 8b 55 08 mov 0x8(%ebp),%edx
10b74c: 8b 45 0c mov 0xc(%ebp),%eax
States_Control previous_state;
_Assert( state != 0 );
_Assert( _Thread_State_is_owner( the_thread ) );
previous_state = the_thread->current_state;
10b74f: 8b 5a 1c mov 0x1c(%edx),%ebx
if ( ( previous_state & state ) != 0 ) {
10b752: 85 c3 test %eax,%ebx
10b754: 74 21 je 10b777 <_Thread_Clear_state_locked+0x37>
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10b756: f7 d0 not %eax
10b758: 21 d8 and %ebx,%eax
States_Control next_state;
next_state = _States_Clear( state, previous_state );
the_thread->current_state = next_state;
10b75a: 89 42 1c mov %eax,0x1c(%edx)
if ( _States_Is_ready( next_state ) ) {
10b75d: 75 18 jne 10b777 <_Thread_Clear_state_locked+0x37> <== NEVER TAKEN
( *scheduler->Operations.unblock )( scheduler, the_thread, scheduler_node );
10b75f: 8b 42 38 mov 0x38(%edx),%eax
10b762: 89 54 24 04 mov %edx,0x4(%esp)
10b766: c7 04 24 c0 48 12 00 movl $0x1248c0,(%esp)
10b76d: 89 44 24 08 mov %eax,0x8(%esp)
10b771: ff 15 d4 48 12 00 call *0x1248d4
_Scheduler_Unblock( the_thread );
}
}
return previous_state;
}
10b777: 89 d8 mov %ebx,%eax
10b779: 8b 5d fc mov -0x4(%ebp),%ebx
10b77c: 89 ec mov %ebp,%esp
10b77e: 5d pop %ebp
10b77f: c3 ret
0011a310 <_Thread_Dispatch>:
void _Thread_Dispatch( void )
{
ISR_Level level;
Per_CPU_Control *cpu_self;
_ISR_Local_disable( level );
11a310: 9c pushf
11a311: fa cli
11a312: 58 pop %eax
cpu_self = _Per_CPU_Get();
if ( cpu_self->dispatch_necessary ) {
11a313: 0f b6 15 34 a8 1a 00 movzbl 0x1aa834,%edx
11a31a: 84 d2 test %dl,%dl
11a31c: 75 12 jne 11a330 <_Thread_Dispatch+0x20>
_Profiling_Thread_dispatch_disable( cpu_self, 0 );
_Assert( cpu_self->thread_dispatch_disable_level == 0 );
cpu_self->thread_dispatch_disable_level = 1;
_Thread_Do_dispatch( cpu_self, level );
} else {
_ISR_Local_enable( level );
11a31e: 50 push %eax
11a31f: 9d popf
11a320: c3 ret
11a321: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a328: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11a32f: 90 nop
{
11a330: 55 push %ebp
cpu_self->thread_dispatch_disable_level = 1;
11a331: ba 01 00 00 00 mov $0x1,%edx
{
11a336: 89 e5 mov %esp,%ebp
11a338: 83 ec 18 sub $0x18,%esp
_Thread_Do_dispatch( cpu_self, level );
11a33b: 89 44 24 04 mov %eax,0x4(%esp)
11a33f: c7 04 24 20 a8 1a 00 movl $0x1aa820,(%esp)
cpu_self->thread_dispatch_disable_level = 1;
11a346: 89 15 30 a8 1a 00 mov %edx,0x1aa830
_Thread_Do_dispatch( cpu_self, level );
11a34c: e8 5f fe ff ff call 11a1b0 <_Thread_Do_dispatch>
}
}
11a351: 89 ec mov %ebp,%esp <== NOT EXECUTED
11a353: 5d pop %ebp <== NOT EXECUTED
11a354: c3 ret <== NOT EXECUTED
11a355: 90 nop
11a356: 90 nop
11a357: 90 nop
11a358: 90 nop
11a359: 90 nop
11a35a: 90 nop
11a35b: 90 nop
11a35c: 90 nop
11a35d: 90 nop
11a35e: 90 nop
11a35f: 90 nop
00107140 <_Thread_Do_dispatch>:
_Thread_State_release( executing, &lock_context );
}
void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level )
{
107140: 55 push %ebp
107141: 89 e5 mov %esp,%ebp
107143: 57 push %edi
107144: 56 push %esi
107145: 53 push %ebx
107146: 83 ec 3c sub $0x3c,%esp
107149: 8b 45 08 mov 0x8(%ebp),%eax
10714c: 8b 4d 0c mov 0xc(%ebp),%ecx
) {
_Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT );
}
#endif
executing = cpu_self->executing;
10714f: 8b 58 18 mov 0x18(%eax),%ebx
#if !defined(RTEMS_SMP)
_User_extensions_Thread_switch( executing, heir );
#endif
_Thread_Save_fp( executing );
_Context_Switch( &executing->Registers, &heir->Registers );
107152: 8d 93 dc 00 00 00 lea 0xdc(%ebx),%edx
107158: 89 55 d4 mov %edx,-0x2c(%ebp)
10715b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10715f: 90 nop
cpu_self->dispatch_necessary = false;
107160: c6 40 14 00 movb $0x0,0x14(%eax)
heir = cpu_self->heir;
107164: 8b 78 1c mov 0x1c(%eax),%edi
cpu_self->executing = heir;
107167: 89 78 18 mov %edi,0x18(%eax)
if ( heir == executing )
10716a: 39 fb cmp %edi,%ebx
10716c: 0f 84 a8 00 00 00 je 10721a <_Thread_Do_dispatch+0xda>
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
107172: 83 bf 88 00 00 00 01 cmpl $0x1,0x88(%edi)
107179: 75 0b jne 107186 <_Thread_Do_dispatch+0x46>
heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice();
10717b: a1 bc 54 12 00 mov 0x1254bc,%eax
107180: 89 87 84 00 00 00 mov %eax,0x84(%edi)
_ISR_Local_enable( level );
107186: 51 push %ecx
107187: 9d popf
return _Chain_Immutable_head( the_chain )->next;
107188: 8b 35 e8 a3 12 00 mov 0x12a3e8,%esi
if ( node != tail ) {
10718e: 81 fe ec a3 12 00 cmp $0x12a3ec,%esi
107194: 74 20 je 1071b6 <_Thread_Do_dispatch+0x76>
107196: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10719d: 8d 76 00 lea 0x0(%esi),%esi
return the_node->next;
1071a0: 89 f1 mov %esi,%ecx
1071a2: 8b 36 mov (%esi),%esi
(*extension->thread_switch)( executing, heir );
1071a4: 89 7c 24 04 mov %edi,0x4(%esp)
1071a8: 89 1c 24 mov %ebx,(%esp)
1071ab: ff 51 08 call *0x8(%ecx)
while ( node != tail ) {
1071ae: 81 fe ec a3 12 00 cmp $0x12a3ec,%esi
1071b4: 75 ea jne 1071a0 <_Thread_Do_dispatch+0x60>
_Context_Switch( &executing->Registers, &heir->Registers );
1071b6: 8b 45 d4 mov -0x2c(%ebp),%eax
1071b9: 8d 97 dc 00 00 00 lea 0xdc(%edi),%edx
1071bf: 89 54 24 04 mov %edx,0x4(%esp)
1071c3: 89 04 24 mov %eax,(%esp)
1071c6: e8 d5 1d 00 00 call 108fa0 <_CPU_Context_switch>
if ( (executing->fp_context != NULL) &&
1071cb: 8b 83 00 01 00 00 mov 0x100(%ebx),%eax
1071d1: 85 c0 test %eax,%eax
1071d3: 74 2e je 107203 <_Thread_Do_dispatch+0xc3>
return ( the_thread == _Thread_Allocated_fp );
1071d5: a1 2c 04 13 00 mov 0x13042c,%eax
if ( (executing->fp_context != NULL) &&
1071da: 39 c3 cmp %eax,%ebx
1071dc: 74 25 je 107203 <_Thread_Do_dispatch+0xc3>
if ( _Thread_Allocated_fp != NULL )
1071de: 85 c0 test %eax,%eax
1071e0: 74 0d je 1071ef <_Thread_Do_dispatch+0xaf> <== NEVER TAKEN
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
1071e2: 05 00 01 00 00 add $0x100,%eax
1071e7: 89 04 24 mov %eax,(%esp)
1071ea: e8 21 1e 00 00 call 109010 <_CPU_Context_save_fp>
_Context_Restore_fp( &executing->fp_context );
1071ef: 8d 83 00 01 00 00 lea 0x100(%ebx),%eax
1071f5: 89 04 24 mov %eax,(%esp)
1071f8: e8 1d 1e 00 00 call 10901a <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
1071fd: 89 1d 2c 04 13 00 mov %ebx,0x13042c
* heir thread may have migrated from another processor. Values from the
* stack or non-volatile registers reflect the old execution environment.
*/
cpu_self = _Per_CPU_Get();
_ISR_Local_disable( level );
107203: 9c pushf
107204: fa cli
107205: 59 pop %ecx
} while ( cpu_self->dispatch_necessary );
107206: 0f b6 15 f4 03 13 00 movzbl 0x1303f4,%edx
cpu_self = _Per_CPU_Get();
10720d: b8 e0 03 13 00 mov $0x1303e0,%eax
} while ( cpu_self->dispatch_necessary );
107212: 84 d2 test %dl,%dl
107214: 0f 85 46 ff ff ff jne 107160 <_Thread_Do_dispatch+0x20>
post_switch:
_Assert( cpu_self->thread_dispatch_disable_level == 1 );
cpu_self->thread_dispatch_disable_level = 0;
10721a: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
_Profiling_Thread_dispatch_enable( cpu_self, 0 );
_ISR_Local_enable( level );
107221: 51 push %ecx
107222: 9d popf
_ISR_lock_ISR_disable( lock_context );
107223: 9c pushf
107224: fa cli
107225: 58 pop %eax
107226: 89 45 e4 mov %eax,-0x1c(%ebp)
return _Chain_Immutable_head( the_chain )->next;
107229: 8b 83 d0 00 00 00 mov 0xd0(%ebx),%eax
return &the_chain->Tail.Node;
10722f: 8d 93 d4 00 00 00 lea 0xd4(%ebx),%edx
107235: 89 55 d4 mov %edx,-0x2c(%ebp)
107238: 8d b3 d0 00 00 00 lea 0xd0(%ebx),%esi
if ( !_Chain_Is_empty(the_chain))
10723e: 39 d0 cmp %edx,%eax
107240: 74 4e je 107290 <_Thread_Do_dispatch+0x150>
new_first = old_first->next;
107242: 8b 10 mov (%eax),%edx
head->next = new_first;
107244: 8d 7d e4 lea -0x1c(%ebp),%edi
107247: 89 93 d0 00 00 00 mov %edx,0xd0(%ebx)
new_first->previous = head;
10724d: 89 72 04 mov %esi,0x4(%edx)
while ( action != NULL ) {
107250: eb 19 jmp 10726b <_Thread_Do_dispatch+0x12b>
107252: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107259: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
new_first = old_first->next;
107260: 8b 10 mov (%eax),%edx <== NOT EXECUTED
head->next = new_first;
107262: 89 93 d0 00 00 00 mov %edx,0xd0(%ebx) <== NOT EXECUTED
new_first->previous = head;
107268: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED
node->next = NULL;
10726b: c7 00 00 00 00 00 movl $0x0,(%eax)
( *action->handler )( executing, action, &lock_context );
107271: 89 7c 24 08 mov %edi,0x8(%esp)
107275: 89 44 24 04 mov %eax,0x4(%esp)
107279: 89 1c 24 mov %ebx,(%esp)
10727c: ff 50 08 call *0x8(%eax)
10727f: 9c pushf
107280: fa cli
107281: 58 pop %eax
107282: 89 45 e4 mov %eax,-0x1c(%ebp)
return _Chain_Immutable_head( the_chain )->next;
107285: 8b 83 d0 00 00 00 mov 0xd0(%ebx),%eax
if ( !_Chain_Is_empty(the_chain))
10728b: 39 45 d4 cmp %eax,-0x2c(%ebp)
10728e: 75 d0 jne 107260 <_Thread_Do_dispatch+0x120> <== NEVER TAKEN
_ISR_lock_ISR_enable( lock_context );
107290: ff 75 e4 push -0x1c(%ebp)
107293: 9d popf
_Thread_Run_post_switch_actions( executing );
}
107294: 83 c4 3c add $0x3c,%esp
107297: 5b pop %ebx
107298: 5e pop %esi
107299: 5f pop %edi
10729a: 5d pop %ebp
10729b: c3 ret
10729c: 90 nop
10729d: 90 nop
10729e: 90 nop
10729f: 90 nop
0010c200 <_Thread_Exit>:
void _Thread_Exit(
Thread_Control *executing,
Thread_Life_state set,
void *exit_value
)
{
10c200: 55 push %ebp
10c201: 89 e5 mov %esp,%ebp
10c203: 83 ec 08 sub $0x8,%esp
10c206: 89 5d f8 mov %ebx,-0x8(%ebp)
10c209: 8b 45 08 mov 0x8(%ebp),%eax
10c20c: 89 75 fc mov %esi,-0x4(%ebp)
_ISR_lock_ISR_disable( lock_context );
10c20f: 9c pushf
10c210: fa cli
10c211: 59 pop %ecx
the_thread->Life.exit_value = exit_value;
10c212: 8b 55 10 mov 0x10(%ebp),%edx
state |= set;
10c215: 8b 98 20 01 00 00 mov 0x120(%eax),%ebx
the_thread->Life.exit_value = exit_value;
10c21b: 89 90 28 01 00 00 mov %edx,0x128(%eax)
state |= set;
10c221: 8b 55 0c mov 0xc(%ebp),%edx
10c224: 09 da or %ebx,%edx
the_thread->Life.state = state;
10c226: 89 90 20 01 00 00 mov %edx,0x120(%eax)
&& _Thread_Is_life_changing( state )
10c22c: f6 c2 06 test $0x6,%dl
10c22f: 74 42 je 10c273 <_Thread_Exit+0x73> <== NEVER TAKEN
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10c231: 8b 90 a8 00 00 00 mov 0xa8(%eax),%edx
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10c237: 0f b6 98 a4 00 00 00 movzbl 0xa4(%eax),%ebx
if ( _Chain_Is_node_off_chain( the_node ) ) {
10c23e: 8b b0 14 01 00 00 mov 0x114(%eax),%esi
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10c244: 89 90 88 00 00 00 mov %edx,0x88(%eax)
the_thread->budget_callout = the_thread->Start.budget_callout;
10c24a: 8b 90 ac 00 00 00 mov 0xac(%eax),%edx
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10c250: 88 98 81 00 00 00 mov %bl,0x81(%eax)
cpu_self->dispatch_necessary = true;
10c256: b3 01 mov $0x1,%bl
10c258: 85 f6 test %esi,%esi
the_thread->budget_callout = the_thread->Start.budget_callout;
10c25a: 89 90 8c 00 00 00 mov %edx,0x8c(%eax)
action->handler = handler;
10c260: ba 40 bd 10 00 mov $0x10bd40,%edx
10c265: 89 90 1c 01 00 00 mov %edx,0x11c(%eax)
10c26b: 88 1d 54 48 13 00 mov %bl,0x134854
10c271: 74 0d je 10c280 <_Thread_Exit+0x80> <== ALWAYS TAKEN
_ISR_lock_ISR_enable( lock_context );
10c273: 51 push %ecx
10c274: 9d popf
0,
set,
THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED
);
_Thread_State_release( executing, &lock_context );
}
10c275: 8b 5d f8 mov -0x8(%ebp),%ebx
10c278: 8b 75 fc mov -0x4(%ebp),%esi
10c27b: 89 ec mov %ebp,%esp
10c27d: 5d pop %ebp
10c27e: c3 ret
10c27f: 90 nop
old_last = tail->previous;
10c280: 8b 90 d8 00 00 00 mov 0xd8(%eax),%edx
_Chain_Append_if_is_off_chain_unprotected(
10c286: 8d 98 14 01 00 00 lea 0x114(%eax),%ebx
tail->previous = the_node;
10c28c: 89 98 d8 00 00 00 mov %ebx,0xd8(%eax)
return &the_chain->Tail.Node;
10c292: 8d b0 d4 00 00 00 lea 0xd4(%eax),%esi
10c298: 89 b0 14 01 00 00 mov %esi,0x114(%eax)
old_last->next = the_node;
10c29e: 89 1a mov %ebx,(%edx)
the_node->previous = old_last;
10c2a0: 89 90 18 01 00 00 mov %edx,0x118(%eax)
}
10c2a6: eb cb jmp 10c273 <_Thread_Exit+0x73>
10c2a8: 90 nop
10c2a9: 90 nop
10c2aa: 90 nop
10c2ab: 90 nop
10c2ac: 90 nop
10c2ad: 90 nop
10c2ae: 90 nop
10c2af: 90 nop
00118e90 <_Thread_Get_name>:
size_t _Thread_Get_name(
const Thread_Control *the_thread,
char *buffer,
size_t buffer_size
)
{
118e90: 55 push %ebp
118e91: 89 e5 mov %esp,%ebp
118e93: 83 ec 18 sub $0x18,%esp
118e96: 89 5d fc mov %ebx,-0x4(%ebp)
118e99: 8b 55 08 mov 0x8(%ebp),%edx
118e9c: 8b 4d 0c mov 0xc(%ebp),%ecx
118e9f: 8b 5d 10 mov 0x10(%ebp),%ebx
const char *name;
name = the_thread->Join_queue.Queue.name;
118ea2: 8b 42 18 mov 0x18(%edx),%eax
if ( name != NULL && name[ 0 ] != '\0' ) {
118ea5: 85 c0 test %eax,%eax
118ea7: 74 05 je 118eae <_Thread_Get_name+0x1e> <== NEVER TAKEN
118ea9: 80 38 00 cmpb $0x0,(%eax)
118eac: 75 22 jne 118ed0 <_Thread_Get_name+0x40>
return strlcpy( buffer, name, buffer_size );
} else {
return _Objects_Name_to_string(
118eae: 89 5c 24 0c mov %ebx,0xc(%esp)
118eb2: 31 c0 xor %eax,%eax
118eb4: 89 4c 24 08 mov %ecx,0x8(%esp)
118eb8: 89 44 24 04 mov %eax,0x4(%esp)
118ebc: 8b 42 0c mov 0xc(%edx),%eax
118ebf: 89 04 24 mov %eax,(%esp)
118ec2: e8 49 00 00 00 call 118f10 <_Objects_Name_to_string>
false,
buffer,
buffer_size
);
}
}
118ec7: 8b 5d fc mov -0x4(%ebp),%ebx
118eca: 89 ec mov %ebp,%esp
118ecc: 5d pop %ebp
118ecd: c3 ret
118ece: 66 90 xchg %ax,%ax
return strlcpy( buffer, name, buffer_size );
118ed0: 89 45 0c mov %eax,0xc(%ebp)
}
118ed3: 8b 5d fc mov -0x4(%ebp),%ebx
return strlcpy( buffer, name, buffer_size );
118ed6: 89 4d 08 mov %ecx,0x8(%ebp)
}
118ed9: 89 ec mov %ebp,%esp
118edb: 5d pop %ebp
return strlcpy( buffer, name, buffer_size );
118edc: e9 ff 0b 00 00 jmp 119ae0 <strlcpy>
118ee1: 90 nop
118ee2: 90 nop
118ee3: 90 nop
118ee4: 90 nop
118ee5: 90 nop
118ee6: 90 nop
118ee7: 90 nop
118ee8: 90 nop
118ee9: 90 nop
118eea: 90 nop
118eeb: 90 nop
118eec: 90 nop
118eed: 90 nop
118eee: 90 nop
118eef: 90 nop
0010b900 <_Thread_Initialize>:
bool _Thread_Initialize(
Thread_Information *information,
Thread_Control *the_thread,
const Thread_Configuration *config
)
{
10b900: 55 push %ebp
10b901: 89 e5 mov %esp,%ebp
10b903: 57 push %edi
10b904: 56 push %esi
10b905: 53 push %ebx
10b906: 83 ec 4c sub $0x4c,%esp
Per_CPU_Control *cpu = _Per_CPU_Get_by_index( 0 );
memset(
&the_thread->Join_queue,
0,
information->Objects.object_size - offsetof( Thread_Control, Join_queue )
10b909: 8b 45 08 mov 0x8(%ebp),%eax
{
10b90c: 8b 5d 0c mov 0xc(%ebp),%ebx
10b90f: 8b 75 10 mov 0x10(%ebp),%esi
information->Objects.object_size - offsetof( Thread_Control, Join_queue )
10b912: 0f b7 40 14 movzwl 0x14(%eax),%eax
memset(
10b916: 8d 7b 10 lea 0x10(%ebx),%edi
10b919: 8d 50 f0 lea -0x10(%eax),%edx
10b91c: 83 fa 08 cmp $0x8,%edx
10b91f: 0f 83 4b 02 00 00 jae 10bb70 <_Thread_Initialize+0x270> <== ALWAYS TAKEN
10b925: f6 c2 04 test $0x4,%dl
10b928: 74 09 je 10b933 <_Thread_Initialize+0x33> <== ALWAYS TAKEN
10b92a: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
10b930: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
10b933: f6 c2 02 test $0x2,%dl
10b936: 74 08 je 10b940 <_Thread_Initialize+0x40> <== ALWAYS TAKEN
10b938: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
10b93d: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10b940: f6 c2 01 test $0x1,%dl
10b943: 74 03 je 10b948 <_Thread_Initialize+0x48> <== ALWAYS TAKEN
10b945: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
);
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
10b948: 8b 3d 70 48 12 00 mov 0x124870,%edi
10b94e: 85 ff test %edi,%edi
10b950: 74 26 je 10b978 <_Thread_Initialize+0x78> <== NEVER TAKEN
10b952: 31 c0 xor %eax,%eax
10b954: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b95b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10b95f: 90 nop
const Thread_Control_add_on *add_on = &_Thread_Control_add_ons[ i ];
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
(char *) the_thread + add_on->source_offset;
10b960: 8b 0c c5 84 48 12 00 mov 0x124884(,%eax,8),%ecx
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
10b967: 8b 14 c5 80 48 12 00 mov 0x124880(,%eax,8),%edx
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
10b96e: 40 inc %eax
(char *) the_thread + add_on->source_offset;
10b96f: 01 d9 add %ebx,%ecx
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
10b971: 39 f8 cmp %edi,%eax
*(void **) ( (char *) the_thread + add_on->destination_offset ) =
10b973: 89 0c 13 mov %ecx,(%ebx,%edx,1)
for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) {
10b976: 75 e8 jne 10b960 <_Thread_Initialize+0x60>
) {
goto failed;
}
#endif
stack_begin = config->stack_area;
10b978: 8b 56 04 mov 0x4(%esi),%edx
stack_end = stack_begin + config->stack_size;
10b97b: 8b 7e 08 mov 0x8(%esi),%edi
the_thread->Start.stack_free = config->stack_free;
10b97e: 8b 46 0c mov 0xc(%esi),%eax
stack_end = stack_begin + config->stack_size;
10b981: 01 d7 add %edx,%edi
/* Allocate floating-point context in stack area */
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( config->is_fp ) {
10b983: 80 7e 28 00 cmpb $0x0,0x28(%esi)
the_thread->Start.stack_free = config->stack_free;
10b987: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
if ( config->is_fp ) {
10b98d: 74 0f je 10b99e <_Thread_Initialize+0x9e>
stack_end -= CONTEXT_FP_SIZE;
10b98f: 83 ef 6c sub $0x6c,%edi
the_thread->fp_context = (Context_Control_fp *) stack_end;
10b992: 89 bb 00 01 00 00 mov %edi,0x100(%ebx)
the_thread->Start.fp_context = (Context_Control_fp *) stack_end;
10b998: 89 bb c8 00 00 00 mov %edi,0xc8(%ebx)
10b99e: 89 55 d4 mov %edx,-0x2c(%ebp)
}
#endif
tls_size = _TLS_Get_allocation_size();
10b9a1: e8 fa 04 00 00 call 10bea0 <_TLS_Get_allocation_size>
/* Allocate thread-local storage (TLS) area in stack area */
if ( tls_size > 0 ) {
10b9a6: 8b 55 d4 mov -0x2c(%ebp),%edx
10b9a9: 85 c0 test %eax,%eax
10b9ab: 74 17 je 10b9c4 <_Thread_Initialize+0xc4>
uintptr_t tls_align;
stack_end -= tls_size;
10b9ad: 29 c7 sub %eax,%edi
tls_align = (uintptr_t) _TLS_Alignment;
the_thread->Start.tls_area = (void *)
( ( (uintptr_t) stack_end + tls_align - 1 ) & ~( tls_align - 1 ) );
10b9af: b8 01 00 00 00 mov $0x1,%eax
10b9b4: 8d 8f 00 00 00 00 lea 0x0(%edi),%ecx
10b9ba: f7 d8 neg %eax
10b9bc: 21 c8 and %ecx,%eax
10b9be: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx)
the_stack->area = starting_address;
10b9c4: 89 93 c4 00 00 00 mov %edx,0xc4(%ebx)
return &the_chain->Head.Node;
10b9ca: 8b 45 08 mov 0x8(%ebp),%eax
}
_Stack_Initialize(
&the_thread->Start.Initial_stack,
stack_begin,
stack_end - stack_begin
10b9cd: 29 d7 sub %edx,%edi
10b9cf: 89 bb c0 00 00 00 mov %edi,0xc0(%ebx)
head->next = new_first;
10b9d5: 8b 4d 08 mov 0x8(%ebp),%ecx
return &the_chain->Head.Node;
10b9d8: 8d 78 30 lea 0x30(%eax),%edi
old_first = head->next;
10b9db: 8b 40 30 mov 0x30(%eax),%eax
return &the_chain->Head.Node;
10b9de: 89 7d d4 mov %edi,-0x2c(%ebp)
new_first = old_first->next;
10b9e1: 8b 10 mov (%eax),%edx
head->next = new_first;
10b9e3: 89 51 30 mov %edx,0x30(%ecx)
return &the_chain->Tail.Node;
10b9e6: 8d 48 2c lea 0x2c(%eax),%ecx
new_first->previous = head;
10b9e9: 89 7a 04 mov %edi,0x4(%edx)
return &the_chain->Tail.Node;
10b9ec: 8d 50 28 lea 0x28(%eax),%edx
);
/*
* Get thread queue heads
*/
the_thread->Wait.spare_heads = _Freechain_Pop(
10b9ef: 89 43 5c mov %eax,0x5c(%ebx)
return &the_chain->Head.Node;
10b9f2: 89 50 30 mov %edx,0x30(%eax)
the_thread->is_fp = config->is_fp;
the_thread->Start.isr_level = config->isr_level;
the_thread->Start.is_preemptible = config->is_preemptible;
the_thread->Start.budget_algorithm = config->budget_algorithm;
the_thread->Start.budget_callout = config->budget_callout;
10b9f5: 8b 56 1c mov 0x1c(%esi),%edx
return &the_chain->Tail.Node;
10b9f8: 89 48 28 mov %ecx,0x28(%eax)
head->previous = NULL;
10b9fb: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_thread->is_fp = config->is_fp;
10ba02: 0f b6 46 28 movzbl 0x28(%esi),%eax
10ba06: 88 83 82 00 00 00 mov %al,0x82(%ebx)
the_thread->Start.isr_level = config->isr_level;
10ba0c: 8b 46 24 mov 0x24(%esi),%eax
10ba0f: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
the_thread->Start.is_preemptible = config->is_preemptible;
10ba15: 0f b6 46 29 movzbl 0x29(%esi),%eax
10ba19: 88 83 a4 00 00 00 mov %al,0xa4(%ebx)
the_thread->Start.budget_algorithm = config->budget_algorithm;
10ba1f: 8b 46 18 mov 0x18(%esi),%eax
the_thread->Start.budget_callout = config->budget_callout;
10ba22: 89 93 ac 00 00 00 mov %edx,0xac(%ebx)
timer->header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ];
10ba28: c7 43 60 10 04 13 00 movl $0x130410,0x60(%ebx)
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
10ba2f: c7 43 70 02 00 00 00 movl $0x2,0x70(%ebx)
the_thread->Start.budget_algorithm = config->budget_algorithm;
10ba36: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
_Thread_Timer_initialize( &the_thread->Timer, cpu );
switch ( config->budget_algorithm ) {
10ba3c: 83 f8 02 cmp $0x2,%eax
10ba3f: 75 0b jne 10ba4c <_Thread_Initialize+0x14c>
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget =
10ba41: a1 bc 54 12 00 mov 0x1254bc,%eax
10ba46: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
return the_thread->Scheduler.nodes;
10ba4c: 8b 7b 38 mov 0x38(%ebx),%edi
&scheduler_node->Thread.Scheduler_node.Chain
);
#else
scheduler_node = _Thread_Scheduler_get_home_node( the_thread );
_Scheduler_Node_initialize(
config->scheduler,
10ba4f: 8b 06 mov (%esi),%eax
( *scheduler->Operations.node_initialize )(
10ba51: 8b 56 10 mov 0x10(%esi),%edx
10ba54: 8b 4e 14 mov 0x14(%esi),%ecx
10ba57: 89 5c 24 08 mov %ebx,0x8(%esp)
10ba5b: 89 04 24 mov %eax,(%esp)
10ba5e: 89 54 24 0c mov %edx,0xc(%esp)
10ba62: 89 4c 24 10 mov %ecx,0x10(%esp)
10ba66: 89 7c 24 04 mov %edi,0x4(%esp)
10ba6a: ff 50 24 call *0x24(%eax)
config->priority
);
scheduler_index = 1;
#endif
_Priority_Node_initialize( &the_thread->Real_priority, config->priority );
10ba6d: 8b 56 10 mov 0x10(%esi),%edx
_RBTree_Initialize_one( &aggregation->Contributors, &node->Node.RBTree );
10ba70: 8d 43 20 lea 0x20(%ebx),%eax
10ba73: 8b 4e 14 mov 0x14(%esi),%ecx
node->priority = priority;
10ba76: 89 53 30 mov %edx,0x30(%ebx)
10ba79: 89 4b 34 mov %ecx,0x34(%ebx)
_RBTree_Initialize_one( &aggregation->Contributors, &node->Node.RBTree );
10ba7c: 89 47 1c mov %eax,0x1c(%edi)
RB_INIT( the_rbtree );
10ba7f: 31 c0 xor %eax,%eax
node->priority = priority;
10ba81: 89 57 14 mov %edx,0x14(%edi)
10ba84: 89 4f 18 mov %ecx,0x18(%edi)
10ba87: 89 83 10 01 00 00 mov %eax,0x110(%ebx)
return &the_chain->Tail.Node;
10ba8d: 8d 83 d0 00 00 00 lea 0xd0(%ebx),%eax
return &the_chain->Head.Node;
10ba93: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx)
10ba99: 8b 46 20 mov 0x20(%esi),%eax
/* Initialize the CPU for the non-SMP schedulers */
_Thread_Set_CPU( the_thread, cpu );
the_thread->current_state = STATES_DORMANT;
the_thread->Wait.operations = &_Thread_queue_Operations_default;
the_thread->Start.initial_priority = config->priority;
10ba9c: 89 93 b4 00 00 00 mov %edx,0xb4(%ebx)
return &the_chain->Tail.Node;
10baa2: 8d 93 d4 00 00 00 lea 0xd4(%ebx),%edx
10baa8: 89 93 d0 00 00 00 mov %edx,0xd0(%ebx)
head->previous = NULL;
10baae: 31 d2 xor %edx,%edx
10bab0: 89 93 d4 00 00 00 mov %edx,0xd4(%ebx)
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
10bab6: 0f b7 53 08 movzwl 0x8(%ebx),%edx
the_object->name = name;
10baba: 89 43 0c mov %eax,0xc(%ebx)
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
10babd: 8b 45 08 mov 0x8(%ebp),%eax
10bac0: 89 8b b8 00 00 00 mov %ecx,0xb8(%ebx)
_User_extensions_Iterate(
10bac6: 31 c9 xor %ecx,%ecx
RB_PARENT( the_node, Node ) = NULL;
10bac8: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
RB_LEFT( the_node, Node ) = NULL;
10bacf: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
RB_RIGHT( the_node, Node ) = NULL;
10bad6: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
10badd: 8b 40 04 mov 0x4(%eax),%eax
RB_COLOR( the_node, Node ) = RB_BLACK;
10bae0: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx)
the_thread->current_state = STATES_DORMANT;
10bae7: c7 43 1c 00 00 00 80 movl $0x80000000,0x1c(%ebx)
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10baee: c7 43 58 a8 54 12 00 movl $0x1254a8,0x58(%ebx)
10baf5: 89 5c 90 fc mov %ebx,-0x4(%eax,%edx,4)
10baf9: b8 40 8a 10 00 mov $0x108a40,%eax
10bafe: 89 44 24 04 mov %eax,0x4(%esp)
10bb02: 8d 45 e0 lea -0x20(%ebp),%eax
10bb05: 89 04 24 mov %eax,(%esp)
User_extensions_Thread_create_context ctx = { created, true };
10bb08: 89 5d e0 mov %ebx,-0x20(%ebp)
10bb0b: c6 45 e4 01 movb $0x1,-0x1c(%ebp)
_User_extensions_Iterate(
10bb0f: 89 4c 24 08 mov %ecx,0x8(%esp)
10bb13: e8 68 d0 ff ff call 108b80 <_User_extensions_Iterate>
return ctx.ok;
10bb18: 0f b6 45 e4 movzbl -0x1c(%ebp),%eax
* 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 )
10bb1c: 84 c0 test %al,%al
10bb1e: 75 39 jne 10bb59 <_Thread_Initialize+0x259>
10bb20: 88 45 d3 mov %al,-0x2d(%ebp)
--scheduler_index;
_Scheduler_Node_destroy( scheduler_for_index, scheduler_node_for_index );
}
#else
if ( scheduler_index > 0 ) {
_Scheduler_Node_destroy( config->scheduler, scheduler_node );
10bb23: 8b 16 mov (%esi),%edx
( *scheduler->Operations.node_destroy )( scheduler, node );
10bb25: 89 7c 24 04 mov %edi,0x4(%esp)
10bb29: 89 14 24 mov %edx,(%esp)
10bb2c: ff 52 28 call *0x28(%edx)
}
#endif
_Freechain_Push(
&information->Thread_queue_heads.Free,
the_thread->Wait.spare_heads
10bb2f: 8b 53 5c mov 0x5c(%ebx),%edx
the_node->previous = after_node;
10bb32: 8b 45 d4 mov -0x2c(%ebp),%eax
10bb35: 89 42 04 mov %eax,0x4(%edx)
before_node = after_node->next;
10bb38: 8b 45 08 mov 0x8(%ebp),%eax
10bb3b: 8b 48 30 mov 0x30(%eax),%ecx
after_node->next = the_node;
10bb3e: 89 50 30 mov %edx,0x30(%eax)
the_node->next = before_node;
10bb41: 89 0a mov %ecx,(%edx)
before_node->previous = the_node;
10bb43: 89 51 04 mov %edx,0x4(%ecx)
#if defined(RTEMS_SMP) || CPU_ENABLE_ROBUST_THREAD_DISPATCH == TRUE
failed:
#endif
( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area );
10bb46: 8b 93 c4 00 00 00 mov 0xc4(%ebx),%edx
10bb4c: 89 14 24 mov %edx,(%esp)
10bb4f: ff 93 bc 00 00 00 call *0xbc(%ebx)
10bb55: 0f b6 45 d3 movzbl -0x2d(%ebp),%eax
return false;
}
10bb59: 83 c4 4c add $0x4c,%esp
10bb5c: 5b pop %ebx
10bb5d: 5e pop %esi
10bb5e: 5f pop %edi
10bb5f: 5d pop %ebp
10bb60: c3 ret
10bb61: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10bb68: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10bb6f: 90 nop
memset(
10bb70: f7 c7 01 00 00 00 test $0x1,%edi
10bb76: 75 21 jne 10bb99 <_Thread_Initialize+0x299> <== NEVER TAKEN
10bb78: f7 c7 02 00 00 00 test $0x2,%edi
10bb7e: 75 25 jne 10bba5 <_Thread_Initialize+0x2a5> <== NEVER TAKEN
10bb80: f7 c7 04 00 00 00 test $0x4,%edi
10bb86: 75 2a jne 10bbb2 <_Thread_Initialize+0x2b2>
10bb88: 89 d1 mov %edx,%ecx
10bb8a: 31 c0 xor %eax,%eax
10bb8c: c1 e9 02 shr $0x2,%ecx
10bb8f: 83 e2 03 and $0x3,%edx
10bb92: f3 ab rep stos %eax,%es:(%edi)
10bb94: e9 8c fd ff ff jmp 10b925 <_Thread_Initialize+0x25>
10bb99: c6 43 10 00 movb $0x0,0x10(%ebx) <== NOT EXECUTED
10bb9d: 8d 7b 11 lea 0x11(%ebx),%edi <== NOT EXECUTED
10bba0: 8d 50 ef lea -0x11(%eax),%edx <== NOT EXECUTED
10bba3: eb d3 jmp 10bb78 <_Thread_Initialize+0x278> <== NOT EXECUTED
10bba5: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
10bbaa: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
10bbad: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10bbb0: eb ce jmp 10bb80 <_Thread_Initialize+0x280> <== NOT EXECUTED
10bbb2: c7 07 00 00 00 00 movl $0x0,(%edi)
10bbb8: 83 ea 04 sub $0x4,%edx
10bbbb: 83 c7 04 add $0x4,%edi
10bbbe: eb c8 jmp 10bb88 <_Thread_Initialize+0x288>
0010a4d0 <_Thread_Iterate>:
void _Thread_Iterate(
Thread_Visitor visitor,
void *arg
)
{
10a4d0: 55 push %ebp
10a4d1: 89 e5 mov %esp,%ebp
10a4d3: 57 push %edi
10a4d4: 56 push %esi
10a4d5: 53 push %ebx
10a4d6: 83 ec 2c sub $0x2c,%esp
int api_index;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) {
10a4d9: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
const Objects_Information *information;
Objects_Maximum maximum;
Objects_Maximum index;
_Assert( _Objects_Information_table[ api_index ] != NULL );
information = _Objects_Information_table[ api_index ][ 1 ];
10a4e0: 8b 45 e4 mov -0x1c(%ebp),%eax
10a4e3: 8b 04 85 90 98 12 00 mov 0x129890(,%eax,4),%eax
10a4ea: 8b 78 04 mov 0x4(%eax),%edi
if ( information == NULL ) {
10a4ed: 85 ff test %edi,%edi
10a4ef: 74 31 je 10a522 <_Thread_Iterate+0x52>
continue;
}
maximum = _Objects_Get_maximum_index( information );
for ( index = 0 ; index < maximum ; ++index ) {
10a4f1: 0f b7 1f movzwl (%edi),%ebx
10a4f4: 85 db test %ebx,%ebx
10a4f6: 74 2a je 10a522 <_Thread_Iterate+0x52> <== NEVER TAKEN
10a4f8: c1 e3 02 shl $0x2,%ebx
10a4fb: 31 f6 xor %esi,%esi
10a4fd: 8d 76 00 lea 0x0(%esi),%esi
Thread_Control *the_thread;
the_thread = (Thread_Control *) information->local_table[ index ];
10a500: 8b 47 04 mov 0x4(%edi),%eax
10a503: 8b 04 30 mov (%eax,%esi,1),%eax
if ( the_thread != NULL ) {
10a506: 85 c0 test %eax,%eax
10a508: 74 11 je 10a51b <_Thread_Iterate+0x4b>
bool done;
done = (* visitor )( the_thread, arg );
10a50a: 89 04 24 mov %eax,(%esp)
10a50d: 8b 55 0c mov 0xc(%ebp),%edx
10a510: 89 54 24 04 mov %edx,0x4(%esp)
10a514: ff 55 08 call *0x8(%ebp)
if ( done ) {
10a517: 84 c0 test %al,%al
10a519: 75 12 jne 10a52d <_Thread_Iterate+0x5d> <== NEVER TAKEN
for ( index = 0 ; index < maximum ; ++index ) {
10a51b: 83 c6 04 add $0x4,%esi
10a51e: 39 f3 cmp %esi,%ebx
10a520: 75 de jne 10a500 <_Thread_Iterate+0x30>
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) {
10a522: ff 45 e4 incl -0x1c(%ebp)
10a525: 8b 45 e4 mov -0x1c(%ebp),%eax
10a528: 83 f8 04 cmp $0x4,%eax
10a52b: 75 b3 jne 10a4e0 <_Thread_Iterate+0x10>
return;
}
}
}
}
}
10a52d: 83 c4 2c add $0x2c,%esp
10a530: 5b pop %ebx
10a531: 5e pop %esi
10a532: 5f pop %edi
10a533: 5d pop %ebp
10a534: c3 ret
10a535: 90 nop
10a536: 90 nop
10a537: 90 nop
10a538: 90 nop
10a539: 90 nop
10a53a: 90 nop
10a53b: 90 nop
10a53c: 90 nop
10a53d: 90 nop
10a53e: 90 nop
10a53f: 90 nop
00108560 <_Thread_Kill_zombies>:
{
108560: 55 push %ebp
108561: 89 e5 mov %esp,%ebp
108563: 57 push %edi
108564: 56 push %esi
108565: 53 push %ebx
108566: 83 ec 1c sub $0x1c,%esp
108569: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
_ISR_lock_ISR_disable_and_acquire( &zombies->Lock, &lock_context );
108570: 9c pushf
108571: fa cli
108572: 58 pop %eax
return _Chain_Immutable_head( the_chain )->next;
108573: 8b 1d f4 a3 12 00 mov 0x12a3f4,%ebx
if ( !_Chain_Is_empty(the_chain))
108579: 81 fb f8 a3 12 00 cmp $0x12a3f8,%ebx
10857f: 0f 84 cb 00 00 00 je 108650 <_Thread_Kill_zombies+0xf0>
new_first = old_first->next;
108585: 8b 13 mov (%ebx),%edx
head->next = new_first;
108587: 89 15 f4 a3 12 00 mov %edx,0x12a3f4
new_first->previous = head;
10858d: c7 42 04 f4 a3 12 00 movl $0x12a3f4,0x4(%edx)
_ISR_lock_Release_and_ISR_enable( &zombies->Lock, &lock_context );
108594: 50 push %eax
108595: 9d popf
_Objects_Get_information_id( the_thread->Object.id );
108596: 8b 43 08 mov 0x8(%ebx),%eax
108599: 89 04 24 mov %eax,(%esp)
10859c: e8 3f 26 00 00 call 10abe0 <_Objects_Get_information_id>
_User_extensions_Iterate(
1085a1: ba 01 00 00 00 mov $0x1,%edx
1085a6: b9 80 8a 10 00 mov $0x108a80,%ecx
1085ab: 89 54 24 08 mov %edx,0x8(%esp)
1085af: 89 4c 24 04 mov %ecx,0x4(%esp)
1085b3: 89 1c 24 mov %ebx,(%esp)
1085b6: 89 c6 mov %eax,%esi
1085b8: e8 c3 05 00 00 call 108b80 <_User_extensions_Iterate>
_ISR_lock_ISR_disable_and_acquire(
1085bd: 9c pushf
1085be: fa cli
1085bf: 5f pop %edi
iter = the_thread->last_user_extensions_iterator;
1085c0: 8b 83 3c 01 00 00 mov 0x13c(%ebx),%eax
while ( iter != NULL ) {
1085c6: 85 c0 test %eax,%eax
1085c8: 74 17 je 1085e1 <_Thread_Kill_zombies+0x81>
1085ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
next = the_node->next;
1085d0: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
1085d2: 8b 50 04 mov 0x4(%eax),%edx
iter = iter->previous;
1085d5: 8b 40 10 mov 0x10(%eax),%eax
next->previous = previous;
1085d8: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
1085db: 89 0a mov %ecx,(%edx)
while ( iter != NULL ) {
1085dd: 85 c0 test %eax,%eax
1085df: 75 ef jne 1085d0 <_Thread_Kill_zombies+0x70> <== NEVER TAKEN
_ISR_lock_Release_and_ISR_enable(
1085e1: 57 push %edi
1085e2: 9d popf
( *scheduler->Operations.node_destroy )( scheduler, node );
1085e3: 8b 43 38 mov 0x38(%ebx),%eax
1085e6: c7 04 24 c0 48 12 00 movl $0x1248c0,(%esp)
1085ed: 89 44 24 04 mov %eax,0x4(%esp)
1085f1: ff 15 e8 48 12 00 call *0x1248e8
if ( _Thread_Is_allocated_fp( the_thread ) )
1085f7: 39 1d 2c 04 13 00 cmp %ebx,0x13042c
1085fd: 74 41 je 108640 <_Thread_Kill_zombies+0xe0>
the_thread->Wait.spare_heads
1085ff: 8b 43 5c mov 0x5c(%ebx),%eax
return &the_chain->Head.Node;
108602: 8d 56 30 lea 0x30(%esi),%edx
108605: 89 50 04 mov %edx,0x4(%eax)
before_node = after_node->next;
108608: 8b 56 30 mov 0x30(%esi),%edx
after_node->next = the_node;
10860b: 89 46 30 mov %eax,0x30(%esi)
the_node->next = before_node;
10860e: 89 10 mov %edx,(%eax)
before_node->previous = the_node;
108610: 89 42 04 mov %eax,0x4(%edx)
( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area );
108613: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax
108619: 89 04 24 mov %eax,(%esp)
10861c: ff 93 bc 00 00 00 call *0xbc(%ebx)
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
108622: 89 5c 24 04 mov %ebx,0x4(%esp)
108626: 89 34 24 mov %esi,(%esp)
108629: ff 56 0c call *0xc(%esi)
_ISR_lock_ISR_disable_and_acquire( &zombies->Lock, &lock_context );
10862c: e9 3f ff ff ff jmp 108570 <_Thread_Kill_zombies+0x10>
108631: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108638: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10863f: 90 nop
_Thread_Allocated_fp = NULL;
108640: 31 c0 xor %eax,%eax
108642: a3 2c 04 13 00 mov %eax,0x13042c
}
108647: eb b6 jmp 1085ff <_Thread_Kill_zombies+0x9f>
108649: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
_ISR_lock_Release_and_ISR_enable( &zombies->Lock, &lock_context );
108650: 50 push %eax
108651: 9d popf
}
108652: 83 c4 1c add $0x1c,%esp
108655: 5b pop %ebx
108656: 5e pop %esi
108657: 5f pop %edi
108658: 5d pop %ebp
108659: c3 ret
10865a: 90 nop
10865b: 90 nop
10865c: 90 nop
10865d: 90 nop
10865e: 90 nop
10865f: 90 nop
0010bbc0 <_Thread_Load_environment>:
#include <rtems/score/threadimpl.h>
void _Thread_Load_environment(
Thread_Control *the_thread
)
{
10bbc0: 55 push %ebp
10bbc1: 89 e5 mov %esp,%ebp
10bbc3: 57 push %edi
10bbc4: 56 push %esi
10bbc5: 53 push %ebx
10bbc6: 83 ec 2c sub $0x2c,%esp
10bbc9: 8b 45 08 mov 0x8(%ebp),%eax
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( the_thread->Start.fp_context ) {
10bbcc: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx
10bbd2: 85 d2 test %edx,%edx
10bbd4: 74 57 je 10bc2d <_Thread_Load_environment+0x6d>
the_thread->fp_context = the_thread->Start.fp_context;
10bbd6: 89 90 00 01 00 00 mov %edx,0x100(%eax)
_Context_Initialize_fp( &the_thread->fp_context );
10bbdc: f6 c2 01 test $0x1,%dl
10bbdf: bb 40 04 13 00 mov $0x130440,%ebx
10bbe4: be 6c 00 00 00 mov $0x6c,%esi
10bbe9: 0f 85 a1 00 00 00 jne 10bc90 <_Thread_Load_environment+0xd0> <== NEVER TAKEN
10bbef: f6 c2 02 test $0x2,%dl
10bbf2: 0f 85 b8 00 00 00 jne 10bcb0 <_Thread_Load_environment+0xf0> <== NEVER TAKEN
10bbf8: 89 45 08 mov %eax,0x8(%ebp)
10bbfb: 89 f7 mov %esi,%edi
10bbfd: 31 c9 xor %ecx,%ecx
10bbff: 83 e7 fc and $0xfffffffc,%edi
10bc02: 8b 04 0b mov (%ebx,%ecx,1),%eax
10bc05: 89 04 0a mov %eax,(%edx,%ecx,1)
10bc08: 83 c1 04 add $0x4,%ecx
10bc0b: 39 f9 cmp %edi,%ecx
10bc0d: 72 f3 jb 10bc02 <_Thread_Load_environment+0x42>
10bc0f: 01 ca add %ecx,%edx
10bc11: 01 cb add %ecx,%ebx
10bc13: 8b 45 08 mov 0x8(%ebp),%eax
10bc16: 31 c9 xor %ecx,%ecx
10bc18: f7 c6 02 00 00 00 test $0x2,%esi
10bc1e: 0f 85 bc 00 00 00 jne 10bce0 <_Thread_Load_environment+0x120> <== NEVER TAKEN
10bc24: 83 e6 01 and $0x1,%esi
10bc27: 0f 85 a3 00 00 00 jne 10bcd0 <_Thread_Load_environment+0x110> <== NEVER TAKEN
}
#endif
the_thread->is_preemptible = the_thread->Start.is_preemptible;
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10bc2d: 8b 90 a8 00 00 00 mov 0xa8(%eax),%edx
the_thread->budget_callout = the_thread->Start.budget_callout;
_Context_Initialize(
10bc33: 05 dc 00 00 00 add $0xdc,%eax
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10bc38: 0f b6 58 c8 movzbl -0x38(%eax),%ebx
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10bc3c: 89 50 ac mov %edx,-0x54(%eax)
the_thread->budget_callout = the_thread->Start.budget_callout;
10bc3f: 8b 50 d0 mov -0x30(%eax),%edx
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10bc42: 88 58 a5 mov %bl,-0x5b(%eax)
the_thread->budget_callout = the_thread->Start.budget_callout;
10bc45: 89 50 b0 mov %edx,-0x50(%eax)
_Context_Initialize(
10bc48: 8b 50 f0 mov -0x10(%eax),%edx
10bc4b: 89 54 24 18 mov %edx,0x18(%esp)
10bc4f: 0f b6 50 a6 movzbl -0x5a(%eax),%edx
10bc53: 89 54 24 14 mov %edx,0x14(%esp)
10bc57: ba c0 73 10 00 mov $0x1073c0,%edx
10bc5c: 89 54 24 10 mov %edx,0x10(%esp)
10bc60: 8b 50 d4 mov -0x2c(%eax),%edx
10bc63: 89 54 24 0c mov %edx,0xc(%esp)
10bc67: 8b 50 e4 mov -0x1c(%eax),%edx
10bc6a: 89 54 24 08 mov %edx,0x8(%esp)
10bc6e: 8b 50 e8 mov -0x18(%eax),%edx
10bc71: 89 04 24 mov %eax,(%esp)
10bc74: 89 54 24 04 mov %edx,0x4(%esp)
10bc78: e8 c3 d5 ff ff call 109240 <_CPU_Context_Initialize>
the_thread->Start.isr_level,
_Thread_Handler,
the_thread->is_fp,
the_thread->Start.tls_area
);
}
10bc7d: 83 c4 2c add $0x2c,%esp
10bc80: 5b pop %ebx
10bc81: 5e pop %esi
10bc82: 5f pop %edi
10bc83: 5d pop %ebp
10bc84: c3 ret
10bc85: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10bc8c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
_Context_Initialize_fp( &the_thread->fp_context );
10bc90: 0f b6 1d 40 04 13 00 movzbl 0x130440,%ebx <== NOT EXECUTED
10bc97: 42 inc %edx <== NOT EXECUTED
10bc98: be 6b 00 00 00 mov $0x6b,%esi <== NOT EXECUTED
10bc9d: 88 5a ff mov %bl,-0x1(%edx) <== NOT EXECUTED
10bca0: bb 41 04 13 00 mov $0x130441,%ebx <== NOT EXECUTED
10bca5: e9 45 ff ff ff jmp 10bbef <_Thread_Load_environment+0x2f> <== NOT EXECUTED
10bcaa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
10bcb0: 0f b7 0b movzwl (%ebx),%ecx <== NOT EXECUTED
10bcb3: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
10bcb6: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED
10bcb9: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED
10bcbc: 66 89 4a fe mov %cx,-0x2(%edx) <== NOT EXECUTED
10bcc0: e9 33 ff ff ff jmp 10bbf8 <_Thread_Load_environment+0x38> <== NOT EXECUTED
10bcc5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10bccc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10bcd0: 0f b6 1c 0b movzbl (%ebx,%ecx,1),%ebx <== NOT EXECUTED
10bcd4: 88 1c 0a mov %bl,(%edx,%ecx,1) <== NOT EXECUTED
10bcd7: e9 51 ff ff ff jmp 10bc2d <_Thread_Load_environment+0x6d> <== NOT EXECUTED
10bcdc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10bce0: 0f b7 0b movzwl (%ebx),%ecx <== NOT EXECUTED
10bce3: 66 89 0a mov %cx,(%edx) <== NOT EXECUTED
10bce6: b9 02 00 00 00 mov $0x2,%ecx <== NOT EXECUTED
10bceb: e9 34 ff ff ff jmp 10bc24 <_Thread_Load_environment+0x64> <== NOT EXECUTED
0010dfa0 <_Thread_Priority_add>:
void _Thread_Priority_add(
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
10dfa0: 55 push %ebp
10dfa1: 89 e5 mov %esp,%ebp
10dfa3: 57 push %edi
10dfa4: 56 push %esi
10dfa5: 53 push %ebx
10dfa6: 83 ec 1c sub $0x1c,%esp
10dfa9: 8b 75 08 mov 0x8(%ebp),%esi
aggregation->Action.node = node;
10dfac: 8b 55 0c mov 0xc(%ebp),%edx
10dfaf: 8b 5d 10 mov 0x10(%ebp),%ebx
return the_thread->Scheduler.nodes;
10dfb2: 8b 46 38 mov 0x38(%esi),%eax
queue = the_thread->Wait.queue;
10dfb5: 8b 7e 54 mov 0x54(%esi),%edi
_Thread_Priority_do_perform_actions(
10dfb8: 8b 4e 58 mov 0x58(%esi),%ecx
10dfbb: 89 50 20 mov %edx,0x20(%eax)
_Priority_Actions_initialize_one(
10dfbe: 83 c0 04 add $0x4,%eax
aggregation->Action.type = type;
10dfc1: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
_Thread_Priority_do_perform_actions(
10dfc8: 89 fa mov %edi,%edx
_Priority_Actions_initialize_one(
10dfca: 89 43 10 mov %eax,0x10(%ebx)
_Thread_Priority_do_perform_actions(
10dfcd: 89 f0 mov %esi,%eax
10dfcf: 89 5c 24 04 mov %ebx,0x4(%esp)
10dfd3: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10dfda: e8 01 fd ff ff call 10dce0 <_Thread_Priority_do_perform_actions>
if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
10dfdf: 8b 53 10 mov 0x10(%ebx),%edx
10dfe2: 85 d2 test %edx,%edx
10dfe4: 74 2f je 10e015 <_Thread_Priority_add+0x75> <== ALWAYS TAKEN
_Thread_Priority_perform_actions( queue->owner, queue_context );
10dfe6: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
return queue_context->Priority.update_count;
10dfe9: 8b 73 14 mov 0x14(%ebx),%esi <== NOT EXECUTED
10dfec: eb 08 jmp 10dff6 <_Thread_Priority_add+0x56> <== NOT EXECUTED
10dfee: 66 90 xchg %ax,%ax <== NOT EXECUTED
the_thread = queue->owner;
10dff0: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
queue_context->Priority.update_count = update_count;
10dff3: 89 73 14 mov %esi,0x14(%ebx) <== NOT EXECUTED
queue = the_thread->Wait.queue;
10dff6: 8b 78 54 mov 0x54(%eax),%edi <== NOT EXECUTED
_Thread_Priority_do_perform_actions(
10dff9: 8b 48 58 mov 0x58(%eax),%ecx <== NOT EXECUTED
10dffc: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10e000: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
10e007: 89 fa mov %edi,%edx <== NOT EXECUTED
10e009: e8 d2 fc ff ff call 10dce0 <_Thread_Priority_do_perform_actions> <== NOT EXECUTED
if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
10e00e: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10e011: 85 c0 test %eax,%eax <== NOT EXECUTED
10e013: 75 db jne 10dff0 <_Thread_Priority_add+0x50> <== NOT EXECUTED
priority_node,
queue_context,
false,
PRIORITY_ACTION_ADD
);
}
10e015: 83 c4 1c add $0x1c,%esp
10e018: 5b pop %ebx
10e019: 5e pop %esi
10e01a: 5f pop %edi
10e01b: 5d pop %ebp
10e01c: c3 ret
10e01d: 90 nop
10e01e: 90 nop
10e01f: 90 nop
0010e020 <_Thread_Priority_remove>:
void _Thread_Priority_remove(
Thread_Control *the_thread,
Priority_Node *priority_node,
Thread_queue_Context *queue_context
)
{
10e020: 55 push %ebp
10e021: 89 e5 mov %esp,%ebp
10e023: 57 push %edi
10e024: 56 push %esi
10e025: 53 push %ebx
10e026: 83 ec 1c sub $0x1c,%esp
10e029: 8b 75 08 mov 0x8(%ebp),%esi
aggregation->Action.node = node;
10e02c: 8b 55 0c mov 0xc(%ebp),%edx
10e02f: 8b 5d 10 mov 0x10(%ebp),%ebx
10e032: 8b 46 38 mov 0x38(%esi),%eax
queue = the_thread->Wait.queue;
10e035: 8b 7e 54 mov 0x54(%esi),%edi
_Thread_Priority_do_perform_actions(
10e038: 8b 4e 58 mov 0x58(%esi),%ecx
10e03b: 89 50 20 mov %edx,0x20(%eax)
_Priority_Actions_initialize_one(
10e03e: 83 c0 04 add $0x4,%eax
aggregation->Action.type = type;
10e041: c7 40 20 02 00 00 00 movl $0x2,0x20(%eax)
_Thread_Priority_do_perform_actions(
10e048: 89 fa mov %edi,%edx
_Priority_Actions_initialize_one(
10e04a: 89 43 10 mov %eax,0x10(%ebx)
_Thread_Priority_do_perform_actions(
10e04d: 89 f0 mov %esi,%eax
10e04f: 89 5c 24 04 mov %ebx,0x4(%esp)
10e053: c7 04 24 01 00 00 00 movl $0x1,(%esp)
10e05a: e8 81 fc ff ff call 10dce0 <_Thread_Priority_do_perform_actions>
if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
10e05f: 8b 53 10 mov 0x10(%ebx),%edx
10e062: 85 d2 test %edx,%edx
10e064: 74 2f je 10e095 <_Thread_Priority_remove+0x75> <== ALWAYS TAKEN
_Thread_Priority_perform_actions( queue->owner, queue_context );
10e066: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
return queue_context->Priority.update_count;
10e069: 8b 73 14 mov 0x14(%ebx),%esi <== NOT EXECUTED
10e06c: eb 08 jmp 10e076 <_Thread_Priority_remove+0x56> <== NOT EXECUTED
10e06e: 66 90 xchg %ax,%ax <== NOT EXECUTED
the_thread = queue->owner;
10e070: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
queue_context->Priority.update_count = update_count;
10e073: 89 73 14 mov %esi,0x14(%ebx) <== NOT EXECUTED
queue = the_thread->Wait.queue;
10e076: 8b 78 54 mov 0x54(%eax),%edi <== NOT EXECUTED
_Thread_Priority_do_perform_actions(
10e079: 8b 48 58 mov 0x58(%eax),%ecx <== NOT EXECUTED
10e07c: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10e080: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
10e087: 89 fa mov %edi,%edx <== NOT EXECUTED
10e089: e8 52 fc ff ff call 10dce0 <_Thread_Priority_do_perform_actions> <== NOT EXECUTED
if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) {
10e08e: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10e091: 85 c0 test %eax,%eax <== NOT EXECUTED
10e093: 75 db jne 10e070 <_Thread_Priority_remove+0x50> <== NOT EXECUTED
priority_node,
queue_context,
true,
PRIORITY_ACTION_REMOVE
);
}
10e095: 83 c4 1c add $0x1c,%esp
10e098: 5b pop %ebx
10e099: 5e pop %esi
10e09a: 5f pop %edi
10e09b: 5d pop %ebp
10e09c: c3 ret
10e09d: 90 nop
10e09e: 90 nop
10e09f: 90 nop
00106ef0 <_Thread_Restart_other>:
bool _Thread_Restart_other(
Thread_Control *the_thread,
const Thread_Entry_information *entry,
ISR_lock_Context *lock_context
)
{
106ef0: 55 push %ebp
106ef1: 89 e5 mov %esp,%ebp
106ef3: 83 ec 38 sub $0x38,%esp
106ef6: 89 5d f4 mov %ebx,-0xc(%ebp)
106ef9: 8b 5d 08 mov 0x8(%ebp),%ebx
106efc: 89 75 f8 mov %esi,-0x8(%ebp)
106eff: 8b 45 0c mov 0xc(%ebp),%eax
106f02: 89 7d fc mov %edi,-0x4(%ebp)
Thread_Life_state previous;
Per_CPU_Control *cpu_self;
_Thread_State_acquire_critical( the_thread, lock_context );
if ( _States_Is_dormant( the_thread->current_state ) ) {
106f05: 8b 53 1c mov 0x1c(%ebx),%edx
106f08: 85 d2 test %edx,%edx
106f0a: 0f 88 30 01 00 00 js 107040 <_Thread_Restart_other+0x150>
_Thread_State_release( the_thread, lock_context );
return false;
}
the_thread->Start.Entry = *entry;
106f10: 8b 10 mov (%eax),%edx
106f12: 89 93 98 00 00 00 mov %edx,0x98(%ebx)
106f18: 8b 50 04 mov 0x4(%eax),%edx
106f1b: 89 93 9c 00 00 00 mov %edx,0x9c(%ebx)
106f21: 8b 40 08 mov 0x8(%eax),%eax
106f24: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx)
previous = the_thread->Life.state;
106f2a: 8b 83 20 01 00 00 mov 0x120(%ebx),%eax
state |= set;
106f30: 89 c2 mov %eax,%edx
106f32: 83 ca 02 or $0x2,%edx
if (
106f35: a8 09 test $0x9,%al
state |= set;
106f37: 89 93 20 01 00 00 mov %edx,0x120(%ebx)
if (
106f3d: 74 41 je 106f80 <_Thread_Restart_other+0x90> <== ALWAYS TAKEN
_Thread_Finalize_life_change(
the_thread,
the_thread->Start.initial_priority
);
} else {
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
106f3f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
disable_level = cpu_self->thread_dispatch_disable_level;
106f42: a1 90 8f 12 00 mov 0x128f90,%eax <== NOT EXECUTED
cpu_self->thread_dispatch_disable_level = disable_level + 1;
106f47: 40 inc %eax <== NOT EXECUTED
106f48: a3 90 8f 12 00 mov %eax,0x128f90 <== NOT EXECUTED
106f4d: b8 00 80 00 00 mov $0x8000,%eax <== NOT EXECUTED
106f52: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106f56: e8 45 40 00 00 call 10afa0 <_Thread_Clear_state_locked> <== NOT EXECUTED
_ISR_lock_ISR_enable( lock_context );
106f5b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
106f5e: ff 30 push (%eax) <== NOT EXECUTED
106f60: 9d popf <== NOT EXECUTED
_Thread_State_release( the_thread, lock_context );
}
_Thread_Dispatch_enable( cpu_self );
106f61: c7 04 24 80 8f 12 00 movl $0x128f80,(%esp)
106f68: e8 63 f6 ff ff call 1065d0 <_Thread_Dispatch_enable>
return true;
}
106f6d: 8b 5d f4 mov -0xc(%ebp),%ebx
return true;
106f70: b0 01 mov $0x1,%al
}
106f72: 8b 75 f8 mov -0x8(%ebp),%esi
106f75: 8b 7d fc mov -0x4(%ebp),%edi
106f78: 89 ec mov %ebp,%esp
106f7a: 5d pop %ebp
106f7b: c3 ret
106f7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
the_thread->is_preemptible = the_thread->Start.is_preemptible;
106f80: 0f b6 83 a4 00 00 00 movzbl 0xa4(%ebx),%eax
action->handler = handler;
106f87: be 80 69 10 00 mov $0x106980,%esi
106f8c: 89 b3 1c 01 00 00 mov %esi,0x11c(%ebx)
106f92: 88 83 81 00 00 00 mov %al,0x81(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
106f98: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
106f9e: 89 83 88 00 00 00 mov %eax,0x88(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
106fa4: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
106faa: 89 83 8c 00 00 00 mov %eax,0x8c(%ebx)
cpu_self->dispatch_necessary = true;
106fb0: b0 01 mov $0x1,%al
106fb2: a2 94 8f 12 00 mov %al,0x128f94
if ( _Chain_Is_node_off_chain( the_node ) ) {
106fb7: 8b 83 14 01 00 00 mov 0x114(%ebx),%eax
106fbd: 85 c0 test %eax,%eax
106fbf: 0f 84 db 00 00 00 je 1070a0 <_Thread_Restart_other+0x1b0> <== ALWAYS TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
106fc5: a1 90 8f 12 00 mov 0x128f90,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
106fca: 40 inc %eax
106fcb: a3 90 8f 12 00 mov %eax,0x128f90
pending_requests = the_thread->Life.pending_life_change_requests;
106fd0: 8b 83 24 01 00 00 mov 0x124(%ebx),%eax
the_thread->Life.pending_life_change_requests = pending_requests + 1;
106fd6: 8d 50 01 lea 0x1(%eax),%edx
if ( pending_requests == 0 ) {
106fd9: 85 c0 test %eax,%eax
the_thread->Life.pending_life_change_requests = pending_requests + 1;
106fdb: 89 93 24 01 00 00 mov %edx,0x124(%ebx)
if ( pending_requests == 0 ) {
106fe1: 74 7d je 107060 <_Thread_Restart_other+0x170> <== ALWAYS TAKEN
_ISR_lock_ISR_enable( lock_context );
106fe3: 8b 45 10 mov 0x10(%ebp),%eax
106fe6: ff 30 push (%eax)
106fe8: 9d popf
_Thread_Finalize_life_change(
106fe9: 8b b3 b4 00 00 00 mov 0xb4(%ebx),%esi
106fef: 8b bb b8 00 00 00 mov 0xb8(%ebx),%edi
_Thread_queue_Extract_with_proxy( the_thread );
106ff5: 89 1c 24 mov %ebx,(%esp)
106ff8: e8 73 49 00 00 call 10b970 <_Thread_queue_Extract_with_proxy>
_ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock, &lock_context );
106ffd: 9c pushf
106ffe: fa cli
106fff: 8f 45 e4 pop -0x1c(%ebp)
_Watchdog_Per_CPU_remove(
107002: 8d 4b 64 lea 0x64(%ebx),%ecx
107005: 89 4c 24 04 mov %ecx,0x4(%esp)
107009: 8b 4b 60 mov 0x60(%ebx),%ecx
10700c: 89 0c 24 mov %ecx,(%esp)
10700f: e8 7c 09 00 00 call 107990 <_Watchdog_Remove>
_ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock, &lock_context );
107014: ff 75 e4 push -0x1c(%ebp)
107017: 9d popf
_Thread_Raise_real_priority( the_thread, priority );
107018: 89 f2 mov %esi,%edx
10701a: 89 f9 mov %edi,%ecx
10701c: 89 d8 mov %ebx,%eax
10701e: e8 8d f7 ff ff call 1067b0 <_Thread_Raise_real_priority>
_ISR_lock_ISR_disable( lock_context );
107023: 9c pushf
107024: fa cli
107025: 5e pop %esi
pending_requests = the_thread->Life.pending_life_change_requests;
107026: 8b 83 24 01 00 00 mov 0x124(%ebx),%eax
the_thread->Life.pending_life_change_requests = pending_requests - 1;
10702c: 8d 50 ff lea -0x1(%eax),%edx
if ( pending_requests == 1 ) {
10702f: 48 dec %eax
the_thread->Life.pending_life_change_requests = pending_requests - 1;
107030: 89 93 24 01 00 00 mov %edx,0x124(%ebx)
if ( pending_requests == 1 ) {
107036: 74 48 je 107080 <_Thread_Restart_other+0x190> <== ALWAYS TAKEN
_ISR_lock_ISR_enable( lock_context );
107038: 56 push %esi
107039: 9d popf
}
10703a: e9 22 ff ff ff jmp 106f61 <_Thread_Restart_other+0x71>
10703f: 90 nop
107040: 8b 45 10 mov 0x10(%ebp),%eax
107043: ff 30 push (%eax)
107045: 9d popf
}
107046: 8b 5d f4 mov -0xc(%ebp),%ebx
return false;
107049: 31 c0 xor %eax,%eax
}
10704b: 8b 75 f8 mov -0x8(%ebp),%esi
10704e: 8b 7d fc mov -0x4(%ebp),%edi
107051: 89 ec mov %ebp,%esp
107053: 5d pop %ebp
107054: c3 ret
107055: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10705c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
_Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING );
107060: 89 1c 24 mov %ebx,(%esp)
107063: b9 00 00 02 00 mov $0x20000,%ecx
107068: 89 4c 24 04 mov %ecx,0x4(%esp)
10706c: e8 df 01 00 00 call 107250 <_Thread_Set_state_locked>
107071: e9 6d ff ff ff jmp 106fe3 <_Thread_Restart_other+0xf3>
107076: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10707d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Clear_state_locked(
107080: 89 1c 24 mov %ebx,(%esp)
107083: ba 0c 83 02 30 mov $0x3002830c,%edx
107088: 89 54 24 04 mov %edx,0x4(%esp)
10708c: e8 0f 3f 00 00 call 10afa0 <_Thread_Clear_state_locked>
107091: eb a5 jmp 107038 <_Thread_Restart_other+0x148>
107093: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10709a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
old_last = tail->previous;
1070a0: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax
_Chain_Append_if_is_off_chain_unprotected(
1070a6: 8d 93 14 01 00 00 lea 0x114(%ebx),%edx
tail->previous = the_node;
1070ac: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx)
return &the_chain->Tail.Node;
1070b2: 8d 8b d4 00 00 00 lea 0xd4(%ebx),%ecx
1070b8: 89 8b 14 01 00 00 mov %ecx,0x114(%ebx)
old_last->next = the_node;
1070be: 89 10 mov %edx,(%eax)
the_node->previous = old_last;
1070c0: 89 83 18 01 00 00 mov %eax,0x118(%ebx)
}
1070c6: e9 fa fe ff ff jmp 106fc5 <_Thread_Restart_other+0xd5>
1070cb: 90 nop
1070cc: 90 nop
1070cd: 90 nop
1070ce: 90 nop
1070cf: 90 nop
00108660 <_Thread_Set_life_protection>:
return previous;
}
Thread_Life_state _Thread_Set_life_protection( Thread_Life_state state )
{
108660: 55 push %ebp
108661: 89 e5 mov %esp,%ebp
108663: 83 ec 28 sub $0x28,%esp
108666: 89 5d f4 mov %ebx,-0xc(%ebp)
108669: 89 75 f8 mov %esi,-0x8(%ebp)
10866c: 89 7d fc mov %edi,-0x4(%ebp)
_ISR_lock_ISR_disable( lock_context );
10866f: 9c pushf
108670: fa cli
108671: 59 pop %ecx
108672: 8b 15 f8 03 13 00 mov 0x1303f8,%edx
return _Thread_Change_life(
THREAD_LIFE_PROTECTED,
state & THREAD_LIFE_PROTECTED,
108678: 8b 45 08 mov 0x8(%ebp),%eax
previous = the_thread->Life.state;
10867b: 8b 9a 20 01 00 00 mov 0x120(%edx),%ebx
state & THREAD_LIFE_PROTECTED,
108681: 83 e0 01 and $0x1,%eax
state &= ~clear;
108684: 89 de mov %ebx,%esi
108686: 83 e6 fe and $0xfffffffe,%esi
state |= set;
108689: 09 f0 or %esi,%eax
the_thread->Life.state = state;
10868b: 89 82 20 01 00 00 mov %eax,0x120(%edx)
if (
108691: a8 09 test $0x9,%al
108693: 75 45 jne 1086da <_Thread_Set_life_protection+0x7a>
&& _Thread_Is_life_changing( state )
108695: a8 06 test $0x6,%al
108697: 74 41 je 1086da <_Thread_Set_life_protection+0x7a>
the_thread->is_preemptible = the_thread->Start.is_preemptible;
108699: 0f b6 82 a4 00 00 00 movzbl 0xa4(%edx),%eax
1086a0: 88 82 81 00 00 00 mov %al,0x81(%edx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
1086a6: 8b 82 a8 00 00 00 mov 0xa8(%edx),%eax
1086ac: 89 82 88 00 00 00 mov %eax,0x88(%edx)
the_thread->budget_callout = the_thread->Start.budget_callout;
1086b2: 8b 82 ac 00 00 00 mov 0xac(%edx),%eax
1086b8: 89 82 8c 00 00 00 mov %eax,0x8c(%edx)
action->handler = handler;
1086be: b8 10 84 10 00 mov $0x108410,%eax
1086c3: 89 82 1c 01 00 00 mov %eax,0x11c(%edx)
cpu_self->dispatch_necessary = true;
1086c9: b0 01 mov $0x1,%al
1086cb: a2 f4 03 13 00 mov %al,0x1303f4
if ( _Chain_Is_node_off_chain( the_node ) ) {
1086d0: 8b 82 14 01 00 00 mov 0x114(%edx),%eax
1086d6: 85 c0 test %eax,%eax
1086d8: 74 36 je 108710 <_Thread_Set_life_protection+0xb0> <== ALWAYS TAKEN
disable_level = cpu_self->thread_dispatch_disable_level;
1086da: a1 f0 03 13 00 mov 0x1303f0,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
1086df: 40 inc %eax
1086e0: a3 f0 03 13 00 mov %eax,0x1303f0
_ISR_lock_ISR_enable( lock_context );
1086e5: 51 push %ecx
1086e6: 9d popf
_Thread_Dispatch_enable( cpu_self );
1086e7: c7 04 24 e0 03 13 00 movl $0x1303e0,(%esp)
1086ee: e8 dd eb ff ff call 1072d0 <_Thread_Dispatch_enable>
0
);
}
1086f3: 8b 75 f8 mov -0x8(%ebp),%esi
1086f6: 89 d8 mov %ebx,%eax
1086f8: 8b 7d fc mov -0x4(%ebp),%edi
1086fb: 8b 5d f4 mov -0xc(%ebp),%ebx
1086fe: 89 ec mov %ebp,%esp
108700: 5d pop %ebp
108701: c3 ret
108702: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108709: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
old_last = tail->previous;
108710: 8b 82 d8 00 00 00 mov 0xd8(%edx),%eax
_Chain_Append_if_is_off_chain_unprotected(
108716: 8d b2 14 01 00 00 lea 0x114(%edx),%esi
tail->previous = the_node;
10871c: 89 b2 d8 00 00 00 mov %esi,0xd8(%edx)
return &the_chain->Tail.Node;
108722: 8d ba d4 00 00 00 lea 0xd4(%edx),%edi
108728: 89 ba 14 01 00 00 mov %edi,0x114(%edx)
old_last->next = the_node;
10872e: 89 30 mov %esi,(%eax)
the_node->previous = old_last;
108730: 89 82 18 01 00 00 mov %eax,0x118(%edx)
}
108736: eb a2 jmp 1086da <_Thread_Set_life_protection+0x7a>
108738: 90 nop
108739: 90 nop
10873a: 90 nop
10873b: 90 nop
10873c: 90 nop
10873d: 90 nop
10873e: 90 nop
10873f: 90 nop
00109940 <_Thread_Wait_get_id>:
#endif
#include <rtems/score/threadimpl.h>
Objects_Id _Thread_Wait_get_id( const Thread_Control *the_thread )
{
109940: 55 push %ebp
queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue );
return queue_object->Object.id;
}
return 0;
109941: 31 d2 xor %edx,%edx
{
109943: 89 e5 mov %esp,%ebp
queue = the_thread->Wait.queue;
109945: 8b 45 08 mov 0x8(%ebp),%eax
109948: 8b 40 54 mov 0x54(%eax),%eax
if ( queue != NULL && queue->name == _Thread_queue_Object_name ) {
10994b: 85 c0 test %eax,%eax
10994d: 74 09 je 109958 <_Thread_Wait_get_id+0x18>
10994f: 81 78 08 a6 19 12 00 cmpl $0x1219a6,0x8(%eax)
109956: 74 08 je 109960 <_Thread_Wait_get_id+0x20> <== ALWAYS TAKEN
}
109958: 5d pop %ebp
109959: 89 d0 mov %edx,%eax
10995b: c3 ret
10995c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return queue_object->Object.id;
109960: 8b 50 f8 mov -0x8(%eax),%edx
}
109963: 5d pop %ebp
109964: 89 d0 mov %edx,%eax
109966: c3 ret
109967: 90 nop
109968: 90 nop
109969: 90 nop
10996a: 90 nop
10996b: 90 nop
10996c: 90 nop
10996d: 90 nop
10996e: 90 nop
10996f: 90 nop
00108980 <_Thread_Yield>:
#include <rtems/score/threadimpl.h>
#include <rtems/score/schedulerimpl.h>
void _Thread_Yield( Thread_Control *executing )
{
108980: 55 push %ebp
108981: 89 e5 mov %esp,%ebp
108983: 83 ec 18 sub $0x18,%esp
108986: 89 5d fc mov %ebx,-0x4(%ebp)
108989: 8b 45 08 mov 0x8(%ebp),%eax
_ISR_lock_ISR_disable( lock_context );
10898c: 9c pushf
10898d: fa cli
10898e: 5b pop %ebx
ISR_lock_Context lock_context;
_Thread_State_acquire( executing, &lock_context );
if ( _States_Is_ready( executing->current_state ) ) {
10898f: 8b 50 1c mov 0x1c(%eax),%edx
108992: 85 d2 test %edx,%edx
108994: 75 18 jne 1089ae <_Thread_Yield+0x2e> <== NEVER TAKEN
( *scheduler->Operations.yield )(
108996: 8b 50 38 mov 0x38(%eax),%edx
108999: 89 44 24 04 mov %eax,0x4(%esp)
10899d: c7 04 24 c0 48 12 00 movl $0x1248c0,(%esp)
1089a4: 89 54 24 08 mov %edx,0x8(%esp)
1089a8: ff 15 cc 48 12 00 call *0x1248cc
_ISR_lock_ISR_enable( lock_context );
1089ae: 53 push %ebx
1089af: 9d popf
_Scheduler_Yield( executing );
}
_Thread_State_release( executing, &lock_context );
}
1089b0: 8b 5d fc mov -0x4(%ebp),%ebx
1089b3: 89 ec mov %ebp,%esp
1089b5: 5d pop %ebp
1089b6: c3 ret
1089b7: 90 nop
1089b8: 90 nop
1089b9: 90 nop
1089ba: 90 nop
1089bb: 90 nop
1089bc: 90 nop
1089bd: 90 nop
1089be: 90 nop
1089bf: 90 nop
00107740 <_Thread_queue_Extract>:
void _Thread_queue_Extract( Thread_Control *the_thread )
{
107740: 55 push %ebp
107741: 89 e5 mov %esp,%ebp
107743: 83 ec 48 sub $0x48,%esp
107746: 89 5d f8 mov %ebx,-0x8(%ebp)
107749: 8b 5d 08 mov 0x8(%ebp),%ebx
10774c: 89 75 fc mov %esi,-0x4(%ebp)
queue_context->Priority.update_count = 0;
10774f: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
107756: 9c pushf
107757: fa cli
107758: 58 pop %eax
107759: 89 45 d4 mov %eax,-0x2c(%ebp)
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_clear_priority_updates( &queue_context );
_Thread_Wait_acquire( the_thread, &queue_context );
queue = the_thread->Wait.queue;
10775c: 8b 43 54 mov 0x54(%ebx),%eax
if ( queue != NULL ) {
10775f: 85 c0 test %eax,%eax
107761: 74 4d je 1077b0 <_Thread_queue_Extract+0x70>
( *operations->extract )( queue, the_thread, queue_context );
107763: 8b 53 58 mov 0x58(%ebx),%edx
107766: 8d 75 d4 lea -0x2c(%ebp),%esi
107769: 89 74 24 08 mov %esi,0x8(%esp)
10776d: 89 5c 24 04 mov %ebx,0x4(%esp)
107771: 89 04 24 mov %eax,(%esp)
107774: ff 52 08 call *0x8(%edx)
if ( success ) {
107777: 81 7b 50 01 04 00 00 cmpl $0x401,0x50(%ebx)
the_thread->Wait.queue = NULL;
10777e: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
the_thread->Wait.flags = desired_flags;
107785: c7 43 50 04 04 00 00 movl $0x404,0x50(%ebx)
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10778c: c7 43 58 a8 54 12 00 movl $0x1254a8,0x58(%ebx)
if ( success ) {
107793: 74 1b je 1077b0 <_Thread_queue_Extract+0x70> <== NEVER TAKEN
if ( unblock ) {
107795: 89 f2 mov %esi,%edx
107797: 89 d8 mov %ebx,%eax
107799: e8 f2 fc ff ff call 107490 <_Thread_queue_Unblock_critical.part.0>
&queue_context.Lock_context.Lock_context
);
} else {
_Thread_Wait_release( the_thread, &queue_context );
}
}
10779e: 8b 5d f8 mov -0x8(%ebp),%ebx
1077a1: 8b 75 fc mov -0x4(%ebp),%esi
1077a4: 89 ec mov %ebp,%esp
1077a6: 5d pop %ebp
1077a7: c3 ret
1077a8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1077af: 90 nop
_ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context );
1077b0: ff 75 d4 push -0x2c(%ebp)
1077b3: 9d popf
1077b4: 8b 5d f8 mov -0x8(%ebp),%ebx
1077b7: 8b 75 fc mov -0x4(%ebp),%esi
1077ba: 89 ec mov %ebp,%esp
1077bc: 5d pop %ebp
1077bd: c3 ret
1077be: 90 nop
1077bf: 90 nop
0011aab0 <_Thread_queue_Queue_get_name_and_id>:
const Thread_queue_Queue *queue,
char *buffer,
size_t buffer_size,
Objects_Id *id
)
{
11aab0: 55 push %ebp <== NOT EXECUTED
11aab1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
11aab3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
11aab6: 89 5d f8 mov %ebx,-0x8(%ebp) <== NOT EXECUTED
11aab9: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
11aabc: 89 75 fc mov %esi,-0x4(%ebp) <== NOT EXECUTED
11aabf: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
11aac2: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED
11aac5: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED
const char *name;
name = queue->name;
11aac8: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
if ( name == _Thread_queue_Object_name ) {
11aacb: 3d 65 1d 19 00 cmp $0x191d65,%eax <== NOT EXECUTED
11aad0: 74 3e je 11ab10 <_Thread_queue_Queue_get_name_and_id+0x60><== NOT EXECUTED
false,
buffer,
buffer_size
);
} else {
if ( name == NULL ) {
11aad2: 85 c0 test %eax,%eax <== NOT EXECUTED
11aad4: 74 2a je 11ab00 <_Thread_queue_Queue_get_name_and_id+0x50><== NOT EXECUTED
name = _Thread_queue_Object_name;
}
*id = 0;
11aad6: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
}
}
11aadc: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
11aadf: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED
}
11aae2: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
11aae5: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
11aae8: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED
}
11aaeb: 89 ec mov %ebp,%esp <== NOT EXECUTED
11aaed: 5d pop %ebp <== NOT EXECUTED
return strlcpy( buffer, name, buffer_size );
11aaee: e9 ed f5 04 00 jmp 16a0e0 <strlcpy> <== NOT EXECUTED
11aaf3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11aafa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
name = _Thread_queue_Object_name;
11ab00: b8 65 1d 19 00 mov $0x191d65,%eax <== NOT EXECUTED
11ab05: eb cf jmp 11aad6 <_Thread_queue_Queue_get_name_and_id+0x26><== NOT EXECUTED
11ab07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
11ab0e: 66 90 xchg %ax,%ax <== NOT EXECUTED
*id = queue_object->Object.id;
11ab10: 8b 42 f8 mov -0x8(%edx),%eax <== NOT EXECUTED
11ab13: 89 06 mov %eax,(%esi) <== NOT EXECUTED
}
11ab15: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
return _Objects_Name_to_string(
11ab18: 89 5d 14 mov %ebx,0x14(%ebp) <== NOT EXECUTED
}
11ab1b: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
return _Objects_Name_to_string(
11ab1e: 89 4d 10 mov %ecx,0x10(%ebp) <== NOT EXECUTED
11ab21: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) <== NOT EXECUTED
11ab28: 8b 42 fc mov -0x4(%edx),%eax <== NOT EXECUTED
11ab2b: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
11ab2e: 89 ec mov %ebp,%esp <== NOT EXECUTED
11ab30: 5d pop %ebp <== NOT EXECUTED
return _Objects_Name_to_string(
11ab31: e9 8a d9 ff ff jmp 1184c0 <_Objects_Name_to_string> <== NOT EXECUTED
11ab36: 90 nop
11ab37: 90 nop
11ab38: 90 nop
11ab39: 90 nop
11ab3a: 90 nop
11ab3b: 90 nop
11ab3c: 90 nop
11ab3d: 90 nop
11ab3e: 90 nop
11ab3f: 90 nop
001077c0 <_Thread_queue_Surrender>:
Thread_queue_Heads *heads,
Thread_Control *previous_owner,
Thread_queue_Context *queue_context,
const Thread_queue_Operations *operations
)
{
1077c0: 55 push %ebp
1077c1: 89 e5 mov %esp,%ebp
1077c3: 83 ec 28 sub $0x28,%esp
1077c6: 89 75 f8 mov %esi,-0x8(%ebp)
Per_CPU_Control *cpu_self;
_Assert( heads != NULL );
_Thread_queue_Context_clear_priority_updates( queue_context );
new_owner = ( *operations->surrender )(
1077c9: 8b 45 10 mov 0x10(%ebp),%eax
{
1077cc: 89 5d f4 mov %ebx,-0xc(%ebp)
1077cf: 8b 75 14 mov 0x14(%ebp),%esi
1077d2: 89 7d fc mov %edi,-0x4(%ebp)
1077d5: 8b 7d 08 mov 0x8(%ebp),%edi
1077d8: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
new_owner = ( *operations->surrender )(
1077df: 89 44 24 08 mov %eax,0x8(%esp)
1077e3: 8b 45 0c mov 0xc(%ebp),%eax
1077e6: 89 3c 24 mov %edi,(%esp)
1077e9: 89 74 24 0c mov %esi,0xc(%esp)
1077ed: 89 44 24 04 mov %eax,0x4(%esp)
1077f1: 8b 45 18 mov 0x18(%ebp),%eax
1077f4: ff 50 0c call *0xc(%eax)
queue,
heads,
previous_owner,
queue_context
);
queue->owner = new_owner;
1077f7: 89 47 04 mov %eax,0x4(%edi)
bool success = ( the_thread->Wait.flags == expected_flags );
1077fa: 8b 78 50 mov 0x50(%eax),%edi
new_owner = ( *operations->surrender )(
1077fd: 89 c3 mov %eax,%ebx
if ( success ) {
1077ff: c7 40 50 04 04 00 00 movl $0x404,0x50(%eax)
the_thread->Wait.queue = NULL;
107806: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
the_thread->Wait.operations = &_Thread_queue_Operations_default;
10780d: c7 40 58 a8 54 12 00 movl $0x1254a8,0x58(%eax)
disable_level = cpu_self->thread_dispatch_disable_level;
107814: a1 f0 03 13 00 mov 0x1303f0,%eax
cpu_self->thread_dispatch_disable_level = disable_level + 1;
107819: 40 inc %eax
10781a: a3 f0 03 13 00 mov %eax,0x1303f0
_ISR_lock_ISR_enable( lock_context );
10781f: ff 36 push (%esi)
107821: 9d popf
_Thread_queue_Queue_release(
queue,
&queue_context->Lock_context.Lock_context
);
_Thread_Priority_update( queue_context );
107822: 89 34 24 mov %esi,(%esp)
107825: e8 b6 3e 00 00 call 10b6e0 <_Thread_Priority_update>
if ( unblock ) {
10782a: 81 ff 01 04 00 00 cmp $0x401,%edi
107830: 75 1e jne 107850 <_Thread_queue_Surrender+0x90> <== ALWAYS TAKEN
_Thread_Remove_timer_and_unblock( new_owner, queue );
}
_Thread_Dispatch_enable( cpu_self );
}
107832: 8b 5d f4 mov -0xc(%ebp),%ebx
_Thread_Dispatch_enable( cpu_self );
107835: c7 45 08 e0 03 13 00 movl $0x1303e0,0x8(%ebp)
}
10783c: 8b 75 f8 mov -0x8(%ebp),%esi
10783f: 8b 7d fc mov -0x4(%ebp),%edi
107842: 89 ec mov %ebp,%esp
107844: 5d pop %ebp
_Thread_Dispatch_enable( cpu_self );
107845: e9 86 fa ff ff jmp 1072d0 <_Thread_Dispatch_enable>
10784a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
_ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock, &lock_context );
107850: 9c pushf
107851: fa cli
107852: 5e pop %esi
_Watchdog_Per_CPU_remove(
107853: 8d 43 64 lea 0x64(%ebx),%eax
107856: 89 44 24 04 mov %eax,0x4(%esp)
10785a: 8b 43 60 mov 0x60(%ebx),%eax
10785d: 89 04 24 mov %eax,(%esp)
107860: e8 2b 15 00 00 call 108d90 <_Watchdog_Remove>
_ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock, &lock_context );
107865: 56 push %esi
107866: 9d popf
_Thread_Clear_state( the_thread, STATES_BLOCKED );
107867: 89 1c 24 mov %ebx,(%esp)
10786a: b8 ff 5f 01 30 mov $0x30015fff,%eax
10786f: 89 44 24 04 mov %eax,0x4(%esp)
107873: e8 08 3f 00 00 call 10b780 <_Thread_Clear_state>
}
107878: eb b8 jmp 107832 <_Thread_queue_Surrender+0x72>
10787a: 90 nop
10787b: 90 nop
10787c: 90 nop
10787d: 90 nop
10787e: 90 nop
10787f: 90 nop
001063d0 <_Timecounter_Bintime>:
{
1063d0: 55 push %ebp
1063d1: 89 e5 mov %esp,%ebp
1063d3: 57 push %edi
1063d4: 56 push %esi
1063d5: 53 push %ebx
1063d6: 83 ec 2c sub $0x2c,%esp
1063d9: 8b 7d 08 mov 0x8(%ebp),%edi
1063dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
th = timehands;
1063e0: 8b 1d 2c a3 12 00 mov 0x12a32c,%ebx
1063e6: 8b 73 60 mov 0x60(%ebx),%esi
*bt = th->th_bintime;
1063e9: 8b 43 28 mov 0x28(%ebx),%eax
tc = th->th_counter;
1063ec: 8b 13 mov (%ebx),%edx
bintime_addx(bt, th->th_scale * tc_delta(th));
1063ee: 8b 4b 10 mov 0x10(%ebx),%ecx
*bt = th->th_bintime;
1063f1: 89 07 mov %eax,(%edi)
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
1063f3: 89 55 e0 mov %edx,-0x20(%ebp)
*bt = th->th_bintime;
1063f6: 8b 43 2c mov 0x2c(%ebx),%eax
bintime_addx(bt, th->th_scale * tc_delta(th));
1063f9: 89 4d dc mov %ecx,-0x24(%ebp)
*bt = th->th_bintime;
1063fc: 89 47 04 mov %eax,0x4(%edi)
1063ff: 8b 43 30 mov 0x30(%ebx),%eax
106402: 89 47 08 mov %eax,0x8(%edi)
106405: 8b 43 34 mov 0x34(%ebx),%eax
106408: 89 47 0c mov %eax,0xc(%edi)
bintime_addx(bt, th->th_scale * tc_delta(th));
10640b: 8b 43 0c mov 0xc(%ebx),%eax
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
10640e: 89 14 24 mov %edx,(%esp)
bintime_addx(bt, th->th_scale * tc_delta(th));
106411: 89 45 e4 mov %eax,-0x1c(%ebp)
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
106414: ff 12 call *(%edx)
106416: 8b 53 14 mov 0x14(%ebx),%edx
106419: 29 d0 sub %edx,%eax
10641b: 8b 55 e0 mov -0x20(%ebp),%edx
10641e: 8b 4a 04 mov 0x4(%edx),%ecx
106421: 21 c8 and %ecx,%eax
bintime_addx(bt, th->th_scale * tc_delta(th));
106423: 8b 4d dc mov -0x24(%ebp),%ecx
106426: 0f af c8 imul %eax,%ecx
106429: f7 65 e4 mull -0x1c(%ebp)
10642c: 01 ca add %ecx,%edx
10642e: 31 c9 xor %ecx,%ecx
106430: 03 47 08 add 0x8(%edi),%eax
106433: 13 57 0c adc 0xc(%edi),%edx
106436: 72 22 jb 10645a <_Timecounter_Bintime+0x8a>
_bt->frac += _x;
106438: 89 47 08 mov %eax,0x8(%edi)
if (_u > _bt->frac)
10643b: 85 c9 test %ecx,%ecx
_bt->frac += _x;
10643d: 89 57 0c mov %edx,0xc(%edi)
if (_u > _bt->frac)
106440: 74 07 je 106449 <_Timecounter_Bintime+0x79>
_bt->sec++;
106442: 83 07 01 addl $0x1,(%edi)
106445: 83 57 04 00 adcl $0x0,0x4(%edi)
} while (gen == 0 || gen != th->th_generation);
106449: 85 f6 test %esi,%esi
10644b: 74 93 je 1063e0 <_Timecounter_Bintime+0x10> <== NEVER TAKEN
10644d: 39 73 60 cmp %esi,0x60(%ebx)
106450: 75 8e jne 1063e0 <_Timecounter_Bintime+0x10>
}
106452: 83 c4 2c add $0x2c,%esp
106455: 5b pop %ebx
106456: 5e pop %esi
106457: 5f pop %edi
106458: 5d pop %ebp
106459: c3 ret
10645a: b9 01 00 00 00 mov $0x1,%ecx
10645f: eb d7 jmp 106438 <_Timecounter_Bintime+0x68>
106461: 90 nop
106462: 90 nop
106463: 90 nop
106464: 90 nop
106465: 90 nop
106466: 90 nop
106467: 90 nop
106468: 90 nop
106469: 90 nop
10646a: 90 nop
10646b: 90 nop
10646c: 90 nop
10646d: 90 nop
10646e: 90 nop
10646f: 90 nop
001076c0 <_Timecounter_Binuptime>:
{
1076c0: 55 push %ebp
1076c1: 89 e5 mov %esp,%ebp
1076c3: 57 push %edi
1076c4: 56 push %esi
1076c5: 53 push %ebx
1076c6: 83 ec 2c sub $0x2c,%esp
1076c9: 8b 7d 08 mov 0x8(%ebp),%edi
1076cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
th = timehands;
1076d0: 8b 1d ac 53 12 00 mov 0x1253ac,%ebx
val = *obj;
1076d6: 8b 73 60 mov 0x60(%ebx),%esi
*bt = th->th_offset;
1076d9: 8b 43 18 mov 0x18(%ebx),%eax
tc = th->th_counter;
1076dc: 8b 13 mov (%ebx),%edx
bintime_addx(bt, th->th_scale * tc_delta(th));
1076de: 8b 4b 10 mov 0x10(%ebx),%ecx
*bt = th->th_offset;
1076e1: 89 07 mov %eax,(%edi)
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
1076e3: 89 55 e0 mov %edx,-0x20(%ebp)
*bt = th->th_offset;
1076e6: 8b 43 1c mov 0x1c(%ebx),%eax
bintime_addx(bt, th->th_scale * tc_delta(th));
1076e9: 89 4d dc mov %ecx,-0x24(%ebp)
*bt = th->th_offset;
1076ec: 89 47 04 mov %eax,0x4(%edi)
1076ef: 8b 43 20 mov 0x20(%ebx),%eax
1076f2: 89 47 08 mov %eax,0x8(%edi)
1076f5: 8b 43 24 mov 0x24(%ebx),%eax
1076f8: 89 47 0c mov %eax,0xc(%edi)
bintime_addx(bt, th->th_scale * tc_delta(th));
1076fb: 8b 43 0c mov 0xc(%ebx),%eax
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
1076fe: 89 14 24 mov %edx,(%esp)
bintime_addx(bt, th->th_scale * tc_delta(th));
107701: 89 45 e4 mov %eax,-0x1c(%ebp)
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
107704: ff 12 call *(%edx)
107706: 8b 53 14 mov 0x14(%ebx),%edx
107709: 29 d0 sub %edx,%eax
10770b: 8b 55 e0 mov -0x20(%ebp),%edx
10770e: 8b 4a 04 mov 0x4(%edx),%ecx
107711: 21 c8 and %ecx,%eax
bintime_addx(bt, th->th_scale * tc_delta(th));
107713: 8b 4d dc mov -0x24(%ebp),%ecx
107716: 0f af c8 imul %eax,%ecx
107719: f7 65 e4 mull -0x1c(%ebp)
10771c: 01 ca add %ecx,%edx
10771e: 31 c9 xor %ecx,%ecx
107720: 03 47 08 add 0x8(%edi),%eax
107723: 13 57 0c adc 0xc(%edi),%edx
107726: 72 22 jb 10774a <_Timecounter_Binuptime+0x8a>
_bt->frac += _x;
107728: 89 47 08 mov %eax,0x8(%edi)
if (_u > _bt->frac)
10772b: 85 c9 test %ecx,%ecx
_bt->frac += _x;
10772d: 89 57 0c mov %edx,0xc(%edi)
if (_u > _bt->frac)
107730: 74 07 je 107739 <_Timecounter_Binuptime+0x79>
_bt->sec++;
107732: 83 07 01 addl $0x1,(%edi)
107735: 83 57 04 00 adcl $0x0,0x4(%edi)
} while (gen == 0 || gen != th->th_generation);
107739: 85 f6 test %esi,%esi
10773b: 74 93 je 1076d0 <_Timecounter_Binuptime+0x10> <== NEVER TAKEN
10773d: 39 73 60 cmp %esi,0x60(%ebx)
107740: 75 8e jne 1076d0 <_Timecounter_Binuptime+0x10>
}
107742: 83 c4 2c add $0x2c,%esp
107745: 5b pop %ebx
107746: 5e pop %esi
107747: 5f pop %edi
107748: 5d pop %ebp
107749: c3 ret
10774a: b9 01 00 00 00 mov $0x1,%ecx
10774f: eb d7 jmp 107728 <_Timecounter_Binuptime+0x68>
107751: 90 nop
107752: 90 nop
107753: 90 nop
107754: 90 nop
107755: 90 nop
107756: 90 nop
107757: 90 nop
107758: 90 nop
107759: 90 nop
10775a: 90 nop
10775b: 90 nop
10775c: 90 nop
10775d: 90 nop
10775e: 90 nop
10775f: 90 nop
001064f0 <_Timecounter_Getbintime>:
{
1064f0: 55 push %ebp
1064f1: 89 e5 mov %esp,%ebp
1064f3: 53 push %ebx
1064f4: 8b 55 08 mov 0x8(%ebp),%edx
1064f7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1064fe: 66 90 xchg %ax,%ax
th = timehands;
106500: a1 2c a3 12 00 mov 0x12a32c,%eax
106505: 8b 48 60 mov 0x60(%eax),%ecx
*bt = th->th_bintime;
106508: 8b 58 28 mov 0x28(%eax),%ebx
10650b: 89 1a mov %ebx,(%edx)
10650d: 8b 58 2c mov 0x2c(%eax),%ebx
106510: 89 5a 04 mov %ebx,0x4(%edx)
106513: 8b 58 30 mov 0x30(%eax),%ebx
106516: 89 5a 08 mov %ebx,0x8(%edx)
106519: 8b 58 34 mov 0x34(%eax),%ebx
10651c: 89 5a 0c mov %ebx,0xc(%edx)
} while (gen == 0 || gen != th->th_generation);
10651f: 85 c9 test %ecx,%ecx
106521: 74 dd je 106500 <_Timecounter_Getbintime+0x10> <== NEVER TAKEN
106523: 39 48 60 cmp %ecx,0x60(%eax)
106526: 75 d8 jne 106500 <_Timecounter_Getbintime+0x10> <== NEVER TAKEN
}
106528: 5b pop %ebx
106529: 5d pop %ebp
10652a: c3 ret
10652b: 90 nop
10652c: 90 nop
10652d: 90 nop
10652e: 90 nop
10652f: 90 nop
00102020 <_Timecounter_Getbinuptime>:
{
102020: 55 push %ebp
102021: 89 e5 mov %esp,%ebp
102023: 53 push %ebx
102024: 8b 55 08 mov 0x8(%ebp),%edx
102027: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10202e: 66 90 xchg %ax,%ax
th = timehands;
102030: a1 8c e8 10 00 mov 0x10e88c,%eax
102035: 8b 48 60 mov 0x60(%eax),%ecx
*bt = th->th_offset;
102038: 8b 58 18 mov 0x18(%eax),%ebx
10203b: 89 1a mov %ebx,(%edx)
10203d: 8b 58 1c mov 0x1c(%eax),%ebx
102040: 89 5a 04 mov %ebx,0x4(%edx)
102043: 8b 58 20 mov 0x20(%eax),%ebx
102046: 89 5a 08 mov %ebx,0x8(%edx)
102049: 8b 58 24 mov 0x24(%eax),%ebx
10204c: 89 5a 0c mov %ebx,0xc(%edx)
} while (gen == 0 || gen != th->th_generation);
10204f: 85 c9 test %ecx,%ecx
102051: 74 dd je 102030 <_Timecounter_Getbinuptime+0x10> <== NEVER TAKEN
102053: 39 48 60 cmp %ecx,0x60(%eax)
102056: 75 d8 jne 102030 <_Timecounter_Getbinuptime+0x10> <== NEVER TAKEN
}
102058: 5b pop %ebx
102059: 5d pop %ebp
10205a: c3 ret
10205b: 90 nop
10205c: 90 nop
10205d: 90 nop
10205e: 90 nop
10205f: 90 nop
00102160 <_Timecounter_Getmicrotime>:
{
102160: 55 push %ebp
102161: 89 e5 mov %esp,%ebp
102163: 53 push %ebx
102164: 8b 55 08 mov 0x8(%ebp),%edx
102167: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10216e: 66 90 xchg %ax,%ax
th = timehands;
102170: a1 8c e8 10 00 mov 0x10e88c,%eax
102175: 8b 48 60 mov 0x60(%eax),%ecx
*tvp = th->th_microtime;
102178: 8b 58 38 mov 0x38(%eax),%ebx
10217b: 89 1a mov %ebx,(%edx)
10217d: 8b 58 3c mov 0x3c(%eax),%ebx
102180: 89 5a 04 mov %ebx,0x4(%edx)
102183: 8b 58 40 mov 0x40(%eax),%ebx
102186: 89 5a 08 mov %ebx,0x8(%edx)
} while (gen == 0 || gen != th->th_generation);
102189: 85 c9 test %ecx,%ecx
10218b: 74 e3 je 102170 <_Timecounter_Getmicrotime+0x10> <== NEVER TAKEN
10218d: 39 48 60 cmp %ecx,0x60(%eax)
102190: 75 de jne 102170 <_Timecounter_Getmicrotime+0x10> <== NEVER TAKEN
}
102192: 5b pop %ebx
102193: 5d pop %ebp
102194: c3 ret
102195: 90 nop
102196: 90 nop
102197: 90 nop
102198: 90 nop
102199: 90 nop
10219a: 90 nop
10219b: 90 nop
10219c: 90 nop
10219d: 90 nop
10219e: 90 nop
10219f: 90 nop
001020a0 <_Timecounter_Getmicrouptime>:
{
1020a0: 55 push %ebp
1020a1: 89 e5 mov %esp,%ebp
1020a3: 57 push %edi
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
1020a4: bf 40 42 0f 00 mov $0xf4240,%edi
1020a9: 56 push %esi
1020aa: 8b 75 08 mov 0x8(%ebp),%esi
1020ad: 53 push %ebx
1020ae: 66 90 xchg %ax,%ax
th = timehands;
1020b0: 8b 0d 8c e8 10 00 mov 0x10e88c,%ecx
1020b6: 8b 59 60 mov 0x60(%ecx),%ebx
_tv->tv_sec = _bt->sec;
1020b9: 8b 41 18 mov 0x18(%ecx),%eax
1020bc: 8b 51 1c mov 0x1c(%ecx),%edx
1020bf: 89 06 mov %eax,(%esi)
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
1020c1: 89 f8 mov %edi,%eax
_tv->tv_sec = _bt->sec;
1020c3: 89 56 04 mov %edx,0x4(%esi)
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
1020c6: f7 61 24 mull 0x24(%ecx)
1020c9: 89 56 08 mov %edx,0x8(%esi)
} while (gen == 0 || gen != th->th_generation);
1020cc: 85 db test %ebx,%ebx
1020ce: 74 e0 je 1020b0 <_Timecounter_Getmicrouptime+0x10> <== NEVER TAKEN
1020d0: 39 59 60 cmp %ebx,0x60(%ecx)
1020d3: 75 db jne 1020b0 <_Timecounter_Getmicrouptime+0x10> <== NEVER TAKEN
}
1020d5: 5b pop %ebx
1020d6: 5e pop %esi
1020d7: 5f pop %edi
1020d8: 5d pop %ebp
1020d9: c3 ret
1020da: 90 nop
1020db: 90 nop
1020dc: 90 nop
1020dd: 90 nop
1020de: 90 nop
1020df: 90 nop
00106530 <_Timecounter_Getnanotime>:
{
106530: 55 push %ebp
106531: 89 e5 mov %esp,%ebp
106533: 53 push %ebx
106534: 8b 55 08 mov 0x8(%ebp),%edx
106537: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10653e: 66 90 xchg %ax,%ax
th = timehands;
106540: a1 2c a3 12 00 mov 0x12a32c,%eax
106545: 8b 48 60 mov 0x60(%eax),%ecx
*tsp = th->th_nanotime;
106548: 8b 58 44 mov 0x44(%eax),%ebx
10654b: 89 1a mov %ebx,(%edx)
10654d: 8b 58 48 mov 0x48(%eax),%ebx
106550: 89 5a 04 mov %ebx,0x4(%edx)
106553: 8b 58 4c mov 0x4c(%eax),%ebx
106556: 89 5a 08 mov %ebx,0x8(%edx)
} while (gen == 0 || gen != th->th_generation);
106559: 85 c9 test %ecx,%ecx
10655b: 74 e3 je 106540 <_Timecounter_Getnanotime+0x10> <== NEVER TAKEN
10655d: 39 48 60 cmp %ecx,0x60(%eax)
106560: 75 de jne 106540 <_Timecounter_Getnanotime+0x10> <== NEVER TAKEN
}
106562: 5b pop %ebx
106563: 5d pop %ebp
106564: c3 ret
106565: 90 nop
106566: 90 nop
106567: 90 nop
106568: 90 nop
106569: 90 nop
10656a: 90 nop
10656b: 90 nop
10656c: 90 nop
10656d: 90 nop
10656e: 90 nop
10656f: 90 nop
001064b0 <_Timecounter_Getnanouptime>:
{
1064b0: 55 push %ebp
1064b1: 89 e5 mov %esp,%ebp
1064b3: 57 push %edi
_ts->tv_nsec = ((uint64_t)1000000000 *
1064b4: bf 00 ca 9a 3b mov $0x3b9aca00,%edi
1064b9: 56 push %esi
1064ba: 8b 75 08 mov 0x8(%ebp),%esi
1064bd: 53 push %ebx
1064be: 66 90 xchg %ax,%ax
th = timehands;
1064c0: 8b 0d 2c a3 12 00 mov 0x12a32c,%ecx
1064c6: 8b 59 60 mov 0x60(%ecx),%ebx
_ts->tv_sec = _bt->sec;
1064c9: 8b 41 18 mov 0x18(%ecx),%eax
1064cc: 8b 51 1c mov 0x1c(%ecx),%edx
1064cf: 89 06 mov %eax,(%esi)
_ts->tv_nsec = ((uint64_t)1000000000 *
1064d1: 89 f8 mov %edi,%eax
_ts->tv_sec = _bt->sec;
1064d3: 89 56 04 mov %edx,0x4(%esi)
_ts->tv_nsec = ((uint64_t)1000000000 *
1064d6: f7 61 24 mull 0x24(%ecx)
1064d9: 89 56 08 mov %edx,0x8(%esi)
} while (gen == 0 || gen != th->th_generation);
1064dc: 85 db test %ebx,%ebx
1064de: 74 e0 je 1064c0 <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN
1064e0: 39 59 60 cmp %ebx,0x60(%ecx)
1064e3: 75 db jne 1064c0 <_Timecounter_Getnanouptime+0x10> <== NEVER TAKEN
}
1064e5: 5b pop %ebx
1064e6: 5e pop %esi
1064e7: 5f pop %edi
1064e8: 5d pop %ebp
1064e9: c3 ret
1064ea: 90 nop
1064eb: 90 nop
1064ec: 90 nop
1064ed: 90 nop
1064ee: 90 nop
1064ef: 90 nop
00106570 <_Timecounter_Install>:
{
106570: 55 push %ebp
106571: 89 e5 mov %esp,%ebp
106573: 83 ec 18 sub $0x18,%esp
106576: 89 5d fc mov %ebx,-0x4(%ebp)
if (tc->tc_quality < timecounter->tc_quality)
106579: 8b 15 28 a3 12 00 mov 0x12a328,%edx
{
10657f: 8b 45 08 mov 0x8(%ebp),%eax
if (tc->tc_quality < timecounter->tc_quality)
106582: 8b 4a 14 mov 0x14(%edx),%ecx
106585: 39 48 14 cmp %ecx,0x14(%eax)
106588: 7c 25 jl 1065af <_Timecounter_Install+0x3f> <== NEVER TAKEN
if (tc->tc_quality == timecounter->tc_quality &&
10658a: 75 0e jne 10659a <_Timecounter_Install+0x2a>
10658c: 8b 5a 08 mov 0x8(%edx),%ebx
10658f: 39 58 08 cmp %ebx,0x8(%eax)
106592: 8b 48 0c mov 0xc(%eax),%ecx
106595: 1b 4a 0c sbb 0xc(%edx),%ecx
106598: 72 15 jb 1065af <_Timecounter_Install+0x3f>
timecounter = tc;
10659a: a3 28 a3 12 00 mov %eax,0x12a328
_Timecounter_Acquire(&lock_context);
10659f: 9c pushf
1065a0: fa cli
1065a1: 58 pop %eax
1065a2: 89 45 f4 mov %eax,-0xc(%ebp)
_Timecounter_Windup(new_boottimebin, &lock_context);
1065a5: 8d 55 f4 lea -0xc(%ebp),%edx
1065a8: 31 c0 xor %eax,%eax
1065aa: e8 d1 fa ff ff call 106080 <_Timecounter_Windup>
}
1065af: 8b 5d fc mov -0x4(%ebp),%ebx
1065b2: 89 ec mov %ebp,%esp
1065b4: 5d pop %ebp
1065b5: c3 ret
1065b6: 90 nop
1065b7: 90 nop
1065b8: 90 nop
1065b9: 90 nop
1065ba: 90 nop
1065bb: 90 nop
1065bc: 90 nop
1065bd: 90 nop
1065be: 90 nop
1065bf: 90 nop
00106350 <_Timecounter_Sbinuptime>:
{
106350: 55 push %ebp
106351: 89 e5 mov %esp,%ebp
106353: 57 push %edi
106354: 56 push %esi
106355: 53 push %ebx
106356: 83 ec 2c sub $0x2c,%esp
106359: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
th = timehands;
106360: 8b 1d 2c a3 12 00 mov 0x12a32c,%ebx
val = *obj;
106366: 8b 7b 60 mov 0x60(%ebx),%edi
sbt = bttosbt(th->th_offset);
106369: 8b 43 18 mov 0x18(%ebx),%eax
tc = th->th_counter;
10636c: 8b 33 mov (%ebx),%esi
10636e: 89 45 e4 mov %eax,-0x1c(%ebp)
106371: 8b 43 24 mov 0x24(%ebx),%eax
106374: 89 45 d8 mov %eax,-0x28(%ebp)
sbt += (th->th_scale * tc_delta(th)) >> 32;
106377: 8b 43 0c mov 0xc(%ebx),%eax
10637a: 89 45 e0 mov %eax,-0x20(%ebp)
10637d: 8b 43 10 mov 0x10(%ebx),%eax
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
106380: 89 34 24 mov %esi,(%esp)
sbt += (th->th_scale * tc_delta(th)) >> 32;
106383: 89 45 dc mov %eax,-0x24(%ebp)
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
106386: ff 16 call *(%esi)
106388: 8b 4b 14 mov 0x14(%ebx),%ecx
tc->tc_counter_mask);
10638b: 8b 76 04 mov 0x4(%esi),%esi
} while (gen == 0 || gen != th->th_generation);
10638e: 85 ff test %edi,%edi
106390: 74 ce je 106360 <_Timecounter_Sbinuptime+0x10> <== NEVER TAKEN
106392: 39 7b 60 cmp %edi,0x60(%ebx)
106395: 75 c9 jne 106360 <_Timecounter_Sbinuptime+0x10>
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
106397: 29 c8 sub %ecx,%eax
sbt += (th->th_scale * tc_delta(th)) >> 32;
106399: 8b 7d dc mov -0x24(%ebp),%edi
return (((sbintime_t)_bt.sec << 32) + (_bt.frac >> 32));
10639c: 31 db xor %ebx,%ebx
return ((tc->tc_get_timecount(tc) - th->th_offset_count) &
10639e: 21 c6 and %eax,%esi
sbt += (th->th_scale * tc_delta(th)) >> 32;
1063a0: 8b 45 e0 mov -0x20(%ebp),%eax
1063a3: 8b 4d d8 mov -0x28(%ebp),%ecx
1063a6: 0f af fe imul %esi,%edi
1063a9: f7 e6 mul %esi
1063ab: 01 fa add %edi,%edx
1063ad: 89 d0 mov %edx,%eax
1063af: 31 d2 xor %edx,%edx
1063b1: 89 d7 mov %edx,%edi
1063b3: 8b 55 e4 mov -0x1c(%ebp),%edx
1063b6: 89 c6 mov %eax,%esi
1063b8: 31 c0 xor %eax,%eax
1063ba: 01 c8 add %ecx,%eax
1063bc: 11 da adc %ebx,%edx
1063be: 01 f0 add %esi,%eax
1063c0: 11 fa adc %edi,%edx
}
1063c2: 83 c4 2c add $0x2c,%esp
1063c5: 5b pop %ebx
1063c6: 5e pop %esi
1063c7: 5f pop %edi
1063c8: 5d pop %ebp
1063c9: c3 ret
1063ca: 90 nop
1063cb: 90 nop
1063cc: 90 nop
1063cd: 90 nop
1063ce: 90 nop
1063cf: 90 nop
001074f0 <_Timecounter_Tick_simple>:
void
_Timecounter_Tick_simple(uint32_t delta, uint32_t offset,
ISR_lock_Context *lock_context)
{
1074f0: 55 push %ebp
1074f1: 89 e5 mov %esp,%ebp
1074f3: 57 push %edi
1074f4: 56 push %esi
1074f5: 53 push %ebx
1074f6: 83 ec 2c sub $0x2c,%esp
struct bintime bt;
struct timehands *th;
uint32_t ogen;
th = timehands;
1074f9: 8b 0d 8c 73 12 00 mov 0x12738c,%ecx
{
1074ff: 8b 55 10 mov 0x10(%ebp),%edx
107502: 8b 45 08 mov 0x8(%ebp),%eax
ogen = th->th_generation;
th->th_offset_count = offset;
bintime_addx(&th->th_offset, th->th_scale * delta);
107505: 8b 59 10 mov 0x10(%ecx),%ebx
{
107508: 89 55 d4 mov %edx,-0x2c(%ebp)
ogen = th->th_generation;
10750b: 8b 51 60 mov 0x60(%ecx),%edx
bintime_addx(&th->th_offset, th->th_scale * delta);
10750e: 0f af d8 imul %eax,%ebx
ogen = th->th_generation;
107511: 89 55 d8 mov %edx,-0x28(%ebp)
th->th_offset_count = offset;
107514: 8b 55 0c mov 0xc(%ebp),%edx
107517: 89 51 14 mov %edx,0x14(%ecx)
bintime_addx(&th->th_offset, th->th_scale * delta);
10751a: f7 61 0c mull 0xc(%ecx)
10751d: 01 da add %ebx,%edx
10751f: 03 41 20 add 0x20(%ecx),%eax
107522: 13 51 24 adc 0x24(%ecx),%edx
107525: 0f 82 dc 00 00 00 jb 107607 <_Timecounter_Tick_simple+0x117> <== NEVER TAKEN
10752b: 31 db xor %ebx,%ebx
_bt->frac += _x;
10752d: 89 41 20 mov %eax,0x20(%ecx)
if (_u > _bt->frac)
107530: 85 db test %ebx,%ebx
_bt->sec++;
107532: 8b 71 1c mov 0x1c(%ecx),%esi
_bt->frac += _x;
107535: 89 51 24 mov %edx,0x24(%ecx)
_bt->sec++;
107538: 8b 59 18 mov 0x18(%ecx),%ebx
if (_u > _bt->frac)
10753b: 0f 85 af 00 00 00 jne 1075f0 <_Timecounter_Tick_simple+0x100> <== NEVER TAKEN
bt = th->th_offset;
107541: 89 5d e0 mov %ebx,-0x20(%ebp)
107544: 89 75 e4 mov %esi,-0x1c(%ebp)
_bt->frac += _bt2->frac;
107547: 03 41 58 add 0x58(%ecx),%eax
10754a: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
107551: 13 51 5c adc 0x5c(%ecx),%edx
107554: 89 c6 mov %eax,%esi
107556: 89 d7 mov %edx,%edi
107558: 0f 82 b3 00 00 00 jb 107611 <_Timecounter_Tick_simple+0x121>
if (_u > _bt->frac)
10755e: 8b 55 dc mov -0x24(%ebp),%edx
_bt->frac += _bt2->frac;
107561: 89 f0 mov %esi,%eax
107563: 89 fb mov %edi,%ebx
107565: 8b 75 e0 mov -0x20(%ebp),%esi
107568: 8b 7d e4 mov -0x1c(%ebp),%edi
if (_u > _bt->frac)
10756b: 85 d2 test %edx,%edx
10756d: 74 06 je 107575 <_Timecounter_Tick_simple+0x85>
_bt->sec++;
10756f: 83 c6 01 add $0x1,%esi
107572: 83 d7 00 adc $0x0,%edi
_bt->sec += _bt2->sec;
107575: 03 71 50 add 0x50(%ecx),%esi
bintime_add(&bt, &th->th_boottime);
/* Update the UTC timestamps used by the get*() functions. */
th->th_bintime = bt;
107578: 89 41 30 mov %eax,0x30(%ecx)
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
10757b: b8 40 42 0f 00 mov $0xf4240,%eax
_bt->sec += _bt2->sec;
107580: 13 79 54 adc 0x54(%ecx),%edi
107583: 89 71 28 mov %esi,0x28(%ecx)
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
107586: f7 e3 mul %ebx
_ts->tv_nsec = ((uint64_t)1000000000 *
107588: b8 00 ca 9a 3b mov $0x3b9aca00,%eax
10758d: 89 59 34 mov %ebx,0x34(%ecx)
107590: 89 79 2c mov %edi,0x2c(%ecx)
_tv->tv_sec = _bt->sec;
107593: 89 71 38 mov %esi,0x38(%ecx)
_tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32;
107596: 89 51 40 mov %edx,0x40(%ecx)
_ts->tv_nsec = ((uint64_t)1000000000 *
107599: f7 e3 mul %ebx
* Now that the struct timehands is again consistent, set the new
* generation number, making sure to not make it zero.
*/
if (++ogen == 0)
ogen = 1;
th->th_generation = ogen;
10759b: 8b 45 d8 mov -0x28(%ebp),%eax
_tv->tv_sec = _bt->sec;
10759e: 89 79 3c mov %edi,0x3c(%ecx)
_ts->tv_sec = _bt->sec;
1075a1: 89 71 44 mov %esi,0x44(%ecx)
1075a4: 89 79 48 mov %edi,0x48(%ecx)
_ts->tv_nsec = ((uint64_t)1000000000 *
1075a7: 89 51 4c mov %edx,0x4c(%ecx)
1075aa: 40 inc %eax
1075ab: 75 05 jne 1075b2 <_Timecounter_Tick_simple+0xc2> <== ALWAYS TAKEN
1075ad: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
1075b2: 89 41 60 mov %eax,0x60(%ecx)
/* Go live with the new struct timehands. */
time_second = th->th_microtime.tv_sec;
time_uptime = th->th_offset.sec;
1075b5: 8b 45 e0 mov -0x20(%ebp),%eax
time_second = th->th_microtime.tv_sec;
1075b8: 89 35 80 73 12 00 mov %esi,0x127380
1075be: 89 3d 84 73 12 00 mov %edi,0x127384
time_uptime = th->th_offset.sec;
1075c4: a3 78 73 12 00 mov %eax,0x127378
_Timecounter_Release(lock_context);
1075c9: 8b 45 d4 mov -0x2c(%ebp),%eax
1075cc: ff 30 push (%eax)
1075ce: 9d popf
_Watchdog_Tick(_Per_CPU_Get_snapshot());
1075cf: c7 45 08 60 af 12 00 movl $0x12af60,0x8(%ebp)
}
1075d6: 83 c4 2c add $0x2c,%esp
1075d9: 5b pop %ebx
1075da: 5e pop %esi
1075db: 5f pop %edi
1075dc: 5d pop %ebp
_Watchdog_Tick(_Per_CPU_Get_snapshot());
1075dd: e9 2e 2c 00 00 jmp 10a210 <_Watchdog_Tick>
1075e2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1075e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
_bt->sec++;
1075f0: 83 c3 01 add $0x1,%ebx <== NOT EXECUTED
1075f3: 89 5d e0 mov %ebx,-0x20(%ebp) <== NOT EXECUTED
1075f6: 83 d6 00 adc $0x0,%esi <== NOT EXECUTED
1075f9: 89 75 e4 mov %esi,-0x1c(%ebp) <== NOT EXECUTED
1075fc: 89 59 18 mov %ebx,0x18(%ecx) <== NOT EXECUTED
1075ff: 89 71 1c mov %esi,0x1c(%ecx) <== NOT EXECUTED
}
107602: e9 40 ff ff ff jmp 107547 <_Timecounter_Tick_simple+0x57> <== NOT EXECUTED
107607: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
10760c: e9 1c ff ff ff jmp 10752d <_Timecounter_Tick_simple+0x3d> <== NOT EXECUTED
107611: c7 45 dc 01 00 00 00 movl $0x1,-0x24(%ebp)
107618: e9 41 ff ff ff jmp 10755e <_Timecounter_Tick_simple+0x6e>
10761d: 90 nop
10761e: 90 nop
10761f: 90 nop
00106350 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
106350: 55 push %ebp
106351: 89 e5 mov %esp,%ebp
106353: 56 push %esi
106354: 8b 75 0c mov 0xc(%ebp),%esi
106357: 53 push %ebx
106358: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t seconds = add->tv_sec;
10635b: 8b 06 mov (%esi),%eax
10635d: 8b 56 04 mov 0x4(%esi),%edx
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
106360: 8b 76 08 mov 0x8(%esi),%esi
uint32_t seconds = add->tv_sec;
106363: 89 c1 mov %eax,%ecx
time->tv_sec += add->tv_sec;
106365: 03 03 add (%ebx),%eax
106367: 13 53 04 adc 0x4(%ebx),%edx
time->tv_nsec += add->tv_nsec;
10636a: 03 73 08 add 0x8(%ebx),%esi
time->tv_sec += add->tv_sec;
10636d: 89 03 mov %eax,(%ebx)
10636f: 89 53 04 mov %edx,0x4(%ebx)
time->tv_nsec += add->tv_nsec;
106372: 89 73 08 mov %esi,0x8(%ebx)
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
106375: 81 fe ff c9 9a 3b cmp $0x3b9ac9ff,%esi
10637b: 76 20 jbe 10639d <_Timespec_Add_to+0x4d>
10637d: 8d 76 00 lea 0x0(%esi),%esi
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
106380: 81 ee 00 ca 9a 3b sub $0x3b9aca00,%esi
time->tv_sec++;
106386: 83 c0 01 add $0x1,%eax
106389: 83 d2 00 adc $0x0,%edx
seconds++;
10638c: 41 inc %ecx
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10638d: 81 fe ff c9 9a 3b cmp $0x3b9ac9ff,%esi
106393: 77 eb ja 106380 <_Timespec_Add_to+0x30> <== NEVER TAKEN
106395: 89 73 08 mov %esi,0x8(%ebx)
106398: 89 03 mov %eax,(%ebx)
10639a: 89 53 04 mov %edx,0x4(%ebx)
}
return seconds;
}
10639d: 5b pop %ebx
10639e: 89 c8 mov %ecx,%eax
1063a0: 5e pop %esi
1063a1: 5d pop %ebp
1063a2: c3 ret
1063a3: 90 nop
1063a4: 90 nop
1063a5: 90 nop
1063a6: 90 nop
1063a7: 90 nop
1063a8: 90 nop
1063a9: 90 nop
1063aa: 90 nop
1063ab: 90 nop
1063ac: 90 nop
1063ad: 90 nop
1063ae: 90 nop
1063af: 90 nop
001089c0 <_User_extensions_Handler_initialization>:
size_t n;
size_t i;
initial_table = _User_extensions_Initial_extensions;
initial_switch_controls = _User_extensions_Initial_switch_controls;
n = _User_extensions_Initial_count;
1089c0: a1 10 49 12 00 mov 0x124910,%eax
for ( i = 0 ; i < n ; ++i ) {
1089c5: 85 c0 test %eax,%eax
1089c7: 74 67 je 108a30 <_User_extensions_Handler_initialization+0x70><== NEVER TAKEN
{
1089c9: 55 push %ebp
1089ca: 8b 0d f0 a3 12 00 mov 0x12a3f0,%ecx
1089d0: 89 e5 mov %esp,%ebp
1089d2: 56 push %esi
1089d3: 8d 34 40 lea (%eax,%eax,2),%esi
for ( i = 0 ; i < n ; ++i ) {
1089d6: 31 c0 xor %eax,%eax
{
1089d8: 53 push %ebx
for ( i = 0 ; i < n ; ++i ) {
1089d9: 31 db xor %ebx,%ebx
1089db: c1 e6 02 shl $0x2,%esi
1089de: 66 90 xchg %ax,%ax
User_extensions_thread_switch_extension callout;
callout = initial_table[ i ].thread_switch;
1089e0: 8b 94 40 30 49 12 00 mov 0x124930(%eax,%eax,2),%edx
if ( callout != NULL ) {
1089e7: 85 d2 test %edx,%edx
1089e9: 74 23 je 108a0e <_User_extensions_Handler_initialization+0x4e>
User_extensions_Switch_control *c;
c = &initial_switch_controls[ i ];
c->thread_switch = callout;
1089eb: 89 90 c8 da 12 00 mov %edx,0x12dac8(%eax)
_Chain_Initialize_node( &c->Node );
1089f1: 8d 90 c0 da 12 00 lea 0x12dac0(%eax),%edx
the_node->next = tail;
1089f7: bb ec a3 12 00 mov $0x12a3ec,%ebx
1089fc: 89 98 c0 da 12 00 mov %ebx,0x12dac0(%eax)
}
108a02: b3 01 mov $0x1,%bl
old_last->next = the_node;
108a04: 89 11 mov %edx,(%ecx)
the_node->previous = old_last;
108a06: 89 88 c4 da 12 00 mov %ecx,0x12dac4(%eax)
tail->previous = the_node;
108a0c: 89 d1 mov %edx,%ecx
for ( i = 0 ; i < n ; ++i ) {
108a0e: 83 c0 0c add $0xc,%eax
108a11: 39 c6 cmp %eax,%esi
108a13: 75 cb jne 1089e0 <_User_extensions_Handler_initialization+0x20>
108a15: 84 db test %bl,%bl
108a17: 74 06 je 108a1f <_User_extensions_Handler_initialization+0x5f>
108a19: 89 0d f0 a3 12 00 mov %ecx,0x12a3f0
_Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node );
}
}
}
108a1f: 5b pop %ebx
108a20: 5e pop %esi
108a21: 5d pop %ebp
108a22: c3 ret
108a23: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108a2a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
108a30: c3 ret <== NOT EXECUTED
108a31: 90 nop
108a32: 90 nop
108a33: 90 nop
108a34: 90 nop
108a35: 90 nop
108a36: 90 nop
108a37: 90 nop
108a38: 90 nop
108a39: 90 nop
108a3a: 90 nop
108a3b: 90 nop
108a3c: 90 nop
108a3d: 90 nop
108a3e: 90 nop
108a3f: 90 nop
00108b80 <_User_extensions_Iterate>:
void _User_extensions_Iterate(
void *arg,
User_extensions_Visitor visitor,
Chain_Iterator_direction direction
)
{
108b80: 55 push %ebp
108b81: 89 e5 mov %esp,%ebp
108b83: 57 push %edi
108b84: 56 push %esi
108b85: 53 push %ebx
108b86: 83 ec 4c sub $0x4c,%esp
ISR_lock_Context lock_context;
executing = _Thread_Get_executing();
initial_begin = _User_extensions_Initial_extensions;
initial_end = initial_begin + _User_extensions_Initial_count;
108b89: a1 10 49 12 00 mov 0x124910,%eax
{
108b8e: 8b 75 08 mov 0x8(%ebp),%esi
++initial_current;
}
end = _Chain_Immutable_tail( &_User_extensions_List.Active );
} else {
end = _Chain_Immutable_head( &_User_extensions_List.Active );
108b91: c7 45 c0 00 a4 12 00 movl $0x12a400,-0x40(%ebp)
{
108b98: 8b 7d 0c mov 0xc(%ebp),%edi
108b9b: 8b 1d f8 03 13 00 mov 0x1303f8,%ebx
initial_end = initial_begin + _User_extensions_Initial_count;
108ba1: 8d 04 c0 lea (%eax,%eax,8),%eax
108ba4: 8d 14 85 20 49 12 00 lea 0x124920(,%eax,4),%edx
if ( direction == CHAIN_ITERATOR_FORWARD ) {
108bab: 8b 45 10 mov 0x10(%ebp),%eax
initial_end = initial_begin + _User_extensions_Initial_count;
108bae: 89 55 bc mov %edx,-0x44(%ebp)
if ( direction == CHAIN_ITERATOR_FORWARD ) {
108bb1: 85 c0 test %eax,%eax
108bb3: 75 3d jne 108bf2 <_User_extensions_Iterate+0x72>
initial_current = initial_begin;
108bb5: b8 20 49 12 00 mov $0x124920,%eax
while ( initial_current != initial_end ) {
108bba: 39 c2 cmp %eax,%edx
108bbc: 74 2d je 108beb <_User_extensions_Iterate+0x6b> <== NEVER TAKEN
108bbe: 89 5d c4 mov %ebx,-0x3c(%ebp)
108bc1: 89 c3 mov %eax,%ebx
108bc3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108bca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
(*visitor)( executing, arg, initial_current );
108bd0: 89 5c 24 08 mov %ebx,0x8(%esp)
108bd4: 8b 45 c4 mov -0x3c(%ebp),%eax
++initial_current;
108bd7: 83 c3 24 add $0x24,%ebx
(*visitor)( executing, arg, initial_current );
108bda: 89 74 24 04 mov %esi,0x4(%esp)
108bde: 89 04 24 mov %eax,(%esp)
108be1: ff d7 call *%edi
while ( initial_current != initial_end ) {
108be3: 39 5d bc cmp %ebx,-0x44(%ebp)
108be6: 75 e8 jne 108bd0 <_User_extensions_Iterate+0x50>
108be8: 8b 5d c4 mov -0x3c(%ebp),%ebx
end = _Chain_Immutable_tail( &_User_extensions_List.Active );
108beb: c7 45 c0 04 a4 12 00 movl $0x12a404,-0x40(%ebp)
_ISR_lock_ISR_disable_and_acquire(
108bf2: 9c pushf
108bf3: fa cli
108bf4: 58 pop %eax
108bf5: 89 45 c4 mov %eax,-0x3c(%ebp)
old_last = tail->previous;
108bf8: 8b 15 14 a4 12 00 mov 0x12a414,%edx
tail->previous = the_node;
108bfe: 8d 45 d4 lea -0x2c(%ebp),%eax
the_node->next = tail;
108c01: c7 45 d4 10 a4 12 00 movl $0x12a410,-0x2c(%ebp)
&the_iterator->Registry_node
);
the_iterator->direction = direction;
if ( direction == CHAIN_ITERATOR_FORWARD ) {
108c08: 8b 4d 10 mov 0x10(%ebp),%ecx
tail->previous = the_node;
108c0b: a3 14 a4 12 00 mov %eax,0x12a414
old_last->next = the_node;
108c10: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
108c12: 89 55 d8 mov %edx,-0x28(%ebp)
the_iterator->direction = direction;
108c15: 8b 55 10 mov 0x10(%ebp),%edx
if ( direction == CHAIN_ITERATOR_FORWARD ) {
108c18: 85 c9 test %ecx,%ecx
the_iterator->direction = direction;
108c1a: 89 55 dc mov %edx,-0x24(%ebp)
the_iterator->position = _Chain_Head( the_chain );
} else {
the_iterator->position = _Chain_Tail( the_chain );
108c1d: ba 04 a4 12 00 mov $0x12a404,%edx
if ( direction == CHAIN_ITERATOR_FORWARD ) {
108c22: 75 05 jne 108c29 <_User_extensions_Iterate+0xa9>
the_iterator->position = _Chain_Head( the_chain );
108c24: ba 00 a4 12 00 mov $0x12a400,%edx
108c29: 89 55 e0 mov %edx,-0x20(%ebp)
&_User_extensions_List.Iterators,
&iter.Iterator,
direction
);
if ( executing != NULL ) {
108c2c: 85 db test %ebx,%ebx
108c2e: 74 0f je 108c3f <_User_extensions_Iterate+0xbf>
iter.previous = executing->last_user_extensions_iterator;
108c30: 8b 8b 3c 01 00 00 mov 0x13c(%ebx),%ecx
executing->last_user_extensions_iterator = &iter;
108c36: 89 83 3c 01 00 00 mov %eax,0x13c(%ebx)
iter.previous = executing->last_user_extensions_iterator;
108c3c: 89 4d e4 mov %ecx,-0x1c(%ebp)
108c3f: 8b 4d 10 mov 0x10(%ebp),%ecx
108c42: eb 2f jmp 108c73 <_User_extensions_Iterate+0xf3>
108c44: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108c4b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
108c4f: 90 nop
RTEMS_INLINE_ROUTINE void _Chain_Iterator_set_position(
Chain_Iterator *the_iterator,
Chain_Node *the_node
)
{
the_iterator->position = the_node;
108c50: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_lock_Release_and_ISR_enable(
108c53: ff 75 c4 push -0x3c(%ebp)
108c56: 9d popf
_Chain_Iterator_set_position( &iter.Iterator, node );
_User_extensions_Release( &lock_context );
extension = (const User_extensions_Control *) node;
( *visitor )( executing, arg, &extension->Callouts );
108c57: 89 74 24 04 mov %esi,0x4(%esp)
108c5b: 83 c0 14 add $0x14,%eax
108c5e: 89 44 24 08 mov %eax,0x8(%esp)
108c62: 89 1c 24 mov %ebx,(%esp)
108c65: ff d7 call *%edi
_ISR_lock_ISR_disable_and_acquire(
108c67: 9c pushf
108c68: fa cli
108c69: 58 pop %eax
108c6a: 89 45 c4 mov %eax,-0x3c(%ebp)
if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) {
108c6d: 8b 4d dc mov -0x24(%ebp),%ecx
return _Chain_Next( the_iterator->position );
108c70: 8b 55 e0 mov -0x20(%ebp),%edx
if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) {
108c73: 85 c9 test %ecx,%ecx
return the_node->next;
108c75: 8b 02 mov (%edx),%eax
return the_node->previous;
108c77: 8b 52 04 mov 0x4(%edx),%edx
if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) {
108c7a: 74 02 je 108c7e <_User_extensions_Iterate+0xfe>
return _Chain_Previous( the_iterator->position );
108c7c: 89 d0 mov %edx,%eax
while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) {
108c7e: 39 45 c0 cmp %eax,-0x40(%ebp)
108c81: 75 cd jne 108c50 <_User_extensions_Iterate+0xd0>
_User_extensions_Acquire( &lock_context );
}
if ( executing != NULL ) {
108c83: 85 db test %ebx,%ebx
108c85: 74 09 je 108c90 <_User_extensions_Iterate+0x110>
executing->last_user_extensions_iterator = iter.previous;
108c87: 8b 45 e4 mov -0x1c(%ebp),%eax
108c8a: 89 83 3c 01 00 00 mov %eax,0x13c(%ebx)
next = the_node->next;
108c90: 8b 55 d4 mov -0x2c(%ebp),%edx
previous = the_node->previous;
108c93: 8b 45 d8 mov -0x28(%ebp),%eax
next->previous = previous;
108c96: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
108c99: 89 10 mov %edx,(%eax)
_ISR_lock_Release_and_ISR_enable(
108c9b: ff 75 c4 push -0x3c(%ebp)
108c9e: 9d popf
_Chain_Iterator_destroy( &iter.Iterator );
_User_extensions_Release( &lock_context );
if ( direction == CHAIN_ITERATOR_BACKWARD ) {
108c9f: 83 7d 10 01 cmpl $0x1,0x10(%ebp)
108ca3: 74 0b je 108cb0 <_User_extensions_Iterate+0x130>
while ( initial_current != initial_begin ) {
--initial_current;
(*visitor)( executing, arg, initial_current );
}
}
}
108ca5: 83 c4 4c add $0x4c,%esp
108ca8: 5b pop %ebx
108ca9: 5e pop %esi
108caa: 5f pop %edi
108cab: 5d pop %ebp
108cac: c3 ret
108cad: 8d 76 00 lea 0x0(%esi),%esi
while ( initial_current != initial_begin ) {
108cb0: 8b 45 bc mov -0x44(%ebp),%eax
108cb3: 3d 20 49 12 00 cmp $0x124920,%eax
108cb8: 74 eb je 108ca5 <_User_extensions_Iterate+0x125> <== NEVER TAKEN
108cba: 89 5d c4 mov %ebx,-0x3c(%ebp)
108cbd: 89 c3 mov %eax,%ebx
108cbf: 90 nop
(*visitor)( executing, arg, initial_current );
108cc0: 89 74 24 04 mov %esi,0x4(%esp)
108cc4: 8b 45 c4 mov -0x3c(%ebp),%eax
--initial_current;
108cc7: 83 eb 24 sub $0x24,%ebx
(*visitor)( executing, arg, initial_current );
108cca: 89 5c 24 08 mov %ebx,0x8(%esp)
108cce: 89 04 24 mov %eax,(%esp)
108cd1: ff d7 call *%edi
while ( initial_current != initial_begin ) {
108cd3: 81 fb 20 49 12 00 cmp $0x124920,%ebx
108cd9: 75 e5 jne 108cc0 <_User_extensions_Iterate+0x140>
}
108cdb: 83 c4 4c add $0x4c,%esp
108cde: 5b pop %ebx
108cdf: 5e pop %esi
108ce0: 5f pop %edi
108ce1: 5d pop %ebp
108ce2: c3 ret
108ce3: 90 nop
108ce4: 90 nop
108ce5: 90 nop
108ce6: 90 nop
108ce7: 90 nop
108ce8: 90 nop
108ce9: 90 nop
108cea: 90 nop
108ceb: 90 nop
108cec: 90 nop
108ced: 90 nop
108cee: 90 nop
108cef: 90 nop
0011df50 <_User_extensions_Remove_set>:
#include <rtems/score/percpu.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
11df50: 55 push %ebp
11df51: 89 e5 mov %esp,%ebp
11df53: 56 push %esi
11df54: 8b 55 08 mov 0x8(%ebp),%edx
11df57: 53 push %ebx
_ISR_lock_ISR_disable_and_acquire(
11df58: 9c pushf
11df59: fa cli
11df5a: 5e pop %esi
return the_node->next;
11df5b: a1 18 a4 12 00 mov 0x12a418,%eax
11df60: 8b 4a 04 mov 0x4(%edx),%ecx
11df63: 8b 1a mov (%edx),%ebx
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
11df65: 3d 1c a4 12 00 cmp $0x12a41c,%eax
11df6a: 75 0d jne 11df79 <_User_extensions_Remove_set+0x29> <== NEVER TAKEN
11df6c: eb 22 jmp 11df90 <_User_extensions_Remove_set+0x40>
11df6e: 66 90 xchg %ax,%ax
return the_node->next;
11df70: 8b 00 mov (%eax),%eax <== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
11df72: 3d 1c a4 12 00 cmp $0x12a41c,%eax <== NOT EXECUTED
11df77: 74 17 je 11df90 <_User_extensions_Remove_set+0x40> <== NOT EXECUTED
if ( iter->position == the_node_to_extract ) {
11df79: 3b 50 0c cmp 0xc(%eax),%edx <== NOT EXECUTED
11df7c: 75 f2 jne 11df70 <_User_extensions_Remove_set+0x20> <== NOT EXECUTED
if ( iter->direction == CHAIN_ITERATOR_FORWARD ) {
11df7e: 83 78 08 00 cmpl $0x0,0x8(%eax) <== NOT EXECUTED
11df82: 75 3c jne 11dfc0 <_User_extensions_Remove_set+0x70> <== NOT EXECUTED
iter->position = _Chain_Previous( the_node_to_extract );
11df84: 89 48 0c mov %ecx,0xc(%eax) <== NOT EXECUTED
return the_node->next;
11df87: 8b 00 mov (%eax),%eax <== NOT EXECUTED
while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) {
11df89: 3d 1c a4 12 00 cmp $0x12a41c,%eax <== NOT EXECUTED
11df8e: 75 e9 jne 11df79 <_User_extensions_Remove_set+0x29> <== NOT EXECUTED
next->previous = previous;
11df90: 89 4b 04 mov %ecx,0x4(%ebx)
previous->next = next;
11df93: 89 19 mov %ebx,(%ecx)
_ISR_lock_Release_and_ISR_enable(
11df95: 56 push %esi
11df96: 9d popf
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
11df97: 8b 42 24 mov 0x24(%edx),%eax
11df9a: 85 c0 test %eax,%eax
11df9c: 74 10 je 11dfae <_User_extensions_Remove_set+0x5e>
_ISR_lock_ISR_disable( lock_context );
11df9e: 9c pushf
11df9f: fa cli
11dfa0: 5b pop %ebx
next = the_node->next;
11dfa1: 8b 4a 08 mov 0x8(%edx),%ecx
previous = the_node->previous;
11dfa4: 8b 42 0c mov 0xc(%edx),%eax
next->previous = previous;
11dfa7: 89 41 04 mov %eax,0x4(%ecx)
previous->next = next;
11dfaa: 89 08 mov %ecx,(%eax)
_ISR_lock_ISR_enable( lock_context );
11dfac: 53 push %ebx
11dfad: 9d popf
_Per_CPU_Acquire_all( &lock_context );
_Chain_Extract_unprotected( &the_extension->Switch.Node );
_Per_CPU_Release_all( &lock_context );
}
}
11dfae: 5b pop %ebx
11dfaf: 5e pop %esi
11dfb0: 5d pop %ebp
11dfb1: c3 ret
11dfb2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
11dfb9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
iter->position = _Chain_Next( the_node_to_extract );
11dfc0: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED
11dfc3: eb ab jmp 11df70 <_User_extensions_Remove_set+0x20> <== NOT EXECUTED
11dfc5: 90 nop
11dfc6: 90 nop
11dfc7: 90 nop
11dfc8: 90 nop
11dfc9: 90 nop
11dfca: 90 nop
11dfcb: 90 nop
11dfcc: 90 nop
11dfcd: 90 nop
11dfce: 90 nop
11dfcf: 90 nop
00108a40 <_User_extensions_Thread_create_visitor>:
void _User_extensions_Thread_create_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
108a40: 55 push %ebp
108a41: 89 e5 mov %esp,%ebp
108a43: 83 ec 18 sub $0x18,%esp
108a46: 89 5d fc mov %ebx,-0x4(%ebp)
User_extensions_thread_create_extension callout = callouts->thread_create;
108a49: 8b 45 10 mov 0x10(%ebp),%eax
{
108a4c: 8b 5d 0c mov 0xc(%ebp),%ebx
User_extensions_thread_create_extension callout = callouts->thread_create;
108a4f: 8b 10 mov (%eax),%edx
if ( callout != NULL ) {
108a51: 85 d2 test %edx,%edx
108a53: 74 0b je 108a60 <_User_extensions_Thread_create_visitor+0x20>
User_extensions_Thread_create_context *ctx = arg;
ctx->ok = ctx->ok && (*callout)( executing, ctx->created );
108a55: 0f b6 43 04 movzbl 0x4(%ebx),%eax
108a59: 84 c0 test %al,%al
108a5b: 75 13 jne 108a70 <_User_extensions_Thread_create_visitor+0x30><== ALWAYS TAKEN
108a5d: 88 43 04 mov %al,0x4(%ebx)
}
}
108a60: 8b 5d fc mov -0x4(%ebp),%ebx
108a63: 89 ec mov %ebp,%esp
108a65: 5d pop %ebp
108a66: c3 ret
108a67: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108a6e: 66 90 xchg %ax,%ax
ctx->ok = ctx->ok && (*callout)( executing, ctx->created );
108a70: 8b 03 mov (%ebx),%eax
108a72: 89 44 24 04 mov %eax,0x4(%esp)
108a76: 8b 45 08 mov 0x8(%ebp),%eax
108a79: 89 04 24 mov %eax,(%esp)
108a7c: ff d2 call *%edx
108a7e: eb dd jmp 108a5d <_User_extensions_Thread_create_visitor+0x1d>
00108e10 <_Watchdog_Do_tickle>:
#ifdef RTEMS_SMP
ISR_lock_Control *lock,
#endif
ISR_lock_Context *lock_context
)
{
108e10: 55 push %ebp
108e11: 89 e5 mov %esp,%ebp
108e13: 57 push %edi
108e14: 56 push %esi
108e15: 53 push %ebx
108e16: 83 ec 2c sub $0x2c,%esp
108e19: 8b 45 10 mov 0x10(%ebp),%eax
108e1c: 8b 75 08 mov 0x8(%ebp),%esi
108e1f: 8b 7d 0c mov 0xc(%ebp),%edi
108e22: 8b 5d 18 mov 0x18(%ebp),%ebx
108e25: 89 45 e4 mov %eax,-0x1c(%ebp)
108e28: 8b 45 14 mov 0x14(%ebp),%eax
108e2b: 89 45 e0 mov %eax,-0x20(%ebp)
108e2e: 66 90 xchg %ax,%ax
do {
if ( first->expire <= now ) {
108e30: 8b 45 e4 mov -0x1c(%ebp),%eax
108e33: 3b 47 14 cmp 0x14(%edi),%eax
108e36: 8b 45 e0 mov -0x20(%ebp),%eax
108e39: 1b 47 18 sbb 0x18(%edi),%eax
108e3c: 72 47 jb 108e85 <_Watchdog_Do_tickle+0x75>
return RB_RIGHT( the_node, Node );
108e3e: 8b 47 04 mov 0x4(%edi),%eax
if ( node != NULL ) {
108e41: 85 c0 test %eax,%eax
108e43: 74 4b je 108e90 <_Watchdog_Do_tickle+0x80>
108e45: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108e4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return RB_LEFT( the_node, Node );
108e50: 89 c2 mov %eax,%edx
108e52: 8b 00 mov (%eax),%eax
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
108e54: 85 c0 test %eax,%eax
108e56: 75 f8 jne 108e50 <_Watchdog_Do_tickle+0x40> <== NEVER TAKEN
header->first = node;
108e58: 89 56 04 mov %edx,0x4(%esi)
Watchdog_Service_routine_entry routine;
_Watchdog_Next_first( header, first );
_RBTree_Extract( &header->Watchdogs, &first->Node.RBTree );
108e5b: 89 7c 24 04 mov %edi,0x4(%esp)
108e5f: 89 34 24 mov %esi,(%esp)
108e62: e8 49 1e 00 00 call 10acb0 <_RBTree_Extract>
_Watchdog_Set_state( first, WATCHDOG_INACTIVE );
routine = first->routine;
108e67: 8b 47 10 mov 0x10(%edi),%eax
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
108e6a: c7 47 0c 02 00 00 00 movl $0x2,0xc(%edi)
_ISR_lock_Release_and_ISR_enable( lock, lock_context );
108e71: ff 33 push (%ebx)
108e73: 9d popf
( *routine )( first );
108e74: 89 3c 24 mov %edi,(%esp)
108e77: ff d0 call *%eax
_ISR_lock_ISR_disable_and_acquire( lock, lock_context );
108e79: 9c pushf
108e7a: fa cli
108e7b: 58 pop %eax
108e7c: 89 03 mov %eax,(%ebx)
return (Watchdog_Control *) header->first;
108e7e: 8b 7e 04 mov 0x4(%esi),%edi
} else {
break;
}
first = _Watchdog_Header_first( header );
} while ( first != NULL );
108e81: 85 ff test %edi,%edi
108e83: 75 ab jne 108e30 <_Watchdog_Do_tickle+0x20>
}
108e85: 83 c4 2c add $0x2c,%esp
108e88: 5b pop %ebx
108e89: 5e pop %esi
108e8a: 5f pop %edi
108e8b: 5d pop %ebp
108e8c: c3 ret
108e8d: 8d 76 00 lea 0x0(%esi),%esi
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
108e90: 8b 47 08 mov 0x8(%edi),%eax
108e93: 89 46 04 mov %eax,0x4(%esi)
108e96: eb c3 jmp 108e5b <_Watchdog_Do_tickle+0x4b>
108e98: 90 nop
108e99: 90 nop
108e9a: 90 nop
108e9b: 90 nop
108e9c: 90 nop
108e9d: 90 nop
108e9e: 90 nop
108e9f: 90 nop
00108d90 <_Watchdog_Remove>:
void _Watchdog_Remove(
Watchdog_Header *header,
Watchdog_Control *the_watchdog
)
{
108d90: 55 push %ebp
108d91: 89 e5 mov %esp,%ebp
108d93: 83 ec 18 sub $0x18,%esp
108d96: 89 5d fc mov %ebx,-0x4(%ebp)
108d99: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( _Watchdog_Is_scheduled( the_watchdog ) ) {
108d9c: 83 7b 0c 01 cmpl $0x1,0xc(%ebx)
108da0: 76 0e jbe 108db0 <_Watchdog_Remove+0x20>
}
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
_Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
}
}
108da2: 8b 5d fc mov -0x4(%ebp),%ebx
108da5: 89 ec mov %ebp,%esp
108da7: 5d pop %ebp
108da8: c3 ret
108da9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if ( header->first == &the_watchdog->Node.RBTree ) {
108db0: 8b 45 08 mov 0x8(%ebp),%eax
108db3: 39 58 04 cmp %ebx,0x4(%eax)
108db6: 74 28 je 108de0 <_Watchdog_Remove+0x50>
_RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
108db8: 89 5c 24 04 mov %ebx,0x4(%esp)
108dbc: 8b 45 08 mov 0x8(%ebp),%eax
108dbf: 89 04 24 mov %eax,(%esp)
108dc2: e8 e9 1e 00 00 call 10acb0 <_RBTree_Extract>
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
108dc7: c7 43 0c 02 00 00 00 movl $0x2,0xc(%ebx)
}
108dce: 8b 5d fc mov -0x4(%ebp),%ebx
108dd1: 89 ec mov %ebp,%esp
108dd3: 5d pop %ebp
108dd4: c3 ret
108dd5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108ddc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return RB_RIGHT( the_node, Node );
108de0: 8b 43 04 mov 0x4(%ebx),%eax
if ( node != NULL ) {
108de3: 85 c0 test %eax,%eax
108de5: 74 19 je 108e00 <_Watchdog_Remove+0x70>
108de7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108dee: 66 90 xchg %ax,%ax
return RB_LEFT( the_node, Node );
108df0: 89 c2 mov %eax,%edx
108df2: 8b 00 mov (%eax),%eax
while ( ( left = _RBTree_Left( node ) ) != NULL ) {
108df4: 85 c0 test %eax,%eax
108df6: 75 f8 jne 108df0 <_Watchdog_Remove+0x60> <== NEVER TAKEN
header->first = node;
108df8: 8b 45 08 mov 0x8(%ebp),%eax
108dfb: 89 50 04 mov %edx,0x4(%eax)
108dfe: eb b8 jmp 108db8 <_Watchdog_Remove+0x28>
header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
108e00: 8b 43 08 mov 0x8(%ebx),%eax
108e03: 8b 4d 08 mov 0x8(%ebp),%ecx
108e06: 89 41 04 mov %eax,0x4(%ecx)
108e09: eb ad jmp 108db8 <_Watchdog_Remove+0x28>
108e0b: 90 nop
108e0c: 90 nop
108e0d: 90 nop
108e0e: 90 nop
108e0f: 90 nop
0010c960 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
const Memory_Information *mem,
Heap_Initialization_or_extend_handler extend
)
{
10c960: 55 push %ebp
10c961: 31 c0 xor %eax,%eax
10c963: 89 e5 mov %esp,%ebp
10c965: 57 push %edi
10c966: 56 push %esi
10c967: 53 push %ebx
10c968: 83 ec 2c sub $0x2c,%esp
uintptr_t page_size;
uintptr_t overhead;
size_t i;
page_size = CPU_HEAP_ALIGNMENT;
remaining = rtems_configuration_get_work_space_size();
10c96b: 80 3d e4 57 12 00 00 cmpb $0x0,0x1257e4
{
10c972: 8b 55 08 mov 0x8(%ebp),%edx
remaining = rtems_configuration_get_work_space_size();
10c975: 0f 84 f5 00 00 00 je 10ca70 <_Workspace_Handler_initialization+0x110><== ALWAYS TAKEN
10c97b: 8b 1d 98 47 12 00 mov 0x124798,%ebx
init_or_extend = _Heap_Initialize;
unified = rtems_configuration_get_unified_work_area();
overhead = _Heap_Area_overhead( page_size );
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10c981: 8b 32 mov (%edx),%esi
remaining = rtems_configuration_get_work_space_size();
10c983: 01 d8 add %ebx,%eax
10c985: 89 45 e4 mov %eax,-0x1c(%ebp)
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10c988: 85 f6 test %esi,%esi
10c98a: 0f 84 a0 00 00 00 je 10ca30 <_Workspace_Handler_initialization+0xd0><== NEVER TAKEN
init_or_extend = _Heap_Initialize;
10c990: b9 50 50 10 00 mov $0x105050,%ecx
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10c995: 31 db xor %ebx,%ebx
init_or_extend = _Heap_Initialize;
10c997: 89 4d e0 mov %ecx,-0x20(%ebp)
10c99a: eb 18 jmp 10c9b4 <_Workspace_Handler_initialization+0x54>
10c99c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
);
_Memory_Consume( area, size );
if ( space_available < remaining ) {
remaining -= space_available;
10c9a0: 29 c1 sub %eax,%ecx <== NOT EXECUTED
} else {
remaining = 0;
}
init_or_extend = extend;
10c9a2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
remaining -= space_available;
10c9a5: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED
init_or_extend = extend;
10c9a8: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10c9ab: 43 inc %ebx
10c9ac: 3b 1a cmp (%edx),%ebx
10c9ae: 0f 83 7c 00 00 00 jae 10ca30 <_Workspace_Handler_initialization+0xd0><== ALWAYS TAKEN
return &information->areas[ index ];
10c9b4: 8b 72 04 mov 0x4(%edx),%esi
10c9b7: 8d 04 5b lea (%ebx,%ebx,2),%eax
10c9ba: 8d 3c 86 lea (%esi,%eax,4),%edi
return (uintptr_t) area->end - (uintptr_t) area->free;
10c9bd: 8b 47 04 mov 0x4(%edi),%eax
10c9c0: 8b 77 08 mov 0x8(%edi),%esi
10c9c3: 29 c6 sub %eax,%esi
if ( free_size > overhead ) {
10c9c5: 83 fe 0e cmp $0xe,%esi
10c9c8: 76 e1 jbe 10c9ab <_Workspace_Handler_initialization+0x4b>
if ( unified ) {
10c9ca: 80 3d e5 57 12 00 00 cmpb $0x0,0x1257e5
10c9d1: 75 1d jne 10c9f0 <_Workspace_Handler_initialization+0x90>
if ( remaining > 0 ) {
10c9d3: 8b 4d e4 mov -0x1c(%ebp),%ecx
10c9d6: 85 c9 test %ecx,%ecx
10c9d8: 74 66 je 10ca40 <_Workspace_Handler_initialization+0xe0><== NEVER TAKEN
size = remaining < free_size - overhead ?
10c9da: 8d 4e f2 lea -0xe(%esi),%ecx
remaining + overhead : free_size;
10c9dd: 3b 4d e4 cmp -0x1c(%ebp),%ecx
10c9e0: 76 0e jbe 10c9f0 <_Workspace_Handler_initialization+0x90><== NEVER TAKEN
10c9e2: 8b 75 e4 mov -0x1c(%ebp),%esi
10c9e5: 83 c6 0e add $0xe,%esi
10c9e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10c9ef: 90 nop
10c9f0: 89 55 08 mov %edx,0x8(%ebp)
space_available = ( *init_or_extend )(
10c9f3: ba 04 00 00 00 mov $0x4,%edx
10c9f8: 89 54 24 0c mov %edx,0xc(%esp)
10c9fc: 89 44 24 04 mov %eax,0x4(%esp)
10ca00: 8b 45 e0 mov -0x20(%ebp),%eax
10ca03: 89 74 24 08 mov %esi,0x8(%esp)
10ca07: c7 04 24 a0 05 13 00 movl $0x1305a0,(%esp)
10ca0e: ff d0 call *%eax
if ( space_available < remaining ) {
10ca10: 8b 4d e4 mov -0x1c(%ebp),%ecx
area->free = (char *) area->free + consume;
10ca13: 01 77 04 add %esi,0x4(%edi)
10ca16: 8b 55 08 mov 0x8(%ebp),%edx
10ca19: 39 c8 cmp %ecx,%eax
10ca1b: 72 83 jb 10c9a0 <_Workspace_Handler_initialization+0x40><== NEVER TAKEN
remaining = 0;
10ca1d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
init_or_extend = extend;
10ca24: 8b 45 0c mov 0xc(%ebp),%eax
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10ca27: 43 inc %ebx
10ca28: 3b 1a cmp (%edx),%ebx
init_or_extend = extend;
10ca2a: 89 45 e0 mov %eax,-0x20(%ebp)
for ( i = 0; i < _Memory_Get_count( mem ); ++i ) {
10ca2d: 72 85 jb 10c9b4 <_Workspace_Handler_initialization+0x54><== NEVER TAKEN
10ca2f: 90 nop
}
}
if ( remaining > 0 ) {
10ca30: 8b 5d e4 mov -0x1c(%ebp),%ebx
10ca33: 85 db test %ebx,%ebx
10ca35: 75 46 jne 10ca7d <_Workspace_Handler_initialization+0x11d>
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
}
_Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 );
}
10ca37: 83 c4 2c add $0x2c,%esp
10ca3a: 5b pop %ebx
10ca3b: 5e pop %esi
10ca3c: 5f pop %edi
10ca3d: 5d pop %ebp
10ca3e: c3 ret
10ca3f: 90 nop
10ca40: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
space_available = ( *init_or_extend )(
10ca43: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10ca45: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED
10ca4a: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
10ca4e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10ca52: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
10ca55: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
10ca59: c7 04 24 a0 05 13 00 movl $0x1305a0,(%esp) <== NOT EXECUTED
10ca60: ff d0 call *%eax <== NOT EXECUTED
init_or_extend = extend;
10ca62: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10ca65: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10ca68: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
10ca6b: e9 3b ff ff ff jmp 10c9ab <_Workspace_Handler_initialization+0x4b><== NOT EXECUTED
remaining = rtems_configuration_get_work_space_size();
10ca70: e8 db 03 00 00 call 10ce50 <rtems_configuration_get_stack_space_size>
10ca75: 8b 55 08 mov 0x8(%ebp),%edx
10ca78: e9 fe fe ff ff jmp 10c97b <_Workspace_Handler_initialization+0x1b>
_Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE );
10ca7d: c7 04 24 02 00 00 00 movl $0x2,(%esp)
10ca84: e8 97 89 ff ff call 105420 <_Internal_error>
10ca89: 90 nop
10ca8a: 90 nop
10ca8b: 90 nop
10ca8c: 90 nop
10ca8d: 90 nop
10ca8e: 90 nop
10ca8f: 90 nop
00107e40 <_Workspace_String_duplicate>:
char *_Workspace_String_duplicate(
const char *string,
size_t len
)
{
107e40: 55 push %ebp
107e41: 89 e5 mov %esp,%ebp
107e43: 83 ec 28 sub $0x28,%esp
107e46: 89 5d f4 mov %ebx,-0xc(%ebp)
107e49: 8b 5d 0c mov 0xc(%ebp),%ebx
107e4c: 89 75 f8 mov %esi,-0x8(%ebp)
107e4f: 89 7d fc mov %edi,-0x4(%ebp)
char *dup;
dup = _Workspace_Allocate( len + 1 );
107e52: 8d 43 01 lea 0x1(%ebx),%eax
107e55: 89 04 24 mov %eax,(%esp)
107e58: e8 93 ff ff ff call 107df0 <_Workspace_Allocate>
if ( dup == NULL ) {
107e5d: 85 c0 test %eax,%eax
107e5f: 74 12 je 107e73 <_Workspace_String_duplicate+0x33>
return NULL;
}
dup[ len ] = '\0';
return memcpy( dup, string, len );
107e61: 83 fb 08 cmp $0x8,%ebx
107e64: 8b 75 08 mov 0x8(%ebp),%esi
107e67: 89 d9 mov %ebx,%ecx
dup[ len ] = '\0';
107e69: c6 04 18 00 movb $0x0,(%eax,%ebx,1)
return memcpy( dup, string, len );
107e6d: 89 c7 mov %eax,%edi
107e6f: 73 0f jae 107e80 <_Workspace_String_duplicate+0x40>
107e71: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
}
107e73: 8b 5d f4 mov -0xc(%ebp),%ebx
107e76: 8b 75 f8 mov -0x8(%ebp),%esi
107e79: 8b 7d fc mov -0x4(%ebp),%edi
107e7c: 89 ec mov %ebp,%esp
107e7e: 5d pop %ebp
107e7f: c3 ret
return memcpy( dup, string, len );
107e80: a8 01 test $0x1,%al
107e82: 75 2c jne 107eb0 <_Workspace_String_duplicate+0x70> <== NEVER TAKEN
107e84: f7 c7 02 00 00 00 test $0x2,%edi
107e8a: 75 34 jne 107ec0 <_Workspace_String_duplicate+0x80> <== NEVER TAKEN
107e8c: f7 c7 04 00 00 00 test $0x4,%edi
107e92: 74 dd je 107e71 <_Workspace_String_duplicate+0x31>
107e94: 8b 16 mov (%esi),%edx
107e96: 83 c7 04 add $0x4,%edi
107e99: 83 c6 04 add $0x4,%esi
107e9c: 83 e9 04 sub $0x4,%ecx
107e9f: 89 57 fc mov %edx,-0x4(%edi)
107ea2: eb cd jmp 107e71 <_Workspace_String_duplicate+0x31>
107ea4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107eab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
107eaf: 90 nop
107eb0: 0f b6 16 movzbl (%esi),%edx <== NOT EXECUTED
107eb3: 8d 78 01 lea 0x1(%eax),%edi <== NOT EXECUTED
107eb6: 46 inc %esi <== NOT EXECUTED
107eb7: 49 dec %ecx <== NOT EXECUTED
107eb8: 88 10 mov %dl,(%eax) <== NOT EXECUTED
107eba: eb c8 jmp 107e84 <_Workspace_String_duplicate+0x44> <== NOT EXECUTED
107ebc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
107ec0: 0f b7 16 movzwl (%esi),%edx <== NOT EXECUTED
107ec3: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
107ec6: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
107ec9: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
107ecc: 66 89 57 fe mov %dx,-0x2(%edi) <== NOT EXECUTED
107ed0: eb ba jmp 107e8c <_Workspace_String_duplicate+0x4c> <== NOT EXECUTED
107ed2: 90 nop
107ed3: 90 nop
107ed4: 90 nop
107ed5: 90 nop
107ed6: 90 nop
107ed7: 90 nop
107ed8: 90 nop
107ed9: 90 nop
107eda: 90 nop
107edb: 90 nop
107edc: 90 nop
107edd: 90 nop
107ede: 90 nop
107edf: 90 nop