=============================================================================== 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 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 #include 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 /* 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 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 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 #include 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 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 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 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 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 #include 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 <== 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 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 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