=============================================================================== 001272dc : static rtems_printk_plugin_t print_handler; static void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 1272dc: 55 push %ebp <== NOT EXECUTED 1272dd: 57 push %edi <== NOT EXECUTED 1272de: 56 push %esi <== NOT EXECUTED 1272df: 53 push %ebx <== NOT EXECUTED 1272e0: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED 1272e3: 8b 5c 24 60 mov 0x60(%esp),%ebx <== NOT EXECUTED /* * Obtain interrupt stack information */ #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (the_thread == (Thread_Control *) -1) { 1272e7: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 1272ea: 0f 84 58 01 00 00 je 127448 <== NOT EXECUTED the_thread = 0; current = 0; } else #endif { stack = &the_thread->Start.Initial_stack; 1272f0: 8d b3 b0 00 00 00 lea 0xb0(%ebx),%esi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 1272f6: 8b 93 c4 00 00 00 mov 0xc4(%ebx),%edx <== NOT EXECUTED 1272fc: 8b bb b4 00 00 00 mov 0xb4(%ebx),%edi <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); size = Stack_check_usable_stack_size(stack); 127302: 8b 2e mov (%esi),%ebp <== NOT EXECUTED 127304: 83 ed 10 sub $0x10,%ebp <== NOT EXECUTED /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; 127307: 8d 47 20 lea 0x20(%edi),%eax <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 12730a: 89 e9 mov %ebp,%ecx <== NOT EXECUTED 12730c: 83 e1 fc and $0xfffffffc,%ecx <== NOT EXECUTED 12730f: 01 c1 add %eax,%ecx <== NOT EXECUTED 127311: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 127313: 73 22 jae 127337 <== NOT EXECUTED if (*base != U32_PATTERN) 127315: 81 7f 20 a5 a5 a5 a5 cmpl $0xa5a5a5a5,0x20(%edi) <== NOT EXECUTED 12731c: 74 12 je 127330 <== NOT EXECUTED 12731e: e9 e9 00 00 00 jmp 12740c <== NOT EXECUTED 127323: 90 nop <== NOT EXECUTED 127324: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED 12732a: 0f 85 dc 00 00 00 jne 12740c <== NOT EXECUTED * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; for (ebase = base + length; base < ebase; base++) 127330: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 127333: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 127335: 77 ed ja 127324 <== NOT EXECUTED high_water_mark = Stack_check_find_high_water_mark(low, size); if ( high_water_mark ) used = Stack_check_Calculate_used( low, size, high_water_mark ); else used = 0; 127337: 31 ff xor %edi,%edi <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 127339: 85 db test %ebx,%ebx <== NOT EXECUTED 12733b: 0f 84 d9 00 00 00 je 12741a <== NOT EXECUTED #endif { (*print_handler)( 127341: 8b 0d 30 a9 17 00 mov 0x17a930,%ecx <== NOT EXECUTED 127347: 8d 44 24 3b lea 0x3b(%esp),%eax <== NOT EXECUTED 12734b: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 12734f: c7 44 24 04 05 00 00 movl $0x5,0x4(%esp) <== NOT EXECUTED 127356: 00 127357: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 12735a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 12735d: 89 54 24 28 mov %edx,0x28(%esp) <== NOT EXECUTED 127361: 89 4c 24 2c mov %ecx,0x2c(%esp) <== NOT EXECUTED 127365: e8 02 b7 fe ff call 112a6c <== NOT EXECUTED 12736a: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 12736e: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 127371: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 127375: c7 44 24 04 5e ad 15 movl $0x15ad5e,0x4(%esp) <== NOT EXECUTED 12737c: 00 12737d: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED 127382: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 127385: 8b 4c 24 2c mov 0x2c(%esp),%ecx <== NOT EXECUTED 127389: ff d1 call *%ecx <== NOT EXECUTED 12738b: 8b 54 24 28 mov 0x28(%esp),%edx <== NOT EXECUTED (*print_handler)( print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 12738f: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 127392: 89 6c 24 14 mov %ebp,0x14(%esp) <== NOT EXECUTED 127396: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 12739a: 8b 16 mov (%esi),%edx <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 12739c: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 1273a0: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED 1273a4: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1273a8: c7 44 24 04 79 ad 15 movl $0x15ad79,0x4(%esp) <== NOT EXECUTED 1273af: 00 1273b0: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED 1273b5: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1273b8: ff 15 30 a9 17 00 call *0x17a930 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 1273be: a1 28 a9 17 00 mov 0x17a928,%eax <== NOT EXECUTED 1273c3: 85 c0 test %eax,%eax <== NOT EXECUTED 1273c5: 74 25 je 1273ec <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 1273c7: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED 1273cb: c7 44 24 04 a4 ad 15 movl $0x15ada4,0x4(%esp) <== NOT EXECUTED 1273d2: 00 1273d3: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED 1273d8: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1273db: ff 15 30 a9 17 00 call *0x17a930 <== NOT EXECUTED } } 1273e1: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 1273e4: 5b pop %ebx <== NOT EXECUTED 1273e5: 5e pop %esi <== NOT EXECUTED 1273e6: 5f pop %edi <== NOT EXECUTED 1273e7: 5d pop %ebp <== NOT EXECUTED 1273e8: c3 ret <== NOT EXECUTED 1273e9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED current, size ); if (Stack_check_Initialized == 0) { (*print_handler)( print_context, "Unavailable\n" ); 1273ec: c7 44 24 04 97 ad 15 movl $0x15ad97,0x4(%esp) <== NOT EXECUTED 1273f3: 00 1273f4: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED 1273f9: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1273fc: ff 15 30 a9 17 00 call *0x17a930 <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); } } 127402: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 127405: 5b pop %ebx <== NOT EXECUTED 127406: 5e pop %esi <== NOT EXECUTED 127407: 5f pop %edi <== NOT EXECUTED 127408: 5d pop %ebp <== NOT EXECUTED 127409: c3 ret <== NOT EXECUTED 12740a: 66 90 xchg %ax,%ax <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); high_water_mark = Stack_check_find_high_water_mark(low, size); if ( high_water_mark ) used = Stack_check_Calculate_used( low, size, high_water_mark ); 12740c: 8d 7c 2f 10 lea 0x10(%edi,%ebp,1),%edi <== NOT EXECUTED 127410: 29 c7 sub %eax,%edi <== NOT EXECUTED else used = 0; #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 127412: 85 db test %ebx,%ebx <== NOT EXECUTED 127414: 0f 85 27 ff ff ff jne 127341 <== NOT EXECUTED rtems_object_get_name( the_thread->Object.id, sizeof(name), name ) ); } #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); 12741a: c7 44 24 08 ff ff ff movl $0xffffffff,0x8(%esp) <== NOT EXECUTED 127421: ff 127422: c7 44 24 04 6b ad 15 movl $0x15ad6b,0x4(%esp) <== NOT EXECUTED 127429: 00 12742a: a1 2c a9 17 00 mov 0x17a92c,%eax <== NOT EXECUTED 12742f: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 127432: 89 54 24 28 mov %edx,0x28(%esp) <== NOT EXECUTED 127436: ff 15 30 a9 17 00 call *0x17a930 <== NOT EXECUTED 12743c: 8b 54 24 28 mov 0x28(%esp),%edx <== NOT EXECUTED 127440: e9 4a ff ff ff jmp 12738f <== NOT EXECUTED 127445: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Obtain interrupt stack information */ #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (the_thread == (Thread_Control *) -1) { if (!Stack_check_Interrupt_stack.area) 127448: 8b 3d 80 b5 17 00 mov 0x17b580,%edi <== NOT EXECUTED 12744e: 85 ff test %edi,%edi <== NOT EXECUTED 127450: 74 8f je 1273e1 <== NOT EXECUTED return; stack = &Stack_check_Interrupt_stack; 127452: be 7c b5 17 00 mov $0x17b57c,%esi <== NOT EXECUTED the_thread = 0; current = 0; 127457: 31 d2 xor %edx,%edx <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (the_thread == (Thread_Control *) -1) { if (!Stack_check_Interrupt_stack.area) return; stack = &Stack_check_Interrupt_stack; the_thread = 0; 127459: 31 db xor %ebx,%ebx <== NOT EXECUTED 12745b: e9 a2 fe ff ff jmp 127302 <== NOT EXECUTED =============================================================================== 00127510 : Thread_Control *running, bool pattern_ok ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { 127510: 56 push %esi <== NOT EXECUTED 127511: 53 push %ebx <== NOT EXECUTED 127512: 83 ec 44 sub $0x44,%esp <== NOT EXECUTED 127515: 8b 5c 24 50 mov 0x50(%esp),%ebx <== NOT EXECUTED 127519: 8a 4c 24 54 mov 0x54(%esp),%cl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack); 12751d: 8b b3 b4 00 00 00 mov 0xb4(%ebx),%esi <== NOT EXECUTED char name[32]; printk("BLOWN STACK!!!\n"); 127523: c7 04 24 aa ad 15 00 movl $0x15adaa,(%esp) <== NOT EXECUTED 12752a: 88 4c 24 1c mov %cl,0x1c(%esp) <== NOT EXECUTED 12752e: e8 d5 10 fe ff call 108608 <== NOT EXECUTED printk("task control block: 0x%08" PRIxPTR "\n", running); 127533: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 127537: c7 04 24 ba ad 15 00 movl $0x15adba,(%esp) <== NOT EXECUTED 12753e: e8 c5 10 fe ff call 108608 <== NOT EXECUTED printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id); 127543: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 127546: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 12754a: c7 04 24 d7 ad 15 00 movl $0x15add7,(%esp) <== NOT EXECUTED 127551: e8 b2 10 fe ff call 108608 <== NOT EXECUTED printk( 127556: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 127559: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 12755d: c7 04 24 e9 ad 15 00 movl $0x15ade9,(%esp) <== NOT EXECUTED 127564: e8 9f 10 fe ff call 108608 <== NOT EXECUTED "task name: 0x%08" PRIx32 "\n", running->Object.name.name_u32 ); printk( 127569: 8d 44 24 20 lea 0x20(%esp),%eax <== NOT EXECUTED 12756d: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 127571: c7 44 24 04 20 00 00 movl $0x20,0x4(%esp) <== NOT EXECUTED 127578: 00 127579: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 12757c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 12757f: e8 e8 b4 fe ff call 112a6c <== NOT EXECUTED 127584: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 127588: c7 04 24 fd ad 15 00 movl $0x15adfd,(%esp) <== NOT EXECUTED 12758f: e8 74 10 fe ff call 108608 <== NOT EXECUTED ); printk( "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n", (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) 127594: 8b 93 b4 00 00 00 mov 0xb4(%ebx),%edx <== NOT EXECUTED 12759a: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED ); printk( "task name string: %s\n", rtems_object_get_name(running->Object.id, sizeof(name), name) ); printk( 1275a0: 8d 1c 02 lea (%edx,%eax,1),%ebx <== NOT EXECUTED 1275a3: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED 1275a7: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED 1275ab: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1275af: c7 04 24 2c ae 15 00 movl $0x15ae2c,(%esp) <== NOT EXECUTED 1275b6: e8 4d 10 fe ff call 108608 <== NOT EXECUTED "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n", (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { 1275bb: 8a 4c 24 1c mov 0x1c(%esp),%cl <== NOT EXECUTED 1275bf: 84 c9 test %cl,%cl <== NOT EXECUTED 1275c1: 74 0c je 1275cf <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif rtems_fatal_error_occurred(0x81); 1275c3: c7 04 24 81 00 00 00 movl $0x81,(%esp) <== NOT EXECUTED 1275ca: e8 29 48 fe ff call 10bdf8 <== NOT EXECUTED (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { printk( 1275cf: 8d 46 18 lea 0x18(%esi),%eax <== NOT EXECUTED 1275d2: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack); 1275d6: 83 c6 08 add $0x8,%esi <== NOT EXECUTED (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { printk( 1275d9: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED 1275dd: c7 44 24 04 10 00 00 movl $0x10,0x4(%esp) <== NOT EXECUTED 1275e4: 00 1275e5: c7 04 24 60 ae 15 00 movl $0x15ae60,(%esp) <== NOT EXECUTED 1275ec: e8 17 10 fe ff call 108608 <== NOT EXECUTED 1275f1: eb d0 jmp 1275c3 <== NOT EXECUTED =============================================================================== 0010c214 <_API_extensions_Run_postdriver>: /* * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10c214: 53 push %ebx 10c215: 83 ec 08 sub $0x8,%esp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10c218: 8b 1d f8 f7 12 00 mov 0x12f7f8,%ebx Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10c21e: 81 fb fc f7 12 00 cmp $0x12f7fc,%ebx 10c224: 74 0f je 10c235 <_API_extensions_Run_postdriver+0x21><== NEVER TAKEN 10c226: 66 90 xchg %ax,%ax * Currently all APIs configure this hook so it is always non-NULL. */ #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) if ( the_extension->postdriver_hook ) #endif (*the_extension->postdriver_hook)(); 10c228: ff 53 08 call *0x8(%ebx) Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 10c22b: 8b 1b mov (%ebx),%ebx void _API_extensions_Run_postdriver( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10c22d: 81 fb fc f7 12 00 cmp $0x12f7fc,%ebx 10c233: 75 f3 jne 10c228 <_API_extensions_Run_postdriver+0x14><== NEVER TAKEN #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) if ( the_extension->postdriver_hook ) #endif (*the_extension->postdriver_hook)(); } } 10c235: 83 c4 08 add $0x8,%esp 10c238: 5b pop %ebx 10c239: c3 ret =============================================================================== 0010c23c <_API_extensions_Run_postswitch>: /* * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10c23c: 53 push %ebx 10c23d: 83 ec 18 sub $0x18,%esp 10c240: 8b 1d f8 f7 12 00 mov 0x12f7f8,%ebx Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10c246: 81 fb fc f7 12 00 cmp $0x12f7fc,%ebx 10c24c: 74 17 je 10c265 <_API_extensions_Run_postswitch+0x29><== NEVER TAKEN 10c24e: 66 90 xchg %ax,%ax !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); 10c250: a1 6c f8 12 00 mov 0x12f86c,%eax 10c255: 89 04 24 mov %eax,(%esp) 10c258: ff 53 0c call *0xc(%ebx) Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 10c25b: 8b 1b mov (%ebx),%ebx void _API_extensions_Run_postswitch( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10c25d: 81 fb fc f7 12 00 cmp $0x12f7fc,%ebx 10c263: 75 eb jne 10c250 <_API_extensions_Run_postswitch+0x14><== NEVER TAKEN the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10c265: 83 c4 18 add $0x18,%esp 10c268: 5b pop %ebx 10c269: c3 ret =============================================================================== 00110c74 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 110c74: 57 push %edi 110c75: 56 push %esi 110c76: 53 push %ebx 110c77: 83 ec 20 sub $0x20,%esp 110c7a: 8b 5c 24 30 mov 0x30(%esp),%ebx 110c7e: 8b 74 24 38 mov 0x38(%esp),%esi 110c82: 8b 44 24 3c mov 0x3c(%esp),%eax size_t message_buffering_required = 0; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 110c86: 89 73 44 mov %esi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 110c89: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 110c90: 89 43 4c mov %eax,0x4c(%ebx) /* * Check if allocated_message_size is aligned to uintptr-size boundary. * If not, it will increase allocated_message_size to multiplicity of pointer * size. */ if (allocated_message_size & (sizeof(uintptr_t) - 1)) { 110c93: a8 03 test $0x3,%al 110c95: 74 15 je 110cac <_CORE_message_queue_Initialize+0x38> allocated_message_size += sizeof(uintptr_t); 110c97: 8d 50 04 lea 0x4(%eax),%edx allocated_message_size &= ~(sizeof(uintptr_t) - 1); 110c9a: 83 e2 fc and $0xfffffffc,%edx /* * Check for an overflow. It can occur while increasing allocated_message_size * to multiplicity of uintptr_t above. */ if (allocated_message_size < maximum_message_size) 110c9d: 39 d0 cmp %edx,%eax 110c9f: 76 0d jbe 110cae <_CORE_message_queue_Initialize+0x3a> return false; 110ca1: 31 c0 xor %eax,%eax STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 110ca3: 83 c4 20 add $0x20,%esp 110ca6: 5b pop %ebx 110ca7: 5e pop %esi 110ca8: 5f pop %edi 110ca9: c3 ret 110caa: 66 90 xchg %ax,%ax /* * Check if allocated_message_size is aligned to uintptr-size boundary. * If not, it will increase allocated_message_size to multiplicity of pointer * size. */ if (allocated_message_size & (sizeof(uintptr_t) - 1)) { 110cac: 89 c2 mov %eax,%edx /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ if ( !size_t_mult32_with_overflow( 110cae: 8d 7a 10 lea 0x10(%edx),%edi size_t a, size_t b, size_t *c ) { long long x = (long long)a*b; 110cb1: 89 f0 mov %esi,%eax 110cb3: f7 e7 mul %edi 110cb5: 89 44 24 18 mov %eax,0x18(%esp) 110cb9: 89 54 24 1c mov %edx,0x1c(%esp) if ( x > SIZE_MAX ) 110cbd: 85 d2 test %edx,%edx 110cbf: 7f e0 jg 110ca1 <_CORE_message_queue_Initialize+0x2d> return false; *c = (size_t) x; 110cc1: 89 04 24 mov %eax,(%esp) /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 110cc4: e8 33 df ff ff call 10ebfc <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 110cc9: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 110ccc: 85 c0 test %eax,%eax 110cce: 74 d1 je 110ca1 <_CORE_message_queue_Initialize+0x2d><== NEVER TAKEN /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 110cd0: 89 7c 24 0c mov %edi,0xc(%esp) 110cd4: 89 74 24 08 mov %esi,0x8(%esp) 110cd8: 89 44 24 04 mov %eax,0x4(%esp) 110cdc: 8d 43 60 lea 0x60(%ebx),%eax 110cdf: 89 04 24 mov %eax,(%esp) 110ce2: e8 e5 b6 ff ff call 10c3cc <_Chain_Initialize> Chain_Node *tail = _Chain_Tail( the_chain ); 110ce7: 8d 43 50 lea 0x50(%ebx),%eax 110cea: 8d 53 54 lea 0x54(%ebx),%edx 110ced: 89 53 50 mov %edx,0x50(%ebx) head->next = tail; head->previous = NULL; 110cf0: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 110cf7: 89 43 58 mov %eax,0x58(%ebx) allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 110cfa: c7 44 24 0c 06 00 00 movl $0x6,0xc(%esp) 110d01: 00 110d02: c7 44 24 08 80 00 00 movl $0x80,0x8(%esp) 110d09: 00 */ RTEMS_INLINE_ROUTINE bool _CORE_message_queue_Is_priority( CORE_message_queue_Attributes *the_attribute ) { return 110d0a: 8b 44 24 34 mov 0x34(%esp),%eax 110d0e: 83 38 01 cmpl $0x1,(%eax) 110d11: 0f 94 c0 sete %al 110d14: 0f b6 c0 movzbl %al,%eax 110d17: 89 44 24 04 mov %eax,0x4(%esp) 110d1b: 89 1c 24 mov %ebx,(%esp) 110d1e: e8 89 d7 ff ff call 10e4ac <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 110d23: b0 01 mov $0x1,%al } 110d25: 83 c4 20 add $0x20,%esp 110d28: 5b pop %ebx 110d29: 5e pop %esi 110d2a: 5f pop %edi 110d2b: c3 ret =============================================================================== 0010c548 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10c548: 56 push %esi 10c549: 53 push %ebx 10c54a: 83 ec 14 sub $0x14,%esp 10c54d: 8b 74 24 20 mov 0x20(%esp),%esi 10c551: 8a 5c 24 28 mov 0x28(%esp),%bl * This routine returns true if thread dispatch indicates * that we are in a critical section. */ RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void) { if ( _Thread_Dispatch_disable_level == 0 ) 10c555: a1 04 f6 12 00 mov 0x12f604,%eax 10c55a: 85 c0 test %eax,%eax 10c55c: 74 6e je 10c5cc <_CORE_mutex_Seize+0x84> _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10c55e: 84 db test %bl,%bl 10c560: 0f 84 95 00 00 00 je 10c5fb <_CORE_mutex_Seize+0xb3> 10c566: 83 3d 60 f7 12 00 01 cmpl $0x1,0x12f760 10c56d: 0f 87 9e 00 00 00 ja 10c611 <_CORE_mutex_Seize+0xc9> 10c573: 8d 44 24 30 lea 0x30(%esp),%eax 10c577: 89 44 24 04 mov %eax,0x4(%esp) 10c57b: 89 34 24 mov %esi,(%esp) 10c57e: e8 35 49 00 00 call 110eb8 <_CORE_mutex_Seize_interrupt_trylock> 10c583: 85 c0 test %eax,%eax 10c585: 74 3c je 10c5c3 <_CORE_mutex_Seize+0x7b><== ALWAYS TAKEN 10c587: 90 nop RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c588: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) 10c58f: a1 6c f8 12 00 mov 0x12f86c,%eax 10c594: 89 70 44 mov %esi,0x44(%eax) 10c597: 8b 54 24 24 mov 0x24(%esp),%edx 10c59b: 89 50 20 mov %edx,0x20(%eax) * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10c59e: a1 04 f6 12 00 mov 0x12f604,%eax 10c5a3: 40 inc %eax 10c5a4: a3 04 f6 12 00 mov %eax,0x12f604 return _Thread_Dispatch_disable_level; 10c5a9: a1 04 f6 12 00 mov 0x12f604,%eax 10c5ae: ff 74 24 30 pushl 0x30(%esp) 10c5b2: 9d popf 10c5b3: 8b 44 24 2c mov 0x2c(%esp),%eax 10c5b7: 89 44 24 04 mov %eax,0x4(%esp) 10c5bb: 89 34 24 mov %esi,(%esp) 10c5be: e8 11 ff ff ff call 10c4d4 <_CORE_mutex_Seize_interrupt_blocking> } 10c5c3: 83 c4 14 add $0x14,%esp 10c5c6: 5b pop %ebx 10c5c7: 5e pop %esi 10c5c8: c3 ret 10c5c9: 8d 76 00 lea 0x0(%esi),%esi bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10c5cc: 8d 44 24 30 lea 0x30(%esp),%eax 10c5d0: 89 44 24 04 mov %eax,0x4(%esp) 10c5d4: 89 34 24 mov %esi,(%esp) 10c5d7: e8 dc 48 00 00 call 110eb8 <_CORE_mutex_Seize_interrupt_trylock> 10c5dc: 85 c0 test %eax,%eax 10c5de: 74 e3 je 10c5c3 <_CORE_mutex_Seize+0x7b> 10c5e0: 84 db test %bl,%bl 10c5e2: 75 a4 jne 10c588 <_CORE_mutex_Seize+0x40> 10c5e4: ff 74 24 30 pushl 0x30(%esp) 10c5e8: 9d popf 10c5e9: a1 6c f8 12 00 mov 0x12f86c,%eax 10c5ee: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) } 10c5f5: 83 c4 14 add $0x14,%esp 10c5f8: 5b pop %ebx 10c5f9: 5e pop %esi 10c5fa: c3 ret bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10c5fb: 8d 44 24 30 lea 0x30(%esp),%eax 10c5ff: 89 44 24 04 mov %eax,0x4(%esp) 10c603: 89 34 24 mov %esi,(%esp) 10c606: e8 ad 48 00 00 call 110eb8 <_CORE_mutex_Seize_interrupt_trylock> 10c60b: 85 c0 test %eax,%eax 10c60d: 75 d5 jne 10c5e4 <_CORE_mutex_Seize+0x9c><== NEVER TAKEN 10c60f: eb b2 jmp 10c5c3 <_CORE_mutex_Seize+0x7b> 10c611: c7 44 24 08 12 00 00 movl $0x12,0x8(%esp) 10c618: 00 10c619: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10c620: 00 10c621: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c628: e8 93 05 00 00 call 10cbc0 <_Internal_error_Occurred> =============================================================================== 0010c768 <_CORE_semaphore_Surrender>: CORE_semaphore_Status _CORE_semaphore_Surrender( CORE_semaphore_Control *the_semaphore, Objects_Id id, CORE_semaphore_API_mp_support_callout api_semaphore_mp_support ) { 10c768: 53 push %ebx 10c769: 83 ec 18 sub $0x18,%esp 10c76c: 8b 5c 24 20 mov 0x20(%esp),%ebx ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10c770: 89 1c 24 mov %ebx,(%esp) 10c773: e8 c4 19 00 00 call 10e13c <_Thread_queue_Dequeue> 10c778: 85 c0 test %eax,%eax 10c77a: 74 08 je 10c784 <_CORE_semaphore_Surrender+0x1c> { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10c77c: 31 c0 xor %eax,%eax status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10c77e: 83 c4 18 add $0x18,%esp 10c781: 5b pop %ebx 10c782: c3 ret 10c783: 90 nop if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10c784: 9c pushf 10c785: fa cli 10c786: 5a pop %edx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10c787: 8b 43 48 mov 0x48(%ebx),%eax 10c78a: 3b 43 40 cmp 0x40(%ebx),%eax 10c78d: 72 0d jb 10c79c <_CORE_semaphore_Surrender+0x34><== ALWAYS TAKEN the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10c78f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED _ISR_Enable( level ); 10c794: 52 push %edx 10c795: 9d popf } return status; } 10c796: 83 c4 18 add $0x18,%esp 10c799: 5b pop %ebx 10c79a: c3 ret 10c79b: 90 nop #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10c79c: 40 inc %eax 10c79d: 89 43 48 mov %eax,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10c7a0: 31 c0 xor %eax,%eax 10c7a2: eb f0 jmp 10c794 <_CORE_semaphore_Surrender+0x2c> =============================================================================== 0010c3cc <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10c3cc: 55 push %ebp 10c3cd: 57 push %edi 10c3ce: 56 push %esi 10c3cf: 53 push %ebx 10c3d0: 8b 74 24 14 mov 0x14(%esp),%esi 10c3d4: 8b 44 24 1c mov 0x1c(%esp),%eax 10c3d8: 8b 5c 24 20 mov 0x20(%esp),%ebx size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10c3dc: 8d 6e 04 lea 0x4(%esi),%ebp Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; 10c3df: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) while ( count-- ) { 10c3e6: 8d 78 ff lea -0x1(%eax),%edi 10c3e9: 85 c0 test %eax,%eax 10c3eb: 74 2b je 10c418 <_Chain_Initialize+0x4c><== NEVER TAKEN 10c3ed: 89 f9 mov %edi,%ecx 10c3ef: 8b 44 24 18 mov 0x18(%esp),%eax 10c3f3: 89 f2 mov %esi,%edx 10c3f5: 8d 76 00 lea 0x0(%esi),%esi current->next = next; 10c3f8: 89 02 mov %eax,(%edx) next->previous = current; 10c3fa: 89 50 04 mov %edx,0x4(%eax) Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 10c3fd: 49 dec %ecx 10c3fe: 89 c2 mov %eax,%edx current->next = next; next->previous = current; current = next; next = (Chain_Node *) 10c400: 01 d8 add %ebx,%eax Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 10c402: 83 f9 ff cmp $0xffffffff,%ecx 10c405: 75 f1 jne 10c3f8 <_Chain_Initialize+0x2c> * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 10c407: 0f af df imul %edi,%ebx 10c40a: 03 5c 24 18 add 0x18(%esp),%ebx current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = tail; 10c40e: 89 2b mov %ebp,(%ebx) tail->previous = current; 10c410: 89 5e 08 mov %ebx,0x8(%esi) } 10c413: 5b pop %ebx 10c414: 5e pop %esi 10c415: 5f pop %edi 10c416: 5d pop %ebp 10c417: c3 ret ) { size_t count = number_nodes; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *current = head; 10c418: 89 f3 mov %esi,%ebx <== NOT EXECUTED 10c41a: eb f2 jmp 10c40e <_Chain_Initialize+0x42><== NOT EXECUTED =============================================================================== 0010b544 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 10b544: 55 push %ebp 10b545: 57 push %edi 10b546: 56 push %esi 10b547: 53 push %ebx 10b548: 83 ec 2c sub $0x2c,%esp 10b54b: 8b 5c 24 40 mov 0x40(%esp),%ebx rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; RTEMS_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 10b54f: 8b 8b e0 00 00 00 mov 0xe0(%ebx),%ecx option_set = (rtems_option) the_thread->Wait.option; 10b555: 8b 6b 30 mov 0x30(%ebx),%ebp _ISR_Disable( level ); 10b558: 9c pushf 10b559: fa cli 10b55a: 5e pop %esi pending_events = api->pending_events; 10b55b: 8b 11 mov (%ecx),%edx event_condition = (rtems_event_set) the_thread->Wait.count; 10b55d: 8b 43 24 mov 0x24(%ebx),%eax seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 10b560: 89 c7 mov %eax,%edi 10b562: 21 d7 and %edx,%edi 10b564: 89 7c 24 18 mov %edi,0x18(%esp) 10b568: 0f 84 ae 00 00 00 je 10b61c <_Event_Surrender+0xd8> /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 10b56e: 8b 3d 68 f8 12 00 mov 0x12f868,%edi 10b574: 85 ff test %edi,%edi 10b576: 74 08 je 10b580 <_Event_Surrender+0x3c> 10b578: 3b 1d 6c f8 12 00 cmp 0x12f86c,%ebx 10b57e: 74 58 je 10b5d8 <_Event_Surrender+0x94> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 10b580: f6 43 11 01 testb $0x1,0x11(%ebx) 10b584: 0f 84 92 00 00 00 je 10b61c <_Event_Surrender+0xd8> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 10b58a: 3b 44 24 18 cmp 0x18(%esp),%eax 10b58e: 74 09 je 10b599 <_Event_Surrender+0x55> 10b590: 83 e5 02 and $0x2,%ebp 10b593: 0f 84 83 00 00 00 je 10b61c <_Event_Surrender+0xd8> <== NEVER TAKEN RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear( rtems_event_set the_event_set, rtems_event_set the_mask ) { return ( the_event_set & ~(the_mask) ); 10b599: 8b 44 24 18 mov 0x18(%esp),%eax 10b59d: f7 d0 not %eax 10b59f: 21 d0 and %edx,%eax 10b5a1: 89 01 mov %eax,(%ecx) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 10b5a3: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 10b5aa: 8b 43 28 mov 0x28(%ebx),%eax 10b5ad: 8b 7c 24 18 mov 0x18(%esp),%edi 10b5b1: 89 38 mov %edi,(%eax) _ISR_Flash( level ); 10b5b3: 56 push %esi 10b5b4: 9d popf 10b5b5: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10b5b6: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10b5ba: 74 6c je 10b628 <_Event_Surrender+0xe4> _ISR_Enable( level ); 10b5bc: 56 push %esi 10b5bd: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b5be: c7 44 24 04 f8 ff 03 movl $0x1003fff8,0x4(%esp) 10b5c5: 10 10b5c6: 89 1c 24 mov %ebx,(%esp) 10b5c9: e8 36 24 00 00 call 10da04 <_Thread_Clear_state> } return; } } _ISR_Enable( level ); } 10b5ce: 83 c4 2c add $0x2c,%esp 10b5d1: 5b pop %ebx 10b5d2: 5e pop %esi 10b5d3: 5f pop %edi 10b5d4: 5d pop %ebp 10b5d5: c3 ret 10b5d6: 66 90 xchg %ax,%ax * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 10b5d8: 8b 3d e0 f8 12 00 mov 0x12f8e0,%edi /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && 10b5de: 83 ff 02 cmp $0x2,%edi 10b5e1: 74 09 je 10b5ec <_Event_Surrender+0xa8> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 10b5e3: 8b 3d e0 f8 12 00 mov 0x12f8e0,%edi * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 10b5e9: 4f dec %edi 10b5ea: 75 94 jne 10b580 <_Event_Surrender+0x3c> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 10b5ec: 3b 44 24 18 cmp 0x18(%esp),%eax 10b5f0: 74 05 je 10b5f7 <_Event_Surrender+0xb3> 10b5f2: 83 e5 02 and $0x2,%ebp 10b5f5: 74 25 je 10b61c <_Event_Surrender+0xd8> <== NEVER TAKEN 10b5f7: 8b 44 24 18 mov 0x18(%esp),%eax 10b5fb: f7 d0 not %eax 10b5fd: 21 d0 and %edx,%eax 10b5ff: 89 01 mov %eax,(%ecx) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 10b601: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 10b608: 8b 43 28 mov 0x28(%ebx),%eax 10b60b: 8b 54 24 18 mov 0x18(%esp),%edx 10b60f: 89 10 mov %edx,(%eax) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10b611: c7 05 e0 f8 12 00 03 movl $0x3,0x12f8e0 10b618: 00 00 00 10b61b: 90 nop _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 10b61c: 56 push %esi 10b61d: 9d popf } 10b61e: 83 c4 2c add $0x2c,%esp 10b621: 5b pop %ebx 10b622: 5e pop %esi 10b623: 5f pop %edi 10b624: 5d pop %ebp 10b625: c3 ret 10b626: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 10b628: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10b62f: 56 push %esi 10b630: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10b631: 8d 43 48 lea 0x48(%ebx),%eax 10b634: 89 04 24 mov %eax,(%esp) 10b637: e8 6c 34 00 00 call 10eaa8 <_Watchdog_Remove> 10b63c: c7 44 24 04 f8 ff 03 movl $0x1003fff8,0x4(%esp) 10b643: 10 10b644: 89 1c 24 mov %ebx,(%esp) 10b647: e8 b8 23 00 00 call 10da04 <_Thread_Clear_state> 10b64c: eb d0 jmp 10b61e <_Event_Surrender+0xda> =============================================================================== 0010b650 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 10b650: 83 ec 2c sub $0x2c,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 10b653: 8d 44 24 1c lea 0x1c(%esp),%eax 10b657: 89 44 24 04 mov %eax,0x4(%esp) 10b65b: 8b 44 24 30 mov 0x30(%esp),%eax 10b65f: 89 04 24 mov %eax,(%esp) 10b662: e8 61 27 00 00 call 10ddc8 <_Thread_Get> switch ( location ) { 10b667: 8b 54 24 1c mov 0x1c(%esp),%edx 10b66b: 85 d2 test %edx,%edx 10b66d: 75 3b jne 10b6aa <_Event_Timeout+0x5a> <== NEVER TAKEN * * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 10b66f: 9c pushf 10b670: fa cli 10b671: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 10b672: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 10b679: 3b 05 6c f8 12 00 cmp 0x12f86c,%eax 10b67f: 74 2f je 10b6b0 <_Event_Timeout+0x60> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } the_thread->Wait.return_code = RTEMS_TIMEOUT; 10b681: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 10b688: 52 push %edx 10b689: 9d popf 10b68a: c7 44 24 04 f8 ff 03 movl $0x1003fff8,0x4(%esp) 10b691: 10 10b692: 89 04 24 mov %eax,(%esp) 10b695: e8 6a 23 00 00 call 10da04 <_Thread_Clear_state> * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 10b69a: a1 04 f6 12 00 mov 0x12f604,%eax 10b69f: 48 dec %eax 10b6a0: a3 04 f6 12 00 mov %eax,0x12f604 return _Thread_Dispatch_disable_level; 10b6a5: a1 04 f6 12 00 mov 0x12f604,%eax case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b6aa: 83 c4 2c add $0x2c,%esp 10b6ad: c3 ret 10b6ae: 66 90 xchg %ax,%ax } #endif the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10b6b0: 8b 0d e0 f8 12 00 mov 0x12f8e0,%ecx 10b6b6: 49 dec %ecx 10b6b7: 75 c8 jne 10b681 <_Event_Timeout+0x31> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10b6b9: c7 05 e0 f8 12 00 02 movl $0x2,0x12f8e0 10b6c0: 00 00 00 10b6c3: eb bc jmp 10b681 <_Event_Timeout+0x31> =============================================================================== 00110fd4 <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 110fd4: 55 push %ebp 110fd5: 57 push %edi 110fd6: 56 push %esi 110fd7: 53 push %ebx 110fd8: 83 ec 3c sub $0x3c,%esp 110fdb: 8b 6c 24 54 mov 0x54(%esp),%ebp Heap_Statistics *const stats = &heap->stats; uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE 110fdf: 8d 45 04 lea 0x4(%ebp),%eax 110fe2: 89 44 24 10 mov %eax,0x10(%esp) - HEAP_ALLOC_BONUS; uintptr_t const page_size = heap->page_size; 110fe6: 8b 54 24 50 mov 0x50(%esp),%edx 110fea: 8b 52 10 mov 0x10(%edx),%edx 110fed: 89 54 24 18 mov %edx,0x18(%esp) Heap_Block *block = NULL; uintptr_t alloc_begin = 0; uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { 110ff1: 39 c5 cmp %eax,%ebp 110ff3: 0f 87 ab 01 00 00 ja 1111a4 <_Heap_Allocate_aligned_with_boundary+0x1d0> /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 110ff9: 8b 5c 24 5c mov 0x5c(%esp),%ebx 110ffd: 85 db test %ebx,%ebx 110fff: 0f 85 77 01 00 00 jne 11117c <_Heap_Allocate_aligned_with_boundary+0x1a8> return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 111005: 8b 54 24 50 mov 0x50(%esp),%edx 111009: 8b 72 08 mov 0x8(%edx),%esi do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 11100c: 31 ff xor %edi,%edi 11100e: 39 f2 cmp %esi,%edx 111010: 74 4a je 11105c <_Heap_Allocate_aligned_with_boundary+0x88> uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 111012: 8b 44 24 18 mov 0x18(%esp),%eax 111016: 83 c0 07 add $0x7,%eax 111019: 89 44 24 24 mov %eax,0x24(%esp) + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 11101d: c7 44 24 14 04 00 00 movl $0x4,0x14(%esp) 111024: 00 111025: 29 6c 24 14 sub %ebp,0x14(%esp) 111029: eb 1e jmp 111049 <_Heap_Allocate_aligned_with_boundary+0x75> 11102b: 90 nop * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag * field. Thus the value is about one unit larger than the real block * size. The greater than operator takes this into account. */ if ( block->size_and_flag > block_size_floor ) { if ( alignment == 0 ) { 11102c: 8b 54 24 58 mov 0x58(%esp),%edx 111030: 85 d2 test %edx,%edx 111032: 75 40 jne 111074 <_Heap_Allocate_aligned_with_boundary+0xa0> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 111034: 8d 5e 08 lea 0x8(%esi),%ebx ); } } /* Statistics */ ++search_count; 111037: 47 inc %edi if ( alloc_begin != 0 ) { 111038: 85 db test %ebx,%ebx 11103a: 0f 85 14 01 00 00 jne 111154 <_Heap_Allocate_aligned_with_boundary+0x180><== ALWAYS TAKEN break; } block = block->next; 111040: 8b 76 08 mov 0x8(%esi),%esi do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 111043: 39 74 24 50 cmp %esi,0x50(%esp) 111047: 74 13 je 11105c <_Heap_Allocate_aligned_with_boundary+0x88> /* * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag * field. Thus the value is about one unit larger than the real block * size. The greater than operator takes this into account. */ if ( block->size_and_flag > block_size_floor ) { 111049: 8b 5e 04 mov 0x4(%esi),%ebx 11104c: 39 5c 24 10 cmp %ebx,0x10(%esp) 111050: 72 da jb 11102c <_Heap_Allocate_aligned_with_boundary+0x58> ); } } /* Statistics */ ++search_count; 111052: 47 inc %edi if ( alloc_begin != 0 ) { break; } block = block->next; 111053: 8b 76 08 mov 0x8(%esi),%esi do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 111056: 39 74 24 50 cmp %esi,0x50(%esp) 11105a: 75 ed jne 111049 <_Heap_Allocate_aligned_with_boundary+0x75> ); } } /* Statistics */ ++search_count; 11105c: 31 c0 xor %eax,%eax boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 11105e: 8b 54 24 50 mov 0x50(%esp),%edx 111062: 39 7a 44 cmp %edi,0x44(%edx) 111065: 73 03 jae 11106a <_Heap_Allocate_aligned_with_boundary+0x96> stats->max_search = search_count; 111067: 89 7a 44 mov %edi,0x44(%edx) } return (void *) alloc_begin; } 11106a: 83 c4 3c add $0x3c,%esp 11106d: 5b pop %ebx 11106e: 5e pop %esi 11106f: 5f pop %edi 111070: 5d pop %ebp 111071: c3 ret 111072: 66 90 xchg %ax,%ax 111074: 8b 54 24 50 mov 0x50(%esp),%edx 111078: 8b 52 14 mov 0x14(%edx),%edx 11107b: 89 54 24 1c mov %edx,0x1c(%esp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 11107f: 83 e3 fe and $0xfffffffe,%ebx uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; 111082: 01 f3 add %esi,%ebx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 111084: 8d 46 08 lea 0x8(%esi),%eax 111087: 89 44 24 20 mov %eax,0x20(%esp) uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size + HEAP_BLOCK_HEADER_SIZE + page_size - 1; 11108b: 8b 4c 24 24 mov 0x24(%esp),%ecx 11108f: 29 d1 sub %edx,%ecx uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 111091: 01 d9 add %ebx,%ecx + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; uintptr_t alloc_begin = alloc_end - alloc_size; 111093: 03 5c 24 14 add 0x14(%esp),%ebx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 111097: 89 d8 mov %ebx,%eax 111099: 31 d2 xor %edx,%edx 11109b: f7 74 24 58 divl 0x58(%esp) 11109f: 29 d3 sub %edx,%ebx alloc_begin = _Heap_Align_down( alloc_begin, alignment ); /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { 1110a1: 39 d9 cmp %ebx,%ecx 1110a3: 73 0c jae 1110b1 <_Heap_Allocate_aligned_with_boundary+0xdd> 1110a5: 89 c8 mov %ecx,%eax 1110a7: 31 d2 xor %edx,%edx 1110a9: f7 74 24 58 divl 0x58(%esp) 1110ad: 89 cb mov %ecx,%ebx 1110af: 29 d3 sub %edx,%ebx } alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { 1110b1: 8b 44 24 5c mov 0x5c(%esp),%eax 1110b5: 85 c0 test %eax,%eax 1110b7: 74 64 je 11111d <_Heap_Allocate_aligned_with_boundary+0x149> /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment ); } alloc_end = alloc_begin + alloc_size; 1110b9: 8d 0c 2b lea (%ebx,%ebp,1),%ecx /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; 1110bc: 8b 54 24 20 mov 0x20(%esp),%edx 1110c0: 01 ea add %ebp,%edx 1110c2: 89 54 24 28 mov %edx,0x28(%esp) 1110c6: 89 c8 mov %ecx,%eax 1110c8: 31 d2 xor %edx,%edx 1110ca: f7 74 24 5c divl 0x5c(%esp) 1110ce: 89 c8 mov %ecx,%eax 1110d0: 29 d0 sub %edx,%eax uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 1110d2: 39 c3 cmp %eax,%ebx 1110d4: 73 47 jae 11111d <_Heap_Allocate_aligned_with_boundary+0x149> 1110d6: 39 c1 cmp %eax,%ecx 1110d8: 76 43 jbe 11111d <_Heap_Allocate_aligned_with_boundary+0x149> if ( boundary_line < boundary_floor ) { 1110da: 39 44 24 28 cmp %eax,0x28(%esp) 1110de: 77 68 ja 111148 <_Heap_Allocate_aligned_with_boundary+0x174> 1110e0: 89 74 24 2c mov %esi,0x2c(%esp) 1110e4: 8b 74 24 28 mov 0x28(%esp),%esi 1110e8: eb 0e jmp 1110f8 <_Heap_Allocate_aligned_with_boundary+0x124> 1110ea: 66 90 xchg %ax,%ax /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 1110ec: 39 c1 cmp %eax,%ecx 1110ee: 76 29 jbe 111119 <_Heap_Allocate_aligned_with_boundary+0x145> if ( boundary_line < boundary_floor ) { 1110f0: 39 c6 cmp %eax,%esi 1110f2: 0f 87 a0 00 00 00 ja 111198 <_Heap_Allocate_aligned_with_boundary+0x1c4><== NEVER TAKEN return 0; } alloc_begin = boundary_line - alloc_size; 1110f8: 89 c3 mov %eax,%ebx 1110fa: 29 eb sub %ebp,%ebx 1110fc: 89 d8 mov %ebx,%eax 1110fe: 31 d2 xor %edx,%edx 111100: f7 74 24 58 divl 0x58(%esp) 111104: 29 d3 sub %edx,%ebx alloc_begin = _Heap_Align_down( alloc_begin, alignment ); alloc_end = alloc_begin + alloc_size; 111106: 8d 0c 2b lea (%ebx,%ebp,1),%ecx 111109: 89 c8 mov %ecx,%eax 11110b: 31 d2 xor %edx,%edx 11110d: f7 74 24 5c divl 0x5c(%esp) 111111: 89 c8 mov %ecx,%eax 111113: 29 d0 sub %edx,%eax /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 111115: 39 c3 cmp %eax,%ebx 111117: 72 d3 jb 1110ec <_Heap_Allocate_aligned_with_boundary+0x118> 111119: 8b 74 24 2c mov 0x2c(%esp),%esi boundary_line = _Heap_Align_down( alloc_end, boundary ); } } /* Ensure that the we have a valid new block at the beginning */ if ( alloc_begin >= alloc_begin_floor ) { 11111d: 39 5c 24 20 cmp %ebx,0x20(%esp) 111121: 77 25 ja 111148 <_Heap_Allocate_aligned_with_boundary+0x174> 111123: b9 f8 ff ff ff mov $0xfffffff8,%ecx 111128: 29 f1 sub %esi,%ecx uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 11112a: 01 d9 add %ebx,%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 11112c: 89 d8 mov %ebx,%eax 11112e: 31 d2 xor %edx,%edx 111130: f7 74 24 18 divl 0x18(%esp) uintptr_t const alloc_block_begin = (uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size ); uintptr_t const free_size = alloc_block_begin - block_begin; 111134: 29 d1 sub %edx,%ecx if ( free_size >= min_block_size || free_size == 0 ) { 111136: 39 4c 24 1c cmp %ecx,0x1c(%esp) 11113a: 0f 86 f7 fe ff ff jbe 111037 <_Heap_Allocate_aligned_with_boundary+0x63> 111140: 85 c9 test %ecx,%ecx 111142: 0f 84 ef fe ff ff je 111037 <_Heap_Allocate_aligned_with_boundary+0x63> uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { if ( boundary_line < boundary_floor ) { return 0; 111148: 31 db xor %ebx,%ebx ); } } /* Statistics */ ++search_count; 11114a: 47 inc %edi if ( alloc_begin != 0 ) { 11114b: 85 db test %ebx,%ebx 11114d: 0f 84 ed fe ff ff je 111040 <_Heap_Allocate_aligned_with_boundary+0x6c><== ALWAYS TAKEN 111153: 90 nop search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; 111154: 8b 44 24 50 mov 0x50(%esp),%eax 111158: ff 40 48 incl 0x48(%eax) stats->searches += search_count; 11115b: 01 78 4c add %edi,0x4c(%eax) block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 11115e: 89 6c 24 0c mov %ebp,0xc(%esp) 111162: 89 5c 24 08 mov %ebx,0x8(%esp) 111166: 89 74 24 04 mov %esi,0x4(%esp) 11116a: 89 04 24 mov %eax,(%esp) 11116d: e8 6a b9 ff ff call 10cadc <_Heap_Block_allocate> 111172: 89 d8 mov %ebx,%eax 111174: e9 e5 fe ff ff jmp 11105e <_Heap_Allocate_aligned_with_boundary+0x8a> 111179: 8d 76 00 lea 0x0(%esi),%esi /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { if ( boundary < alloc_size ) { 11117c: 3b 6c 24 5c cmp 0x5c(%esp),%ebp 111180: 77 22 ja 1111a4 <_Heap_Allocate_aligned_with_boundary+0x1d0> return NULL; } if ( alignment == 0 ) { 111182: 8b 4c 24 58 mov 0x58(%esp),%ecx 111186: 85 c9 test %ecx,%ecx 111188: 0f 85 77 fe ff ff jne 111005 <_Heap_Allocate_aligned_with_boundary+0x31> alignment = page_size; 11118e: 89 54 24 58 mov %edx,0x58(%esp) 111192: e9 6e fe ff ff jmp 111005 <_Heap_Allocate_aligned_with_boundary+0x31> 111197: 90 nop 111198: 8b 74 24 2c mov 0x2c(%esp),%esi <== NOT EXECUTED uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { if ( boundary_line < boundary_floor ) { return 0; 11119c: 31 db xor %ebx,%ebx <== NOT EXECUTED 11119e: e9 94 fe ff ff jmp 111037 <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED 1111a3: 90 nop <== NOT EXECUTED uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { /* Integer overflow occured */ return NULL; 1111a4: 31 c0 xor %eax,%eax if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 1111a6: 83 c4 3c add $0x3c,%esp 1111a9: 5b pop %ebx 1111aa: 5e pop %esi 1111ab: 5f pop %edi 1111ac: 5d pop %ebp 1111ad: c3 ret =============================================================================== 0011120c <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 11120c: 55 push %ebp 11120d: 57 push %edi 11120e: 56 push %esi 11120f: 53 push %ebx 111210: 83 ec 5c sub $0x5c,%esp 111213: 8b 7c 24 70 mov 0x70(%esp),%edi Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 111217: 8b 4f 20 mov 0x20(%edi),%ecx 11121a: 89 4c 24 28 mov %ecx,0x28(%esp) Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 11121e: c7 44 24 48 00 00 00 movl $0x0,0x48(%esp) 111225: 00 Heap_Block *extend_last_block = NULL; 111226: c7 44 24 4c 00 00 00 movl $0x0,0x4c(%esp) 11122d: 00 uintptr_t const page_size = heap->page_size; 11122e: 8b 4f 10 mov 0x10(%edi),%ecx 111231: 89 4c 24 24 mov %ecx,0x24(%esp) uintptr_t const min_block_size = heap->min_block_size; 111235: 8b 47 14 mov 0x14(%edi),%eax uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size; 111238: 8b 4f 30 mov 0x30(%edi),%ecx 11123b: 89 4c 24 2c mov %ecx,0x2c(%esp) uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 11123f: 8b 6c 24 74 mov 0x74(%esp),%ebp 111243: 03 6c 24 78 add 0x78(%esp),%ebp 111247: 73 0b jae 111254 <_Heap_Extend+0x48> return false; 111249: 31 c0 xor %eax,%eax if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 11124b: 83 c4 5c add $0x5c,%esp 11124e: 5b pop %ebx 11124f: 5e pop %esi 111250: 5f pop %edi 111251: 5d pop %ebp 111252: c3 ret 111253: 90 nop if ( extend_area_end < extend_area_begin ) { return false; } extend_area_ok = _Heap_Get_first_and_last_block( 111254: 8d 54 24 4c lea 0x4c(%esp),%edx 111258: 89 54 24 14 mov %edx,0x14(%esp) 11125c: 8d 54 24 48 lea 0x48(%esp),%edx 111260: 89 54 24 10 mov %edx,0x10(%esp) 111264: 89 44 24 0c mov %eax,0xc(%esp) 111268: 8b 4c 24 24 mov 0x24(%esp),%ecx 11126c: 89 4c 24 08 mov %ecx,0x8(%esp) 111270: 8b 44 24 78 mov 0x78(%esp),%eax 111274: 89 44 24 04 mov %eax,0x4(%esp) 111278: 8b 4c 24 74 mov 0x74(%esp),%ecx 11127c: 89 0c 24 mov %ecx,(%esp) 11127f: e8 38 b7 ff ff call 10c9bc <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 111284: 84 c0 test %al,%al 111286: 74 c1 je 111249 <_Heap_Extend+0x3d> 111288: 8b 5c 24 28 mov 0x28(%esp),%ebx 11128c: c7 44 24 34 00 00 00 movl $0x0,0x34(%esp) 111293: 00 111294: c7 44 24 38 00 00 00 movl $0x0,0x38(%esp) 11129b: 00 11129c: c7 44 24 20 00 00 00 movl $0x0,0x20(%esp) 1112a3: 00 1112a4: c7 44 24 30 00 00 00 movl $0x0,0x30(%esp) 1112ab: 00 1112ac: 89 7c 24 3c mov %edi,0x3c(%esp) 1112b0: eb 28 jmp 1112da <_Heap_Extend+0xce> 1112b2: 66 90 xchg %ax,%ax return false; } if ( extend_area_end == sub_area_begin ) { merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 1112b4: 39 cd cmp %ecx,%ebp 1112b6: 73 04 jae 1112bc <_Heap_Extend+0xb0> 1112b8: 89 5c 24 38 mov %ebx,0x38(%esp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 1112bc: 3b 4c 24 74 cmp 0x74(%esp),%ecx 1112c0: 74 4f je 111311 <_Heap_Extend+0x105> start_block->prev_size = extend_area_end; merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 1112c2: 39 4c 24 74 cmp %ecx,0x74(%esp) 1112c6: 76 04 jbe 1112cc <_Heap_Extend+0xc0> RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area( uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) 1112c8: 89 74 24 34 mov %esi,0x34(%esp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 1112cc: 8b 5e 04 mov 0x4(%esi),%ebx 1112cf: 83 e3 fe and $0xfffffffe,%ebx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 1112d2: 01 f3 add %esi,%ebx link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 1112d4: 39 5c 24 28 cmp %ebx,0x28(%esp) 1112d8: 74 4b je 111325 <_Heap_Extend+0x119> return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 1112da: 3b 5c 24 28 cmp 0x28(%esp),%ebx 1112de: 0f 84 40 01 00 00 je 111424 <_Heap_Extend+0x218> 1112e4: 89 df mov %ebx,%edi uintptr_t const sub_area_end = start_block->prev_size; 1112e6: 8b 0b mov (%ebx),%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 1112e8: 8d 71 f8 lea -0x8(%ecx),%esi 1112eb: 89 c8 mov %ecx,%eax 1112ed: 31 d2 xor %edx,%edx 1112ef: f7 74 24 24 divl 0x24(%esp) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 1112f3: 29 d6 sub %edx,%esi Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 1112f5: 39 4c 24 74 cmp %ecx,0x74(%esp) 1112f9: 73 08 jae 111303 <_Heap_Extend+0xf7> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin 1112fb: 39 ef cmp %ebp,%edi 1112fd: 0f 82 46 ff ff ff jb 111249 <_Heap_Extend+0x3d> ) { return false; } if ( extend_area_end == sub_area_begin ) { 111303: 39 ef cmp %ebp,%edi 111305: 75 ad jne 1112b4 <_Heap_Extend+0xa8> 111307: 89 5c 24 30 mov %ebx,0x30(%esp) merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 11130b: 3b 4c 24 74 cmp 0x74(%esp),%ecx 11130f: 75 b1 jne 1112c2 <_Heap_Extend+0xb6> <== ALWAYS TAKEN start_block->prev_size = extend_area_end; 111311: 89 2b mov %ebp,(%ebx) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area( uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) 111313: 89 74 24 20 mov %esi,0x20(%esp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 111317: 8b 5e 04 mov 0x4(%esi),%ebx 11131a: 83 e3 fe and $0xfffffffe,%ebx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11131d: 01 f3 add %esi,%ebx } else if ( sub_area_end < extend_area_begin ) { link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 11131f: 39 5c 24 28 cmp %ebx,0x28(%esp) 111323: 75 b5 jne 1112da <_Heap_Extend+0xce> <== NEVER TAKEN 111325: 8b 7c 24 3c mov 0x3c(%esp),%edi if ( extend_area_begin < heap->area_begin ) { 111329: 8b 4c 24 74 mov 0x74(%esp),%ecx 11132d: 3b 4f 18 cmp 0x18(%edi),%ecx 111330: 0f 82 fa 00 00 00 jb 111430 <_Heap_Extend+0x224> heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { 111336: 3b 6f 1c cmp 0x1c(%edi),%ebp 111339: 76 03 jbe 11133e <_Heap_Extend+0x132> heap->area_end = extend_area_end; 11133b: 89 6f 1c mov %ebp,0x1c(%edi) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 11133e: 8b 54 24 4c mov 0x4c(%esp),%edx 111342: 8b 44 24 48 mov 0x48(%esp),%eax heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = 111346: 89 d1 mov %edx,%ecx 111348: 29 c1 sub %eax,%ecx (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 11134a: 89 28 mov %ebp,(%eax) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 11134c: 89 cb mov %ecx,%ebx 11134e: 83 cb 01 or $0x1,%ebx 111351: 89 58 04 mov %ebx,0x4(%eax) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 111354: 89 0a mov %ecx,(%edx) extend_last_block->size_and_flag = 0; 111356: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 11135d: 39 47 20 cmp %eax,0x20(%edi) 111360: 0f 86 d2 00 00 00 jbe 111438 <_Heap_Extend+0x22c> heap->first_block = extend_first_block; 111366: 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 ) { 111369: 8b 44 24 30 mov 0x30(%esp),%eax 11136d: 85 c0 test %eax,%eax 11136f: 0f 84 d7 00 00 00 je 11144c <_Heap_Extend+0x240> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 111375: 8b 4f 10 mov 0x10(%edi),%ecx uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 111378: 8b 5c 24 74 mov 0x74(%esp),%ebx 11137c: 83 c3 08 add $0x8,%ebx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 11137f: 89 d8 mov %ebx,%eax 111381: 31 d2 xor %edx,%edx 111383: f7 f1 div %ecx if ( remainder != 0 ) { 111385: 85 d2 test %edx,%edx 111387: 74 04 je 11138d <_Heap_Extend+0x181> return value - remainder + alignment; 111389: 01 cb add %ecx,%ebx 11138b: 29 d3 sub %edx,%ebx uintptr_t const new_first_block_begin = 11138d: 8d 53 f8 lea -0x8(%ebx),%edx uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; 111390: 8b 4c 24 30 mov 0x30(%esp),%ecx 111394: 8b 01 mov (%ecx),%eax 111396: 89 43 f8 mov %eax,-0x8(%ebx) uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const new_first_block_begin = new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = 111399: 89 c8 mov %ecx,%eax 11139b: 29 d0 sub %edx,%eax first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED; 11139d: 83 c8 01 or $0x1,%eax 1113a0: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 1113a3: 89 f8 mov %edi,%eax 1113a5: e8 46 fe ff ff call 1111f0 <_Heap_Free_block> link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 1113aa: 8b 5c 24 20 mov 0x20(%esp),%ebx 1113ae: 85 db test %ebx,%ebx 1113b0: 0f 84 b6 00 00 00 je 11146c <_Heap_Extend+0x260> ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE, 1113b6: 8d 4d f8 lea -0x8(%ebp),%ecx uintptr_t extend_area_end ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( 1113b9: 2b 4c 24 20 sub 0x20(%esp),%ecx RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 1113bd: 89 c8 mov %ecx,%eax 1113bf: 31 d2 xor %edx,%edx 1113c1: f7 77 10 divl 0x10(%edi) 1113c4: 29 d1 sub %edx,%ecx ); Heap_Block *const new_last_block = _Heap_Block_at( last_block, last_block_new_size ); new_last_block->size_and_flag = (last_block->size_and_flag - last_block_new_size) 1113c6: 8b 54 24 20 mov 0x20(%esp),%edx 1113ca: 8b 42 04 mov 0x4(%edx),%eax 1113cd: 29 c8 sub %ecx,%eax | HEAP_PREV_BLOCK_USED; 1113cf: 83 c8 01 or $0x1,%eax 1113d2: 89 44 11 04 mov %eax,0x4(%ecx,%edx,1) RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 1113d6: 8b 42 04 mov 0x4(%edx),%eax 1113d9: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 1113dc: 09 c8 or %ecx,%eax 1113de: 89 42 04 mov %eax,0x4(%edx) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 1113e1: 89 f8 mov %edi,%eax 1113e3: e8 08 fe ff ff call 1111f0 <_Heap_Free_block> if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 1113e8: 8b 57 24 mov 0x24(%edi),%edx RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 1113eb: 8b 42 04 mov 0x4(%edx),%eax 1113ee: 83 e0 01 and $0x1,%eax * This feature will be used to terminate the scattered heap area list. See * also _Heap_Extend(). */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( 1113f1: 8b 4f 20 mov 0x20(%edi),%ecx 1113f4: 29 d1 sub %edx,%ecx uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; block->size_and_flag = size | flag; 1113f6: 09 c8 or %ecx,%eax 1113f8: 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; 1113fb: 8b 47 30 mov 0x30(%edi),%eax 1113fe: 2b 44 24 2c sub 0x2c(%esp),%eax /* Statistics */ stats->size += extended_size; 111402: 01 47 2c add %eax,0x2c(%edi) if ( extended_size_ptr != NULL ) 111405: 8b 54 24 7c mov 0x7c(%esp),%edx 111409: 85 d2 test %edx,%edx 11140b: 0f 84 a3 00 00 00 je 1114b4 <_Heap_Extend+0x2a8> <== NEVER TAKEN *extended_size_ptr = extended_size; 111411: 8b 4c 24 7c mov 0x7c(%esp),%ecx 111415: 89 01 mov %eax,(%ecx) return true; 111417: b0 01 mov $0x1,%al } 111419: 83 c4 5c add $0x5c,%esp 11141c: 5b pop %ebx 11141d: 5e pop %esi 11141e: 5f pop %edi 11141f: 5d pop %ebp 111420: c3 ret 111421: 8d 76 00 lea 0x0(%esi),%esi return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 111424: 8b 4c 24 3c mov 0x3c(%esp),%ecx 111428: 8b 79 18 mov 0x18(%ecx),%edi 11142b: e9 b6 fe ff ff jmp 1112e6 <_Heap_Extend+0xda> start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); if ( extend_area_begin < heap->area_begin ) { heap->area_begin = extend_area_begin; 111430: 89 4f 18 mov %ecx,0x18(%edi) 111433: e9 06 ff ff ff jmp 11133e <_Heap_Extend+0x132> extend_last_block->size_and_flag = 0; _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { heap->first_block = extend_first_block; } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 111438: 39 57 24 cmp %edx,0x24(%edi) 11143b: 0f 83 28 ff ff ff jae 111369 <_Heap_Extend+0x15d> heap->last_block = extend_last_block; 111441: 89 57 24 mov %edx,0x24(%edi) 111444: e9 20 ff ff ff jmp 111369 <_Heap_Extend+0x15d> 111449: 8d 76 00 lea 0x0(%esi),%esi } if ( merge_below_block != NULL ) { _Heap_Merge_below( heap, extend_area_begin, merge_below_block ); } else if ( link_below_block != NULL ) { 11144c: 8b 74 24 38 mov 0x38(%esp),%esi 111450: 85 f6 test %esi,%esi 111452: 0f 84 52 ff ff ff je 1113aa <_Heap_Extend+0x19e> { uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const link_begin = (uintptr_t) link; last_block->size_and_flag = (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED; 111458: 8b 44 24 38 mov 0x38(%esp),%eax 11145c: 29 d0 sub %edx,%eax 11145e: 83 c8 01 or $0x1,%eax 111461: 89 42 04 mov %eax,0x4(%edx) 111464: e9 41 ff ff ff jmp 1113aa <_Heap_Extend+0x19e> 111469: 8d 76 00 lea 0x0(%esi),%esi ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 11146c: 8b 4c 24 34 mov 0x34(%esp),%ecx 111470: 85 c9 test %ecx,%ecx 111472: 74 23 je 111497 <_Heap_Extend+0x28b> _Heap_Link_above( 111474: 8b 4c 24 4c mov 0x4c(%esp),%ecx RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 111478: 8b 54 24 34 mov 0x34(%esp),%edx 11147c: 8b 42 04 mov 0x4(%edx),%eax 11147f: 83 e0 01 and $0x1,%eax ) { uintptr_t const link_begin = (uintptr_t) link; uintptr_t const first_block_begin = (uintptr_t) first_block; _Heap_Block_set_size( link, first_block_begin - link_begin ); 111482: 8b 54 24 48 mov 0x48(%esp),%edx 111486: 2b 54 24 34 sub 0x34(%esp),%edx block->size_and_flag = size | flag; 11148a: 09 d0 or %edx,%eax 11148c: 8b 54 24 34 mov 0x34(%esp),%edx 111490: 89 42 04 mov %eax,0x4(%edx) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 111493: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 111497: 83 7c 24 30 00 cmpl $0x0,0x30(%esp) 11149c: 0f 85 46 ff ff ff jne 1113e8 <_Heap_Extend+0x1dc> _Heap_Free_block( heap, extend_first_block ); 1114a2: 8b 54 24 48 mov 0x48(%esp),%edx 1114a6: 89 f8 mov %edi,%eax 1114a8: e8 43 fd ff ff call 1111f0 <_Heap_Free_block> 1114ad: e9 36 ff ff ff jmp 1113e8 <_Heap_Extend+0x1dc> 1114b2: 66 90 xchg %ax,%ax stats->size += extended_size; if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 1114b4: b0 01 mov $0x1,%al <== NOT EXECUTED 1114b6: e9 90 fd ff ff jmp 11124b <_Heap_Extend+0x3f> <== NOT EXECUTED =============================================================================== 001111b0 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 1111b0: 55 push %ebp 1111b1: 57 push %edi 1111b2: 56 push %esi 1111b3: 53 push %ebx 1111b4: 83 ec 0c sub $0xc,%esp 1111b7: 8b 4c 24 20 mov 0x20(%esp),%ecx 1111bb: 8b 44 24 24 mov 0x24(%esp),%eax /* * If NULL return true so a free on NULL is considered a valid release. This * is a special case that could be handled by the in heap check how-ever that * would result in false being returned which is wrong. */ if ( alloc_begin_ptr == NULL ) { 1111bf: 85 c0 test %eax,%eax 1111c1: 0f 84 a1 00 00 00 je 111268 <_Heap_Free+0xb8> 1111c7: 8d 58 f8 lea -0x8(%eax),%ebx 1111ca: 31 d2 xor %edx,%edx 1111cc: f7 71 10 divl 0x10(%ecx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 1111cf: 29 d3 sub %edx,%ebx RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap( const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block 1111d1: 8b 41 20 mov 0x20(%ecx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 1111d4: 39 c3 cmp %eax,%ebx 1111d6: 72 1c jb 1111f4 <_Heap_Free+0x44> 1111d8: 8b 71 24 mov 0x24(%ecx),%esi 1111db: 39 f3 cmp %esi,%ebx 1111dd: 77 15 ja 1111f4 <_Heap_Free+0x44> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 1111df: 8b 53 04 mov 0x4(%ebx),%edx 1111e2: 89 14 24 mov %edx,(%esp) - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 1111e5: 89 d7 mov %edx,%edi 1111e7: 83 e7 fe and $0xfffffffe,%edi RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 1111ea: 8d 14 1f lea (%edi,%ebx,1),%edx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 1111ed: 39 d0 cmp %edx,%eax 1111ef: 76 0f jbe 111200 <_Heap_Free+0x50> <== ALWAYS TAKEN 1111f1: 8d 76 00 lea 0x0(%esi),%esi alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 1111f4: 31 c0 xor %eax,%eax --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 1111f6: 83 c4 0c add $0xc,%esp 1111f9: 5b pop %ebx 1111fa: 5e pop %esi 1111fb: 5f pop %edi 1111fc: 5d pop %ebp 1111fd: c3 ret 1111fe: 66 90 xchg %ax,%ax 111200: 39 d6 cmp %edx,%esi 111202: 72 f0 jb 1111f4 <_Heap_Free+0x44> <== NEVER TAKEN 111204: 8b 6a 04 mov 0x4(%edx),%ebp 111207: 89 6c 24 04 mov %ebp,0x4(%esp) return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 11120b: 83 e5 01 and $0x1,%ebp 11120e: 74 e4 je 1111f4 <_Heap_Free+0x44> <== NEVER TAKEN - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 111210: 8b 6c 24 04 mov 0x4(%esp),%ebp 111214: 83 e5 fe and $0xfffffffe,%ebp 111217: 89 6c 24 04 mov %ebp,0x4(%esp) 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 )); 11121b: 39 d6 cmp %edx,%esi 11121d: 74 53 je 111272 <_Heap_Free+0xc2> 11121f: f6 44 2a 04 01 testb $0x1,0x4(%edx,%ebp,1) 111224: 75 4c jne 111272 <_Heap_Free+0xc2> if ( !_Heap_Is_prev_used( block ) ) { 111226: f6 04 24 01 testb $0x1,(%esp) 11122a: 0f 84 df 00 00 00 je 11130f <_Heap_Free+0x15f> 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; 111230: 8b 6c 24 04 mov 0x4(%esp),%ebp 111234: 01 fd add %edi,%ebp --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 111236: 8b 72 08 mov 0x8(%edx),%esi 111239: 8b 42 0c mov 0xc(%edx),%eax ) { Heap_Block *next = old_block->next; Heap_Block *prev = old_block->prev; new_block->next = next; 11123c: 89 73 08 mov %esi,0x8(%ebx) new_block->prev = prev; 11123f: 89 43 0c mov %eax,0xc(%ebx) next->prev = new_block; 111242: 89 5e 0c mov %ebx,0xc(%esi) prev->next = new_block; 111245: 89 58 08 mov %ebx,0x8(%eax) next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ uintptr_t const size = block_size + next_block_size; _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 111248: 89 e8 mov %ebp,%eax 11124a: 83 c8 01 or $0x1,%eax 11124d: 89 43 04 mov %eax,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 111250: 89 6c 1d 00 mov %ebp,0x0(%ebp,%ebx,1) stats->max_free_blocks = stats->free_blocks; } } /* Statistics */ --stats->used_blocks; 111254: ff 49 40 decl 0x40(%ecx) ++stats->frees; 111257: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 11125a: 01 79 30 add %edi,0x30(%ecx) return( true ); 11125d: b0 01 mov $0x1,%al } 11125f: 83 c4 0c add $0xc,%esp 111262: 5b pop %ebx 111263: 5e pop %esi 111264: 5f pop %edi 111265: 5d pop %ebp 111266: c3 ret 111267: 90 nop * If NULL return true so a free on NULL is considered a valid release. This * is a special case that could be handled by the in heap check how-ever that * would result in false being returned which is wrong. */ if ( alloc_begin_ptr == NULL ) { return true; 111268: b0 01 mov $0x1,%al --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 11126a: 83 c4 0c add $0xc,%esp 11126d: 5b pop %ebx 11126e: 5e pop %esi 11126f: 5f pop %edi 111270: 5d pop %ebp 111271: c3 ret next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { 111272: f6 04 24 01 testb $0x1,(%esp) 111276: 75 4d jne 1112c5 <_Heap_Free+0x115> if ( !_Heap_Protection_determine_block_free( heap, block ) ) { return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block 111278: c6 44 24 0b 00 movb $0x0,0xb(%esp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { uintptr_t const prev_size = block->prev_size; 11127d: 8b 2b mov (%ebx),%ebp RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11127f: 29 eb sub %ebp,%ebx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 111281: 39 d8 cmp %ebx,%eax 111283: 0f 87 6b ff ff ff ja 1111f4 <_Heap_Free+0x44> <== NEVER TAKEN 111289: 39 de cmp %ebx,%esi 11128b: 0f 82 63 ff ff ff jb 1111f4 <_Heap_Free+0x44> <== NEVER TAKEN return( false ); } /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { 111291: f6 43 04 01 testb $0x1,0x4(%ebx) 111295: 0f 84 59 ff ff ff je 1111f4 <_Heap_Free+0x44> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ uintptr_t const size = block_size + prev_size + next_block_size; 11129b: 01 fd add %edi,%ebp if ( !_Heap_Is_prev_used ( prev_block) ) { _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 11129d: 80 7c 24 0b 00 cmpb $0x0,0xb(%esp) 1112a2: 74 58 je 1112fc <_Heap_Free+0x14c> uintptr_t const size = block_size + prev_size + next_block_size; 1112a4: 03 6c 24 04 add 0x4(%esp),%ebp --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 1112a8: 8b 42 08 mov 0x8(%edx),%eax 1112ab: 8b 52 0c mov 0xc(%edx),%edx RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; Heap_Block *prev = block->prev; prev->next = next; 1112ae: 89 42 08 mov %eax,0x8(%edx) next->prev = prev; 1112b1: 89 50 0c mov %edx,0xc(%eax) } if ( next_is_free ) { /* coalesce both */ uintptr_t const size = block_size + prev_size + next_block_size; _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 1112b4: ff 49 38 decl 0x38(%ecx) prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 1112b7: 89 e8 mov %ebp,%eax 1112b9: 83 c8 01 or $0x1,%eax 1112bc: 89 43 04 mov %eax,0x4(%ebx) next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; 1112bf: 89 6c 1d 00 mov %ebp,0x0(%ebp,%ebx,1) 1112c3: eb 8f jmp 111254 <_Heap_Free+0xa4> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 1112c5: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 1112c8: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 1112cb: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 1112ce: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 1112d1: 89 58 0c mov %ebx,0xc(%eax) next_block->prev_size = size; } else { /* no coalesce */ /* Add 'block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block ); block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 1112d4: 89 f8 mov %edi,%eax 1112d6: 83 c8 01 or $0x1,%eax 1112d9: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 1112dc: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 1112e0: 89 3a mov %edi,(%edx) /* Statistics */ ++stats->free_blocks; 1112e2: 8b 41 38 mov 0x38(%ecx),%eax 1112e5: 40 inc %eax 1112e6: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 1112e9: 3b 41 3c cmp 0x3c(%ecx),%eax 1112ec: 0f 86 62 ff ff ff jbe 111254 <_Heap_Free+0xa4> stats->max_free_blocks = stats->free_blocks; 1112f2: 89 41 3c mov %eax,0x3c(%ecx) 1112f5: e9 5a ff ff ff jmp 111254 <_Heap_Free+0xa4> 1112fa: 66 90 xchg %ax,%ax next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uintptr_t const size = block_size + prev_size; prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 1112fc: 89 e8 mov %ebp,%eax 1112fe: 83 c8 01 or $0x1,%eax 111301: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 111304: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 111308: 89 2a mov %ebp,(%edx) 11130a: e9 45 ff ff ff jmp 111254 <_Heap_Free+0xa4> if ( !_Heap_Protection_determine_block_free( heap, block ) ) { return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block 11130f: c6 44 24 0b 01 movb $0x1,0xb(%esp) 111314: e9 64 ff ff ff jmp 11127d <_Heap_Free+0xcd> =============================================================================== 00115330 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 115330: 55 push %ebp 115331: 57 push %edi 115332: 56 push %esi 115333: 53 push %ebx 115334: 8b 6c 24 14 mov 0x14(%esp),%ebp 115338: 8b 7c 24 18 mov 0x18(%esp),%edi Heap_Block *the_block; Heap_Block *const tail = _Heap_Free_list_tail(the_heap); info->number = 0; 11533c: c7 07 00 00 00 00 movl $0x0,(%edi) info->largest = 0; 115342: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) info->total = 0; 115349: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 115350: 8b 55 08 mov 0x8(%ebp),%edx for(the_block = _Heap_Free_list_first(the_heap); 115353: 39 d5 cmp %edx,%ebp 115355: 74 30 je 115387 <_Heap_Get_free_information+0x57><== NEVER TAKEN 115357: bb 01 00 00 00 mov $0x1,%ebx 11535c: 31 f6 xor %esi,%esi 11535e: 31 c9 xor %ecx,%ecx 115360: eb 07 jmp 115369 <_Heap_Get_free_information+0x39> 115362: 66 90 xchg %ax,%ax 115364: 8b 77 04 mov 0x4(%edi),%esi 115367: 89 c3 mov %eax,%ebx - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 115369: 8b 42 04 mov 0x4(%edx),%eax 11536c: 83 e0 fe and $0xfffffffe,%eax /* 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; 11536f: 01 c1 add %eax,%ecx if ( info->largest < the_size ) 115371: 39 f0 cmp %esi,%eax 115373: 76 03 jbe 115378 <_Heap_Get_free_information+0x48> info->largest = the_size; 115375: 89 47 04 mov %eax,0x4(%edi) info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); the_block != tail; the_block = the_block->next) 115378: 8b 52 08 mov 0x8(%edx),%edx 11537b: 8d 43 01 lea 0x1(%ebx),%eax info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_Free_list_first(the_heap); 11537e: 39 d5 cmp %edx,%ebp 115380: 75 e2 jne 115364 <_Heap_Get_free_information+0x34> 115382: 89 1f mov %ebx,(%edi) 115384: 89 4f 08 mov %ecx,0x8(%edi) info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 115387: 5b pop %ebx 115388: 5e pop %esi 115389: 5f pop %edi 11538a: 5d pop %ebp 11538b: c3 ret =============================================================================== 0010e818 <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) { 10e818: 55 push %ebp 10e819: 57 push %edi 10e81a: 56 push %esi 10e81b: 53 push %ebx 10e81c: 83 ec 1c sub $0x1c,%esp 10e81f: 8b 5c 24 30 mov 0x30(%esp),%ebx 10e823: 8b 7c 24 34 mov 0x34(%esp),%edi Heap_Block *allocated_blocks = NULL; Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 10e827: 8b 44 24 38 mov 0x38(%esp),%eax 10e82b: 85 c0 test %eax,%eax 10e82d: 0f 84 9f 00 00 00 je 10e8d2 <_Heap_Greedy_allocate+0xba> 10e833: 31 ed xor %ebp,%ebp 10e835: 31 f6 xor %esi,%esi 10e837: 90 nop * @brief See _Heap_Allocate_aligned_with_boundary() with alignment and * boundary equals zero. */ RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 10e838: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 10e83f: 00 10e840: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10e847: 00 10e848: 8b 04 af mov (%edi,%ebp,4),%eax 10e84b: 89 44 24 04 mov %eax,0x4(%esp) 10e84f: 89 1c 24 mov %ebx,(%esp) 10e852: e8 59 6d 00 00 call 1155b0 <_Heap_Allocate_aligned_with_boundary> void *next = _Heap_Allocate( heap, block_sizes [i] ); if ( next != NULL ) { 10e857: 85 c0 test %eax,%eax 10e859: 74 0f je 10e86a <_Heap_Greedy_allocate+0x52><== NEVER TAKEN RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10e85b: 8d 48 f8 lea -0x8(%eax),%ecx 10e85e: 31 d2 xor %edx,%edx 10e860: f7 73 10 divl 0x10(%ebx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 10e863: 29 d1 sub %edx,%ecx Heap_Block *next_block = _Heap_Block_of_alloc_area( (uintptr_t) next, heap->page_size ); next_block->next = allocated_blocks; 10e865: 89 71 08 mov %esi,0x8(%ecx) 10e868: 89 ce mov %ecx,%esi Heap_Block *allocated_blocks = NULL; Heap_Block *blocks = NULL; Heap_Block *current; size_t i; for (i = 0; i < block_count; ++i) { 10e86a: 45 inc %ebp 10e86b: 3b 6c 24 38 cmp 0x38(%esp),%ebp 10e86f: 75 c7 jne 10e838 <_Heap_Greedy_allocate+0x20> return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10e871: 8b 7b 08 mov 0x8(%ebx),%edi next_block->next = allocated_blocks; allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 10e874: 39 fb cmp %edi,%ebx 10e876: 74 5e je 10e8d6 <_Heap_Greedy_allocate+0xbe><== NEVER TAKEN 10e878: 31 ed xor %ebp,%ebp 10e87a: eb 02 jmp 10e87e <_Heap_Greedy_allocate+0x66> 10e87c: 89 c7 mov %eax,%edi - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10e87e: 8b 47 04 mov 0x4(%edi),%eax 10e881: 83 e0 fe and $0xfffffffe,%eax _Heap_Block_allocate( 10e884: 83 e8 08 sub $0x8,%eax 10e887: 89 44 24 0c mov %eax,0xc(%esp) RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10e88b: 8d 47 08 lea 0x8(%edi),%eax 10e88e: 89 44 24 08 mov %eax,0x8(%esp) 10e892: 89 7c 24 04 mov %edi,0x4(%esp) 10e896: 89 1c 24 mov %ebx,(%esp) 10e899: e8 ce 02 00 00 call 10eb6c <_Heap_Block_allocate> current, _Heap_Alloc_area_of_block( current ), _Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE ); current->next = blocks; 10e89e: 89 6f 08 mov %ebp,0x8(%edi) return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10e8a1: 8b 43 08 mov 0x8(%ebx),%eax 10e8a4: 89 fd mov %edi,%ebp next_block->next = allocated_blocks; allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 10e8a6: 39 c3 cmp %eax,%ebx 10e8a8: 75 d2 jne 10e87c <_Heap_Greedy_allocate+0x64> current->next = blocks; blocks = current; } while ( allocated_blocks != NULL ) { 10e8aa: 85 f6 test %esi,%esi 10e8ac: 74 1a je 10e8c8 <_Heap_Greedy_allocate+0xb0> 10e8ae: 66 90 xchg %ax,%ax current = allocated_blocks; allocated_blocks = allocated_blocks->next; 10e8b0: 8b 6e 08 mov 0x8(%esi),%ebp RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10e8b3: 83 c6 08 add $0x8,%esi _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 10e8b6: 89 74 24 04 mov %esi,0x4(%esp) 10e8ba: 89 1c 24 mov %ebx,(%esp) 10e8bd: e8 ca 6e 00 00 call 11578c <_Heap_Free> blocks = current; } while ( allocated_blocks != NULL ) { current = allocated_blocks; allocated_blocks = allocated_blocks->next; 10e8c2: 89 ee mov %ebp,%esi current->next = blocks; blocks = current; } while ( allocated_blocks != NULL ) { 10e8c4: 85 f6 test %esi,%esi 10e8c6: 75 e8 jne 10e8b0 <_Heap_Greedy_allocate+0x98> allocated_blocks = allocated_blocks->next; _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); } return blocks; } 10e8c8: 89 f8 mov %edi,%eax 10e8ca: 83 c4 1c add $0x1c,%esp 10e8cd: 5b pop %ebx 10e8ce: 5e pop %esi 10e8cf: 5f pop %edi 10e8d0: 5d pop %ebp 10e8d1: c3 ret const uintptr_t *block_sizes, size_t block_count ) { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); Heap_Block *allocated_blocks = NULL; 10e8d2: 31 f6 xor %esi,%esi 10e8d4: eb 9b jmp 10e871 <_Heap_Greedy_allocate+0x59> next_block->next = allocated_blocks; allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 10e8d6: 31 ff xor %edi,%edi <== NOT EXECUTED 10e8d8: eb ea jmp 10e8c4 <_Heap_Greedy_allocate+0xac><== NOT EXECUTED =============================================================================== 0010e8dc <_Heap_Greedy_free>: void _Heap_Greedy_free( Heap_Control *heap, Heap_Block *blocks ) { 10e8dc: 56 push %esi 10e8dd: 53 push %ebx 10e8de: 83 ec 14 sub $0x14,%esp 10e8e1: 8b 74 24 20 mov 0x20(%esp),%esi 10e8e5: 8b 44 24 24 mov 0x24(%esp),%eax while ( blocks != NULL ) { 10e8e9: 85 c0 test %eax,%eax 10e8eb: 74 1b je 10e908 <_Heap_Greedy_free+0x2c><== NEVER TAKEN 10e8ed: 8d 76 00 lea 0x0(%esi),%esi Heap_Block *current = blocks; blocks = blocks->next; 10e8f0: 8b 58 08 mov 0x8(%eax),%ebx 10e8f3: 83 c0 08 add $0x8,%eax _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 10e8f6: 89 44 24 04 mov %eax,0x4(%esp) 10e8fa: 89 34 24 mov %esi,(%esp) 10e8fd: e8 8a 6e 00 00 call 11578c <_Heap_Free> ) { while ( blocks != NULL ) { Heap_Block *current = blocks; blocks = blocks->next; 10e902: 89 d8 mov %ebx,%eax void _Heap_Greedy_free( Heap_Control *heap, Heap_Block *blocks ) { while ( blocks != NULL ) { 10e904: 85 db test %ebx,%ebx 10e906: 75 e8 jne 10e8f0 <_Heap_Greedy_free+0x14> Heap_Block *current = blocks; blocks = blocks->next; _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); } } 10e908: 83 c4 14 add $0x14,%esp 10e90b: 5b pop %ebx 10e90c: 5e pop %esi 10e90d: c3 ret =============================================================================== 001153e0 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) { 1153e0: 55 push %ebp 1153e1: 57 push %edi 1153e2: 56 push %esi 1153e3: 53 push %ebx 1153e4: 83 ec 1c sub $0x1c,%esp 1153e7: 8b 54 24 30 mov 0x30(%esp),%edx 1153eb: 8b 7c 24 34 mov 0x34(%esp),%edi 1153ef: 8b 74 24 38 mov 0x38(%esp),%esi Heap_Block *current = heap->first_block; 1153f3: 8b 42 20 mov 0x20(%edx),%eax Heap_Block *end = heap->last_block; 1153f6: 8b 5a 24 mov 0x24(%edx),%ebx bool stop = false; while ( !stop && current != end ) { 1153f9: 39 d8 cmp %ebx,%eax 1153fb: 75 09 jne 115406 <_Heap_Iterate+0x26> <== ALWAYS TAKEN 1153fd: eb 2b jmp 11542a <_Heap_Iterate+0x4a> <== NOT EXECUTED 1153ff: 90 nop <== NOT EXECUTED 115400: 89 e8 mov %ebp,%eax 115402: 39 eb cmp %ebp,%ebx 115404: 74 24 je 11542a <_Heap_Iterate+0x4a> 115406: 8b 50 04 mov 0x4(%eax),%edx 115409: 83 e2 fe and $0xfffffffe,%edx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11540c: 8d 2c 10 lea (%eax,%edx,1),%ebp 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 ); 11540f: 89 74 24 0c mov %esi,0xc(%esp) block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 115413: 8b 4d 04 mov 0x4(%ebp),%ecx 115416: 83 e1 01 and $0x1,%ecx 115419: 89 4c 24 08 mov %ecx,0x8(%esp) 11541d: 89 54 24 04 mov %edx,0x4(%esp) 115421: 89 04 24 mov %eax,(%esp) 115424: ff d7 call *%edi { Heap_Block *current = heap->first_block; Heap_Block *end = heap->last_block; bool stop = false; while ( !stop && current != end ) { 115426: 84 c0 test %al,%al 115428: 74 d6 je 115400 <_Heap_Iterate+0x20> <== ALWAYS TAKEN stop = (*visitor)( current, size, used, visitor_arg ); current = next; } } 11542a: 83 c4 1c add $0x1c,%esp 11542d: 5b pop %ebx 11542e: 5e pop %esi 11542f: 5f pop %edi 115430: 5d pop %ebp 115431: c3 ret =============================================================================== 00111428 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 111428: 56 push %esi 111429: 53 push %ebx 11142a: 8b 5c 24 0c mov 0xc(%esp),%ebx 11142e: 8b 74 24 10 mov 0x10(%esp),%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 111432: 8d 4e f8 lea -0x8(%esi),%ecx 111435: 89 f0 mov %esi,%eax 111437: 31 d2 xor %edx,%edx 111439: f7 73 10 divl 0x10(%ebx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 11143c: 29 d1 sub %edx,%ecx RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap( const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block 11143e: 8b 43 20 mov 0x20(%ebx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 111441: 39 c1 cmp %eax,%ecx 111443: 72 07 jb 11144c <_Heap_Size_of_alloc_area+0x24> 111445: 8b 53 24 mov 0x24(%ebx),%edx 111448: 39 d1 cmp %edx,%ecx 11144a: 76 08 jbe 111454 <_Heap_Size_of_alloc_area+0x2c><== ALWAYS TAKEN 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; 11144c: 31 c0 xor %eax,%eax } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; return true; } 11144e: 5b pop %ebx 11144f: 5e pop %esi 111450: c3 ret 111451: 8d 76 00 lea 0x0(%esi),%esi - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 111454: 8b 59 04 mov 0x4(%ecx),%ebx 111457: 83 e3 fe and $0xfffffffe,%ebx RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 11145a: 01 d9 add %ebx,%ecx const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 11145c: 39 c8 cmp %ecx,%eax 11145e: 77 ec ja 11144c <_Heap_Size_of_alloc_area+0x24><== NEVER TAKEN 111460: 39 ca cmp %ecx,%edx 111462: 72 e8 jb 11144c <_Heap_Size_of_alloc_area+0x24><== NEVER TAKEN 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 ) 111464: f6 41 04 01 testb $0x1,0x4(%ecx) 111468: 74 e2 je 11144c <_Heap_Size_of_alloc_area+0x24><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11146a: 29 f1 sub %esi,%ecx 11146c: 8d 51 04 lea 0x4(%ecx),%edx 11146f: 8b 44 24 14 mov 0x14(%esp),%eax 111473: 89 10 mov %edx,(%eax) return true; 111475: b0 01 mov $0x1,%al } 111477: 5b pop %ebx 111478: 5e pop %esi 111479: c3 ret =============================================================================== 0010d4bc <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10d4bc: 55 push %ebp 10d4bd: 57 push %edi 10d4be: 56 push %esi 10d4bf: 53 push %ebx 10d4c0: 83 ec 5c sub $0x5c,%esp 10d4c3: 8b 5c 24 70 mov 0x70(%esp),%ebx uintptr_t const page_size = heap->page_size; 10d4c7: 8b 4b 10 mov 0x10(%ebx),%ecx 10d4ca: 89 4c 24 30 mov %ecx,0x30(%esp) uintptr_t const min_block_size = heap->min_block_size; 10d4ce: 8b 43 14 mov 0x14(%ebx),%eax 10d4d1: 89 44 24 38 mov %eax,0x38(%esp) Heap_Block *const first_block = heap->first_block; 10d4d5: 8b 4b 20 mov 0x20(%ebx),%ecx 10d4d8: 89 4c 24 34 mov %ecx,0x34(%esp) Heap_Block *const last_block = heap->last_block; 10d4dc: 8b 4b 24 mov 0x24(%ebx),%ecx 10d4df: 89 4c 24 3c mov %ecx,0x3c(%esp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10d4e3: 80 7c 24 78 00 cmpb $0x0,0x78(%esp) 10d4e8: 74 1a je 10d504 <_Heap_Walk+0x48> 10d4ea: bd 74 d4 10 00 mov $0x10d474,%ebp if ( !_System_state_Is_up( _System_state_Get() ) ) { 10d4ef: 83 3d 00 2a 13 00 03 cmpl $0x3,0x132a00 10d4f6: 74 1a je 10d512 <_Heap_Walk+0x56> <== ALWAYS TAKEN } block = next_block; } while ( block != first_block ); return true; 10d4f8: b0 01 mov $0x1,%al } 10d4fa: 83 c4 5c add $0x5c,%esp 10d4fd: 5b pop %ebx 10d4fe: 5e pop %esi 10d4ff: 5f pop %edi 10d500: 5d pop %ebp 10d501: c3 ret 10d502: 66 90 xchg %ax,%ax 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; 10d504: bd 70 d4 10 00 mov $0x10d470,%ebp if ( !_System_state_Is_up( _System_state_Get() ) ) { 10d509: 83 3d 00 2a 13 00 03 cmpl $0x3,0x132a00 10d510: 75 e6 jne 10d4f8 <_Heap_Walk+0x3c> Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; (*printer)( 10d512: 8b 43 0c mov 0xc(%ebx),%eax 10d515: 89 44 24 28 mov %eax,0x28(%esp) 10d519: 8b 43 08 mov 0x8(%ebx),%eax 10d51c: 89 44 24 24 mov %eax,0x24(%esp) 10d520: 8b 4c 24 3c mov 0x3c(%esp),%ecx 10d524: 89 4c 24 20 mov %ecx,0x20(%esp) 10d528: 8b 4c 24 34 mov 0x34(%esp),%ecx 10d52c: 89 4c 24 1c mov %ecx,0x1c(%esp) 10d530: 8b 43 1c mov 0x1c(%ebx),%eax 10d533: 89 44 24 18 mov %eax,0x18(%esp) 10d537: 8b 43 18 mov 0x18(%ebx),%eax 10d53a: 89 44 24 14 mov %eax,0x14(%esp) 10d53e: 8b 44 24 38 mov 0x38(%esp),%eax 10d542: 89 44 24 10 mov %eax,0x10(%esp) 10d546: 8b 4c 24 30 mov 0x30(%esp),%ecx 10d54a: 89 4c 24 0c mov %ecx,0xc(%esp) 10d54e: c7 44 24 08 50 28 12 movl $0x122850,0x8(%esp) 10d555: 00 10d556: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10d55d: 00 10d55e: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d562: 89 0c 24 mov %ecx,(%esp) 10d565: ff d5 call *%ebp heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 10d567: 8b 4c 24 30 mov 0x30(%esp),%ecx 10d56b: 85 c9 test %ecx,%ecx 10d56d: 0f 84 a1 00 00 00 je 10d614 <_Heap_Walk+0x158> (*printer)( source, true, "page size is zero\n" ); return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10d573: f6 44 24 30 03 testb $0x3,0x30(%esp) 10d578: 0f 85 b6 00 00 00 jne 10d634 <_Heap_Walk+0x178> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d57e: 8b 44 24 38 mov 0x38(%esp),%eax 10d582: 31 d2 xor %edx,%edx 10d584: f7 74 24 30 divl 0x30(%esp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10d588: 85 d2 test %edx,%edx 10d58a: 0f 85 cc 00 00 00 jne 10d65c <_Heap_Walk+0x1a0> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10d590: 8b 44 24 34 mov 0x34(%esp),%eax 10d594: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d597: 31 d2 xor %edx,%edx 10d599: f7 74 24 30 divl 0x30(%esp) ); return false; } if ( 10d59d: 85 d2 test %edx,%edx 10d59f: 0f 85 df 00 00 00 jne 10d684 <_Heap_Walk+0x1c8> block = next_block; } while ( block != first_block ); return true; } 10d5a5: 8b 44 24 34 mov 0x34(%esp),%eax 10d5a9: 8b 48 04 mov 0x4(%eax),%ecx ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10d5ac: f6 c1 01 test $0x1,%cl 10d5af: 0f 84 f7 00 00 00 je 10d6ac <_Heap_Walk+0x1f0> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10d5b5: 8b 54 24 3c mov 0x3c(%esp),%edx 10d5b9: 8b 42 04 mov 0x4(%edx),%eax 10d5bc: 83 e0 fe and $0xfffffffe,%eax RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10d5bf: 01 d0 add %edx,%eax ); return false; } if ( _Heap_Is_free( last_block ) ) { 10d5c1: f6 40 04 01 testb $0x1,0x4(%eax) 10d5c5: 74 2d je 10d5f4 <_Heap_Walk+0x138> ); return false; } if ( 10d5c7: 39 44 24 34 cmp %eax,0x34(%esp) 10d5cb: 0f 84 fb 00 00 00 je 10d6cc <_Heap_Walk+0x210> _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10d5d1: c7 44 24 08 6c 29 12 movl $0x12296c,0x8(%esp) 10d5d8: 00 10d5d9: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d5e0: 00 10d5e1: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d5e5: 89 0c 24 mov %ecx,(%esp) 10d5e8: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d5ea: 31 c0 xor %eax,%eax block = next_block; } while ( block != first_block ); return true; } 10d5ec: 83 c4 5c add $0x5c,%esp 10d5ef: 5b pop %ebx 10d5f0: 5e pop %esi 10d5f1: 5f pop %edi 10d5f2: 5d pop %ebp 10d5f3: c3 ret return false; } if ( _Heap_Is_free( last_block ) ) { (*printer)( 10d5f4: c7 44 24 08 05 28 12 movl $0x122805,0x8(%esp) 10d5fb: 00 10d5fc: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d603: 00 10d604: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d608: 89 0c 24 mov %ecx,(%esp) 10d60b: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d60d: 31 c0 xor %eax,%eax 10d60f: eb db jmp 10d5ec <_Heap_Walk+0x130> 10d611: 8d 76 00 lea 0x0(%esi),%esi first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { (*printer)( source, true, "page size is zero\n" ); 10d614: c7 44 24 08 d4 27 12 movl $0x1227d4,0x8(%esp) 10d61b: 00 10d61c: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d623: 00 10d624: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d628: 89 0c 24 mov %ecx,(%esp) 10d62b: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d62d: 31 c0 xor %eax,%eax 10d62f: eb bb jmp 10d5ec <_Heap_Walk+0x130> 10d631: 8d 76 00 lea 0x0(%esi),%esi return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { (*printer)( 10d634: 8b 4c 24 30 mov 0x30(%esp),%ecx 10d638: 89 4c 24 0c mov %ecx,0xc(%esp) 10d63c: c7 44 24 08 e7 27 12 movl $0x1227e7,0x8(%esp) 10d643: 00 10d644: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d64b: 00 10d64c: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d650: 89 0c 24 mov %ecx,(%esp) 10d653: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d655: 31 c0 xor %eax,%eax 10d657: eb 93 jmp 10d5ec <_Heap_Walk+0x130> 10d659: 8d 76 00 lea 0x0(%esi),%esi return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { (*printer)( 10d65c: 8b 44 24 38 mov 0x38(%esp),%eax 10d660: 89 44 24 0c mov %eax,0xc(%esp) 10d664: c7 44 24 08 e4 28 12 movl $0x1228e4,0x8(%esp) 10d66b: 00 10d66c: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d673: 00 10d674: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d678: 89 0c 24 mov %ecx,(%esp) 10d67b: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d67d: 31 c0 xor %eax,%eax 10d67f: e9 68 ff ff ff jmp 10d5ec <_Heap_Walk+0x130> } if ( !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10d684: 8b 4c 24 34 mov 0x34(%esp),%ecx 10d688: 89 4c 24 0c mov %ecx,0xc(%esp) 10d68c: c7 44 24 08 08 29 12 movl $0x122908,0x8(%esp) 10d693: 00 10d694: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d69b: 00 10d69c: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d6a0: 89 0c 24 mov %ecx,(%esp) 10d6a3: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d6a5: 31 c0 xor %eax,%eax 10d6a7: e9 40 ff ff ff jmp 10d5ec <_Heap_Walk+0x130> return false; } if ( !_Heap_Is_prev_used( first_block ) ) { (*printer)( 10d6ac: c7 44 24 08 3c 29 12 movl $0x12293c,0x8(%esp) 10d6b3: 00 10d6b4: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d6bb: 00 10d6bc: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d6c0: 89 0c 24 mov %ecx,(%esp) 10d6c3: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d6c5: 31 c0 xor %eax,%eax 10d6c7: e9 20 ff ff ff jmp 10d5ec <_Heap_Walk+0x130> int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10d6cc: 8b 43 10 mov 0x10(%ebx),%eax 10d6cf: 89 44 24 40 mov %eax,0x40(%esp) return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10d6d3: 8b 73 08 mov 0x8(%ebx),%esi const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 10d6d6: 39 f3 cmp %esi,%ebx 10d6d8: 0f 84 f3 03 00 00 je 10dad1 <_Heap_Walk+0x615> block = next_block; } while ( block != first_block ); return true; } 10d6de: 8b 43 20 mov 0x20(%ebx),%eax 10d6e1: 89 44 24 48 mov %eax,0x48(%esp) const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10d6e5: 39 f0 cmp %esi,%eax 10d6e7: 76 27 jbe 10d710 <_Heap_Walk+0x254> <== ALWAYS TAKEN 10d6e9: 8d 76 00 lea 0x0(%esi),%esi const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { (*printer)( 10d6ec: 89 74 24 0c mov %esi,0xc(%esp) 10d6f0: c7 44 24 08 9c 29 12 movl $0x12299c,0x8(%esp) 10d6f7: 00 10d6f8: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d6ff: 00 10d700: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d704: 89 0c 24 mov %ecx,(%esp) 10d707: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d709: 31 c0 xor %eax,%eax 10d70b: e9 dc fe ff ff jmp 10d5ec <_Heap_Walk+0x130> 10d710: 8b 53 24 mov 0x24(%ebx),%edx 10d713: 89 54 24 44 mov %edx,0x44(%esp) 10d717: 39 f2 cmp %esi,%edx 10d719: 72 d1 jb 10d6ec <_Heap_Walk+0x230> <== NEVER TAKEN RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10d71b: 8d 46 08 lea 0x8(%esi),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d71e: 31 d2 xor %edx,%edx 10d720: f7 74 24 40 divl 0x40(%esp) ); return false; } if ( 10d724: 85 d2 test %edx,%edx 10d726: 0f 85 a2 00 00 00 jne 10d7ce <_Heap_Walk+0x312> <== NEVER TAKEN - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10d72c: 8b 46 04 mov 0x4(%esi),%eax 10d72f: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d732: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1) 10d737: 75 71 jne 10d7aa <_Heap_Walk+0x2ee> <== NEVER TAKEN 10d739: 89 da mov %ebx,%edx 10d73b: 89 f7 mov %esi,%edi 10d73d: 89 4c 24 4c mov %ecx,0x4c(%esp) 10d741: 8b 4c 24 48 mov 0x48(%esp),%ecx 10d745: eb 34 jmp 10d77b <_Heap_Walk+0x2bf> 10d747: 90 nop return false; } prev_block = free_block; free_block = free_block->next; 10d748: 8b 76 08 mov 0x8(%esi),%esi const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 10d74b: 39 f3 cmp %esi,%ebx 10d74d: 0f 84 9f 00 00 00 je 10d7f2 <_Heap_Walk+0x336> const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10d753: 39 ce cmp %ecx,%esi 10d755: 72 95 jb 10d6ec <_Heap_Walk+0x230> 10d757: 3b 74 24 44 cmp 0x44(%esp),%esi 10d75b: 77 8f ja 10d6ec <_Heap_Walk+0x230> <== NEVER TAKEN RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10d75d: 8d 46 08 lea 0x8(%esi),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d760: 31 d2 xor %edx,%edx 10d762: f7 74 24 40 divl 0x40(%esp) ); return false; } if ( 10d766: 85 d2 test %edx,%edx 10d768: 75 64 jne 10d7ce <_Heap_Walk+0x312> 10d76a: 89 fa mov %edi,%edx - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 10d76c: 8b 46 04 mov 0x4(%esi),%eax 10d76f: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d772: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1) 10d777: 75 31 jne 10d7aa <_Heap_Walk+0x2ee> 10d779: 89 f7 mov %esi,%edi ); return false; } if ( free_block->prev != prev_block ) { 10d77b: 8b 46 0c mov 0xc(%esi),%eax 10d77e: 39 d0 cmp %edx,%eax 10d780: 74 c6 je 10d748 <_Heap_Walk+0x28c> (*printer)( 10d782: 89 44 24 10 mov %eax,0x10(%esp) 10d786: 89 74 24 0c mov %esi,0xc(%esp) 10d78a: c7 44 24 08 ec 29 12 movl $0x1229ec,0x8(%esp) 10d791: 00 10d792: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d799: 00 10d79a: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d79e: 89 0c 24 mov %ecx,(%esp) 10d7a1: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d7a3: 31 c0 xor %eax,%eax 10d7a5: e9 42 fe ff ff jmp 10d5ec <_Heap_Walk+0x130> return false; } if ( _Heap_Is_used( free_block ) ) { (*printer)( 10d7aa: 89 74 24 0c mov %esi,0xc(%esp) 10d7ae: c7 44 24 08 1a 28 12 movl $0x12281a,0x8(%esp) 10d7b5: 00 10d7b6: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d7bd: 00 10d7be: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d7c2: 89 0c 24 mov %ecx,(%esp) 10d7c5: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d7c7: 31 c0 xor %eax,%eax 10d7c9: e9 1e fe ff ff jmp 10d5ec <_Heap_Walk+0x130> } if ( !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10d7ce: 89 74 24 0c mov %esi,0xc(%esp) 10d7d2: c7 44 24 08 bc 29 12 movl $0x1229bc,0x8(%esp) 10d7d9: 00 10d7da: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d7e1: 00 10d7e2: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d7e6: 89 0c 24 mov %ecx,(%esp) 10d7e9: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d7eb: 31 c0 xor %eax,%eax 10d7ed: e9 fa fd ff ff jmp 10d5ec <_Heap_Walk+0x130> 10d7f2: 8b 4c 24 4c mov 0x4c(%esp),%ecx ); return false; } if ( _Heap_Is_used( free_block ) ) { 10d7f6: 8b 74 24 34 mov 0x34(%esp),%esi 10d7fa: 89 6c 24 44 mov %ebp,0x44(%esp) 10d7fe: 8b 44 24 48 mov 0x48(%esp),%eax 10d802: 89 dd mov %ebx,%ebp 10d804: 89 cb mov %ecx,%ebx 10d806: 83 e3 fe and $0xfffffffe,%ebx block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 10d809: 83 e1 01 and $0x1,%ecx 10d80c: 89 4c 24 40 mov %ecx,0x40(%esp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10d810: 8d 3c 33 lea (%ebx,%esi,1),%edi const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 10d813: 39 f8 cmp %edi,%eax 10d815: 76 2d jbe 10d844 <_Heap_Walk+0x388> <== ALWAYS TAKEN 10d817: 8b 6c 24 44 mov 0x44(%esp),%ebp Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { (*printer)( 10d81b: 89 7c 24 10 mov %edi,0x10(%esp) 10d81f: 89 74 24 0c mov %esi,0xc(%esp) 10d823: c7 44 24 08 20 2a 12 movl $0x122a20,0x8(%esp) 10d82a: 00 return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { (*printer)( 10d82b: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d832: 00 10d833: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d837: 89 0c 24 mov %ecx,(%esp) 10d83a: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10d83c: 31 c0 xor %eax,%eax 10d83e: e9 a9 fd ff ff jmp 10d5ec <_Heap_Walk+0x130> 10d843: 90 nop 10d844: 39 7d 24 cmp %edi,0x24(%ebp) 10d847: 72 ce jb 10d817 <_Heap_Walk+0x35b> uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); bool const prev_used = _Heap_Is_prev_used( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; 10d849: 3b 74 24 3c cmp 0x3c(%esp),%esi 10d84d: 0f 95 c1 setne %cl RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10d850: 89 d8 mov %ebx,%eax 10d852: 31 d2 xor %edx,%edx 10d854: f7 74 24 30 divl 0x30(%esp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10d858: 85 d2 test %edx,%edx 10d85a: 74 5c je 10d8b8 <_Heap_Walk+0x3fc> 10d85c: 84 c9 test %cl,%cl 10d85e: 0f 85 54 02 00 00 jne 10dab8 <_Heap_Walk+0x5fc> ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10d864: f6 47 04 01 testb $0x1,0x4(%edi) 10d868: 0f 84 e6 00 00 00 je 10d954 <_Heap_Walk+0x498> if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 10d86e: 8b 44 24 40 mov 0x40(%esp),%eax 10d872: 85 c0 test %eax,%eax 10d874: 0f 84 aa 00 00 00 je 10d924 <_Heap_Walk+0x468> (*printer)( 10d87a: 89 5c 24 10 mov %ebx,0x10(%esp) 10d87e: 89 74 24 0c mov %esi,0xc(%esp) 10d882: c7 44 24 08 36 28 12 movl $0x122836,0x8(%esp) 10d889: 00 10d88a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10d891: 00 10d892: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d896: 89 0c 24 mov %ecx,(%esp) 10d899: 8b 4c 24 44 mov 0x44(%esp),%ecx 10d89d: ff d1 call *%ecx block->prev_size ); } block = next_block; } while ( block != first_block ); 10d89f: 39 7c 24 34 cmp %edi,0x34(%esp) 10d8a3: 0f 84 4f fc ff ff je 10d4f8 <_Heap_Walk+0x3c> 10d8a9: 8b 4f 04 mov 0x4(%edi),%ecx 10d8ac: 8b 45 20 mov 0x20(%ebp),%eax 10d8af: 89 fe mov %edi,%esi 10d8b1: e9 4e ff ff ff jmp 10d804 <_Heap_Walk+0x348> 10d8b6: 66 90 xchg %ax,%ax ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10d8b8: 39 5c 24 38 cmp %ebx,0x38(%esp) 10d8bc: 76 3a jbe 10d8f8 <_Heap_Walk+0x43c> 10d8be: 84 c9 test %cl,%cl 10d8c0: 74 a2 je 10d864 <_Heap_Walk+0x3a8> <== NEVER TAKEN 10d8c2: 8b 6c 24 44 mov 0x44(%esp),%ebp (*printer)( 10d8c6: 8b 44 24 38 mov 0x38(%esp),%eax 10d8ca: 89 44 24 14 mov %eax,0x14(%esp) 10d8ce: 89 5c 24 10 mov %ebx,0x10(%esp) 10d8d2: 89 74 24 0c mov %esi,0xc(%esp) 10d8d6: c7 44 24 08 80 2a 12 movl $0x122a80,0x8(%esp) 10d8dd: 00 10d8de: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10d8e5: 00 10d8e6: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d8ea: 89 0c 24 mov %ecx,(%esp) 10d8ed: ff d5 call *%ebp block, block_size, min_block_size ); return false; 10d8ef: 31 c0 xor %eax,%eax 10d8f1: e9 04 fc ff ff jmp 10d4fa <_Heap_Walk+0x3e> 10d8f6: 66 90 xchg %ax,%ax } if ( next_block_begin <= block_begin && is_not_last_block ) { 10d8f8: 39 fe cmp %edi,%esi 10d8fa: 0f 82 64 ff ff ff jb 10d864 <_Heap_Walk+0x3a8> 10d900: 84 c9 test %cl,%cl 10d902: 0f 84 5c ff ff ff je 10d864 <_Heap_Walk+0x3a8> 10d908: 8b 6c 24 44 mov 0x44(%esp),%ebp (*printer)( 10d90c: 89 7c 24 10 mov %edi,0x10(%esp) 10d910: 89 74 24 0c mov %esi,0xc(%esp) 10d914: c7 44 24 08 ac 2a 12 movl $0x122aac,0x8(%esp) 10d91b: 00 10d91c: e9 0a ff ff ff jmp 10d82b <_Heap_Walk+0x36f> 10d921: 8d 76 00 lea 0x0(%esi),%esi "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10d924: 8b 06 mov (%esi),%eax 10d926: 89 44 24 14 mov %eax,0x14(%esp) 10d92a: 89 5c 24 10 mov %ebx,0x10(%esp) 10d92e: 89 74 24 0c mov %esi,0xc(%esp) 10d932: c7 44 24 08 84 2b 12 movl $0x122b84,0x8(%esp) 10d939: 00 10d93a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10d941: 00 10d942: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d946: 89 0c 24 mov %ecx,(%esp) 10d949: 8b 4c 24 44 mov 0x44(%esp),%ecx 10d94d: ff d1 call *%ecx 10d94f: e9 4b ff ff ff jmp 10d89f <_Heap_Walk+0x3e3> return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 10d954: 8b 4d 08 mov 0x8(%ebp),%ecx block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? 10d957: 8b 56 08 mov 0x8(%esi),%edx Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10d95a: 39 55 0c cmp %edx,0xc(%ebp) 10d95d: 0f 84 fd 00 00 00 je 10da60 <_Heap_Walk+0x5a4> " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10d963: 39 d5 cmp %edx,%ebp 10d965: 0f 84 05 01 00 00 je 10da70 <_Heap_Walk+0x5b4> 10d96b: c7 44 24 48 41 26 12 movl $0x122641,0x48(%esp) 10d972: 00 false, "block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n", block, block_size, block->prev, block->prev == first_free_block ? 10d973: 8b 46 0c mov 0xc(%esi),%eax Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10d976: 39 c1 cmp %eax,%ecx 10d978: 0f 84 d2 00 00 00 je 10da50 <_Heap_Walk+0x594> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10d97e: 39 c5 cmp %eax,%ebp 10d980: 0f 84 fa 00 00 00 je 10da80 <_Heap_Walk+0x5c4> 10d986: c7 44 24 4c 41 26 12 movl $0x122641,0x4c(%esp) 10d98d: 00 Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10d98e: 8b 4c 24 48 mov 0x48(%esp),%ecx 10d992: 89 4c 24 20 mov %ecx,0x20(%esp) 10d996: 89 54 24 1c mov %edx,0x1c(%esp) 10d99a: 8b 54 24 4c mov 0x4c(%esp),%edx 10d99e: 89 54 24 18 mov %edx,0x18(%esp) 10d9a2: 89 44 24 14 mov %eax,0x14(%esp) 10d9a6: 89 5c 24 10 mov %ebx,0x10(%esp) 10d9aa: 89 74 24 0c mov %esi,0xc(%esp) 10d9ae: c7 44 24 08 e0 2a 12 movl $0x122ae0,0x8(%esp) 10d9b5: 00 10d9b6: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10d9bd: 00 10d9be: 8b 4c 24 74 mov 0x74(%esp),%ecx 10d9c2: 89 0c 24 mov %ecx,(%esp) 10d9c5: 8b 4c 24 44 mov 0x44(%esp),%ecx 10d9c9: ff d1 call *%ecx block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 10d9cb: 8b 07 mov (%edi),%eax 10d9cd: 39 c3 cmp %eax,%ebx 10d9cf: 75 4b jne 10da1c <_Heap_Walk+0x560> ); return false; } if ( !prev_used ) { 10d9d1: 8b 54 24 40 mov 0x40(%esp),%edx 10d9d5: 85 d2 test %edx,%edx 10d9d7: 0f 84 b3 00 00 00 je 10da90 <_Heap_Walk+0x5d4> 10d9dd: 8b 45 08 mov 0x8(%ebp),%eax ) { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { 10d9e0: 39 c5 cmp %eax,%ebp 10d9e2: 74 0f je 10d9f3 <_Heap_Walk+0x537> <== NEVER TAKEN if ( free_block == block ) { 10d9e4: 39 c6 cmp %eax,%esi 10d9e6: 0f 84 b3 fe ff ff je 10d89f <_Heap_Walk+0x3e3> return true; } free_block = free_block->next; 10d9ec: 8b 40 08 mov 0x8(%eax),%eax ) { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { 10d9ef: 39 c5 cmp %eax,%ebp 10d9f1: 75 f1 jne 10d9e4 <_Heap_Walk+0x528> 10d9f3: 8b 6c 24 44 mov 0x44(%esp),%ebp return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10d9f7: 89 74 24 0c mov %esi,0xc(%esp) 10d9fb: c7 44 24 08 ac 2b 12 movl $0x122bac,0x8(%esp) 10da02: 00 10da03: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10da0a: 00 10da0b: 8b 4c 24 74 mov 0x74(%esp),%ecx 10da0f: 89 0c 24 mov %ecx,(%esp) 10da12: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10da14: 31 c0 xor %eax,%eax 10da16: e9 d1 fb ff ff jmp 10d5ec <_Heap_Walk+0x130> 10da1b: 90 nop 10da1c: 8b 6c 24 44 mov 0x44(%esp),%ebp " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { (*printer)( 10da20: 89 7c 24 18 mov %edi,0x18(%esp) 10da24: 89 44 24 14 mov %eax,0x14(%esp) 10da28: 89 5c 24 10 mov %ebx,0x10(%esp) 10da2c: 89 74 24 0c mov %esi,0xc(%esp) 10da30: c7 44 24 08 18 2b 12 movl $0x122b18,0x8(%esp) 10da37: 00 10da38: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10da3f: 00 10da40: 8b 4c 24 74 mov 0x74(%esp),%ecx 10da44: 89 0c 24 mov %ecx,(%esp) 10da47: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10da49: 31 c0 xor %eax,%eax 10da4b: e9 9c fb ff ff jmp 10d5ec <_Heap_Walk+0x130> Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 10da50: c7 44 24 4c ba 27 12 movl $0x1227ba,0x4c(%esp) 10da57: 00 10da58: e9 31 ff ff ff jmp 10d98e <_Heap_Walk+0x4d2> 10da5d: 8d 76 00 lea 0x0(%esi),%esi 10da60: c7 44 24 48 a1 27 12 movl $0x1227a1,0x48(%esp) 10da67: 00 10da68: e9 06 ff ff ff jmp 10d973 <_Heap_Walk+0x4b7> 10da6d: 8d 76 00 lea 0x0(%esi),%esi " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10da70: c7 44 24 48 b0 27 12 movl $0x1227b0,0x48(%esp) 10da77: 00 10da78: e9 f6 fe ff ff jmp 10d973 <_Heap_Walk+0x4b7> 10da7d: 8d 76 00 lea 0x0(%esi),%esi block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10da80: c7 44 24 4c ca 27 12 movl $0x1227ca,0x4c(%esp) 10da87: 00 10da88: e9 01 ff ff ff jmp 10d98e <_Heap_Walk+0x4d2> 10da8d: 8d 76 00 lea 0x0(%esi),%esi 10da90: 8b 6c 24 44 mov 0x44(%esp),%ebp return false; } if ( !prev_used ) { (*printer)( 10da94: 89 74 24 0c mov %esi,0xc(%esp) 10da98: c7 44 24 08 54 2b 12 movl $0x122b54,0x8(%esp) 10da9f: 00 10daa0: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10daa7: 00 10daa8: 8b 4c 24 74 mov 0x74(%esp),%ecx 10daac: 89 0c 24 mov %ecx,(%esp) 10daaf: ff d5 call *%ebp "block 0x%08x: block size %u not page aligned\n", block, block_size ); return false; 10dab1: 31 c0 xor %eax,%eax 10dab3: e9 34 fb ff ff jmp 10d5ec <_Heap_Walk+0x130> 10dab8: 8b 6c 24 44 mov 0x44(%esp),%ebp return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { (*printer)( 10dabc: 89 5c 24 10 mov %ebx,0x10(%esp) 10dac0: 89 74 24 0c mov %esi,0xc(%esp) 10dac4: c7 44 24 08 50 2a 12 movl $0x122a50,0x8(%esp) 10dacb: 00 10dacc: e9 5a fd ff ff jmp 10d82b <_Heap_Walk+0x36f> 10dad1: 8b 53 20 mov 0x20(%ebx),%edx 10dad4: 89 54 24 48 mov %edx,0x48(%esp) 10dad8: e9 19 fd ff ff jmp 10d7f6 <_Heap_Walk+0x33a> =============================================================================== 0010c158 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10c158: 53 push %ebx 10c159: 83 ec 18 sub $0x18,%esp rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10c15c: 31 db xor %ebx,%ebx 10c15e: a1 40 f9 12 00 mov 0x12f940,%eax 10c163: 85 c0 test %eax,%eax 10c165: 74 22 je 10c189 <_IO_Initialize_all_drivers+0x31><== NEVER TAKEN 10c167: 90 nop (void) rtems_io_initialize( major, 0, NULL ); 10c168: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10c16f: 00 10c170: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10c177: 00 10c178: 89 1c 24 mov %ebx,(%esp) 10c17b: e8 30 4a 00 00 call 110bb0 void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10c180: 43 inc %ebx 10c181: 39 1d 40 f9 12 00 cmp %ebx,0x12f940 10c187: 77 df ja 10c168 <_IO_Initialize_all_drivers+0x10> (void) rtems_io_initialize( major, 0, NULL ); } 10c189: 83 c4 18 add $0x18,%esp 10c18c: 5b pop %ebx 10c18d: c3 ret =============================================================================== 0010c0d0 <_IO_Manager_initialization>: * workspace. * */ void _IO_Manager_initialization(void) { 10c0d0: 55 push %ebp 10c0d1: 57 push %edi 10c0d2: 56 push %esi 10c0d3: 53 push %ebx 10c0d4: 83 ec 1c sub $0x1c,%esp uint32_t index; rtems_driver_address_table *driver_table; uint32_t drivers_in_table; uint32_t number_of_drivers; driver_table = Configuration.Device_driver_table; 10c0d7: 8b 1d a0 b1 12 00 mov 0x12b1a0,%ebx drivers_in_table = Configuration.number_of_device_drivers; 10c0dd: 8b 35 9c b1 12 00 mov 0x12b19c,%esi number_of_drivers = Configuration.maximum_drivers; 10c0e3: 8b 3d 98 b1 12 00 mov 0x12b198,%edi /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 10c0e9: 39 fe cmp %edi,%esi 10c0eb: 73 57 jae 10c144 <_IO_Manager_initialization+0x74> * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) _Workspace_Allocate_or_fatal_error( 10c0ed: 8d 2c 7f lea (%edi,%edi,2),%ebp 10c0f0: c1 e5 03 shl $0x3,%ebp 10c0f3: 89 2c 24 mov %ebp,(%esp) 10c0f6: e8 49 2b 00 00 call 10ec44 <_Workspace_Allocate_or_fatal_error> 10c0fb: 89 c2 mov %eax,%edx /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 10c0fd: a3 44 f9 12 00 mov %eax,0x12f944 _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10c102: 89 3d 40 f9 12 00 mov %edi,0x12f940 memset( 10c108: 31 c0 xor %eax,%eax 10c10a: 89 d7 mov %edx,%edi 10c10c: 89 e9 mov %ebp,%ecx 10c10e: f3 aa rep stos %al,%es:(%edi) _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10c110: 85 f6 test %esi,%esi 10c112: 74 28 je 10c13c <_IO_Manager_initialization+0x6c><== NEVER TAKEN 10c114: 8b 15 44 f9 12 00 mov 0x12f944,%edx * registration. The driver table is now allocated in the * workspace. * */ void _IO_Manager_initialization(void) 10c11a: 8d 04 76 lea (%esi,%esi,2),%eax 10c11d: 8d 2c c5 00 00 00 00 lea 0x0(,%eax,8),%ebp 10c124: 31 c0 xor %eax,%eax 10c126: 66 90 xchg %ax,%ax _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; 10c128: 8d 3c 02 lea (%edx,%eax,1),%edi 10c12b: 8d 34 03 lea (%ebx,%eax,1),%esi 10c12e: b9 06 00 00 00 mov $0x6,%ecx 10c133: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10c135: 83 c0 18 add $0x18,%eax memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10c138: 39 e8 cmp %ebp,%eax 10c13a: 75 ec jne 10c128 <_IO_Manager_initialization+0x58> _IO_Driver_address_table[index] = driver_table[index]; } 10c13c: 83 c4 1c add $0x1c,%esp 10c13f: 5b pop %ebx 10c140: 5e pop %esi 10c141: 5f pop %edi 10c142: 5d pop %ebp 10c143: c3 ret * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 10c144: 89 1d 44 f9 12 00 mov %ebx,0x12f944 _IO_Number_of_drivers = number_of_drivers; 10c14a: 89 35 40 f9 12 00 mov %esi,0x12f940 sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; } 10c150: 83 c4 1c add $0x1c,%esp 10c153: 5b pop %ebx 10c154: 5e pop %esi 10c155: 5f pop %edi 10c156: 5d pop %ebp 10c157: c3 ret =============================================================================== 0010cbc0 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10cbc0: 53 push %ebx 10cbc1: 83 ec 18 sub $0x18,%esp 10cbc4: 8b 54 24 20 mov 0x20(%esp),%edx 10cbc8: 8b 44 24 24 mov 0x24(%esp),%eax 10cbcc: 8b 5c 24 28 mov 0x28(%esp),%ebx _Internal_errors_What_happened.the_source = the_source; 10cbd0: 89 15 84 f6 12 00 mov %edx,0x12f684 _Internal_errors_What_happened.is_internal = is_internal; 10cbd6: a2 88 f6 12 00 mov %al,0x12f688 _Internal_errors_What_happened.the_error = the_error; 10cbdb: 89 1d 8c f6 12 00 mov %ebx,0x12f68c _User_extensions_Fatal( the_source, is_internal, the_error ); 10cbe1: 89 5c 24 08 mov %ebx,0x8(%esp) 10cbe5: 0f b6 c0 movzbl %al,%eax 10cbe8: 89 44 24 04 mov %eax,0x4(%esp) 10cbec: 89 14 24 mov %edx,(%esp) 10cbef: e8 50 1c 00 00 call 10e844 <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10cbf4: c7 05 60 f7 12 00 05 movl $0x5,0x12f760 <== NOT EXECUTED 10cbfb: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10cbfe: fa cli <== NOT EXECUTED 10cbff: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cc01: f4 hlt <== NOT EXECUTED 10cc02: eb fe jmp 10cc02 <_Internal_error_Occurred+0x42><== NOT EXECUTED =============================================================================== 0010cc5c <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10cc5c: 56 push %esi 10cc5d: 53 push %ebx 10cc5e: 83 ec 14 sub $0x14,%esp 10cc61: 8b 5c 24 20 mov 0x20(%esp),%ebx * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 10cc65: 8b 43 18 mov 0x18(%ebx),%eax 10cc68: 85 c0 test %eax,%eax 10cc6a: 74 54 je 10ccc0 <_Objects_Allocate+0x64><== NEVER TAKEN /* * OK. The manager should be initialized and configured to have objects. * With any luck, it is safe to attempt to allocate an object. */ the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10cc6c: 8d 73 20 lea 0x20(%ebx),%esi 10cc6f: 89 34 24 mov %esi,(%esp) 10cc72: e8 35 f7 ff ff call 10c3ac <_Chain_Get> 10cc77: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10cc79: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10cc7d: 74 20 je 10cc9f <_Objects_Allocate+0x43> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10cc7f: 85 c0 test %eax,%eax 10cc81: 74 25 je 10cca8 <_Objects_Allocate+0x4c> } if ( the_object ) { uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10cc83: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10cc87: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10cc8b: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10cc8d: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10cc91: 31 d2 xor %edx,%edx 10cc93: f7 f6 div %esi information->inactive_per_block[ block ]--; 10cc95: 8b 53 30 mov 0x30(%ebx),%edx 10cc98: ff 0c 82 decl (%edx,%eax,4) information->inactive--; 10cc9b: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10cc9f: 89 c8 mov %ecx,%eax 10cca1: 83 c4 14 add $0x14,%esp 10cca4: 5b pop %ebx 10cca5: 5e pop %esi 10cca6: c3 ret 10cca7: 90 nop * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { _Objects_Extend_information( information ); 10cca8: 89 1c 24 mov %ebx,(%esp) 10ccab: e8 3c 00 00 00 call 10ccec <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10ccb0: 89 34 24 mov %esi,(%esp) 10ccb3: e8 f4 f6 ff ff call 10c3ac <_Chain_Get> 10ccb8: 89 c1 mov %eax,%ecx } if ( the_object ) { 10ccba: 85 c0 test %eax,%eax 10ccbc: 75 c5 jne 10cc83 <_Objects_Allocate+0x27> 10ccbe: 66 90 xchg %ax,%ax * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) return NULL; 10ccc0: 31 c9 xor %ecx,%ecx ); } #endif return the_object; } 10ccc2: 89 c8 mov %ecx,%eax 10ccc4: 83 c4 14 add $0x14,%esp 10ccc7: 5b pop %ebx 10ccc8: 5e pop %esi 10ccc9: c3 ret =============================================================================== 0010ccec <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10ccec: 55 push %ebp 10cced: 57 push %edi 10ccee: 56 push %esi 10ccef: 53 push %ebx 10ccf0: 83 ec 4c sub $0x4c,%esp 10ccf3: 8b 5c 24 60 mov 0x60(%esp),%ebx /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10ccf7: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10ccfb: 89 44 24 20 mov %eax,0x20(%esp) index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 10ccff: 8b 4b 34 mov 0x34(%ebx),%ecx 10cd02: 8b 7b 10 mov 0x10(%ebx),%edi 10cd05: 85 c9 test %ecx,%ecx 10cd07: 0f 84 73 02 00 00 je 10cf80 <_Objects_Extend_information+0x294> block_count = 0; else { block_count = information->maximum / information->allocation_size; 10cd0d: 8b 73 14 mov 0x14(%ebx),%esi 10cd10: 89 f8 mov %edi,%eax 10cd12: 31 d2 xor %edx,%edx 10cd14: 66 f7 f6 div %si 10cd17: 0f b7 c0 movzwl %ax,%eax 10cd1a: 89 44 24 18 mov %eax,0x18(%esp) for ( ; block < block_count; block++ ) { 10cd1e: 85 c0 test %eax,%eax 10cd20: 0f b7 c6 movzwl %si,%eax 10cd23: 0f 84 77 02 00 00 je 10cfa0 <_Objects_Extend_information+0x2b4><== NEVER TAKEN if ( information->object_blocks[ block ] == NULL ) { 10cd29: 8b 11 mov (%ecx),%edx 10cd2b: 85 d2 test %edx,%edx 10cd2d: 0f 84 81 02 00 00 je 10cfb4 <_Objects_Extend_information+0x2c8><== NEVER TAKEN * information - object information table * * Output parameters: NONE */ void _Objects_Extend_information( 10cd33: 8b 74 24 18 mov 0x18(%esp),%esi 10cd37: 4e dec %esi /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10cd38: 8b 54 24 20 mov 0x20(%esp),%edx 10cd3c: 89 54 24 14 mov %edx,0x14(%esp) * information - object information table * * Output parameters: NONE */ void _Objects_Extend_information( 10cd40: 31 d2 xor %edx,%edx 10cd42: 89 5c 24 1c mov %ebx,0x1c(%esp) 10cd46: 8b 5c 24 14 mov 0x14(%esp),%ebx 10cd4a: eb 0c jmp 10cd58 <_Objects_Extend_information+0x6c> 10cd4c: 89 ea mov %ebp,%edx block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { 10cd4e: 83 3c a9 00 cmpl $0x0,(%ecx,%ebp,4) 10cd52: 0f 84 d4 01 00 00 je 10cf2c <_Objects_Extend_information+0x240> do_extend = false; break; } else index_base += information->allocation_size; 10cd58: 01 c3 add %eax,%ebx * information - object information table * * Output parameters: NONE */ void _Objects_Extend_information( 10cd5a: 8d 6a 01 lea 0x1(%edx),%ebp if ( information->object_blocks == NULL ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10cd5d: 39 f2 cmp %esi,%edx 10cd5f: 75 eb jne 10cd4c <_Objects_Extend_information+0x60> 10cd61: 89 5c 24 14 mov %ebx,0x14(%esp) 10cd65: 8b 5c 24 1c mov 0x1c(%esp),%ebx /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10cd69: be 01 00 00 00 mov $0x1,%esi } else index_base += information->allocation_size; } } maximum = (uint32_t) information->maximum + information->allocation_size; 10cd6e: 0f b7 d7 movzwl %di,%edx 10cd71: 01 c2 add %eax,%edx 10cd73: 89 54 24 1c mov %edx,0x1c(%esp) /* * We need to limit the number of objects to the maximum number * representable in the index portion of the object Id. In the * case of 16-bit Ids, this is only 256 object instances. */ if ( maximum > OBJECTS_ID_FINAL_INDEX ) { 10cd77: 81 fa ff ff 00 00 cmp $0xffff,%edx 10cd7d: 0f 87 9f 01 00 00 ja 10cf22 <_Objects_Extend_information+0x236> /* * Allocate the name table, and the objects and if it fails either return or * generate a fatal error depending on auto-extending being active. */ block_size = information->allocation_size * information->size; 10cd83: 0f af 43 18 imul 0x18(%ebx),%eax if ( information->auto_extend ) { 10cd87: 80 7b 12 00 cmpb $0x0,0x12(%ebx) new_object_block = _Workspace_Allocate( block_size ); 10cd8b: 89 04 24 mov %eax,(%esp) /* * Allocate the name table, and the objects and if it fails either return or * generate a fatal error depending on auto-extending being active. */ block_size = information->allocation_size * information->size; if ( information->auto_extend ) { 10cd8e: 0f 84 a8 01 00 00 je 10cf3c <_Objects_Extend_information+0x250> new_object_block = _Workspace_Allocate( block_size ); 10cd94: e8 63 1e 00 00 call 10ebfc <_Workspace_Allocate> 10cd99: 89 44 24 28 mov %eax,0x28(%esp) if ( !new_object_block ) 10cd9d: 85 c0 test %eax,%eax 10cd9f: 0f 84 7d 01 00 00 je 10cf22 <_Objects_Extend_information+0x236> } /* * Do we need to grow the tables? */ if ( do_extend ) { 10cda5: 89 f0 mov %esi,%eax 10cda7: 84 c0 test %al,%al 10cda9: 0f 84 ee 00 00 00 je 10ce9d <_Objects_Extend_information+0x1b1> */ /* * Up the block count and maximum */ block_count++; 10cdaf: 8b 74 24 18 mov 0x18(%esp),%esi 10cdb3: 46 inc %esi /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 10cdb4: 8d 04 76 lea (%esi,%esi,2),%eax ((maximum + minimum_index) * sizeof(Objects_Control *)); 10cdb7: 03 44 24 1c add 0x1c(%esp),%eax /* * Allocate the tables and break it up. */ block_size = block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + 10cdbb: 03 44 24 20 add 0x20(%esp),%eax block_count++; /* * Allocate the tables and break it up. */ block_size = block_count * 10cdbf: c1 e0 02 shl $0x2,%eax (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); 10cdc2: 89 04 24 mov %eax,(%esp) 10cdc5: e8 32 1e 00 00 call 10ebfc <_Workspace_Allocate> 10cdca: 89 c2 mov %eax,%edx if ( !object_blocks ) { 10cdcc: 85 c0 test %eax,%eax 10cdce: 0f 84 f1 01 00 00 je 10cfc5 <_Objects_Extend_information+0x2d9> 10cdd4: 8d 3c b0 lea (%eax,%esi,4),%edi 10cdd7: 89 7c 24 2c mov %edi,0x2c(%esp) 10cddb: 8d 34 f0 lea (%eax,%esi,8),%esi 10cdde: 89 74 24 24 mov %esi,0x24(%esp) * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10cde2: 0f b7 43 10 movzwl 0x10(%ebx),%eax 10cde6: 39 44 24 20 cmp %eax,0x20(%esp) 10cdea: 0f 82 5a 01 00 00 jb 10cf4a <_Objects_Extend_information+0x25e> } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10cdf0: 8b 44 24 20 mov 0x20(%esp),%eax 10cdf4: 85 c0 test %eax,%eax 10cdf6: 74 1d je 10ce15 <_Objects_Extend_information+0x129><== NEVER TAKEN * information - object information table * * Output parameters: NONE */ void _Objects_Extend_information( 10cdf8: 8b 44 24 20 mov 0x20(%esp),%eax 10cdfc: 8b 7c 24 24 mov 0x24(%esp),%edi 10ce00: 8d 0c 87 lea (%edi,%eax,4),%ecx 10ce03: 89 f8 mov %edi,%eax 10ce05: 8d 76 00 lea 0x0(%esi),%esi /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 10ce08: c7 00 00 00 00 00 movl $0x0,(%eax) 10ce0e: 83 c0 04 add $0x4,%eax } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10ce11: 39 c8 cmp %ecx,%eax 10ce13: 75 f3 jne 10ce08 <_Objects_Extend_information+0x11c><== NEVER TAKEN 10ce15: 8b 44 24 18 mov 0x18(%esp),%eax 10ce19: c1 e0 02 shl $0x2,%eax } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10ce1c: c7 04 02 00 00 00 00 movl $0x0,(%edx,%eax,1) inactive_per_block[block_count] = 0; 10ce23: 8b 7c 24 2c mov 0x2c(%esp),%edi 10ce27: c7 04 07 00 00 00 00 movl $0x0,(%edi,%eax,1) for ( index=index_base ; index < ( information->allocation_size + index_base ); 10ce2e: 0f b7 4b 14 movzwl 0x14(%ebx),%ecx 10ce32: 03 4c 24 14 add 0x14(%esp),%ecx * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10ce36: 39 4c 24 14 cmp %ecx,0x14(%esp) 10ce3a: 73 1d jae 10ce59 <_Objects_Extend_information+0x16d><== NEVER TAKEN 10ce3c: 8b 74 24 14 mov 0x14(%esp),%esi 10ce40: 8b 7c 24 24 mov 0x24(%esp),%edi 10ce44: 8d 04 b7 lea (%edi,%esi,4),%eax * information - object information table * * Output parameters: NONE */ void _Objects_Extend_information( 10ce47: 8d 0c 8f lea (%edi,%ecx,4),%ecx 10ce4a: 66 90 xchg %ax,%ax inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; 10ce4c: c7 00 00 00 00 00 movl $0x0,(%eax) 10ce52: 83 c0 04 add $0x4,%eax * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; 10ce55: 39 c8 cmp %ecx,%eax 10ce57: 75 f3 jne 10ce4c <_Objects_Extend_information+0x160> index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10ce59: 9c pushf 10ce5a: fa cli 10ce5b: 59 pop %ecx old_tables = information->object_blocks; 10ce5c: 8b 43 34 mov 0x34(%ebx),%eax information->object_blocks = object_blocks; 10ce5f: 89 53 34 mov %edx,0x34(%ebx) information->inactive_per_block = inactive_per_block; 10ce62: 8b 7c 24 2c mov 0x2c(%esp),%edi 10ce66: 89 7b 30 mov %edi,0x30(%ebx) information->local_table = local_table; 10ce69: 8b 7c 24 24 mov 0x24(%esp),%edi 10ce6d: 89 7b 1c mov %edi,0x1c(%ebx) information->maximum = (Objects_Maximum) maximum; 10ce70: 8b 54 24 1c mov 0x1c(%esp),%edx 10ce74: 66 89 53 10 mov %dx,0x10(%ebx) uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10ce78: 8b 13 mov (%ebx),%edx 10ce7a: c1 e2 18 shl $0x18,%edx 10ce7d: 81 ca 00 00 01 00 or $0x10000,%edx information->maximum_id = _Objects_Build_id( 10ce83: 0f b7 73 04 movzwl 0x4(%ebx),%esi (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10ce87: c1 e6 1b shl $0x1b,%esi 10ce8a: 09 f2 or %esi,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10ce8c: 0b 54 24 1c or 0x1c(%esp),%edx 10ce90: 89 53 0c mov %edx,0xc(%ebx) information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10ce93: 51 push %ecx 10ce94: 9d popf _Workspace_Free( old_tables ); 10ce95: 89 04 24 mov %eax,(%esp) 10ce98: e8 8b 1d 00 00 call 10ec28 <_Workspace_Free> } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 10ce9d: c1 e5 02 shl $0x2,%ebp 10cea0: 89 6c 24 18 mov %ebp,0x18(%esp) 10cea4: 8b 43 34 mov 0x34(%ebx),%eax 10cea7: 8b 54 24 28 mov 0x28(%esp),%edx 10ceab: 89 14 28 mov %edx,(%eax,%ebp,1) /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10ceae: 8b 43 18 mov 0x18(%ebx),%eax 10ceb1: 89 44 24 0c mov %eax,0xc(%esp) 10ceb5: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10ceb9: 89 44 24 08 mov %eax,0x8(%esp) 10cebd: 8b 43 34 mov 0x34(%ebx),%eax 10cec0: 8b 04 28 mov (%eax,%ebp,1),%eax 10cec3: 89 44 24 04 mov %eax,0x4(%esp) 10cec7: 8d 74 24 34 lea 0x34(%esp),%esi 10cecb: 89 34 24 mov %esi,(%esp) 10cece: e8 f9 f4 ff ff call 10c3cc <_Chain_Initialize> /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10ced3: 8b 6c 24 14 mov 0x14(%esp),%ebp information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10ced7: 8d 7b 20 lea 0x20(%ebx),%edi /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10ceda: eb 26 jmp 10cf02 <_Objects_Extend_information+0x216> 10cedc: 8b 13 mov (%ebx),%edx 10cede: c1 e2 18 shl $0x18,%edx 10cee1: 81 ca 00 00 01 00 or $0x10000,%edx the_object->id = _Objects_Build_id( 10cee7: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10ceeb: c1 e1 1b shl $0x1b,%ecx 10ceee: 09 ca or %ecx,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10cef0: 09 ea or %ebp,%edx 10cef2: 89 50 08 mov %edx,0x8(%eax) information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10cef5: 89 44 24 04 mov %eax,0x4(%esp) 10cef9: 89 3c 24 mov %edi,(%esp) 10cefc: e8 87 f4 ff ff call 10c388 <_Chain_Append> index++; 10cf01: 45 inc %ebp /* * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) { 10cf02: 89 34 24 mov %esi,(%esp) 10cf05: e8 a2 f4 ff ff call 10c3ac <_Chain_Get> 10cf0a: 85 c0 test %eax,%eax 10cf0c: 75 ce jne 10cedc <_Objects_Extend_information+0x1f0> _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10cf0e: 8b 43 14 mov 0x14(%ebx),%eax 10cf11: 8b 53 30 mov 0x30(%ebx),%edx 10cf14: 0f b7 c8 movzwl %ax,%ecx 10cf17: 8b 74 24 18 mov 0x18(%esp),%esi 10cf1b: 89 0c 32 mov %ecx,(%edx,%esi,1) information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 10cf1e: 66 01 43 2c add %ax,0x2c(%ebx) } 10cf22: 83 c4 4c add $0x4c,%esp 10cf25: 5b pop %ebx 10cf26: 5e pop %esi 10cf27: 5f pop %edi 10cf28: 5d pop %ebp 10cf29: c3 ret 10cf2a: 66 90 xchg %ax,%ax 10cf2c: 89 5c 24 14 mov %ebx,0x14(%esp) 10cf30: 8b 5c 24 1c mov 0x1c(%esp),%ebx else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { do_extend = false; 10cf34: 31 f6 xor %esi,%esi 10cf36: e9 33 fe ff ff jmp 10cd6e <_Objects_Extend_information+0x82> 10cf3b: 90 nop if ( information->auto_extend ) { new_object_block = _Workspace_Allocate( block_size ); if ( !new_object_block ) return; } else { new_object_block = _Workspace_Allocate_or_fatal_error( block_size ); 10cf3c: e8 03 1d 00 00 call 10ec44 <_Workspace_Allocate_or_fatal_error> 10cf41: 89 44 24 28 mov %eax,0x28(%esp) 10cf45: e9 5b fe ff ff jmp 10cda5 <_Objects_Extend_information+0xb9> /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 10cf4a: 8b 44 24 18 mov 0x18(%esp),%eax 10cf4e: c1 e0 02 shl $0x2,%eax 10cf51: 8b 73 34 mov 0x34(%ebx),%esi 10cf54: 89 d7 mov %edx,%edi 10cf56: 89 c1 mov %eax,%ecx 10cf58: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10cf5a: 8b 73 30 mov 0x30(%ebx),%esi 10cf5d: 8b 7c 24 2c mov 0x2c(%esp),%edi 10cf61: 89 c1 mov %eax,%ecx 10cf63: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, information->local_table, (information->maximum + minimum_index) * sizeof(Objects_Control *) ); 10cf65: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10cf69: 03 4c 24 20 add 0x20(%esp),%ecx information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10cf6d: c1 e1 02 shl $0x2,%ecx 10cf70: 8b 73 1c mov 0x1c(%ebx),%esi 10cf73: 8b 7c 24 24 mov 0x24(%esp),%edi 10cf77: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10cf79: e9 9e fe ff ff jmp 10ce1c <_Objects_Extend_information+0x130> 10cf7e: 66 90 xchg %ax,%ax 10cf80: 0f b7 43 14 movzwl 0x14(%ebx),%eax /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10cf84: 8b 54 24 20 mov 0x20(%esp),%edx 10cf88: 89 54 24 14 mov %edx,0x14(%esp) /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10cf8c: be 01 00 00 00 mov $0x1,%esi minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10cf91: 31 ed xor %ebp,%ebp /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) block_count = 0; 10cf93: c7 44 24 18 00 00 00 movl $0x0,0x18(%esp) 10cf9a: 00 10cf9b: e9 ce fd ff ff jmp 10cd6e <_Objects_Extend_information+0x82> /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10cfa0: 8b 4c 24 20 mov 0x20(%esp),%ecx <== NOT EXECUTED 10cfa4: 89 4c 24 14 mov %ecx,0x14(%esp) <== NOT EXECUTED /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; 10cfa8: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10cfad: 31 ed xor %ebp,%ebp <== NOT EXECUTED 10cfaf: e9 ba fd ff ff jmp 10cd6e <_Objects_Extend_information+0x82><== NOT EXECUTED /* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); 10cfb4: 8b 4c 24 20 mov 0x20(%esp),%ecx <== NOT EXECUTED 10cfb8: 89 4c 24 14 mov %ecx,0x14(%esp) <== NOT EXECUTED else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) { do_extend = false; 10cfbc: 31 f6 xor %esi,%esi <== NOT EXECUTED * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10cfbe: 31 ed xor %ebp,%ebp <== NOT EXECUTED 10cfc0: e9 a9 fd ff ff jmp 10cd6e <_Objects_Extend_information+0x82><== NOT EXECUTED (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)); object_blocks = (void**) _Workspace_Allocate( block_size ); if ( !object_blocks ) { _Workspace_Free( new_object_block ); 10cfc5: 8b 44 24 28 mov 0x28(%esp),%eax 10cfc9: 89 04 24 mov %eax,(%esp) 10cfcc: e8 57 1c 00 00 call 10ec28 <_Workspace_Free> 10cfd1: e9 4c ff ff ff jmp 10cf22 <_Objects_Extend_information+0x236> =============================================================================== 0010d070 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10d070: 56 push %esi 10d071: 53 push %ebx 10d072: 83 ec 14 sub $0x14,%esp 10d075: 8b 74 24 20 mov 0x20(%esp),%esi 10d079: 0f b7 5c 24 24 movzwl 0x24(%esp),%ebx Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10d07e: 66 85 db test %bx,%bx 10d081: 74 31 je 10d0b4 <_Objects_Get_information+0x44> /* * 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 ); 10d083: 89 34 24 mov %esi,(%esp) 10d086: e8 f1 43 00 00 call 11147c <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10d08b: 85 c0 test %eax,%eax 10d08d: 74 25 je 10d0b4 <_Objects_Get_information+0x44> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10d08f: 39 d8 cmp %ebx,%eax 10d091: 72 21 jb 10d0b4 <_Objects_Get_information+0x44> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10d093: 8b 04 b5 dc f5 12 00 mov 0x12f5dc(,%esi,4),%eax 10d09a: 85 c0 test %eax,%eax 10d09c: 74 16 je 10d0b4 <_Objects_Get_information+0x44><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10d09e: 8b 04 98 mov (%eax,%ebx,4),%eax if ( !info ) 10d0a1: 85 c0 test %eax,%eax 10d0a3: 74 0f je 10d0b4 <_Objects_Get_information+0x44><== NEVER TAKEN * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) 10d0a5: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10d0aa: 74 08 je 10d0b4 <_Objects_Get_information+0x44> return NULL; #endif return info; } 10d0ac: 83 c4 14 add $0x14,%esp 10d0af: 5b pop %ebx 10d0b0: 5e pop %esi 10d0b1: c3 ret 10d0b2: 66 90 xchg %ax,%ax { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 10d0b4: 31 c0 xor %eax,%eax if ( info->maximum == 0 ) return NULL; #endif return info; } 10d0b6: 83 c4 14 add $0x14,%esp 10d0b9: 5b pop %ebx 10d0ba: 5e pop %esi 10d0bb: c3 ret =============================================================================== 001198b0 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 1198b0: 55 push %ebp 1198b1: 57 push %edi 1198b2: 56 push %esi 1198b3: 53 push %ebx 1198b4: 83 ec 2c sub $0x2c,%esp 1198b7: 8b 7c 24 40 mov 0x40(%esp),%edi 1198bb: 8b 5c 24 44 mov 0x44(%esp),%ebx 1198bf: 8b 74 24 48 mov 0x48(%esp),%esi char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 1198c3: 85 db test %ebx,%ebx 1198c5: 0f 84 c5 00 00 00 je 119990 <_Objects_Get_name_as_string+0xe0> return NULL; if ( name == NULL ) 1198cb: 85 f6 test %esi,%esi 1198cd: 0f 84 bd 00 00 00 je 119990 <_Objects_Get_name_as_string+0xe0> return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 1198d3: 85 ff test %edi,%edi 1198d5: 0f 84 a5 00 00 00 je 119980 <_Objects_Get_name_as_string+0xd0> information = _Objects_Get_information_id( tmpId ); 1198db: 89 3c 24 mov %edi,(%esp) 1198de: e8 bd 8f ff ff call 1128a0 <_Objects_Get_information_id> if ( !information ) 1198e3: 85 c0 test %eax,%eax 1198e5: 0f 84 a5 00 00 00 je 119990 <_Objects_Get_name_as_string+0xe0> return NULL; the_object = _Objects_Get( information, tmpId, &location ); 1198eb: 8d 54 24 14 lea 0x14(%esp),%edx 1198ef: 89 54 24 08 mov %edx,0x8(%esp) 1198f3: 89 7c 24 04 mov %edi,0x4(%esp) 1198f7: 89 04 24 mov %eax,(%esp) 1198fa: e8 69 90 ff ff call 112968 <_Objects_Get> switch ( location ) { 1198ff: 8b 54 24 14 mov 0x14(%esp),%edx 119903: 85 d2 test %edx,%edx 119905: 0f 85 85 00 00 00 jne 119990 <_Objects_Get_name_as_string+0xe0> if ( information->is_string ) { s = the_object->name.name_p; } else #endif { uint32_t u32_name = (uint32_t) the_object->name.name_u32; 11990b: 8b 40 0c mov 0xc(%eax),%eax lname[ 0 ] = (u32_name >> 24) & 0xff; 11990e: 89 c1 mov %eax,%ecx 119910: c1 e9 18 shr $0x18,%ecx 119913: 88 ca mov %cl,%dl 119915: 88 4c 24 1b mov %cl,0x1b(%esp) lname[ 1 ] = (u32_name >> 16) & 0xff; 119919: 89 c1 mov %eax,%ecx 11991b: c1 e9 10 shr $0x10,%ecx 11991e: 88 4c 24 1c mov %cl,0x1c(%esp) lname[ 2 ] = (u32_name >> 8) & 0xff; 119922: 89 c1 mov %eax,%ecx 119924: c1 e9 08 shr $0x8,%ecx 119927: 88 4c 24 1d mov %cl,0x1d(%esp) lname[ 3 ] = (u32_name >> 0) & 0xff; 11992b: 88 44 24 1e mov %al,0x1e(%esp) lname[ 4 ] = '\0'; 11992f: c6 44 24 1f 00 movb $0x0,0x1f(%esp) s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 119934: 83 fb 01 cmp $0x1,%ebx 119937: 74 63 je 11999c <_Objects_Get_name_as_string+0xec><== NEVER TAKEN 119939: 84 d2 test %dl,%dl 11993b: 74 5f je 11999c <_Objects_Get_name_as_string+0xec> * This method objects the name of an object and returns its name * in the form of a C string. It attempts to be careful about * overflowing the user's string and about returning unprintable characters. */ char *_Objects_Get_name_as_string( 11993d: 8d 7c 1e ff lea -0x1(%esi,%ebx,1),%edi 119941: 89 f1 mov %esi,%ecx lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; 119943: 8d 5c 24 1b lea 0x1b(%esp),%ebx 119947: eb 09 jmp 119952 <_Objects_Get_name_as_string+0xa2> 119949: 8d 76 00 lea 0x0(%esi),%esi } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 11994c: 8a 13 mov (%ebx),%dl 11994e: 84 d2 test %dl,%dl 119950: 74 1c je 11996e <_Objects_Get_name_as_string+0xbe> *d = (isprint((unsigned char)*s)) ? *s : '*'; 119952: 0f b6 c2 movzbl %dl,%eax 119955: 8b 2d 28 db 13 00 mov 0x13db28,%ebp 11995b: 0f be 44 05 01 movsbl 0x1(%ebp,%eax,1),%eax 119960: a8 97 test $0x97,%al 119962: 75 02 jne 119966 <_Objects_Get_name_as_string+0xb6> 119964: b2 2a mov $0x2a,%dl 119966: 88 11 mov %dl,(%ecx) s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 119968: 43 inc %ebx 119969: 41 inc %ecx 11996a: 39 f9 cmp %edi,%ecx 11996c: 75 de jne 11994c <_Objects_Get_name_as_string+0x9c> *d = (isprint((unsigned char)*s)) ? *s : '*'; } } *d = '\0'; 11996e: c6 01 00 movb $0x0,(%ecx) _Thread_Enable_dispatch(); 119971: e8 fa 9c ff ff call 113670 <_Thread_Enable_dispatch> return name; } return NULL; /* unreachable path */ } 119976: 89 f0 mov %esi,%eax 119978: 83 c4 2c add $0x2c,%esp 11997b: 5b pop %ebx 11997c: 5e pop %esi 11997d: 5f pop %edi 11997e: 5d pop %ebp 11997f: c3 ret return NULL; if ( name == NULL ) return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 119980: a1 ec 06 14 00 mov 0x1406ec,%eax 119985: 8b 78 08 mov 0x8(%eax),%edi 119988: e9 4e ff ff ff jmp 1198db <_Objects_Get_name_as_string+0x2b> 11998d: 8d 76 00 lea 0x0(%esi),%esi #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* not supported */ #endif case OBJECTS_ERROR: return NULL; 119990: 31 f6 xor %esi,%esi _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 119992: 89 f0 mov %esi,%eax 119994: 83 c4 2c add $0x2c,%esp 119997: 5b pop %ebx 119998: 5e pop %esi 119999: 5f pop %edi 11999a: 5d pop %ebp 11999b: c3 ret s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 11999c: 89 f1 mov %esi,%ecx 11999e: eb ce jmp 11996e <_Objects_Get_name_as_string+0xbe> =============================================================================== 0011be2c <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 11be2c: 55 push %ebp 11be2d: 57 push %edi 11be2e: 56 push %esi 11be2f: 53 push %ebx 11be30: 83 ec 1c sub $0x1c,%esp 11be33: 8b 74 24 30 mov 0x30(%esp),%esi 11be37: 8b 5c 24 34 mov 0x34(%esp),%ebx 11be3b: 8b 7c 24 38 mov 0x38(%esp),%edi 11be3f: 8b 6c 24 3c mov 0x3c(%esp),%ebp Objects_Control *object; Objects_Id next_id; if ( !information ) 11be43: 85 f6 test %esi,%esi 11be45: 74 59 je 11bea0 <_Objects_Get_next+0x74> return NULL; if ( !location_p ) 11be47: 85 ff test %edi,%edi 11be49: 74 55 je 11bea0 <_Objects_Get_next+0x74> return NULL; if ( !next_id_p ) 11be4b: 85 ed test %ebp,%ebp 11be4d: 74 51 je 11bea0 <_Objects_Get_next+0x74> return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 11be4f: 66 85 db test %bx,%bx 11be52: 74 28 je 11be7c <_Objects_Get_next+0x50> else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 11be54: 66 39 5e 10 cmp %bx,0x10(%esi) 11be58: 72 2e jb 11be88 <_Objects_Get_next+0x5c> *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 11be5a: 89 7c 24 08 mov %edi,0x8(%esp) 11be5e: 89 5c 24 04 mov %ebx,0x4(%esp) 11be62: 89 34 24 mov %esi,(%esp) 11be65: e8 fe 6a ff ff call 112968 <_Objects_Get> next_id++; 11be6a: 43 inc %ebx } while (*location_p != OBJECTS_LOCAL); 11be6b: 8b 17 mov (%edi),%edx 11be6d: 85 d2 test %edx,%edx 11be6f: 75 e3 jne 11be54 <_Objects_Get_next+0x28> *next_id_p = next_id; 11be71: 89 5d 00 mov %ebx,0x0(%ebp) return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 11be74: 83 c4 1c add $0x1c,%esp 11be77: 5b pop %ebx 11be78: 5e pop %esi 11be79: 5f pop %edi 11be7a: 5d pop %ebp 11be7b: c3 ret if ( !next_id_p ) return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) next_id = information->minimum_id; 11be7c: 8b 5e 08 mov 0x8(%esi),%ebx else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 11be7f: 66 39 5e 10 cmp %bx,0x10(%esi) 11be83: 73 d5 jae 11be5a <_Objects_Get_next+0x2e><== ALWAYS TAKEN 11be85: 8d 76 00 lea 0x0(%esi),%esi { *location_p = OBJECTS_ERROR; 11be88: c7 07 01 00 00 00 movl $0x1,(%edi) *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 11be8e: c7 45 00 ff ff ff ff movl $0xffffffff,0x0(%ebp) return 0; 11be95: 31 c0 xor %eax,%eax } 11be97: 83 c4 1c add $0x1c,%esp 11be9a: 5b pop %ebx 11be9b: 5e pop %esi 11be9c: 5f pop %edi 11be9d: 5d pop %ebp 11be9e: c3 ret 11be9f: 90 nop { Objects_Control *object; Objects_Id next_id; if ( !information ) return NULL; 11bea0: 31 c0 xor %eax,%eax 11bea2: eb d0 jmp 11be74 <_Objects_Get_next+0x48> =============================================================================== 0011e390 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 11e390: 8b 54 24 04 mov 0x4(%esp),%edx /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 11e394: b8 01 00 00 00 mov $0x1,%eax 11e399: 2b 42 08 sub 0x8(%edx),%eax 11e39c: 03 44 24 08 add 0x8(%esp),%eax if ( information->maximum >= index ) { 11e3a0: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 11e3a4: 39 c8 cmp %ecx,%eax 11e3a6: 77 18 ja 11e3c0 <_Objects_Get_no_protection+0x30> if ( (the_object = information->local_table[ index ]) != NULL ) { 11e3a8: 8b 52 1c mov 0x1c(%edx),%edx 11e3ab: 8b 04 82 mov (%edx,%eax,4),%eax 11e3ae: 85 c0 test %eax,%eax 11e3b0: 74 0e je 11e3c0 <_Objects_Get_no_protection+0x30><== NEVER TAKEN *location = OBJECTS_LOCAL; 11e3b2: 8b 54 24 0c mov 0xc(%esp),%edx 11e3b6: c7 02 00 00 00 00 movl $0x0,(%edx) return the_object; 11e3bc: c3 ret 11e3bd: 8d 76 00 lea 0x0(%esi),%esi /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 11e3c0: 8b 44 24 0c mov 0xc(%esp),%eax 11e3c4: c7 00 01 00 00 00 movl $0x1,(%eax) return NULL; 11e3ca: 31 c0 xor %eax,%eax } 11e3cc: c3 ret =============================================================================== 001129dc <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 1129dc: 83 ec 2c sub $0x2c,%esp 1129df: 8b 44 24 30 mov 0x30(%esp),%eax /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 1129e3: 85 c0 test %eax,%eax 1129e5: 75 65 jne 112a4c <_Objects_Id_to_name+0x70> 1129e7: a1 ec 06 14 00 mov 0x1406ec,%eax 1129ec: 8b 50 08 mov 0x8(%eax),%edx 1129ef: 89 d0 mov %edx,%eax 1129f1: c1 e8 18 shr $0x18,%eax 1129f4: 83 e0 07 and $0x7,%eax */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 1129f7: 8d 48 ff lea -0x1(%eax),%ecx 1129fa: 83 f9 02 cmp $0x2,%ecx 1129fd: 77 41 ja 112a40 <_Objects_Id_to_name+0x64> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 1129ff: 8b 04 85 1c 04 14 00 mov 0x14041c(,%eax,4),%eax 112a06: 85 c0 test %eax,%eax 112a08: 74 36 je 112a40 <_Objects_Id_to_name+0x64> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 112a0a: 89 d1 mov %edx,%ecx 112a0c: c1 e9 1b shr $0x1b,%ecx return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 112a0f: 8b 04 88 mov (%eax,%ecx,4),%eax if ( !information ) 112a12: 85 c0 test %eax,%eax 112a14: 74 2a je 112a40 <_Objects_Id_to_name+0x64><== NEVER TAKEN #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 112a16: 8d 4c 24 1c lea 0x1c(%esp),%ecx 112a1a: 89 4c 24 08 mov %ecx,0x8(%esp) 112a1e: 89 54 24 04 mov %edx,0x4(%esp) 112a22: 89 04 24 mov %eax,(%esp) 112a25: e8 3e ff ff ff call 112968 <_Objects_Get> if ( !the_object ) 112a2a: 85 c0 test %eax,%eax 112a2c: 74 12 je 112a40 <_Objects_Id_to_name+0x64> return OBJECTS_INVALID_ID; *name = the_object->name; 112a2e: 8b 50 0c mov 0xc(%eax),%edx 112a31: 8b 44 24 34 mov 0x34(%esp),%eax 112a35: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 112a37: e8 34 0c 00 00 call 113670 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 112a3c: 31 c0 xor %eax,%eax 112a3e: eb 05 jmp 112a45 <_Objects_Id_to_name+0x69> tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 112a40: b8 03 00 00 00 mov $0x3,%eax return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 112a45: 83 c4 2c add $0x2c,%esp 112a48: c3 ret 112a49: 8d 76 00 lea 0x0(%esi),%esi /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 112a4c: 89 c2 mov %eax,%edx 112a4e: eb 9f jmp 1129ef <_Objects_Id_to_name+0x13> =============================================================================== 0010d2f8 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10d2f8: 55 push %ebp 10d2f9: 57 push %edi 10d2fa: 56 push %esi 10d2fb: 53 push %ebx 10d2fc: 83 ec 1c sub $0x1c,%esp 10d2ff: 8b 7c 24 30 mov 0x30(%esp),%edi /* * Search the list to find block or chunk with all objects inactive. */ index_base = _Objects_Get_index( information->minimum_id ); 10d303: 0f b7 5f 08 movzwl 0x8(%edi),%ebx block_count = (information->maximum - index_base) / 10d307: 0f b7 77 14 movzwl 0x14(%edi),%esi 10d30b: 0f b7 47 10 movzwl 0x10(%edi),%eax 10d30f: 29 d8 sub %ebx,%eax 10d311: 31 d2 xor %edx,%edx 10d313: f7 f6 div %esi information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10d315: 85 c0 test %eax,%eax 10d317: 74 1e je 10d337 <_Objects_Shrink_information+0x3f><== NEVER TAKEN if ( information->inactive_per_block[ block ] == 10d319: 8b 57 30 mov 0x30(%edi),%edx 10d31c: 3b 32 cmp (%edx),%esi 10d31e: 74 1f je 10d33f <_Objects_Shrink_information+0x47><== NEVER TAKEN 10d320: 31 c9 xor %ecx,%ecx 10d322: eb 0c jmp 10d330 <_Objects_Shrink_information+0x38> * the_block - the block to remove * * Output parameters: NONE */ void _Objects_Shrink_information( 10d324: 8d 2c 8d 00 00 00 00 lea 0x0(,%ecx,4),%ebp index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == 10d32b: 3b 34 8a cmp (%edx,%ecx,4),%esi 10d32e: 74 14 je 10d344 <_Objects_Shrink_information+0x4c> information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 10d330: 01 f3 add %esi,%ebx index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10d332: 41 inc %ecx 10d333: 39 c1 cmp %eax,%ecx 10d335: 75 ed jne 10d324 <_Objects_Shrink_information+0x2c> return; } index_base += information->allocation_size; } } 10d337: 83 c4 1c add $0x1c,%esp 10d33a: 5b pop %ebx 10d33b: 5e pop %esi 10d33c: 5f pop %edi 10d33d: 5d pop %ebp 10d33e: c3 ret index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == 10d33f: 31 ed xor %ebp,%ebp <== NOT EXECUTED 10d341: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10d344: 8b 47 20 mov 0x20(%edi),%eax 10d347: eb 09 jmp 10d352 <_Objects_Shrink_information+0x5a> 10d349: 8d 76 00 lea 0x0(%esi),%esi index = _Objects_Get_index( the_object->id ); /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; 10d34c: 89 f0 mov %esi,%eax if ((index >= index_base) && (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); } } while ( the_object ); 10d34e: 85 f6 test %esi,%esi 10d350: 74 22 je 10d374 <_Objects_Shrink_information+0x7c> * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); do { index = _Objects_Get_index( the_object->id ); 10d352: 0f b7 50 08 movzwl 0x8(%eax),%edx /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; 10d356: 8b 30 mov (%eax),%esi if ((index >= index_base) && 10d358: 39 da cmp %ebx,%edx 10d35a: 72 f0 jb 10d34c <_Objects_Shrink_information+0x54> (index < (index_base + information->allocation_size))) { 10d35c: 0f b7 4f 14 movzwl 0x14(%edi),%ecx 10d360: 01 d9 add %ebx,%ecx /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; if ((index >= index_base) && 10d362: 39 ca cmp %ecx,%edx 10d364: 73 e6 jae 10d34c <_Objects_Shrink_information+0x54> (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); 10d366: 89 04 24 mov %eax,(%esp) 10d369: e8 6e 38 00 00 call 110bdc <_Chain_Extract> index = _Objects_Get_index( the_object->id ); /* * Get the next node before the node is extracted */ extract_me = the_object; the_object = (Objects_Control *) the_object->Node.next; 10d36e: 89 f0 mov %esi,%eax if ((index >= index_base) && (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); } } while ( the_object ); 10d370: 85 f6 test %esi,%esi 10d372: 75 de jne 10d352 <_Objects_Shrink_information+0x5a> /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10d374: 8b 47 34 mov 0x34(%edi),%eax 10d377: 8b 04 28 mov (%eax,%ebp,1),%eax 10d37a: 89 04 24 mov %eax,(%esp) 10d37d: e8 a6 18 00 00 call 10ec28 <_Workspace_Free> information->object_blocks[ block ] = NULL; 10d382: 8b 47 34 mov 0x34(%edi),%eax 10d385: c7 04 28 00 00 00 00 movl $0x0,(%eax,%ebp,1) information->inactive_per_block[ block ] = 0; 10d38c: 8b 47 30 mov 0x30(%edi),%eax 10d38f: c7 04 28 00 00 00 00 movl $0x0,(%eax,%ebp,1) information->inactive -= information->allocation_size; 10d396: 8b 47 14 mov 0x14(%edi),%eax 10d399: 66 29 47 2c sub %ax,0x2c(%edi) return; } index_base += information->allocation_size; } } 10d39d: 83 c4 1c add $0x1c,%esp 10d3a0: 5b pop %ebx 10d3a1: 5e pop %esi 10d3a2: 5f pop %edi 10d3a3: 5d pop %ebp 10d3a4: c3 ret =============================================================================== 0010e0fc <_RBTree_Extract_unprotected>: */ void _RBTree_Extract_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { 10e0fc: 55 push %ebp 10e0fd: 57 push %edi 10e0fe: 56 push %esi 10e0ff: 53 push %ebx 10e100: 83 ec 1c sub $0x1c,%esp 10e103: 8b 6c 24 30 mov 0x30(%esp),%ebp 10e107: 8b 74 24 34 mov 0x34(%esp),%esi RBTree_Node *leaf, *target; RBTree_Color victim_color; RBTree_Direction dir; if (!the_node) return; 10e10b: 85 f6 test %esi,%esi 10e10d: 0f 84 ae 00 00 00 je 10e1c1 <_RBTree_Extract_unprotected+0xc5> /* check if min needs to be updated */ if (the_node == the_rbtree->first[RBT_LEFT]) { 10e113: 39 75 08 cmp %esi,0x8(%ebp) 10e116: 0f 84 d8 00 00 00 je 10e1f4 <_RBTree_Extract_unprotected+0xf8> the_rbtree->first[RBT_LEFT] = next; } /* Check if max needs to be updated. min=max for 1 element trees so * do not use else if here. */ if (the_node == the_rbtree->first[RBT_RIGHT]) { 10e11c: 39 75 0c cmp %esi,0xc(%ebp) 10e11f: 0f 84 e7 00 00 00 je 10e20c <_RBTree_Extract_unprotected+0x110> * either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT], * and replace the_node with the target node. This maintains the binary * search tree property, but may violate the red-black properties. */ if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) { 10e125: 8b 5e 04 mov 0x4(%esi),%ebx 10e128: 85 db test %ebx,%ebx 10e12a: 0f 84 00 01 00 00 je 10e230 <_RBTree_Extract_unprotected+0x134> 10e130: 8b 7e 08 mov 0x8(%esi),%edi 10e133: 85 ff test %edi,%edi 10e135: 75 07 jne 10e13e <_RBTree_Extract_unprotected+0x42> 10e137: e9 9d 00 00 00 jmp 10e1d9 <_RBTree_Extract_unprotected+0xdd> target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */ while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT]; 10e13c: 89 c3 mov %eax,%ebx 10e13e: 8b 43 08 mov 0x8(%ebx),%eax 10e141: 85 c0 test %eax,%eax 10e143: 75 f7 jne 10e13c <_RBTree_Extract_unprotected+0x40> * target's position (target is the right child of target->parent) * when target vacates it. if there is no child, then target->parent * should become NULL. This may cause the coloring to be violated. * For now we store the color of the node being deleted in victim_color. */ leaf = target->child[RBT_LEFT]; 10e145: 8b 7b 04 mov 0x4(%ebx),%edi if(leaf) { 10e148: 85 ff test %edi,%edi 10e14a: 0f 84 d4 00 00 00 je 10e224 <_RBTree_Extract_unprotected+0x128> leaf->parent = target->parent; 10e150: 8b 03 mov (%ebx),%eax 10e152: 89 07 mov %eax,(%edi) } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(target); } victim_color = target->color; 10e154: 8b 53 0c mov 0xc(%ebx),%edx dir = target != target->parent->child[0]; 10e157: 8b 03 mov (%ebx),%eax 10e159: 31 c9 xor %ecx,%ecx 10e15b: 3b 58 04 cmp 0x4(%eax),%ebx 10e15e: 0f 95 c1 setne %cl target->parent->child[dir] = leaf; 10e161: 89 7c 88 04 mov %edi,0x4(%eax,%ecx,4) /* now replace the_node with target */ dir = the_node != the_node->parent->child[0]; 10e165: 8b 06 mov (%esi),%eax 10e167: 31 c9 xor %ecx,%ecx 10e169: 39 70 04 cmp %esi,0x4(%eax) 10e16c: 0f 95 c1 setne %cl the_node->parent->child[dir] = target; 10e16f: 89 5c 88 04 mov %ebx,0x4(%eax,%ecx,4) /* set target's new children to the original node's children */ target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT]; 10e173: 8b 46 08 mov 0x8(%esi),%eax 10e176: 89 43 08 mov %eax,0x8(%ebx) if (the_node->child[RBT_RIGHT]) 10e179: 8b 46 08 mov 0x8(%esi),%eax 10e17c: 85 c0 test %eax,%eax 10e17e: 74 02 je 10e182 <_RBTree_Extract_unprotected+0x86><== NEVER TAKEN the_node->child[RBT_RIGHT]->parent = target; 10e180: 89 18 mov %ebx,(%eax) target->child[RBT_LEFT] = the_node->child[RBT_LEFT]; 10e182: 8b 46 04 mov 0x4(%esi),%eax 10e185: 89 43 04 mov %eax,0x4(%ebx) if (the_node->child[RBT_LEFT]) 10e188: 8b 46 04 mov 0x4(%esi),%eax 10e18b: 85 c0 test %eax,%eax 10e18d: 74 02 je 10e191 <_RBTree_Extract_unprotected+0x95> the_node->child[RBT_LEFT]->parent = target; 10e18f: 89 18 mov %ebx,(%eax) /* finally, update the parent node and recolor. target has completely * replaced the_node, and target's child has moved up the tree if needed. * the_node is no longer part of the tree, although it has valid pointers * still. */ target->parent = the_node->parent; 10e191: 8b 06 mov (%esi),%eax 10e193: 89 03 mov %eax,(%ebx) target->color = the_node->color; 10e195: 8b 46 0c mov 0xc(%esi),%eax 10e198: 89 43 0c mov %eax,0xc(%ebx) /* fix coloring. leaf has moved up the tree. The color of the deleted * node is in victim_color. There are two cases: * 1. Deleted a red node, its child must be black. Nothing must be done. * 2. Deleted a black node, its child must be red. Paint child black. */ if (victim_color == RBT_BLACK) { /* eliminate case 1 */ 10e19b: 85 d2 test %edx,%edx 10e19d: 74 2d je 10e1cc <_RBTree_Extract_unprotected+0xd0> */ RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree( RBTree_Node *node ) { node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL; 10e19f: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) 10e1a6: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) 10e1ad: c7 06 00 00 00 00 movl $0x0,(%esi) /* Wipe the_node */ _RBTree_Set_off_rbtree(the_node); /* set root to black, if it exists */ if (the_rbtree->root) the_rbtree->root->color = RBT_BLACK; 10e1b3: 8b 45 04 mov 0x4(%ebp),%eax 10e1b6: 85 c0 test %eax,%eax 10e1b8: 74 07 je 10e1c1 <_RBTree_Extract_unprotected+0xc5> 10e1ba: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) } 10e1c1: 83 c4 1c add $0x1c,%esp 10e1c4: 5b pop %ebx 10e1c5: 5e pop %esi 10e1c6: 5f pop %edi 10e1c7: 5d pop %ebp 10e1c8: c3 ret 10e1c9: 8d 76 00 lea 0x0(%esi),%esi * node is in victim_color. There are two cases: * 1. Deleted a red node, its child must be black. Nothing must be done. * 2. Deleted a black node, its child must be red. Paint child black. */ if (victim_color == RBT_BLACK) { /* eliminate case 1 */ if (leaf) { 10e1cc: 85 ff test %edi,%edi 10e1ce: 74 cf je 10e19f <_RBTree_Extract_unprotected+0xa3> leaf->color = RBT_BLACK; /* case 2 */ 10e1d0: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) 10e1d7: eb c6 jmp 10e19f <_RBTree_Extract_unprotected+0xa3> * either max in node->child[RBT_LEFT] or min in node->child[RBT_RIGHT], * and replace the_node with the target node. This maintains the binary * search tree property, but may violate the red-black properties. */ if (the_node->child[RBT_LEFT] && the_node->child[RBT_RIGHT]) { 10e1d9: 89 df mov %ebx,%edi * For now we store the color of the node being deleted in victim_color. */ leaf = the_node->child[RBT_LEFT] ? the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT]; if( leaf ) { leaf->parent = the_node->parent; 10e1db: 8b 06 mov (%esi),%eax 10e1dd: 89 07 mov %eax,(%edi) } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(the_node); } victim_color = the_node->color; 10e1df: 8b 56 0c mov 0xc(%esi),%edx /* remove the_node from the tree */ dir = the_node != the_node->parent->child[0]; 10e1e2: 8b 06 mov (%esi),%eax 10e1e4: 31 c9 xor %ecx,%ecx 10e1e6: 39 70 04 cmp %esi,0x4(%eax) 10e1e9: 0f 95 c1 setne %cl the_node->parent->child[dir] = leaf; 10e1ec: 89 7c 88 04 mov %edi,0x4(%eax,%ecx,4) 10e1f0: eb a9 jmp 10e19b <_RBTree_Extract_unprotected+0x9f> 10e1f2: 66 90 xchg %ax,%ax */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected( const RBTree_Node *node ) { return _RBTree_Next_unprotected( node, RBT_RIGHT ); 10e1f4: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10e1fb: 00 10e1fc: 89 34 24 mov %esi,(%esp) 10e1ff: e8 00 03 00 00 call 10e504 <_RBTree_Next_unprotected> /* check if min needs to be updated */ if (the_node == the_rbtree->first[RBT_LEFT]) { RBTree_Node *next; next = _RBTree_Successor_unprotected(the_node); the_rbtree->first[RBT_LEFT] = next; 10e204: 89 45 08 mov %eax,0x8(%ebp) 10e207: e9 10 ff ff ff jmp 10e11c <_RBTree_Extract_unprotected+0x20> */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected( const RBTree_Node *node ) { return _RBTree_Next_unprotected( node, RBT_LEFT ); 10e20c: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10e213: 00 10e214: 89 34 24 mov %esi,(%esp) 10e217: e8 e8 02 00 00 call 10e504 <_RBTree_Next_unprotected> /* Check if max needs to be updated. min=max for 1 element trees so * do not use else if here. */ if (the_node == the_rbtree->first[RBT_RIGHT]) { RBTree_Node *previous; previous = _RBTree_Predecessor_unprotected(the_node); the_rbtree->first[RBT_RIGHT] = previous; 10e21c: 89 45 0c mov %eax,0xc(%ebp) 10e21f: e9 01 ff ff ff jmp 10e125 <_RBTree_Extract_unprotected+0x29> leaf = target->child[RBT_LEFT]; if(leaf) { leaf->parent = target->parent; } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(target); 10e224: 89 d8 mov %ebx,%eax 10e226: e8 95 fc ff ff call 10dec0 <_RBTree_Extract_validate_unprotected> 10e22b: e9 24 ff ff ff jmp 10e154 <_RBTree_Extract_unprotected+0x58> * the_node's location in the tree. This may cause the coloring to be * violated. We will fix it later. * For now we store the color of the node being deleted in victim_color. */ leaf = the_node->child[RBT_LEFT] ? the_node->child[RBT_LEFT] : the_node->child[RBT_RIGHT]; 10e230: 8b 7e 08 mov 0x8(%esi),%edi if( leaf ) { 10e233: 85 ff test %edi,%edi 10e235: 75 a4 jne 10e1db <_RBTree_Extract_unprotected+0xdf> leaf->parent = the_node->parent; } else { /* fix the tree here if the child is a null leaf. */ _RBTree_Extract_validate_unprotected(the_node); 10e237: 89 f0 mov %esi,%eax 10e239: e8 82 fc ff ff call 10dec0 <_RBTree_Extract_validate_unprotected> 10e23e: eb 9f jmp 10e1df <_RBTree_Extract_unprotected+0xe3> =============================================================================== 0010dec0 <_RBTree_Extract_validate_unprotected>: ) { RBTree_Node *parent, *sibling; RBTree_Direction dir; parent = the_node->parent; 10dec0: 8b 10 mov (%eax),%edx if(!parent->parent) return; 10dec2: 8b 0a mov (%edx),%ecx 10dec4: 85 c9 test %ecx,%ecx 10dec6: 0f 84 8f 00 00 00 je 10df5b <_RBTree_Extract_validate_unprotected+0x9b> * of the extract operation. */ static void _RBTree_Extract_validate_unprotected( RBTree_Node *the_node ) { 10decc: 55 push %ebp 10decd: 57 push %edi 10dece: 56 push %esi 10decf: 53 push %ebx 10ded0: 83 ec 08 sub $0x8,%esp { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; if(the_node == the_node->parent->child[RBT_LEFT]) 10ded3: 8b 4a 04 mov 0x4(%edx),%ecx 10ded6: 39 c8 cmp %ecx,%eax 10ded8: 75 68 jne 10df42 <_RBTree_Extract_validate_unprotected+0x82> return the_node->parent->child[RBT_RIGHT]; 10deda: 8b 4a 08 mov 0x8(%edx),%ecx 10dedd: eb 63 jmp 10df42 <_RBTree_Extract_validate_unprotected+0x82> 10dedf: 90 nop if(!parent->parent) return; sibling = _RBTree_Sibling(the_node); /* continue to correct tree as long as the_node is black and not the root */ while (!_RBTree_Is_red(the_node) && parent->parent) { 10dee0: 8b 1a mov (%edx),%ebx 10dee2: 85 db test %ebx,%ebx 10dee4: 74 62 je 10df48 <_RBTree_Extract_validate_unprotected+0x88> */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10dee6: 85 c9 test %ecx,%ecx 10dee8: 74 0a je 10def4 <_RBTree_Extract_validate_unprotected+0x34><== NEVER TAKEN 10deea: 83 79 0c 01 cmpl $0x1,0xc(%ecx) 10deee: 0f 84 18 01 00 00 je 10e00c <_RBTree_Extract_validate_unprotected+0x14c> _RBTree_Rotate(parent, dir); sibling = parent->child[_RBTree_Opposite_direction(dir)]; } /* sibling is black, see if both of its children are also black. */ if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) && 10def4: 8b 59 08 mov 0x8(%ecx),%ebx 10def7: 85 db test %ebx,%ebx 10def9: 74 06 je 10df01 <_RBTree_Extract_validate_unprotected+0x41> 10defb: 83 7b 0c 01 cmpl $0x1,0xc(%ebx) 10deff: 74 5b je 10df5c <_RBTree_Extract_validate_unprotected+0x9c> !_RBTree_Is_red(sibling->child[RBT_LEFT])) { 10df01: 8b 59 04 mov 0x4(%ecx),%ebx 10df04: 85 db test %ebx,%ebx 10df06: 74 06 je 10df0e <_RBTree_Extract_validate_unprotected+0x4e> 10df08: 83 7b 0c 01 cmpl $0x1,0xc(%ebx) 10df0c: 74 4e je 10df5c <_RBTree_Extract_validate_unprotected+0x9c> sibling->color = RBT_RED; 10df0e: c7 41 0c 01 00 00 00 movl $0x1,0xc(%ecx) 10df15: 83 7a 0c 01 cmpl $0x1,0xc(%edx) 10df19: 0f 84 d1 01 00 00 je 10e0f0 <_RBTree_Extract_validate_unprotected+0x230> if (_RBTree_Is_red(parent)) { parent->color = RBT_BLACK; break; } the_node = parent; /* done if parent is red */ parent = the_node->parent; 10df1f: 8b 1a mov (%edx),%ebx RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; 10df21: 85 db test %ebx,%ebx 10df23: 0f 84 3b 01 00 00 je 10e064 <_RBTree_Extract_validate_unprotected+0x1a4><== NEVER TAKEN if(!(the_node->parent->parent)) return NULL; 10df29: 8b 3b mov (%ebx),%edi 10df2b: 85 ff test %edi,%edi 10df2d: 0f 84 31 01 00 00 je 10e064 <_RBTree_Extract_validate_unprotected+0x1a4> if(the_node == the_node->parent->child[RBT_LEFT]) 10df33: 8b 4b 04 mov 0x4(%ebx),%ecx 10df36: 39 ca cmp %ecx,%edx 10df38: 0f 84 2e 01 00 00 je 10e06c <_RBTree_Extract_validate_unprotected+0x1ac> 10df3e: 89 d0 mov %edx,%eax RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; 10df40: 89 da mov %ebx,%edx */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10df42: 83 78 0c 01 cmpl $0x1,0xc(%eax) 10df46: 75 98 jne 10dee0 <_RBTree_Extract_validate_unprotected+0x20> sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK; _RBTree_Rotate(parent, dir); break; /* done */ } } /* while */ if(!the_node->parent->parent) the_node->color = RBT_BLACK; 10df48: 8b 10 mov (%eax),%edx 10df4a: 8b 32 mov (%edx),%esi 10df4c: 85 f6 test %esi,%esi 10df4e: 0f 84 8e 01 00 00 je 10e0e2 <_RBTree_Extract_validate_unprotected+0x222> } 10df54: 83 c4 08 add $0x8,%esp 10df57: 5b pop %ebx 10df58: 5e pop %esi 10df59: 5f pop %edi 10df5a: 5d pop %ebp 10df5b: c3 ret * cases, either the_node is to the left or the right of the parent. * In both cases, first check if one of sibling's children is black, * and if so rotate in the proper direction and update sibling pointer. * Then switch the sibling and parent colors, and rotate through parent. */ dir = the_node != parent->child[0]; 10df5c: 3b 42 04 cmp 0x4(%edx),%eax 10df5f: 0f 95 c3 setne %bl 10df62: 89 dd mov %ebx,%ebp 10df64: 0f b6 f3 movzbl %bl,%esi */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 10df67: 83 f3 01 xor $0x1,%ebx 10df6a: 0f b6 db movzbl %bl,%ebx 10df6d: 89 1c 24 mov %ebx,(%esp) if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) { 10df70: 8b 7c 99 04 mov 0x4(%ecx,%ebx,4),%edi */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10df74: 85 ff test %edi,%edi 10df76: 74 0a je 10df82 <_RBTree_Extract_validate_unprotected+0xc2> 10df78: 83 7f 0c 01 cmpl $0x1,0xc(%edi) 10df7c: 0f 84 f9 00 00 00 je 10e07b <_RBTree_Extract_validate_unprotected+0x1bb> sibling->color = RBT_RED; 10df82: c7 41 0c 01 00 00 00 movl $0x1,0xc(%ecx) sibling->child[dir]->color = RBT_BLACK; 10df89: 8b 7c b1 04 mov 0x4(%ecx,%esi,4),%edi 10df8d: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 10df94: 89 eb mov %ebp,%ebx 10df96: 0f b6 eb movzbl %bl,%ebp 10df99: 89 6c 24 04 mov %ebp,0x4(%esp) RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 10df9d: 8b 6c a9 04 mov 0x4(%ecx,%ebp,4),%ebp 10dfa1: 85 ed test %ebp,%ebp 10dfa3: 74 36 je 10dfdb <_RBTree_Extract_validate_unprotected+0x11b><== NEVER TAKEN c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 10dfa5: 8b 3c 24 mov (%esp),%edi 10dfa8: 8b 5c bd 04 mov 0x4(%ebp,%edi,4),%ebx 10dfac: 8b 7c 24 04 mov 0x4(%esp),%edi 10dfb0: 89 5c b9 04 mov %ebx,0x4(%ecx,%edi,4) if (c->child[dir]) 10dfb4: 8b 1c 24 mov (%esp),%ebx 10dfb7: 8b 7c 9d 04 mov 0x4(%ebp,%ebx,4),%edi 10dfbb: 85 ff test %edi,%edi 10dfbd: 74 02 je 10dfc1 <_RBTree_Extract_validate_unprotected+0x101> c->child[dir]->parent = the_node; 10dfbf: 89 0f mov %ecx,(%edi) c->child[dir] = the_node; 10dfc1: 8b 3c 24 mov (%esp),%edi 10dfc4: 89 4c bd 04 mov %ecx,0x4(%ebp,%edi,4) the_node->parent->child[the_node != the_node->parent->child[0]] = c; 10dfc8: 8b 39 mov (%ecx),%edi 10dfca: 31 db xor %ebx,%ebx 10dfcc: 3b 4f 04 cmp 0x4(%edi),%ecx 10dfcf: 0f 95 c3 setne %bl 10dfd2: 89 6c 9f 04 mov %ebp,0x4(%edi,%ebx,4) c->parent = the_node->parent; 10dfd6: 89 7d 00 mov %edi,0x0(%ebp) the_node->parent = c; 10dfd9: 89 29 mov %ebp,(%ecx) _RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir)); sibling = parent->child[_RBTree_Opposite_direction(dir)]; 10dfdb: 8b 3c 24 mov (%esp),%edi 10dfde: 8b 7c ba 04 mov 0x4(%edx,%edi,4),%edi 10dfe2: 89 7c 24 04 mov %edi,0x4(%esp) 10dfe6: 8b 2c 24 mov (%esp),%ebp 10dfe9: 8b 4c af 04 mov 0x4(%edi,%ebp,4),%ecx } sibling->color = parent->color; 10dfed: 8b 7a 0c mov 0xc(%edx),%edi 10dff0: 8b 5c 24 04 mov 0x4(%esp),%ebx 10dff4: 89 7b 0c mov %edi,0xc(%ebx) parent->color = RBT_BLACK; 10dff7: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK; 10dffe: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx) 10e005: e9 95 00 00 00 jmp 10e09f <_RBTree_Extract_validate_unprotected+0x1df> 10e00a: 66 90 xchg %ax,%ax * then rotate parent left, making the sibling be the_node's grandparent. * Now the_node has a black sibling and red parent. After rotation, * update sibling pointer. */ if (_RBTree_Is_red(sibling)) { parent->color = RBT_RED; 10e00c: c7 42 0c 01 00 00 00 movl $0x1,0xc(%edx) sibling->color = RBT_BLACK; 10e013: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx) dir = the_node != parent->child[0]; 10e01a: 39 42 04 cmp %eax,0x4(%edx) 10e01d: 0f 95 c3 setne %bl 10e020: 0f b6 f3 movzbl %bl,%esi */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 10e023: 83 f3 01 xor $0x1,%ebx 10e026: 0f b6 eb movzbl %bl,%ebp RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 10e029: 8b 4c aa 04 mov 0x4(%edx,%ebp,4),%ecx 10e02d: 85 c9 test %ecx,%ecx 10e02f: 74 43 je 10e074 <_RBTree_Extract_validate_unprotected+0x1b4><== NEVER TAKEN c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 10e031: 8b 7c b1 04 mov 0x4(%ecx,%esi,4),%edi 10e035: 89 7c aa 04 mov %edi,0x4(%edx,%ebp,4) if (c->child[dir]) 10e039: 8b 7c b1 04 mov 0x4(%ecx,%esi,4),%edi 10e03d: 85 ff test %edi,%edi 10e03f: 74 02 je 10e043 <_RBTree_Extract_validate_unprotected+0x183><== NEVER TAKEN c->child[dir]->parent = the_node; 10e041: 89 17 mov %edx,(%edi) c->child[dir] = the_node; 10e043: 89 54 b1 04 mov %edx,0x4(%ecx,%esi,4) the_node->parent->child[the_node != the_node->parent->child[0]] = c; 10e047: 8b 32 mov (%edx),%esi 10e049: 31 db xor %ebx,%ebx 10e04b: 3b 56 04 cmp 0x4(%esi),%edx 10e04e: 0f 95 c3 setne %bl 10e051: 89 df mov %ebx,%edi 10e053: 89 4c be 04 mov %ecx,0x4(%esi,%edi,4) c->parent = the_node->parent; 10e057: 89 31 mov %esi,(%ecx) the_node->parent = c; 10e059: 89 0a mov %ecx,(%edx) 10e05b: 8b 4c aa 04 mov 0x4(%edx,%ebp,4),%ecx 10e05f: e9 90 fe ff ff jmp 10def4 <_RBTree_Extract_validate_unprotected+0x34> RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; 10e064: 31 c9 xor %ecx,%ecx 10e066: e9 d3 fe ff ff jmp 10df3e <_RBTree_Extract_validate_unprotected+0x7e> 10e06b: 90 nop if(!(the_node->parent->parent)) return NULL; if(the_node == the_node->parent->child[RBT_LEFT]) return the_node->parent->child[RBT_RIGHT]; 10e06c: 8b 4b 08 mov 0x8(%ebx),%ecx 10e06f: e9 ca fe ff ff jmp 10df3e <_RBTree_Extract_validate_unprotected+0x7e> RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 10e074: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10e076: e9 79 fe ff ff jmp 10def4 <_RBTree_Extract_validate_unprotected+0x34><== NOT EXECUTED 10e07b: 8b 6c 9a 04 mov 0x4(%edx,%ebx,4),%ebp 10e07f: 89 6c 24 04 mov %ebp,0x4(%esp) sibling->color = RBT_RED; sibling->child[dir]->color = RBT_BLACK; _RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir)); sibling = parent->child[_RBTree_Opposite_direction(dir)]; } sibling->color = parent->color; 10e083: 8b 5a 0c mov 0xc(%edx),%ebx 10e086: 89 59 0c mov %ebx,0xc(%ecx) parent->color = RBT_BLACK; 10e089: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK; 10e090: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) 10e097: 85 ed test %ebp,%ebp 10e099: 0f 84 a9 fe ff ff je 10df48 <_RBTree_Extract_validate_unprotected+0x88><== NEVER TAKEN c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 10e09f: 8b 7c 24 04 mov 0x4(%esp),%edi 10e0a3: 8b 4c b7 04 mov 0x4(%edi,%esi,4),%ecx 10e0a7: 8b 2c 24 mov (%esp),%ebp 10e0aa: 89 4c aa 04 mov %ecx,0x4(%edx,%ebp,4) if (c->child[dir]) 10e0ae: 8b 4c b7 04 mov 0x4(%edi,%esi,4),%ecx 10e0b2: 85 c9 test %ecx,%ecx 10e0b4: 74 02 je 10e0b8 <_RBTree_Extract_validate_unprotected+0x1f8> c->child[dir]->parent = the_node; 10e0b6: 89 11 mov %edx,(%ecx) c->child[dir] = the_node; 10e0b8: 8b 4c 24 04 mov 0x4(%esp),%ecx 10e0bc: 89 54 b1 04 mov %edx,0x4(%ecx,%esi,4) the_node->parent->child[the_node != the_node->parent->child[0]] = c; 10e0c0: 8b 0a mov (%edx),%ecx 10e0c2: 31 db xor %ebx,%ebx 10e0c4: 3b 51 04 cmp 0x4(%ecx),%edx 10e0c7: 0f 95 c3 setne %bl 10e0ca: 8b 74 24 04 mov 0x4(%esp),%esi 10e0ce: 89 74 99 04 mov %esi,0x4(%ecx,%ebx,4) c->parent = the_node->parent; 10e0d2: 89 0e mov %ecx,(%esi) the_node->parent = c; 10e0d4: 89 32 mov %esi,(%edx) _RBTree_Rotate(parent, dir); break; /* done */ } } /* while */ if(!the_node->parent->parent) the_node->color = RBT_BLACK; 10e0d6: 8b 10 mov (%eax),%edx 10e0d8: 8b 32 mov (%edx),%esi 10e0da: 85 f6 test %esi,%esi 10e0dc: 0f 85 72 fe ff ff jne 10df54 <_RBTree_Extract_validate_unprotected+0x94><== ALWAYS TAKEN 10e0e2: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) 10e0e9: e9 66 fe ff ff jmp 10df54 <_RBTree_Extract_validate_unprotected+0x94> 10e0ee: 66 90 xchg %ax,%ax /* sibling is black, see if both of its children are also black. */ if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) && !_RBTree_Is_red(sibling->child[RBT_LEFT])) { sibling->color = RBT_RED; if (_RBTree_Is_red(parent)) { parent->color = RBT_BLACK; 10e0f0: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) break; 10e0f7: e9 4c fe ff ff jmp 10df48 <_RBTree_Extract_validate_unprotected+0x88> =============================================================================== 0010e7c0 <_RBTree_Find>: RBTree_Node *_RBTree_Find( RBTree_Control *the_rbtree, RBTree_Node *search_node ) { 10e7c0: 55 push %ebp 10e7c1: 57 push %edi 10e7c2: 56 push %esi 10e7c3: 53 push %ebx 10e7c4: 83 ec 2c sub $0x2c,%esp 10e7c7: 8b 5c 24 40 mov 0x40(%esp),%ebx 10e7cb: 8b 74 24 44 mov 0x44(%esp),%esi ISR_Level level; RBTree_Node *return_node; return_node = NULL; _ISR_Disable( level ); 10e7cf: 9c pushf 10e7d0: fa cli 10e7d1: 8f 44 24 1c popl 0x1c(%esp) RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; 10e7d5: 8b 6b 04 mov 0x4(%ebx),%ebp RBTree_Node* found = NULL; int compare_result; while (iter_node) { 10e7d8: 31 ff xor %edi,%edi 10e7da: 85 ed test %ebp,%ebp 10e7dc: 74 28 je 10e806 <_RBTree_Find+0x46> <== NEVER TAKEN 10e7de: 66 90 xchg %ax,%ax compare_result = the_rbtree->compare_function(the_node, iter_node); 10e7e0: 89 6c 24 04 mov %ebp,0x4(%esp) 10e7e4: 89 34 24 mov %esi,(%esp) 10e7e7: ff 53 10 call *0x10(%ebx) if ( _RBTree_Is_equal( compare_result ) ) { 10e7ea: 85 c0 test %eax,%eax 10e7ec: 75 08 jne 10e7f6 <_RBTree_Find+0x36> found = iter_node; if ( the_rbtree->is_unique ) 10e7ee: 89 ef mov %ebp,%edi 10e7f0: 80 7b 14 00 cmpb $0x0,0x14(%ebx) 10e7f4: 75 10 jne 10e806 <_RBTree_Find+0x46> RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater( int compare_result ) { return compare_result > 0; 10e7f6: 85 c0 test %eax,%eax 10e7f8: 0f 9f c0 setg %al 10e7fb: 0f b6 c0 movzbl %al,%eax break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 10e7fe: 8b 6c 85 04 mov 0x4(%ebp,%eax,4),%ebp ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { 10e802: 85 ed test %ebp,%ebp 10e804: 75 da jne 10e7e0 <_RBTree_Find+0x20> return_node = _RBTree_Find_unprotected( the_rbtree, search_node ); _ISR_Enable( level ); 10e806: ff 74 24 1c pushl 0x1c(%esp) 10e80a: 9d popf return return_node; } 10e80b: 89 f8 mov %edi,%eax 10e80d: 83 c4 2c add $0x2c,%esp 10e810: 5b pop %ebx 10e811: 5e pop %esi 10e812: 5f pop %edi 10e813: 5d pop %ebp 10e814: c3 ret =============================================================================== 0010eb08 <_RBTree_Initialize>: void *starting_address, size_t number_nodes, size_t node_size, bool is_unique ) { 10eb08: 55 push %ebp 10eb09: 57 push %edi 10eb0a: 56 push %esi 10eb0b: 53 push %ebx 10eb0c: 83 ec 1c sub $0x1c,%esp 10eb0f: 8b 7c 24 30 mov 0x30(%esp),%edi 10eb13: 8b 5c 24 3c mov 0x3c(%esp),%ebx 10eb17: 8b 6c 24 40 mov 0x40(%esp),%ebp 10eb1b: 8b 44 24 44 mov 0x44(%esp),%eax size_t count; RBTree_Node *next; /* TODO: Error message? */ if (!the_rbtree) return; 10eb1f: 85 ff test %edi,%edi 10eb21: 74 3e je 10eb61 <_RBTree_Initialize+0x59><== NEVER TAKEN RBTree_Control *the_rbtree, RBTree_Compare_function compare_function, bool is_unique ) { the_rbtree->permanent_null = NULL; 10eb23: c7 07 00 00 00 00 movl $0x0,(%edi) the_rbtree->root = NULL; 10eb29: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) the_rbtree->first[0] = NULL; 10eb30: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) the_rbtree->first[1] = NULL; 10eb37: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) the_rbtree->compare_function = compare_function; 10eb3e: 8b 54 24 34 mov 0x34(%esp),%edx 10eb42: 89 57 10 mov %edx,0x10(%edi) the_rbtree->is_unique = is_unique; 10eb45: 88 47 14 mov %al,0x14(%edi) /* could do sanity checks here */ _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique); count = number_nodes; next = starting_address; while ( count-- ) { 10eb48: 85 db test %ebx,%ebx 10eb4a: 74 15 je 10eb61 <_RBTree_Initialize+0x59><== NEVER TAKEN 10eb4c: 8b 74 24 38 mov 0x38(%esp),%esi _RBTree_Insert_unprotected(the_rbtree, next); 10eb50: 89 74 24 04 mov %esi,0x4(%esp) 10eb54: 89 3c 24 mov %edi,(%esp) 10eb57: e8 e8 fc ff ff call 10e844 <_RBTree_Insert_unprotected> * node_size - size of node in bytes * * Output parameters: NONE */ void _RBTree_Initialize( 10eb5c: 01 ee add %ebp,%esi /* could do sanity checks here */ _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique); count = number_nodes; next = starting_address; while ( count-- ) { 10eb5e: 4b dec %ebx 10eb5f: 75 ef jne 10eb50 <_RBTree_Initialize+0x48> _RBTree_Insert_unprotected(the_rbtree, next); next = (RBTree_Node *) _Addresses_Add_offset( (void *) next, node_size ); } } 10eb61: 83 c4 1c add $0x1c,%esp 10eb64: 5b pop %ebx 10eb65: 5e pop %esi 10eb66: 5f pop %edi 10eb67: 5d pop %ebp 10eb68: c3 ret =============================================================================== 0010e264 <_RBTree_Insert_unprotected>: */ RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { 10e264: 55 push %ebp 10e265: 57 push %edi 10e266: 56 push %esi 10e267: 53 push %ebx 10e268: 83 ec 2c sub $0x2c,%esp 10e26b: 8b 6c 24 40 mov 0x40(%esp),%ebp 10e26f: 8b 5c 24 44 mov 0x44(%esp),%ebx if(!the_node) return (RBTree_Node*)-1; 10e273: 85 db test %ebx,%ebx 10e275: 0f 84 c5 01 00 00 je 10e440 <_RBTree_Insert_unprotected+0x1dc> RBTree_Node *iter_node = the_rbtree->root; 10e27b: 8b 7d 04 mov 0x4(%ebp),%edi int compare_result; if (!iter_node) { /* special case: first node inserted */ 10e27e: 85 ff test %edi,%edi 10e280: 75 08 jne 10e28a <_RBTree_Insert_unprotected+0x26> 10e282: e9 d6 01 00 00 jmp 10e45d <_RBTree_Insert_unprotected+0x1f9> 10e287: 90 nop (dir && _RBTree_Is_greater(compare_result)) ) { the_rbtree->first[dir] = the_node; } break; } else { iter_node = iter_node->child[dir]; 10e288: 89 d7 mov %edx,%edi the_node->parent = (RBTree_Node *) the_rbtree; the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; } else { /* typical binary search tree insert, descend tree to leaf and insert */ while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); 10e28a: 89 7c 24 04 mov %edi,0x4(%esp) 10e28e: 89 1c 24 mov %ebx,(%esp) 10e291: ff 55 10 call *0x10(%ebp) if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) 10e294: 80 7d 14 00 cmpb $0x0,0x14(%ebp) 10e298: 74 08 je 10e2a2 <_RBTree_Insert_unprotected+0x3e> 10e29a: 85 c0 test %eax,%eax 10e29c: 0f 84 b2 01 00 00 je 10e454 <_RBTree_Insert_unprotected+0x1f0> return iter_node; RBTree_Direction dir = !_RBTree_Is_lesser( compare_result ); 10e2a2: f7 d0 not %eax 10e2a4: c1 e8 1f shr $0x1f,%eax if (!iter_node->child[dir]) { 10e2a7: 8b 54 87 04 mov 0x4(%edi,%eax,4),%edx 10e2ab: 85 d2 test %edx,%edx 10e2ad: 75 d9 jne 10e288 <_RBTree_Insert_unprotected+0x24> 10e2af: 89 54 24 1c mov %edx,0x1c(%esp) 10e2b3: 89 c6 mov %eax,%esi the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; 10e2b5: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10e2bc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) the_node->color = RBT_RED; 10e2c3: c7 43 0c 01 00 00 00 movl $0x1,0xc(%ebx) iter_node->child[dir] = the_node; 10e2ca: 89 5c 87 04 mov %ebx,0x4(%edi,%eax,4) the_node->parent = iter_node; 10e2ce: 89 3b mov %edi,(%ebx) /* update min/max */ compare_result = the_rbtree->compare_function( 10e2d0: 8b 44 85 08 mov 0x8(%ebp,%eax,4),%eax 10e2d4: 89 44 24 04 mov %eax,0x4(%esp) 10e2d8: 89 1c 24 mov %ebx,(%esp) 10e2db: ff 55 10 call *0x10(%ebp) the_node, _RBTree_First(the_rbtree, dir) ); if ( (!dir && _RBTree_Is_lesser(compare_result)) || 10e2de: 85 f6 test %esi,%esi 10e2e0: 75 2e jne 10e310 <_RBTree_Insert_unprotected+0xac> 10e2e2: 85 c0 test %eax,%eax 10e2e4: 78 2e js 10e314 <_RBTree_Insert_unprotected+0xb0> } the_node->parent->color = RBT_BLACK; g->color = RBT_RED; /* now rotate grandparent in the other branch direction (toward uncle) */ _RBTree_Rotate(g, (1-pdir)); 10e2e6: 89 5c 24 18 mov %ebx,0x18(%esp) _ISR_Disable( level ); return_node = _RBTree_Insert_unprotected( tree, node ); _ISR_Enable( level ); return return_node; } 10e2ea: 8b 54 24 18 mov 0x18(%esp),%edx 10e2ee: 8b 02 mov (%edx),%eax */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent( const RBTree_Node *the_node ) { if (!the_node->parent->parent) return NULL; 10e2f0: 8b 10 mov (%eax),%edx 10e2f2: 89 d1 mov %edx,%ecx 10e2f4: 85 d2 test %edx,%edx 10e2f6: 0f 84 03 01 00 00 je 10e3ff <_RBTree_Insert_unprotected+0x19b> */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10e2fc: 83 78 0c 01 cmpl $0x1,0xc(%eax) 10e300: 74 1a je 10e31c <_RBTree_Insert_unprotected+0xb8> /* verify red-black properties */ _RBTree_Validate_insert_unprotected(the_node); } return (RBTree_Node*)0; } 10e302: 8b 44 24 1c mov 0x1c(%esp),%eax 10e306: 83 c4 2c add $0x2c,%esp 10e309: 5b pop %ebx 10e30a: 5e pop %esi 10e30b: 5f pop %edi 10e30c: 5d pop %ebp 10e30d: c3 ret 10e30e: 66 90 xchg %ax,%ax compare_result = the_rbtree->compare_function( the_node, _RBTree_First(the_rbtree, dir) ); if ( (!dir && _RBTree_Is_lesser(compare_result)) || (dir && _RBTree_Is_greater(compare_result)) ) { 10e310: 85 c0 test %eax,%eax 10e312: 7e d2 jle 10e2e6 <_RBTree_Insert_unprotected+0x82> the_rbtree->first[dir] = the_node; 10e314: 89 5c b5 08 mov %ebx,0x8(%ebp,%esi,4) 10e318: eb cc jmp 10e2e6 <_RBTree_Insert_unprotected+0x82> 10e31a: 66 90 xchg %ax,%ax ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; if(!(the_node->parent->parent->parent)) return NULL; 10e31c: 8b 1a mov (%edx),%ebx 10e31e: 85 db test %ebx,%ebx 10e320: 8b 72 04 mov 0x4(%edx),%esi 10e323: 74 18 je 10e33d <_RBTree_Insert_unprotected+0xd9><== NEVER TAKEN { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; if(the_node == the_node->parent->child[RBT_LEFT]) 10e325: 39 f0 cmp %esi,%eax 10e327: 0f 84 0b 01 00 00 je 10e438 <_RBTree_Insert_unprotected+0x1d4> 10e32d: 89 f7 mov %esi,%edi */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_red( const RBTree_Node *the_node ) { return (the_node && the_node->color == RBT_RED); 10e32f: 85 ff test %edi,%edi 10e331: 74 0a je 10e33d <_RBTree_Insert_unprotected+0xd9> 10e333: 83 7f 0c 01 cmpl $0x1,0xc(%edi) 10e337: 0f 84 db 00 00 00 je 10e418 <_RBTree_Insert_unprotected+0x1b4> u->color = RBT_BLACK; g->color = RBT_RED; the_node = g; } else { /* if uncle is black */ RBTree_Direction dir = the_node != the_node->parent->child[0]; RBTree_Direction pdir = the_node->parent != g->child[0]; 10e33d: 31 db xor %ebx,%ebx 10e33f: 39 f0 cmp %esi,%eax 10e341: 0f 95 c3 setne %bl 10e344: 89 de mov %ebx,%esi the_node->parent->color = RBT_BLACK; u->color = RBT_BLACK; g->color = RBT_RED; the_node = g; } else { /* if uncle is black */ RBTree_Direction dir = the_node != the_node->parent->child[0]; 10e346: 8b 5c 24 18 mov 0x18(%esp),%ebx 10e34a: 3b 58 04 cmp 0x4(%eax),%ebx 10e34d: 0f 95 c3 setne %bl 10e350: 0f b6 db movzbl %bl,%ebx RBTree_Direction pdir = the_node->parent != g->child[0]; /* ensure node is on the same branch direction as parent */ if (dir != pdir) { 10e353: 39 f3 cmp %esi,%ebx 10e355: 74 46 je 10e39d <_RBTree_Insert_unprotected+0x139> */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 10e357: 89 f3 mov %esi,%ebx 10e359: 83 f3 01 xor $0x1,%ebx RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 10e35c: 8b 7c 98 04 mov 0x4(%eax,%ebx,4),%edi 10e360: 85 ff test %edi,%edi 10e362: 74 2b je 10e38f <_RBTree_Insert_unprotected+0x12b><== NEVER TAKEN c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 10e364: 8b 6c b7 04 mov 0x4(%edi,%esi,4),%ebp 10e368: 89 6c 98 04 mov %ebp,0x4(%eax,%ebx,4) if (c->child[dir]) 10e36c: 8b 6c b7 04 mov 0x4(%edi,%esi,4),%ebp 10e370: 85 ed test %ebp,%ebp 10e372: 74 05 je 10e379 <_RBTree_Insert_unprotected+0x115> c->child[dir]->parent = the_node; 10e374: 89 45 00 mov %eax,0x0(%ebp) 10e377: 8b 10 mov (%eax),%edx c->child[dir] = the_node; 10e379: 89 44 b7 04 mov %eax,0x4(%edi,%esi,4) the_node->parent->child[the_node != the_node->parent->child[0]] = c; 10e37d: 31 db xor %ebx,%ebx 10e37f: 3b 42 04 cmp 0x4(%edx),%eax 10e382: 0f 95 c3 setne %bl 10e385: 89 dd mov %ebx,%ebp 10e387: 89 7c aa 04 mov %edi,0x4(%edx,%ebp,4) c->parent = the_node->parent; 10e38b: 89 17 mov %edx,(%edi) the_node->parent = c; 10e38d: 89 38 mov %edi,(%eax) _RBTree_Rotate(the_node->parent, pdir); the_node = the_node->child[pdir]; 10e38f: 8b 44 24 18 mov 0x18(%esp),%eax 10e393: 8b 44 b0 04 mov 0x4(%eax,%esi,4),%eax 10e397: 89 44 24 18 mov %eax,0x18(%esp) 10e39b: 8b 00 mov (%eax),%eax } the_node->parent->color = RBT_BLACK; 10e39d: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) g->color = RBT_RED; 10e3a4: c7 41 0c 01 00 00 00 movl $0x1,0xc(%ecx) /* now rotate grandparent in the other branch direction (toward uncle) */ _RBTree_Rotate(g, (1-pdir)); 10e3ab: ba 01 00 00 00 mov $0x1,%edx 10e3b0: 29 f2 sub %esi,%edx 10e3b2: 89 d6 mov %edx,%esi 10e3b4: 83 f6 01 xor $0x1,%esi RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return; if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return; 10e3b7: 8b 44 b1 04 mov 0x4(%ecx,%esi,4),%eax 10e3bb: 85 c0 test %eax,%eax 10e3bd: 0f 84 27 ff ff ff je 10e2ea <_RBTree_Insert_unprotected+0x86><== NEVER TAKEN c = the_node->child[_RBTree_Opposite_direction(dir)]; the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir]; 10e3c3: 8b 7c 90 04 mov 0x4(%eax,%edx,4),%edi 10e3c7: 89 7c b1 04 mov %edi,0x4(%ecx,%esi,4) if (c->child[dir]) 10e3cb: 8b 74 90 04 mov 0x4(%eax,%edx,4),%esi 10e3cf: 85 f6 test %esi,%esi 10e3d1: 74 02 je 10e3d5 <_RBTree_Insert_unprotected+0x171> c->child[dir]->parent = the_node; 10e3d3: 89 0e mov %ecx,(%esi) c->child[dir] = the_node; 10e3d5: 89 4c 90 04 mov %ecx,0x4(%eax,%edx,4) the_node->parent->child[the_node != the_node->parent->child[0]] = c; 10e3d9: 8b 11 mov (%ecx),%edx 10e3db: 31 db xor %ebx,%ebx 10e3dd: 3b 4a 04 cmp 0x4(%edx),%ecx 10e3e0: 0f 95 c3 setne %bl 10e3e3: 89 de mov %ebx,%esi 10e3e5: 89 44 b2 04 mov %eax,0x4(%edx,%esi,4) c->parent = the_node->parent; 10e3e9: 89 10 mov %edx,(%eax) the_node->parent = c; 10e3eb: 89 01 mov %eax,(%ecx) _ISR_Disable( level ); return_node = _RBTree_Insert_unprotected( tree, node ); _ISR_Enable( level ); return return_node; } 10e3ed: 8b 54 24 18 mov 0x18(%esp),%edx 10e3f1: 8b 02 mov (%edx),%eax */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent( const RBTree_Node *the_node ) { if (!the_node->parent->parent) return NULL; 10e3f3: 8b 10 mov (%eax),%edx 10e3f5: 89 d1 mov %edx,%ecx 10e3f7: 85 d2 test %edx,%edx 10e3f9: 0f 85 fd fe ff ff jne 10e2fc <_RBTree_Insert_unprotected+0x98><== ALWAYS TAKEN 10e3ff: 8b 5c 24 18 mov 0x18(%esp),%ebx /* now rotate grandparent in the other branch direction (toward uncle) */ _RBTree_Rotate(g, (1-pdir)); } } if(!the_node->parent->parent) the_node->color = RBT_BLACK; 10e403: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) /* verify red-black properties */ _RBTree_Validate_insert_unprotected(the_node); } return (RBTree_Node*)0; } 10e40a: 8b 44 24 1c mov 0x1c(%esp),%eax 10e40e: 83 c4 2c add $0x2c,%esp 10e411: 5b pop %ebx 10e412: 5e pop %esi 10e413: 5f pop %edi 10e414: 5d pop %ebp 10e415: c3 ret 10e416: 66 90 xchg %ax,%ax u = _RBTree_Parent_sibling(the_node); g = the_node->parent->parent; /* if uncle is red, repaint uncle/parent black and grandparent red */ if(_RBTree_Is_red(u)) { the_node->parent->color = RBT_BLACK; 10e418: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) u->color = RBT_BLACK; 10e41f: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi) g->color = RBT_RED; 10e426: c7 42 0c 01 00 00 00 movl $0x1,0xc(%edx) 10e42d: 89 54 24 18 mov %edx,0x18(%esp) 10e431: e9 b4 fe ff ff jmp 10e2ea <_RBTree_Insert_unprotected+0x86> 10e436: 66 90 xchg %ax,%ax if(!the_node) return NULL; if(!(the_node->parent)) return NULL; if(!(the_node->parent->parent)) return NULL; if(the_node == the_node->parent->child[RBT_LEFT]) return the_node->parent->child[RBT_RIGHT]; 10e438: 8b 7a 08 mov 0x8(%edx),%edi 10e43b: e9 ef fe ff ff jmp 10e32f <_RBTree_Insert_unprotected+0xcb> RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { if(!the_node) return (RBTree_Node*)-1; 10e440: c7 44 24 1c ff ff ff movl $0xffffffff,0x1c(%esp) 10e447: ff /* verify red-black properties */ _RBTree_Validate_insert_unprotected(the_node); } return (RBTree_Node*)0; } 10e448: 8b 44 24 1c mov 0x1c(%esp),%eax 10e44c: 83 c4 2c add $0x2c,%esp 10e44f: 5b pop %ebx 10e450: 5e pop %esi 10e451: 5f pop %edi 10e452: 5d pop %ebp 10e453: c3 ret the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; } else { /* typical binary search tree insert, descend tree to leaf and insert */ while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) ) 10e454: 89 7c 24 1c mov %edi,0x1c(%esp) 10e458: e9 a5 fe ff ff jmp 10e302 <_RBTree_Insert_unprotected+0x9e> RBTree_Node *iter_node = the_rbtree->root; int compare_result; if (!iter_node) { /* special case: first node inserted */ the_node->color = RBT_BLACK; 10e45d: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) the_rbtree->root = the_node; 10e464: 89 5d 04 mov %ebx,0x4(%ebp) the_rbtree->first[0] = the_rbtree->first[1] = the_node; 10e467: 89 5d 0c mov %ebx,0xc(%ebp) 10e46a: 89 5d 08 mov %ebx,0x8(%ebp) the_node->parent = (RBTree_Node *) the_rbtree; 10e46d: 89 2b mov %ebp,(%ebx) the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL; 10e46f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10e476: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) } /* while(iter_node) */ /* verify red-black properties */ _RBTree_Validate_insert_unprotected(the_node); } return (RBTree_Node*)0; 10e47d: c7 44 24 1c 00 00 00 movl $0x0,0x1c(%esp) 10e484: 00 10e485: e9 78 fe ff ff jmp 10e302 <_RBTree_Insert_unprotected+0x9e> =============================================================================== 0010e4b0 <_RBTree_Iterate_unprotected>: const RBTree_Control *rbtree, RBTree_Direction dir, RBTree_Visitor visitor, void *visitor_arg ) { 10e4b0: 55 push %ebp 10e4b1: 57 push %edi 10e4b2: 56 push %esi 10e4b3: 53 push %ebx 10e4b4: 83 ec 1c sub $0x1c,%esp 10e4b7: 8b 74 24 34 mov 0x34(%esp),%esi 10e4bb: 8b 6c 24 38 mov 0x38(%esp),%ebp */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 10e4bf: 31 d2 xor %edx,%edx 10e4c1: 85 f6 test %esi,%esi 10e4c3: 0f 94 c2 sete %dl RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First( const RBTree_Control *the_rbtree, RBTree_Direction dir ) { return the_rbtree->first[dir]; 10e4c6: 8b 44 24 30 mov 0x30(%esp),%eax 10e4ca: 8b 5c 90 08 mov 0x8(%eax,%edx,4),%ebx 10e4ce: 66 90 xchg %ax,%ax RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { 10e4d0: 85 db test %ebx,%ebx 10e4d2: 74 27 je 10e4fb <_RBTree_Iterate_unprotected+0x4b> stop = (*visitor)( current, dir, visitor_arg ); 10e4d4: 8b 44 24 3c mov 0x3c(%esp),%eax 10e4d8: 89 44 24 08 mov %eax,0x8(%esp) 10e4dc: 89 74 24 04 mov %esi,0x4(%esp) 10e4e0: 89 1c 24 mov %ebx,(%esp) 10e4e3: ff d5 call *%ebp 10e4e5: 89 c7 mov %eax,%edi current = _RBTree_Next_unprotected( current, dir ); 10e4e7: 89 74 24 04 mov %esi,0x4(%esp) 10e4eb: 89 1c 24 mov %ebx,(%esp) 10e4ee: e8 11 00 00 00 call 10e504 <_RBTree_Next_unprotected> 10e4f3: 89 c3 mov %eax,%ebx { RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { 10e4f5: 89 f8 mov %edi,%eax 10e4f7: 84 c0 test %al,%al 10e4f9: 74 d5 je 10e4d0 <_RBTree_Iterate_unprotected+0x20><== ALWAYS TAKEN stop = (*visitor)( current, dir, visitor_arg ); current = _RBTree_Next_unprotected( current, dir ); } } 10e4fb: 83 c4 1c add $0x1c,%esp 10e4fe: 5b pop %ebx 10e4ff: 5e pop %esi 10e500: 5f pop %edi 10e501: 5d pop %ebp 10e502: c3 ret =============================================================================== 0010bda0 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 10bda0: 55 push %ebp 10bda1: 57 push %edi 10bda2: 56 push %esi 10bda3: 53 push %ebx 10bda4: 83 ec 3c sub $0x3c,%esp rtems_initialization_tasks_table *user_tasks; /* * Move information into local variables */ user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table; 10bda7: 8b 1d ec b1 12 00 mov 0x12b1ec,%ebx maximum = Configuration_RTEMS_API.number_of_initialization_tasks; 10bdad: 8b 3d e8 b1 12 00 mov 0x12b1e8,%edi /* * Verify that we have a set of user tasks to iterate */ if ( !user_tasks ) 10bdb3: 85 db test %ebx,%ebx 10bdb5: 74 61 je 10be18 <_RTEMS_tasks_Initialize_user_tasks_body+0x78> return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 10bdb7: 85 ff test %edi,%edi 10bdb9: 74 5d je 10be18 <_RTEMS_tasks_Initialize_user_tasks_body+0x78><== NEVER TAKEN 10bdbb: 31 f6 xor %esi,%esi 10bdbd: 8d 6c 24 2c lea 0x2c(%esp),%ebp 10bdc1: 8d 76 00 lea 0x0(%esi),%esi return_value = rtems_task_create( 10bdc4: 89 6c 24 14 mov %ebp,0x14(%esp) 10bdc8: 8b 43 0c mov 0xc(%ebx),%eax 10bdcb: 89 44 24 10 mov %eax,0x10(%esp) 10bdcf: 8b 43 14 mov 0x14(%ebx),%eax 10bdd2: 89 44 24 0c mov %eax,0xc(%esp) 10bdd6: 8b 43 04 mov 0x4(%ebx),%eax 10bdd9: 89 44 24 08 mov %eax,0x8(%esp) 10bddd: 8b 43 08 mov 0x8(%ebx),%eax 10bde0: 89 44 24 04 mov %eax,0x4(%esp) 10bde4: 8b 03 mov (%ebx),%eax 10bde6: 89 04 24 mov %eax,(%esp) 10bde9: e8 5a fd ff ff call 10bb48 user_tasks[ index ].stack_size, user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 10bdee: 85 c0 test %eax,%eax 10bdf0: 75 2e jne 10be20 <_RTEMS_tasks_Initialize_user_tasks_body+0x80> _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); return_value = rtems_task_start( 10bdf2: 8b 43 18 mov 0x18(%ebx),%eax 10bdf5: 89 44 24 08 mov %eax,0x8(%esp) 10bdf9: 8b 43 10 mov 0x10(%ebx),%eax 10bdfc: 89 44 24 04 mov %eax,0x4(%esp) 10be00: 8b 44 24 2c mov 0x2c(%esp),%eax 10be04: 89 04 24 mov %eax,(%esp) 10be07: e8 2c 00 00 00 call 10be38 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10be0c: 85 c0 test %eax,%eax 10be0e: 75 10 jne 10be20 <_RTEMS_tasks_Initialize_user_tasks_body+0x80> return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 10be10: 46 inc %esi 10be11: 83 c3 1c add $0x1c,%ebx 10be14: 39 fe cmp %edi,%esi 10be16: 75 ac jne 10bdc4 <_RTEMS_tasks_Initialize_user_tasks_body+0x24><== NEVER TAKEN user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); } } 10be18: 83 c4 3c add $0x3c,%esp 10be1b: 5b pop %ebx 10be1c: 5e pop %esi 10be1d: 5f pop %edi 10be1e: 5d pop %ebp 10be1f: c3 ret id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); 10be20: 89 44 24 08 mov %eax,0x8(%esp) 10be24: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10be2b: 00 10be2c: c7 04 24 01 00 00 00 movl $0x1,(%esp) 10be33: e8 88 0d 00 00 call 10cbc0 <_Internal_error_Occurred> =============================================================================== 00110a64 <_RTEMS_tasks_Post_switch_extension>: */ static void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 110a64: 57 push %edi 110a65: 56 push %esi 110a66: 53 push %ebx 110a67: 83 ec 20 sub $0x20,%esp RTEMS_API_Control *api; ASR_Information *asr; rtems_signal_set signal_set; Modes_Control prev_mode; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 110a6a: 8b 44 24 30 mov 0x30(%esp),%eax 110a6e: 8b 98 e0 00 00 00 mov 0xe0(%eax),%ebx if ( !api ) 110a74: 85 db test %ebx,%ebx 110a76: 74 13 je 110a8b <_RTEMS_tasks_Post_switch_extension+0x27><== NEVER TAKEN * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 110a78: 9c pushf 110a79: fa cli 110a7a: 58 pop %eax signal_set = asr->signals_posted; 110a7b: 8b 73 14 mov 0x14(%ebx),%esi asr->signals_posted = 0; 110a7e: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) _ISR_Enable( level ); 110a85: 50 push %eax 110a86: 9d popf if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 110a87: 85 f6 test %esi,%esi 110a89: 75 09 jne 110a94 <_RTEMS_tasks_Post_switch_extension+0x30> (*asr->handler)( signal_set ); asr->nest_level -= 1; rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); } 110a8b: 83 c4 20 add $0x20,%esp 110a8e: 5b pop %ebx 110a8f: 5e pop %esi 110a90: 5f pop %edi 110a91: c3 ret 110a92: 66 90 xchg %ax,%ax if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ return; asr->nest_level += 1; 110a94: ff 43 1c incl 0x1c(%ebx) rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 110a97: 8d 7c 24 1c lea 0x1c(%esp),%edi 110a9b: 89 7c 24 08 mov %edi,0x8(%esp) 110a9f: c7 44 24 04 ff ff 00 movl $0xffff,0x4(%esp) 110aa6: 00 110aa7: 8b 43 10 mov 0x10(%ebx),%eax 110aaa: 89 04 24 mov %eax,(%esp) 110aad: e8 16 1e 00 00 call 1128c8 (*asr->handler)( signal_set ); 110ab2: 89 34 24 mov %esi,(%esp) 110ab5: ff 53 0c call *0xc(%ebx) asr->nest_level -= 1; 110ab8: ff 4b 1c decl 0x1c(%ebx) rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 110abb: 89 7c 24 08 mov %edi,0x8(%esp) 110abf: c7 44 24 04 ff ff 00 movl $0xffff,0x4(%esp) 110ac6: 00 110ac7: 8b 44 24 1c mov 0x1c(%esp),%eax 110acb: 89 04 24 mov %eax,(%esp) 110ace: e8 f5 1d 00 00 call 1128c8 } 110ad3: 83 c4 20 add $0x20,%esp 110ad6: 5b pop %ebx 110ad7: 5e pop %esi 110ad8: 5f pop %edi 110ad9: c3 ret =============================================================================== 00110920 <_RTEMS_tasks_Switch_extension>: /* * Per Task Variables */ tvp = executing->task_variables; 110920: 8b 44 24 04 mov 0x4(%esp),%eax 110924: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax while (tvp) { 11092a: 85 c0 test %eax,%eax 11092c: 74 15 je 110943 <_RTEMS_tasks_Switch_extension+0x23> 11092e: 66 90 xchg %ax,%ax tvp->tval = *tvp->ptr; 110930: 8b 50 04 mov 0x4(%eax),%edx 110933: 8b 0a mov (%edx),%ecx 110935: 89 48 0c mov %ecx,0xc(%eax) *tvp->ptr = tvp->gval; 110938: 8b 48 08 mov 0x8(%eax),%ecx 11093b: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 11093d: 8b 00 mov (%eax),%eax /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 11093f: 85 c0 test %eax,%eax 110941: 75 ed jne 110930 <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 110943: 8b 44 24 08 mov 0x8(%esp),%eax 110947: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax while (tvp) { 11094d: 85 c0 test %eax,%eax 11094f: 74 17 je 110968 <_RTEMS_tasks_Switch_extension+0x48> 110951: 8d 76 00 lea 0x0(%esi),%esi tvp->gval = *tvp->ptr; 110954: 8b 50 04 mov 0x4(%eax),%edx 110957: 8b 0a mov (%edx),%ecx 110959: 89 48 08 mov %ecx,0x8(%eax) *tvp->ptr = tvp->tval; 11095c: 8b 48 0c mov 0xc(%eax),%ecx 11095f: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 110961: 8b 00 mov (%eax),%eax *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 110963: 85 c0 test %eax,%eax 110965: 75 ed jne 110954 <_RTEMS_tasks_Switch_extension+0x34><== NEVER TAKEN 110967: c3 ret 110968: c3 ret =============================================================================== 001373e8 <_Rate_monotonic_Get_status>: bool _Rate_monotonic_Get_status( Rate_monotonic_Control *the_period, Rate_monotonic_Period_time_t *wall_since_last_period, Thread_CPU_usage_t *cpu_since_last_period ) { 1373e8: 55 push %ebp 1373e9: 57 push %edi 1373ea: 56 push %esi 1373eb: 53 push %ebx 1373ec: 83 ec 2c sub $0x2c,%esp 1373ef: 8b 74 24 40 mov 0x40(%esp),%esi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ Timestamp_Control uptime; #endif Thread_Control *owning_thread = the_period->owner; 1373f3: 8b 7e 40 mov 0x40(%esi),%edi /* * Determine elapsed wall time since period initiated. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _TOD_Get_uptime( &uptime ); 1373f6: 8d 44 24 18 lea 0x18(%esp),%eax 1373fa: 89 04 24 mov %eax,(%esp) 1373fd: e8 a6 bd fd ff call 1131a8 <_TOD_Get_uptime> _Timestamp_Subtract( 137402: 8b 44 24 18 mov 0x18(%esp),%eax 137406: 8b 54 24 1c mov 0x1c(%esp),%edx const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 13740a: 89 c1 mov %eax,%ecx 13740c: 89 d3 mov %edx,%ebx 13740e: 2b 4e 4c sub 0x4c(%esi),%ecx 137411: 1b 5e 50 sbb 0x50(%esi),%ebx 137414: 8b 6c 24 44 mov 0x44(%esp),%ebp 137418: 89 4d 00 mov %ecx,0x0(%ebp) 13741b: 89 5d 04 mov %ebx,0x4(%ebp) #endif /* * Determine cpu usage since period initiated. */ used = owning_thread->cpu_time_used; 13741e: 8b 8f 80 00 00 00 mov 0x80(%edi),%ecx 137424: 8b 9f 84 00 00 00 mov 0x84(%edi),%ebx #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ if (owning_thread == _Thread_Executing) { 13742a: 39 3d cc b3 17 00 cmp %edi,0x17b3cc 137430: 74 0a je 13743c <_Rate_monotonic_Get_status+0x54> if (used < the_period->cpu_usage_period_initiated) return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; 137432: b0 01 mov $0x1,%al } 137434: 83 c4 2c add $0x2c,%esp 137437: 5b pop %ebx 137438: 5e pop %esi 137439: 5f pop %edi 13743a: 5d pop %ebp 13743b: c3 ret 13743c: 2b 05 dc b3 17 00 sub 0x17b3dc,%eax 137442: 1b 15 e0 b3 17 00 sbb 0x17b3e0,%edx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 137448: 01 c8 add %ecx,%eax 13744a: 11 da adc %ebx,%edx case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 13744c: 8b 4e 44 mov 0x44(%esi),%ecx 13744f: 8b 5e 48 mov 0x48(%esi),%ebx /* * The cpu usage info was reset while executing. Can't * determine a status. */ if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated)) 137452: 39 d3 cmp %edx,%ebx 137454: 7f 06 jg 13745c <_Rate_monotonic_Get_status+0x74><== NEVER TAKEN 137456: 7c 08 jl 137460 <_Rate_monotonic_Get_status+0x78> 137458: 39 c1 cmp %eax,%ecx 13745a: 76 04 jbe 137460 <_Rate_monotonic_Get_status+0x78> return false; 13745c: 31 c0 xor %eax,%eax 13745e: eb d4 jmp 137434 <_Rate_monotonic_Get_status+0x4c> const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 137460: 29 c8 sub %ecx,%eax 137462: 19 da sbb %ebx,%edx 137464: 8b 4c 24 48 mov 0x48(%esp),%ecx 137468: 89 01 mov %eax,(%ecx) 13746a: 89 51 04 mov %edx,0x4(%ecx) if (used < the_period->cpu_usage_period_initiated) return false; *cpu_since_last_period = used - the_period->cpu_usage_period_initiated; #endif return true; 13746d: b0 01 mov $0x1,%al } 13746f: 83 c4 2c add $0x2c,%esp 137472: 5b pop %ebx 137473: 5e pop %esi 137474: 5f pop %edi 137475: 5d pop %ebp 137476: c3 ret =============================================================================== 00137778 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 137778: 83 ec 3c sub $0x3c,%esp /* * When we get here, the Timer is already off the chain so we do not * have to worry about that -- hence no _Watchdog_Remove(). */ the_period = _Rate_monotonic_Get( id, &location ); 13777b: 8d 44 24 2c lea 0x2c(%esp),%eax 13777f: 89 44 24 08 mov %eax,0x8(%esp) 137783: 8b 44 24 40 mov 0x40(%esp),%eax 137787: 89 44 24 04 mov %eax,0x4(%esp) 13778b: c7 04 24 20 b6 17 00 movl $0x17b620,(%esp) 137792: e8 c5 56 fd ff call 10ce5c <_Objects_Get> switch ( location ) { 137797: 8b 54 24 2c mov 0x2c(%esp),%edx 13779b: 85 d2 test %edx,%edx 13779d: 75 2e jne 1377cd <_Rate_monotonic_Timeout+0x55><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 13779f: 8b 50 40 mov 0x40(%eax),%edx if ( _States_Is_waiting_for_period( the_thread->current_state ) && 1377a2: f6 42 11 40 testb $0x40,0x11(%edx) 1377a6: 74 08 je 1377b0 <_Rate_monotonic_Timeout+0x38> 1377a8: 8b 48 08 mov 0x8(%eax),%ecx 1377ab: 39 4a 20 cmp %ecx,0x20(%edx) 1377ae: 74 58 je 137808 <_Rate_monotonic_Timeout+0x90> _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 1377b0: 83 78 38 01 cmpl $0x1,0x38(%eax) 1377b4: 74 1e je 1377d4 <_Rate_monotonic_Timeout+0x5c> _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 1377b6: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 1377bd: a1 64 b1 17 00 mov 0x17b164,%eax 1377c2: 48 dec %eax 1377c3: a3 64 b1 17 00 mov %eax,0x17b164 return _Thread_Dispatch_disable_level; 1377c8: a1 64 b1 17 00 mov 0x17b164,%eax case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 1377cd: 83 c4 3c add $0x3c,%esp 1377d0: c3 ret 1377d1: 8d 76 00 lea 0x0(%esi),%esi _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 1377d4: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax) _Rate_monotonic_Initiate_statistics( the_period ); 1377db: 89 04 24 mov %eax,(%esp) 1377de: 89 44 24 1c mov %eax,0x1c(%esp) 1377e2: e8 71 fd ff ff call 137558 <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 1377e7: 8b 44 24 1c mov 0x1c(%esp),%eax 1377eb: 8b 50 3c mov 0x3c(%eax),%edx 1377ee: 89 50 1c mov %edx,0x1c(%eax) _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 1377f1: 83 c0 10 add $0x10,%eax 1377f4: 89 44 24 04 mov %eax,0x4(%esp) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 1377f8: c7 04 24 08 b2 17 00 movl $0x17b208,(%esp) 1377ff: e8 50 6e fd ff call 10e654 <_Watchdog_Insert> 137804: eb b7 jmp 1377bd <_Rate_monotonic_Timeout+0x45> 137806: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 137808: c7 44 24 04 f8 ff 03 movl $0x1003fff8,0x4(%esp) 13780f: 10 137810: 89 14 24 mov %edx,(%esp) 137813: 89 44 24 1c mov %eax,0x1c(%esp) 137817: e8 b0 5e fd ff call 10d6cc <_Thread_Clear_state> the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 13781c: 8b 44 24 1c mov 0x1c(%esp),%eax 137820: 89 04 24 mov %eax,(%esp) 137823: eb bd jmp 1377e2 <_Rate_monotonic_Timeout+0x6a> =============================================================================== 00137478 <_Rate_monotonic_Update_statistics>: } static void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 137478: 56 push %esi 137479: 53 push %ebx 13747a: 83 ec 24 sub $0x24,%esp 13747d: 89 c6 mov %eax,%esi /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 13747f: ff 40 54 incl 0x54(%eax) if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 137482: 83 78 38 04 cmpl $0x4,0x38(%eax) 137486: 0f 84 a0 00 00 00 je 13752c <_Rate_monotonic_Update_statistics+0xb4> /* * Grab status for time statistics. */ valid_status = _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 13748c: 8d 44 24 10 lea 0x10(%esp),%eax 137490: 89 44 24 08 mov %eax,0x8(%esp) 137494: 8d 44 24 18 lea 0x18(%esp),%eax 137498: 89 44 24 04 mov %eax,0x4(%esp) stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 13749c: 89 34 24 mov %esi,(%esp) 13749f: e8 44 ff ff ff call 1373e8 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) 1374a4: 84 c0 test %al,%al 1374a6: 74 3c je 1374e4 <_Rate_monotonic_Update_statistics+0x6c> /* * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); 1374a8: 8b 4c 24 10 mov 0x10(%esp),%ecx 1374ac: 8b 5c 24 14 mov 0x14(%esp),%ebx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 1374b0: 01 4e 6c add %ecx,0x6c(%esi) 1374b3: 11 5e 70 adc %ebx,0x70(%esi) if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 1374b6: 3b 5e 60 cmp 0x60(%esi),%ebx 1374b9: 7e 59 jle 137514 <_Rate_monotonic_Update_statistics+0x9c><== ALWAYS TAKEN stats->min_cpu_time = executed; if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 1374bb: 3b 5e 68 cmp 0x68(%esi),%ebx 1374be: 7d 61 jge 137521 <_Rate_monotonic_Update_statistics+0xa9><== ALWAYS TAKEN /* * Update Wall time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 1374c0: 8b 4c 24 18 mov 0x18(%esp),%ecx 1374c4: 8b 5c 24 1c mov 0x1c(%esp),%ebx 1374c8: 01 8e 84 00 00 00 add %ecx,0x84(%esi) 1374ce: 11 9e 88 00 00 00 adc %ebx,0x88(%esi) if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 1374d4: 3b 5e 78 cmp 0x78(%esi),%ebx 1374d7: 7e 27 jle 137500 <_Rate_monotonic_Update_statistics+0x88><== ALWAYS TAKEN stats->min_wall_time = since_last_period; if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 1374d9: 3b 9e 80 00 00 00 cmp 0x80(%esi),%ebx 1374df: 7d 0b jge 1374ec <_Rate_monotonic_Update_statistics+0x74> 1374e1: 8d 76 00 lea 0x0(%esi),%esi stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #endif } 1374e4: 83 c4 24 add $0x24,%esp 1374e7: 5b pop %ebx 1374e8: 5e pop %esi 1374e9: c3 ret 1374ea: 66 90 xchg %ax,%ax _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) stats->min_wall_time = since_last_period; if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 1374ec: 7e 62 jle 137550 <_Rate_monotonic_Update_statistics+0xd8><== ALWAYS TAKEN stats->max_wall_time = since_last_period; 1374ee: 89 4e 7c mov %ecx,0x7c(%esi) 1374f1: 89 9e 80 00 00 00 mov %ebx,0x80(%esi) stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #endif } 1374f7: 83 c4 24 add $0x24,%esp 1374fa: 5b pop %ebx 1374fb: 5e pop %esi 1374fc: c3 ret 1374fd: 8d 76 00 lea 0x0(%esi),%esi * Update Wall time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 137500: 7d 46 jge 137548 <_Rate_monotonic_Update_statistics+0xd0> stats->min_wall_time = since_last_period; 137502: 89 4e 74 mov %ecx,0x74(%esi) 137505: 89 5e 78 mov %ebx,0x78(%esi) if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 137508: 3b 9e 80 00 00 00 cmp 0x80(%esi),%ebx 13750e: 7c d4 jl 1374e4 <_Rate_monotonic_Update_statistics+0x6c> 137510: eb da jmp 1374ec <_Rate_monotonic_Update_statistics+0x74> 137512: 66 90 xchg %ax,%ax * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 137514: 7d 26 jge 13753c <_Rate_monotonic_Update_statistics+0xc4> stats->min_cpu_time = executed; 137516: 89 4e 5c mov %ecx,0x5c(%esi) 137519: 89 5e 60 mov %ebx,0x60(%esi) if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 13751c: 3b 5e 68 cmp 0x68(%esi),%ebx 13751f: 7c 9f jl 1374c0 <_Rate_monotonic_Update_statistics+0x48><== NEVER TAKEN 137521: 7e 11 jle 137534 <_Rate_monotonic_Update_statistics+0xbc><== ALWAYS TAKEN stats->max_cpu_time = executed; 137523: 89 4e 64 mov %ecx,0x64(%esi) 137526: 89 5e 68 mov %ebx,0x68(%esi) 137529: eb 95 jmp 1374c0 <_Rate_monotonic_Update_statistics+0x48> 13752b: 90 nop */ stats = &the_period->Statistics; stats->count++; if ( the_period->state == RATE_MONOTONIC_EXPIRED ) stats->missed_count++; 13752c: ff 40 58 incl 0x58(%eax) 13752f: e9 58 ff ff ff jmp 13748c <_Rate_monotonic_Update_statistics+0x14> _Timestamp_Add_to( &stats->total_cpu_time, &executed ); if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) stats->min_cpu_time = executed; if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 137534: 3b 4e 64 cmp 0x64(%esi),%ecx 137537: 76 87 jbe 1374c0 <_Rate_monotonic_Update_statistics+0x48> 137539: eb e8 jmp 137523 <_Rate_monotonic_Update_statistics+0xab> 13753b: 90 nop * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 13753c: 3b 4e 5c cmp 0x5c(%esi),%ecx 13753f: 0f 83 76 ff ff ff jae 1374bb <_Rate_monotonic_Update_statistics+0x43> 137545: eb cf jmp 137516 <_Rate_monotonic_Update_statistics+0x9e> 137547: 90 nop * Update Wall time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 137548: 3b 4e 74 cmp 0x74(%esi),%ecx 13754b: 73 8c jae 1374d9 <_Rate_monotonic_Update_statistics+0x61> 13754d: eb b3 jmp 137502 <_Rate_monotonic_Update_statistics+0x8a> 13754f: 90 nop stats->min_wall_time = since_last_period; if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 137550: 3b 4e 7c cmp 0x7c(%esi),%ecx 137553: 76 8f jbe 1374e4 <_Rate_monotonic_Update_statistics+0x6c> 137555: eb 97 jmp 1374ee <_Rate_monotonic_Update_statistics+0x76> =============================================================================== 0010dd9c <_Scheduler_CBS_Allocate>: #include void *_Scheduler_CBS_Allocate( Thread_Control *the_thread ) { 10dd9c: 53 push %ebx 10dd9d: 83 ec 18 sub $0x18,%esp 10dda0: 8b 5c 24 20 mov 0x20(%esp),%ebx void *sched; Scheduler_CBS_Per_thread *schinfo; sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread)); 10dda4: c7 04 24 1c 00 00 00 movl $0x1c,(%esp) 10ddab: e8 6c 17 00 00 call 10f51c <_Workspace_Allocate> if ( sched ) { 10ddb0: 85 c0 test %eax,%eax 10ddb2: 74 16 je 10ddca <_Scheduler_CBS_Allocate+0x2e><== NEVER TAKEN the_thread->scheduler_info = sched; 10ddb4: 89 83 88 00 00 00 mov %eax,0x88(%ebx) schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info); schinfo->edf_per_thread.thread = the_thread; 10ddba: 89 18 mov %ebx,(%eax) schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN; 10ddbc: c7 40 14 02 00 00 00 movl $0x2,0x14(%eax) schinfo->cbs_server = NULL; 10ddc3: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) } return sched; } 10ddca: 83 c4 18 add $0x18,%esp 10ddcd: 5b pop %ebx 10ddce: c3 ret =============================================================================== 0010f3bc <_Scheduler_CBS_Budget_callout>: Scheduler_CBS_Server **_Scheduler_CBS_Server_list; void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) { 10f3bc: 53 push %ebx 10f3bd: 83 ec 28 sub $0x28,%esp 10f3c0: 8b 5c 24 30 mov 0x30(%esp),%ebx Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info; Scheduler_CBS_Server_id server_id; /* Put violating task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; 10f3c4: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax if ( the_thread->real_priority != new_priority ) 10f3ca: 39 43 18 cmp %eax,0x18(%ebx) 10f3cd: 74 03 je 10f3d2 <_Scheduler_CBS_Budget_callout+0x16><== NEVER TAKEN the_thread->real_priority = new_priority; 10f3cf: 89 43 18 mov %eax,0x18(%ebx) if ( the_thread->current_priority != new_priority ) 10f3d2: 39 43 14 cmp %eax,0x14(%ebx) 10f3d5: 74 14 je 10f3eb <_Scheduler_CBS_Budget_callout+0x2f><== NEVER TAKEN _Thread_Change_priority(the_thread, new_priority, true); 10f3d7: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) 10f3de: 00 10f3df: 89 44 24 04 mov %eax,0x4(%esp) 10f3e3: 89 1c 24 mov %ebx,(%esp) 10f3e6: e8 e1 04 00 00 call 10f8cc <_Thread_Change_priority> /* Invoke callback function if any. */ sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; 10f3eb: 8b 9b 88 00 00 00 mov 0x88(%ebx),%ebx if ( sched_info->cbs_server->cbs_budget_overrun ) { 10f3f1: 8b 43 18 mov 0x18(%ebx),%eax 10f3f4: 8b 50 0c mov 0xc(%eax),%edx 10f3f7: 85 d2 test %edx,%edx 10f3f9: 74 1f je 10f41a <_Scheduler_CBS_Budget_callout+0x5e><== NEVER TAKEN _Scheduler_CBS_Get_server_id( 10f3fb: 8d 54 24 1c lea 0x1c(%esp),%edx 10f3ff: 89 54 24 04 mov %edx,0x4(%esp) 10f403: 8b 00 mov (%eax),%eax 10f405: 89 04 24 mov %eax,(%esp) 10f408: e8 73 ff ff ff call 10f380 <_Scheduler_CBS_Get_server_id> sched_info->cbs_server->task_id, &server_id ); sched_info->cbs_server->cbs_budget_overrun( server_id ); 10f40d: 8b 43 18 mov 0x18(%ebx),%eax 10f410: 8b 54 24 1c mov 0x1c(%esp),%edx 10f414: 89 14 24 mov %edx,(%esp) 10f417: ff 50 0c call *0xc(%eax) } } 10f41a: 83 c4 28 add $0x28,%esp 10f41d: 5b pop %ebx 10f41e: c3 ret =============================================================================== 0010efe4 <_Scheduler_CBS_Cleanup>: #include #include #include int _Scheduler_CBS_Cleanup (void) { 10efe4: 53 push %ebx 10efe5: 83 ec 18 sub $0x18,%esp 10efe8: a1 24 39 13 00 mov 0x133924,%eax unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 10efed: 8b 0d bc f2 12 00 mov 0x12f2bc,%ecx 10eff3: 31 db xor %ebx,%ebx 10eff5: 85 c9 test %ecx,%ecx 10eff7: 74 20 je 10f019 <_Scheduler_CBS_Cleanup+0x35><== NEVER TAKEN 10eff9: 8d 76 00 lea 0x0(%esi),%esi if ( _Scheduler_CBS_Server_list[ i ] ) 10effc: 8b 14 98 mov (%eax,%ebx,4),%edx 10efff: 85 d2 test %edx,%edx 10f001: 74 0d je 10f010 <_Scheduler_CBS_Cleanup+0x2c> _Scheduler_CBS_Destroy_server( i ); 10f003: 89 1c 24 mov %ebx,(%esp) 10f006: e8 d1 00 00 00 call 10f0dc <_Scheduler_CBS_Destroy_server> 10f00b: a1 24 39 13 00 mov 0x133924,%eax int _Scheduler_CBS_Cleanup (void) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 10f010: 43 inc %ebx 10f011: 39 1d bc f2 12 00 cmp %ebx,0x12f2bc 10f017: 77 e3 ja 10effc <_Scheduler_CBS_Cleanup+0x18> if ( _Scheduler_CBS_Server_list[ i ] ) _Scheduler_CBS_Destroy_server( i ); } _Workspace_Free( _Scheduler_CBS_Server_list ); 10f019: 89 04 24 mov %eax,(%esp) 10f01c: e8 97 1b 00 00 call 110bb8 <_Workspace_Free> return SCHEDULER_CBS_OK; } 10f021: 31 c0 xor %eax,%eax 10f023: 83 c4 18 add $0x18,%esp 10f026: 5b pop %ebx 10f027: c3 ret =============================================================================== 0010f028 <_Scheduler_CBS_Create_server>: int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) { 10f028: 57 push %edi 10f029: 56 push %esi 10f02a: 53 push %ebx 10f02b: 83 ec 10 sub $0x10,%esp 10f02e: 8b 74 24 20 mov 0x20(%esp),%esi 10f032: 8b 5c 24 28 mov 0x28(%esp),%ebx unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 10f036: 8b 46 04 mov 0x4(%esi),%eax 10f039: 85 c0 test %eax,%eax 10f03b: 0f 8e 8d 00 00 00 jle 10f0ce <_Scheduler_CBS_Create_server+0xa6> 10f041: 8b 06 mov (%esi),%eax 10f043: 85 c0 test %eax,%eax 10f045: 0f 8e 83 00 00 00 jle 10f0ce <_Scheduler_CBS_Create_server+0xa6> 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++ ) { 10f04b: 8b 0d bc f2 12 00 mov 0x12f2bc,%ecx 10f051: 85 c9 test %ecx,%ecx 10f053: 74 1f je 10f074 <_Scheduler_CBS_Create_server+0x4c><== NEVER TAKEN if ( !_Scheduler_CBS_Server_list[i] ) 10f055: 8b 15 24 39 13 00 mov 0x133924,%edx 10f05b: 8b 02 mov (%edx),%eax 10f05d: 85 c0 test %eax,%eax 10f05f: 74 67 je 10f0c8 <_Scheduler_CBS_Create_server+0xa0> 10f061: 31 c0 xor %eax,%eax 10f063: eb 0a jmp 10f06f <_Scheduler_CBS_Create_server+0x47> 10f065: 8d 76 00 lea 0x0(%esi),%esi 10f068: 8b 3c 82 mov (%edx,%eax,4),%edi 10f06b: 85 ff test %edi,%edi 10f06d: 74 11 je 10f080 <_Scheduler_CBS_Create_server+0x58> 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++ ) { 10f06f: 40 inc %eax 10f070: 39 c8 cmp %ecx,%eax 10f072: 75 f4 jne 10f068 <_Scheduler_CBS_Create_server+0x40> if ( !_Scheduler_CBS_Server_list[i] ) break; } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; 10f074: b8 e6 ff ff ff mov $0xffffffe6,%eax the_server->parameters = *params; the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback; return SCHEDULER_CBS_OK; } 10f079: 83 c4 10 add $0x10,%esp 10f07c: 5b pop %ebx 10f07d: 5e pop %esi 10f07e: 5f pop %edi 10f07f: c3 ret 10f080: 8d 3c 85 00 00 00 00 lea 0x0(,%eax,4),%edi } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; 10f087: 89 03 mov %eax,(%ebx) _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 10f089: 01 d7 add %edx,%edi _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); 10f08b: c7 04 24 10 00 00 00 movl $0x10,(%esp) 10f092: e8 f5 1a 00 00 call 110b8c <_Workspace_Allocate> if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 10f097: 89 07 mov %eax,(%edi) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; 10f099: 8b 13 mov (%ebx),%edx 10f09b: a1 24 39 13 00 mov 0x133924,%eax 10f0a0: 8b 0c 90 mov (%eax,%edx,4),%ecx if ( !the_server ) 10f0a3: 85 c9 test %ecx,%ecx 10f0a5: 74 2e je 10f0d5 <_Scheduler_CBS_Create_server+0xad><== NEVER TAKEN return SCHEDULER_CBS_ERROR_NO_MEMORY; the_server->parameters = *params; 10f0a7: 8b 06 mov (%esi),%eax 10f0a9: 8b 56 04 mov 0x4(%esi),%edx 10f0ac: 89 41 04 mov %eax,0x4(%ecx) 10f0af: 89 51 08 mov %edx,0x8(%ecx) the_server->task_id = -1; 10f0b2: c7 01 ff ff ff ff movl $0xffffffff,(%ecx) the_server->cbs_budget_overrun = budget_overrun_callback; 10f0b8: 8b 44 24 24 mov 0x24(%esp),%eax 10f0bc: 89 41 0c mov %eax,0xc(%ecx) return SCHEDULER_CBS_OK; 10f0bf: 31 c0 xor %eax,%eax } 10f0c1: 83 c4 10 add $0x10,%esp 10f0c4: 5b pop %ebx 10f0c5: 5e pop %esi 10f0c6: 5f pop %edi 10f0c7: c3 ret params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { if ( !_Scheduler_CBS_Server_list[i] ) 10f0c8: 31 ff xor %edi,%edi 10f0ca: 31 c0 xor %eax,%eax 10f0cc: eb b9 jmp 10f087 <_Scheduler_CBS_Create_server+0x5f> if ( params->budget <= 0 || params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 10f0ce: b8 ee ff ff ff mov $0xffffffee,%eax 10f0d3: eb a4 jmp 10f079 <_Scheduler_CBS_Create_server+0x51> *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; 10f0d5: b8 ef ff ff ff mov $0xffffffef,%eax <== NOT EXECUTED 10f0da: eb 9d jmp 10f079 <_Scheduler_CBS_Create_server+0x51><== NOT EXECUTED =============================================================================== 0010f154 <_Scheduler_CBS_Detach_thread>: int _Scheduler_CBS_Detach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 10f154: 56 push %esi 10f155: 53 push %ebx 10f156: 83 ec 34 sub $0x34,%esp 10f159: 8b 74 24 40 mov 0x40(%esp),%esi 10f15d: 8b 5c 24 44 mov 0x44(%esp),%ebx Objects_Locations location; Thread_Control *the_thread; Scheduler_CBS_Per_thread *sched_info; the_thread = _Thread_Get(task_id, &location); 10f161: 8d 44 24 2c lea 0x2c(%esp),%eax 10f165: 89 44 24 04 mov %eax,0x4(%esp) 10f169: 89 1c 24 mov %ebx,(%esp) 10f16c: e8 e7 0b 00 00 call 10fd58 <_Thread_Get> /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 10f171: 85 c0 test %eax,%eax 10f173: 74 5f je 10f1d4 <_Scheduler_CBS_Detach_thread+0x80> _Thread_Enable_dispatch(); 10f175: 89 44 24 1c mov %eax,0x1c(%esp) 10f179: e8 ba 0b 00 00 call 10fd38 <_Thread_Enable_dispatch> } if ( server_id >= _Scheduler_CBS_Maximum_servers ) 10f17e: 3b 35 bc f2 12 00 cmp 0x12f2bc,%esi 10f184: 8b 44 24 1c mov 0x1c(%esp),%eax 10f188: 73 4a jae 10f1d4 <_Scheduler_CBS_Detach_thread+0x80> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !the_thread ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) 10f18a: 8b 15 24 39 13 00 mov 0x133924,%edx 10f190: 8b 14 b2 mov (%edx,%esi,4),%edx 10f193: 85 d2 test %edx,%edx 10f195: 74 48 je 10f1df <_Scheduler_CBS_Detach_thread+0x8b> return SCHEDULER_CBS_ERROR_NOSERVER; /* Thread and server are not attached. */ if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id ) 10f197: 39 1a cmp %ebx,(%edx) 10f199: 75 39 jne 10f1d4 <_Scheduler_CBS_Detach_thread+0x80><== NEVER TAKEN return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; _Scheduler_CBS_Server_list[server_id]->task_id = -1; 10f19b: c7 02 ff ff ff ff movl $0xffffffff,(%edx) sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL; 10f1a1: 8b 90 88 00 00 00 mov 0x88(%eax),%edx 10f1a7: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10f1ae: 8b 90 a0 00 00 00 mov 0xa0(%eax),%edx 10f1b4: 89 50 78 mov %edx,0x78(%eax) the_thread->budget_callout = the_thread->Start.budget_callout; 10f1b7: 8b 90 a4 00 00 00 mov 0xa4(%eax),%edx 10f1bd: 89 50 7c mov %edx,0x7c(%eax) the_thread->is_preemptible = the_thread->Start.is_preemptible; 10f1c0: 8a 90 9c 00 00 00 mov 0x9c(%eax),%dl 10f1c6: 88 50 70 mov %dl,0x70(%eax) return SCHEDULER_CBS_OK; 10f1c9: 31 c0 xor %eax,%eax } 10f1cb: 83 c4 34 add $0x34,%esp 10f1ce: 5b pop %ebx 10f1cf: 5e pop %esi 10f1d0: c3 ret 10f1d1: 8d 76 00 lea 0x0(%esi),%esi if ( the_thread ) { _Thread_Enable_dispatch(); } if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 10f1d4: b8 ee ff ff ff mov $0xffffffee,%eax the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout; the_thread->is_preemptible = the_thread->Start.is_preemptible; return SCHEDULER_CBS_OK; } 10f1d9: 83 c4 34 add $0x34,%esp 10f1dc: 5b pop %ebx 10f1dd: 5e pop %esi 10f1de: c3 ret return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !the_thread ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; 10f1df: b8 e7 ff ff ff mov $0xffffffe7,%eax 10f1e4: eb e5 jmp 10f1cb <_Scheduler_CBS_Detach_thread+0x77> =============================================================================== 0010f380 <_Scheduler_CBS_Get_server_id>: int _Scheduler_CBS_Get_server_id ( rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { 10f380: 56 push %esi 10f381: 53 push %ebx 10f382: 8b 74 24 0c mov 0xc(%esp),%esi unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 10f386: 8b 0d bc f2 12 00 mov 0x12f2bc,%ecx 10f38c: 85 c9 test %ecx,%ecx 10f38e: 74 18 je 10f3a8 <_Scheduler_CBS_Get_server_id+0x28><== NEVER TAKEN 10f390: 8b 1d 24 39 13 00 mov 0x133924,%ebx 10f396: 31 c0 xor %eax,%eax if ( _Scheduler_CBS_Server_list[i] && 10f398: 8b 14 83 mov (%ebx,%eax,4),%edx 10f39b: 85 d2 test %edx,%edx 10f39d: 74 04 je 10f3a3 <_Scheduler_CBS_Get_server_id+0x23> 10f39f: 39 32 cmp %esi,(%edx) 10f3a1: 74 0d je 10f3b0 <_Scheduler_CBS_Get_server_id+0x30> rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 10f3a3: 40 inc %eax 10f3a4: 39 c8 cmp %ecx,%eax 10f3a6: 75 f0 jne 10f398 <_Scheduler_CBS_Get_server_id+0x18> _Scheduler_CBS_Server_list[i]->task_id == task_id ) { *server_id = i; return SCHEDULER_CBS_OK; } } return SCHEDULER_CBS_ERROR_NOSERVER; 10f3a8: b8 e7 ff ff ff mov $0xffffffe7,%eax } 10f3ad: 5b pop %ebx 10f3ae: 5e pop %esi 10f3af: c3 ret { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { if ( _Scheduler_CBS_Server_list[i] && _Scheduler_CBS_Server_list[i]->task_id == task_id ) { *server_id = i; 10f3b0: 8b 54 24 10 mov 0x10(%esp),%edx 10f3b4: 89 02 mov %eax,(%edx) return SCHEDULER_CBS_OK; 10f3b6: 31 c0 xor %eax,%eax } } return SCHEDULER_CBS_ERROR_NOSERVER; } 10f3b8: 5b pop %ebx 10f3b9: 5e pop %esi 10f3ba: c3 ret =============================================================================== 0010f420 <_Scheduler_CBS_Initialize>: int _Scheduler_CBS_Initialize(void) { 10f420: 83 ec 1c sub $0x1c,%esp unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( 10f423: a1 bc f2 12 00 mov 0x12f2bc,%eax 10f428: c1 e0 02 shl $0x2,%eax 10f42b: 89 04 24 mov %eax,(%esp) 10f42e: e8 59 17 00 00 call 110b8c <_Workspace_Allocate> 10f433: a3 24 39 13 00 mov %eax,0x133924 _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) 10f438: 85 c0 test %eax,%eax 10f43a: 74 27 je 10f463 <_Scheduler_CBS_Initialize+0x43><== NEVER TAKEN return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 10f43c: 8b 0d bc f2 12 00 mov 0x12f2bc,%ecx 10f442: 31 d2 xor %edx,%edx 10f444: 85 c9 test %ecx,%ecx 10f446: 75 09 jne 10f451 <_Scheduler_CBS_Initialize+0x31><== ALWAYS TAKEN 10f448: eb 13 jmp 10f45d <_Scheduler_CBS_Initialize+0x3d><== NOT EXECUTED 10f44a: 66 90 xchg %ax,%ax <== NOT EXECUTED 10f44c: a1 24 39 13 00 mov 0x133924,%eax _Scheduler_CBS_Server_list[i] = NULL; 10f451: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 10f458: 42 inc %edx 10f459: 39 ca cmp %ecx,%edx 10f45b: 75 ef jne 10f44c <_Scheduler_CBS_Initialize+0x2c> _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; 10f45d: 31 c0 xor %eax,%eax } 10f45f: 83 c4 1c add $0x1c,%esp 10f462: c3 ret { unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; 10f463: b8 ef ff ff ff mov $0xffffffef,%eax <== NOT EXECUTED 10f468: eb f5 jmp 10f45f <_Scheduler_CBS_Initialize+0x3f><== NOT EXECUTED =============================================================================== 0010ddd0 <_Scheduler_CBS_Release_job>: void _Scheduler_CBS_Release_job( Thread_Control *the_thread, uint32_t deadline ) { 10ddd0: 83 ec 1c sub $0x1c,%esp 10ddd3: 8b 44 24 20 mov 0x20(%esp),%eax 10ddd7: 8b 54 24 24 mov 0x24(%esp),%edx Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; Scheduler_CBS_Server *serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server; 10dddb: 8b 88 88 00 00 00 mov 0x88(%eax),%ecx ) { Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; Scheduler_CBS_Server *serv_info = 10dde1: 8b 49 18 mov 0x18(%ecx),%ecx (Scheduler_CBS_Server *) sched_info->cbs_server; if (deadline) { 10dde4: 85 d2 test %edx,%edx 10dde6: 74 34 je 10de1c <_Scheduler_CBS_Release_job+0x4c> /* Initializing or shifting deadline. */ if (serv_info) 10dde8: 85 c9 test %ecx,%ecx 10ddea: 74 3c je 10de28 <_Scheduler_CBS_Release_job+0x58> new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline) 10ddec: 8b 15 64 17 13 00 mov 0x131764,%edx 10ddf2: 03 51 04 add 0x4(%ecx),%edx 10ddf5: 81 e2 ff ff ff 7f and $0x7fffffff,%edx new_priority = the_thread->Start.initial_priority; } /* Budget replenishment for the next job. */ if (serv_info) the_thread->cpu_time_budget = serv_info->parameters.budget; 10ddfb: 8b 49 08 mov 0x8(%ecx),%ecx 10ddfe: 89 48 74 mov %ecx,0x74(%eax) the_thread->real_priority = new_priority; 10de01: 89 50 18 mov %edx,0x18(%eax) _Thread_Change_priority(the_thread, new_priority, true); 10de04: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) 10de0b: 00 10de0c: 89 54 24 04 mov %edx,0x4(%esp) 10de10: 89 04 24 mov %eax,(%esp) 10de13: e8 d4 03 00 00 call 10e1ec <_Thread_Change_priority> } 10de18: 83 c4 1c add $0x1c,%esp 10de1b: c3 ret new_priority = (_Watchdog_Ticks_since_boot + deadline) & ~SCHEDULER_EDF_PRIO_MSB; } else { /* Switch back to background priority. */ new_priority = the_thread->Start.initial_priority; 10de1c: 8b 90 ac 00 00 00 mov 0xac(%eax),%edx } /* Budget replenishment for the next job. */ if (serv_info) 10de22: 85 c9 test %ecx,%ecx 10de24: 75 d5 jne 10ddfb <_Scheduler_CBS_Release_job+0x2b><== ALWAYS TAKEN 10de26: eb d9 jmp 10de01 <_Scheduler_CBS_Release_job+0x31><== NOT EXECUTED /* Initializing or shifting deadline. */ if (serv_info) new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline) & ~SCHEDULER_EDF_PRIO_MSB; else new_priority = (_Watchdog_Ticks_since_boot + deadline) 10de28: 8b 0d 64 17 13 00 mov 0x131764,%ecx 10de2e: 01 ca add %ecx,%edx 10de30: 81 e2 ff ff ff 7f and $0x7fffffff,%edx 10de36: eb c9 jmp 10de01 <_Scheduler_CBS_Release_job+0x31> =============================================================================== 0010de38 <_Scheduler_CBS_Unblock>: #include void _Scheduler_CBS_Unblock( Thread_Control *the_thread ) { 10de38: 56 push %esi 10de39: 53 push %ebx 10de3a: 83 ec 14 sub $0x14,%esp 10de3d: 8b 5c 24 20 mov 0x20(%esp),%ebx Scheduler_CBS_Per_thread *sched_info; Scheduler_CBS_Server *serv_info; Priority_Control new_priority; _Scheduler_EDF_Enqueue(the_thread); 10de41: 89 1c 24 mov %ebx,(%esp) 10de44: e8 e3 00 00 00 call 10df2c <_Scheduler_EDF_Enqueue> /* TODO: flash critical section? */ sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server; 10de49: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10de4f: 8b 40 18 mov 0x18(%eax),%eax * Late unblock rule for deadline-driven tasks. The remaining time to * deadline must be sufficient to serve the remaining computation time * without increased utilization of this task. It might cause a deadline * miss of another task. */ if (serv_info) { 10de52: 85 c0 test %eax,%eax 10de54: 74 46 je 10de9c <_Scheduler_CBS_Unblock+0x64> time_t deadline = serv_info->parameters.deadline; time_t budget = serv_info->parameters.budget; time_t deadline_left = the_thread->cpu_time_budget; time_t budget_left = the_thread->real_priority - 10de56: 8b 4b 18 mov 0x18(%ebx),%ecx 10de59: 8b 15 64 17 13 00 mov 0x131764,%edx 10de5f: 89 ce mov %ecx,%esi 10de61: 29 d6 sub %edx,%esi _Watchdog_Ticks_since_boot; if ( deadline*budget_left > budget*deadline_left ) { 10de63: 8b 50 04 mov 0x4(%eax),%edx 10de66: 0f af d6 imul %esi,%edx 10de69: 8b 40 08 mov 0x8(%eax),%eax 10de6c: 0f af 43 74 imul 0x74(%ebx),%eax 10de70: 39 c2 cmp %eax,%edx 10de72: 7e 28 jle 10de9c <_Scheduler_CBS_Unblock+0x64> /* Put late unblocked task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; 10de74: 8b 93 ac 00 00 00 mov 0xac(%ebx),%edx if ( the_thread->real_priority != new_priority ) 10de7a: 39 d1 cmp %edx,%ecx 10de7c: 74 03 je 10de81 <_Scheduler_CBS_Unblock+0x49> the_thread->real_priority = new_priority; 10de7e: 89 53 18 mov %edx,0x18(%ebx) if ( the_thread->current_priority != new_priority ) 10de81: 8b 43 14 mov 0x14(%ebx),%eax 10de84: 39 d0 cmp %edx,%eax 10de86: 74 17 je 10de9f <_Scheduler_CBS_Unblock+0x67> _Thread_Change_priority(the_thread, new_priority, true); 10de88: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) 10de8f: 00 10de90: 89 54 24 04 mov %edx,0x4(%esp) 10de94: 89 1c 24 mov %ebx,(%esp) 10de97: e8 50 03 00 00 call 10e1ec <_Thread_Change_priority> 10de9c: 8b 43 14 mov 0x14(%ebx),%eax * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority, 10de9f: 8b 15 d0 18 13 00 mov 0x1318d0,%edx 10dea5: 8b 52 14 mov 0x14(%edx),%edx 10dea8: 89 54 24 04 mov %edx,0x4(%esp) 10deac: 89 04 24 mov %eax,(%esp) 10deaf: ff 15 b0 d2 12 00 call *0x12d2b0 10deb5: 85 c0 test %eax,%eax 10deb7: 7e 18 jle 10ded1 <_Scheduler_CBS_Unblock+0x99> _Thread_Heir->current_priority)) { _Thread_Heir = the_thread; 10deb9: 89 1d d0 18 13 00 mov %ebx,0x1318d0 if ( _Thread_Executing->is_preemptible || 10debf: a1 cc 18 13 00 mov 0x1318cc,%eax 10dec4: 80 78 70 00 cmpb $0x0,0x70(%eax) 10dec8: 74 0e je 10ded8 <_Scheduler_CBS_Unblock+0xa0> the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10deca: c6 05 d8 18 13 00 01 movb $0x1,0x1318d8 } } 10ded1: 83 c4 14 add $0x14,%esp 10ded4: 5b pop %ebx 10ded5: 5e pop %esi 10ded6: c3 ret 10ded7: 90 nop * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority, _Thread_Heir->current_priority)) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 10ded8: 8b 43 14 mov 0x14(%ebx),%eax 10dedb: 85 c0 test %eax,%eax 10dedd: 74 eb je 10deca <_Scheduler_CBS_Unblock+0x92><== NEVER TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; } } 10dedf: 83 c4 14 add $0x14,%esp 10dee2: 5b pop %ebx 10dee3: 5e pop %esi 10dee4: c3 ret =============================================================================== 0010dd9c <_Scheduler_EDF_Allocate>: #include void *_Scheduler_EDF_Allocate( Thread_Control *the_thread ) { 10dd9c: 53 push %ebx 10dd9d: 83 ec 18 sub $0x18,%esp 10dda0: 8b 5c 24 20 mov 0x20(%esp),%ebx void *sched; Scheduler_EDF_Per_thread *schinfo; sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) ); 10dda4: c7 04 24 18 00 00 00 movl $0x18,(%esp) 10ddab: e8 f0 16 00 00 call 10f4a0 <_Workspace_Allocate> if ( sched ) { 10ddb0: 85 c0 test %eax,%eax 10ddb2: 74 0f je 10ddc3 <_Scheduler_EDF_Allocate+0x27><== NEVER TAKEN the_thread->scheduler_info = sched; 10ddb4: 89 83 88 00 00 00 mov %eax,0x88(%ebx) schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info); schinfo->thread = the_thread; 10ddba: 89 18 mov %ebx,(%eax) schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN; 10ddbc: c7 40 14 02 00 00 00 movl $0x2,0x14(%eax) } return sched; } 10ddc3: 83 c4 18 add $0x18,%esp 10ddc6: 5b pop %ebx 10ddc7: c3 ret =============================================================================== 0010df70 <_Scheduler_EDF_Unblock>: #include void _Scheduler_EDF_Unblock( Thread_Control *the_thread ) { 10df70: 53 push %ebx 10df71: 83 ec 18 sub $0x18,%esp 10df74: 8b 5c 24 20 mov 0x20(%esp),%ebx _Scheduler_EDF_Enqueue(the_thread); 10df78: 89 1c 24 mov %ebx,(%esp) 10df7b: e8 8c fe ff ff call 10de0c <_Scheduler_EDF_Enqueue> 10df80: 8b 43 14 mov 0x14(%ebx),%eax 10df83: 89 44 24 04 mov %eax,0x4(%esp) * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_lower_than( 10df87: a1 d0 18 13 00 mov 0x1318d0,%eax 10df8c: 8b 40 14 mov 0x14(%eax),%eax 10df8f: 89 04 24 mov %eax,(%esp) 10df92: ff 15 b0 d2 12 00 call *0x12d2b0 10df98: 85 c0 test %eax,%eax 10df9a: 78 08 js 10dfa4 <_Scheduler_EDF_Unblock+0x34> _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; } } 10df9c: 83 c4 18 add $0x18,%esp 10df9f: 5b pop %ebx 10dfa0: c3 ret 10dfa1: 8d 76 00 lea 0x0(%esi),%esi * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_lower_than( _Thread_Heir->current_priority, the_thread->current_priority )) { _Thread_Heir = the_thread; 10dfa4: 89 1d d0 18 13 00 mov %ebx,0x1318d0 if ( _Thread_Executing->is_preemptible || 10dfaa: a1 cc 18 13 00 mov 0x1318cc,%eax 10dfaf: 80 78 70 00 cmpb $0x0,0x70(%eax) 10dfb3: 74 0f je 10dfc4 <_Scheduler_EDF_Unblock+0x54> the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10dfb5: c6 05 d8 18 13 00 01 movb $0x1,0x1318d8 } } 10dfbc: 83 c4 18 add $0x18,%esp 10dfbf: 5b pop %ebx 10dfc0: c3 ret 10dfc1: 8d 76 00 lea 0x0(%esi),%esi */ if ( _Scheduler_Is_priority_lower_than( _Thread_Heir->current_priority, the_thread->current_priority )) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 10dfc4: 8b 43 14 mov 0x14(%ebx),%eax 10dfc7: 85 c0 test %eax,%eax 10dfc9: 75 d1 jne 10df9c <_Scheduler_EDF_Unblock+0x2c><== ALWAYS TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10dfcb: c6 05 d8 18 13 00 01 movb $0x1,0x1318d8 <== NOT EXECUTED 10dfd2: eb e8 jmp 10dfbc <_Scheduler_EDF_Unblock+0x4c><== NOT EXECUTED =============================================================================== 0010d508 <_Scheduler_priority_Block>: #include void _Scheduler_priority_Block( Thread_Control *the_thread ) { 10d508: 53 push %ebx 10d509: 8b 44 24 08 mov 0x8(%esp),%eax ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info; 10d50d: 8b 88 88 00 00 00 mov 0x88(%eax),%ecx ready = sched_info->ready_chain; 10d513: 8b 11 mov (%ecx),%edx if ( _Chain_Has_only_one_node( ready ) ) { 10d515: 8b 5a 08 mov 0x8(%edx),%ebx 10d518: 39 1a cmp %ebx,(%edx) 10d51a: 74 28 je 10d544 <_Scheduler_priority_Block+0x3c> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10d51c: 8b 08 mov (%eax),%ecx previous = the_node->previous; 10d51e: 8b 50 04 mov 0x4(%eax),%edx next->previous = previous; 10d521: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 10d524: 89 0a mov %ecx,(%edx) _Scheduler_priority_Ready_queue_extract( the_thread ); /* TODO: flash critical section? */ if ( _Thread_Is_heir( the_thread ) ) 10d526: 3b 05 70 f8 12 00 cmp 0x12f870,%eax 10d52c: 74 4a je 10d578 <_Scheduler_priority_Block+0x70> _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) 10d52e: 3b 05 6c f8 12 00 cmp 0x12f86c,%eax 10d534: 74 02 je 10d538 <_Scheduler_priority_Block+0x30> _Thread_Dispatch_necessary = true; } 10d536: 5b pop %ebx 10d537: c3 ret if ( _Thread_Is_heir( the_thread ) ) _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 10d538: c6 05 78 f8 12 00 01 movb $0x1,0x12f878 } 10d53f: 5b pop %ebx 10d540: c3 ret 10d541: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10d544: 8d 5a 04 lea 0x4(%edx),%ebx 10d547: 89 1a mov %ebx,(%edx) head->next = tail; head->previous = NULL; 10d549: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) tail->previous = head; 10d550: 89 52 08 mov %edx,0x8(%edx) RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 10d553: 8b 59 04 mov 0x4(%ecx),%ebx 10d556: 66 8b 13 mov (%ebx),%dx 10d559: 66 23 51 0e and 0xe(%ecx),%dx 10d55d: 66 89 13 mov %dx,(%ebx) if ( *the_priority_map->minor == 0 ) 10d560: 66 85 d2 test %dx,%dx 10d563: 75 c1 jne 10d526 <_Scheduler_priority_Block+0x1e> _Priority_Major_bit_map &= the_priority_map->block_major; 10d565: 66 8b 15 a0 f8 12 00 mov 0x12f8a0,%dx 10d56c: 23 51 0c and 0xc(%ecx),%edx 10d56f: 66 89 15 a0 f8 12 00 mov %dx,0x12f8a0 10d576: eb ae jmp 10d526 <_Scheduler_priority_Block+0x1e> RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void ) { Priority_bit_map_Control minor; Priority_bit_map_Control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 10d578: 66 8b 1d a0 f8 12 00 mov 0x12f8a0,%bx 10d57f: 31 d2 xor %edx,%edx 10d581: 89 d1 mov %edx,%ecx 10d583: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10d587: 0f b7 c9 movzwl %cx,%ecx 10d58a: 66 8b 9c 09 c0 f8 12 mov 0x12f8c0(%ecx,%ecx,1),%bx 10d591: 00 10d592: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 10d596: c1 e1 04 shl $0x4,%ecx 10d599: 0f b7 d2 movzwl %dx,%edx 10d59c: 01 ca add %ecx,%edx Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10d59e: 8d 0c 52 lea (%edx,%edx,2),%ecx 10d5a1: 8b 15 80 b2 12 00 mov 0x12b280,%edx 10d5a7: 8d 0c 8a lea (%edx,%ecx,4),%ecx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10d5aa: 8b 11 mov (%ecx),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10d5ac: 83 c1 04 add $0x4,%ecx 10d5af: 39 ca cmp %ecx,%edx 10d5b1: 74 0b je 10d5be <_Scheduler_priority_Block+0xb6><== NEVER TAKEN * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d5b3: 89 15 70 f8 12 00 mov %edx,0x12f870 10d5b9: e9 70 ff ff ff jmp 10d52e <_Scheduler_priority_Block+0x26> Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10d5be: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d5c0: eb f1 jmp 10d5b3 <_Scheduler_priority_Block+0xab><== NOT EXECUTED =============================================================================== 0010d720 <_Scheduler_priority_Schedule>: RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void ) { Priority_bit_map_Control minor; Priority_bit_map_Control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 10d720: 66 8b 0d a0 f8 12 00 mov 0x12f8a0,%cx 10d727: 31 c0 xor %eax,%eax 10d729: 89 c2 mov %eax,%edx 10d72b: 66 0f bc d1 bsf %cx,%dx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10d72f: 0f b7 d2 movzwl %dx,%edx 10d732: 66 8b 8c 12 c0 f8 12 mov 0x12f8c0(%edx,%edx,1),%cx 10d739: 00 10d73a: 66 0f bc c1 bsf %cx,%ax return (_Priority_Bits_index( major ) << 4) + 10d73e: c1 e2 04 shl $0x4,%edx 10d741: 0f b7 c0 movzwl %ax,%eax 10d744: 01 d0 add %edx,%eax Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10d746: 8d 14 40 lea (%eax,%eax,2),%edx 10d749: a1 80 b2 12 00 mov 0x12b280,%eax 10d74e: 8d 14 90 lea (%eax,%edx,4),%edx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10d751: 8b 02 mov (%edx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10d753: 83 c2 04 add $0x4,%edx 10d756: 39 d0 cmp %edx,%eax 10d758: 74 06 je 10d760 <_Scheduler_priority_Schedule+0x40><== NEVER TAKEN * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d75a: a3 70 f8 12 00 mov %eax,0x12f870 10d75f: c3 ret Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10d760: 31 c0 xor %eax,%eax * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10d762: a3 70 f8 12 00 mov %eax,0x12f870 <== NOT EXECUTED 10d767: c3 ret <== NOT EXECUTED =============================================================================== 0010dee4 <_Scheduler_simple_Ready_queue_enqueue_first>: #include void _Scheduler_simple_Ready_queue_enqueue_first( Thread_Control *the_thread ) { 10dee4: 8b 4c 24 04 mov 0x4(%esp),%ecx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10dee8: a1 80 c2 12 00 mov 0x12c280,%eax 10deed: 8b 00 mov (%eax),%eax */ for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) { current = (Thread_Control *) the_node; /* break when AT HEAD OF (or PAST) our priority */ if ( the_thread->current_priority <= current->current_priority ) { 10deef: 8b 51 14 mov 0x14(%ecx),%edx 10def2: 39 50 14 cmp %edx,0x14(%eax) 10def5: 73 08 jae 10deff <_Scheduler_simple_Ready_queue_enqueue_first+0x1b> 10def7: 90 nop * Do NOT need to check for end of chain because there is always * at least one task on the ready chain -- the IDLE task. It can * never block, should never attempt to obtain a semaphore or mutex, * and thus will always be there. */ for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) { 10def8: 8b 00 mov (%eax),%eax current = (Thread_Control *) the_node; /* break when AT HEAD OF (or PAST) our priority */ if ( the_thread->current_priority <= current->current_priority ) { 10defa: 39 50 14 cmp %edx,0x14(%eax) 10defd: 72 f9 jb 10def8 <_Scheduler_simple_Ready_queue_enqueue_first+0x14><== NEVER TAKEN current = (Thread_Control *)current->Object.Node.previous; 10deff: 8b 40 04 mov 0x4(%eax),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10df02: 89 41 04 mov %eax,0x4(%ecx) before_node = after_node->next; 10df05: 8b 10 mov (%eax),%edx after_node->next = the_node; 10df07: 89 08 mov %ecx,(%eax) the_node->next = before_node; 10df09: 89 11 mov %edx,(%ecx) before_node->previous = the_node; 10df0b: 89 4a 04 mov %ecx,0x4(%edx) 10df0e: c3 ret =============================================================================== 0010c4e0 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10c4e0: 8b 4c 24 04 mov 0x4(%esp),%ecx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10c4e4: b8 40 42 0f 00 mov $0xf4240,%eax 10c4e9: 31 d2 xor %edx,%edx 10c4eb: f7 35 90 e1 12 00 divl 0x12e190 rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10c4f1: 85 c9 test %ecx,%ecx 10c4f3: 74 47 je 10c53c <_TOD_Validate+0x5c> <== NEVER TAKEN 10c4f5: 3b 41 18 cmp 0x18(%ecx),%eax 10c4f8: 76 42 jbe 10c53c <_TOD_Validate+0x5c> (the_tod->ticks >= ticks_per_second) || 10c4fa: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10c4fe: 77 3c ja 10c53c <_TOD_Validate+0x5c> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10c500: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10c504: 77 36 ja 10c53c <_TOD_Validate+0x5c> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10c506: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10c50a: 77 30 ja 10c53c <_TOD_Validate+0x5c> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10c50c: 8b 41 04 mov 0x4(%ecx),%eax rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || 10c50f: 85 c0 test %eax,%eax 10c511: 74 29 je 10c53c <_TOD_Validate+0x5c> <== NEVER TAKEN (the_tod->month == 0) || 10c513: 83 f8 0c cmp $0xc,%eax 10c516: 77 24 ja 10c53c <_TOD_Validate+0x5c> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10c518: 8b 11 mov (%ecx),%edx (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || 10c51a: 81 fa c3 07 00 00 cmp $0x7c3,%edx 10c520: 76 1a jbe 10c53c <_TOD_Validate+0x5c> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10c522: 8b 49 08 mov 0x8(%ecx),%ecx (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10c525: 85 c9 test %ecx,%ecx 10c527: 74 13 je 10c53c <_TOD_Validate+0x5c> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10c529: 83 e2 03 and $0x3,%edx 10c52c: 75 11 jne 10c53f <_TOD_Validate+0x5f> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10c52e: 8b 04 85 54 39 12 00 mov 0x123954(,%eax,4),%eax else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; if ( the_tod->day > days_in_month ) 10c535: 39 c8 cmp %ecx,%eax 10c537: 0f 93 c0 setae %al 10c53a: c3 ret 10c53b: 90 nop (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; 10c53c: 31 c0 xor %eax,%eax if ( the_tod->day > days_in_month ) return false; return true; } 10c53e: c3 ret return false; if ( (the_tod->year % 4) == 0 ) days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10c53f: 8b 04 85 20 39 12 00 mov 0x123920(,%eax,4),%eax 10c546: eb ed jmp 10c535 <_TOD_Validate+0x55> =============================================================================== 0010d93c <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10d93c: 57 push %edi 10d93d: 56 push %esi 10d93e: 53 push %ebx 10d93f: 83 ec 20 sub $0x20,%esp 10d942: 8b 5c 24 30 mov 0x30(%esp),%ebx 10d946: 8b 7c 24 34 mov 0x34(%esp),%edi 10d94a: 8a 44 24 38 mov 0x38(%esp),%al 10d94e: 88 44 24 1f mov %al,0x1f(%esp) States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 10d952: 8b 73 10 mov 0x10(%ebx),%esi /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 10d955: 89 1c 24 mov %ebx,(%esp) 10d958: e8 9b 0c 00 00 call 10e5f8 <_Thread_Set_transient> /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 10d95d: 39 7b 14 cmp %edi,0x14(%ebx) 10d960: 74 0c je 10d96e <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10d962: 89 7c 24 04 mov %edi,0x4(%esp) 10d966: 89 1c 24 mov %ebx,(%esp) 10d969: e8 3e 0c 00 00 call 10e5ac <_Thread_Set_priority> _ISR_Disable( level ); 10d96e: 9c pushf 10d96f: fa cli 10d970: 5f pop %edi /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 10d971: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10d974: 83 f8 04 cmp $0x4,%eax 10d977: 74 23 je 10d99c <_Thread_Change_priority+0x60> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10d979: 83 e6 04 and $0x4,%esi 10d97c: 74 12 je 10d990 <_Thread_Change_priority+0x54><== ALWAYS TAKEN the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10d97e: 57 push %edi 10d97f: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10d980: a9 e0 be 03 00 test $0x3bee0,%eax 10d985: 75 5d jne 10d9e4 <_Thread_Change_priority+0xa8> if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10d987: 83 c4 20 add $0x20,%esp 10d98a: 5b pop %ebx 10d98b: 5e pop %esi 10d98c: 5f pop %edi 10d98d: c3 ret 10d98e: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 10d990: 89 c2 mov %eax,%edx 10d992: 83 e2 fb and $0xfffffffb,%edx 10d995: 89 53 10 mov %edx,0x10(%ebx) 10d998: eb e4 jmp 10d97e <_Thread_Change_priority+0x42> 10d99a: 66 90 xchg %ax,%ax } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10d99c: 83 e6 04 and $0x4,%esi 10d99f: 75 17 jne 10d9b8 <_Thread_Change_priority+0x7c><== NEVER TAKEN * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10d9a1: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10d9a8: 80 7c 24 1f 00 cmpb $0x0,0x1f(%esp) */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 10d9ad: 89 1c 24 mov %ebx,(%esp) 10d9b0: 74 4a je 10d9fc <_Thread_Change_priority+0xc0> 10d9b2: ff 15 a8 b2 12 00 call *0x12b2a8 _Scheduler_Enqueue_first( the_thread ); else _Scheduler_Enqueue( the_thread ); } _ISR_Flash( level ); 10d9b8: 57 push %edi 10d9b9: 9d popf 10d9ba: fa cli * This kernel routine implements the scheduling decision logic for * the scheduler. It does NOT dispatch. */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void ) { _Scheduler.Operations.schedule(); 10d9bb: ff 15 88 b2 12 00 call *0x12b288 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10d9c1: a1 6c f8 12 00 mov 0x12f86c,%eax * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Scheduler_Schedule(); if ( !_Thread_Is_executing_also_the_heir() && 10d9c6: 3b 05 70 f8 12 00 cmp 0x12f870,%eax 10d9cc: 74 0d je 10d9db <_Thread_Change_priority+0x9f> 10d9ce: 80 78 70 00 cmpb $0x0,0x70(%eax) 10d9d2: 74 07 je 10d9db <_Thread_Change_priority+0x9f> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10d9d4: c6 05 78 f8 12 00 01 movb $0x1,0x12f878 _ISR_Enable( level ); 10d9db: 57 push %edi 10d9dc: 9d popf } 10d9dd: 83 c4 20 add $0x20,%esp 10d9e0: 5b pop %ebx 10d9e1: 5e pop %esi 10d9e2: 5f pop %edi 10d9e3: c3 ret /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10d9e4: 89 5c 24 34 mov %ebx,0x34(%esp) 10d9e8: 8b 43 44 mov 0x44(%ebx),%eax 10d9eb: 89 44 24 30 mov %eax,0x30(%esp) if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10d9ef: 83 c4 20 add $0x20,%esp 10d9f2: 5b pop %ebx 10d9f3: 5e pop %esi 10d9f4: 5f pop %edi /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10d9f5: e9 0a 0b 00 00 jmp 10e504 <_Thread_queue_Requeue> 10d9fa: 66 90 xchg %ax,%ax */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 10d9fc: ff 15 a4 b2 12 00 call *0x12b2a4 10da02: eb b4 jmp 10d9b8 <_Thread_Change_priority+0x7c> =============================================================================== 0010dc00 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10dc00: 83 ec 2c sub $0x2c,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10dc03: 8d 44 24 1c lea 0x1c(%esp),%eax 10dc07: 89 44 24 04 mov %eax,0x4(%esp) 10dc0b: 8b 44 24 30 mov 0x30(%esp),%eax 10dc0f: 89 04 24 mov %eax,(%esp) 10dc12: e8 b1 01 00 00 call 10ddc8 <_Thread_Get> switch ( location ) { 10dc17: 8b 54 24 1c mov 0x1c(%esp),%edx 10dc1b: 85 d2 test %edx,%edx 10dc1d: 75 20 jne 10dc3f <_Thread_Delay_ended+0x3f><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10dc1f: c7 44 24 04 18 00 00 movl $0x10000018,0x4(%esp) 10dc26: 10 10dc27: 89 04 24 mov %eax,(%esp) 10dc2a: e8 d5 fd ff ff call 10da04 <_Thread_Clear_state> * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 10dc2f: a1 04 f6 12 00 mov 0x12f604,%eax 10dc34: 48 dec %eax 10dc35: a3 04 f6 12 00 mov %eax,0x12f604 return _Thread_Dispatch_disable_level; 10dc3a: a1 04 f6 12 00 mov 0x12f604,%eax | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10dc3f: 83 c4 2c add $0x2c,%esp 10dc42: c3 ret =============================================================================== 0010dc44 <_Thread_Dispatch>: * INTERRUPT LATENCY: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10dc44: 55 push %ebp 10dc45: 57 push %edi 10dc46: 56 push %esi 10dc47: 53 push %ebx 10dc48: 83 ec 2c sub $0x2c,%esp * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10dc4b: a1 04 f6 12 00 mov 0x12f604,%eax 10dc50: 40 inc %eax 10dc51: a3 04 f6 12 00 mov %eax,0x12f604 return _Thread_Dispatch_disable_level; 10dc56: a1 04 f6 12 00 mov 0x12f604,%eax #endif /* * Now determine if we need to perform a dispatch on the current CPU. */ executing = _Thread_Executing; 10dc5b: 8b 35 6c f8 12 00 mov 0x12f86c,%esi _ISR_Disable( level ); 10dc61: 9c pushf 10dc62: fa cli 10dc63: 58 pop %eax while ( _Thread_Dispatch_necessary == true ) { 10dc64: 8a 15 78 f8 12 00 mov 0x12f878,%dl 10dc6a: 84 d2 test %dl,%dl 10dc6c: 0f 84 16 01 00 00 je 10dd88 <_Thread_Dispatch+0x144> heir = _Thread_Heir; 10dc72: 8b 2d 70 f8 12 00 mov 0x12f870,%ebp _Thread_Dispatch_necessary = false; 10dc78: c6 05 78 f8 12 00 00 movb $0x0,0x12f878 _Thread_Executing = heir; 10dc7f: 89 2d 6c f8 12 00 mov %ebp,0x12f86c /* * When the heir and executing are the same, then we are being * requested to do the post switch dispatching. This is normally * done to dispatch signals. */ if ( heir == executing ) 10dc85: 39 ee cmp %ebp,%esi 10dc87: 0f 84 fb 00 00 00 je 10dd88 <_Thread_Dispatch+0x144> 10dc8d: 8d 7c 24 18 lea 0x18(%esp),%edi 10dc91: e9 da 00 00 00 jmp 10dd70 <_Thread_Dispatch+0x12c> 10dc96: 66 90 xchg %ax,%ax rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) heir->cpu_time_budget = _Thread_Ticks_per_timeslice; _ISR_Enable( level ); 10dc98: 50 push %eax 10dc99: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10dc9a: 89 3c 24 mov %edi,(%esp) 10dc9d: e8 06 33 00 00 call 110fa8 <_TOD_Get_uptime> _Timestamp_Subtract( 10dca2: 8b 44 24 18 mov 0x18(%esp),%eax 10dca6: 8b 54 24 1c mov 0x1c(%esp),%edx const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 10dcaa: 89 c1 mov %eax,%ecx 10dcac: 89 d3 mov %edx,%ebx 10dcae: 2b 0d 7c f8 12 00 sub 0x12f87c,%ecx 10dcb4: 1b 1d 80 f8 12 00 sbb 0x12f880,%ebx static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 10dcba: 01 8e 80 00 00 00 add %ecx,0x80(%esi) 10dcc0: 11 9e 84 00 00 00 adc %ebx,0x84(%esi) &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); _Thread_Time_of_last_context_switch = uptime; 10dcc6: a3 7c f8 12 00 mov %eax,0x12f87c 10dccb: 89 15 80 f8 12 00 mov %edx,0x12f880 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10dcd1: a1 7c f6 12 00 mov 0x12f67c,%eax 10dcd6: 85 c0 test %eax,%eax 10dcd8: 74 10 je 10dcea <_Thread_Dispatch+0xa6> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10dcda: 8b 10 mov (%eax),%edx 10dcdc: 89 96 dc 00 00 00 mov %edx,0xdc(%esi) *_Thread_libc_reent = heir->libc_reent; 10dce2: 8b 95 dc 00 00 00 mov 0xdc(%ebp),%edx 10dce8: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10dcea: 89 6c 24 04 mov %ebp,0x4(%esp) 10dcee: 89 34 24 mov %esi,(%esp) 10dcf1: e8 5e 0c 00 00 call 10e954 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10dcf6: 81 c5 c0 00 00 00 add $0xc0,%ebp 10dcfc: 89 6c 24 04 mov %ebp,0x4(%esp) 10dd00: 8d 86 c0 00 00 00 lea 0xc0(%esi),%eax 10dd06: 89 04 24 mov %eax,(%esp) 10dd09: e8 82 0f 00 00 call 10ec90 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10dd0e: 8b 86 d8 00 00 00 mov 0xd8(%esi),%eax 10dd14: 85 c0 test %eax,%eax 10dd16: 74 2e je 10dd46 <_Thread_Dispatch+0x102> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 10dd18: a1 78 f6 12 00 mov 0x12f678,%eax 10dd1d: 39 c6 cmp %eax,%esi 10dd1f: 74 25 je 10dd46 <_Thread_Dispatch+0x102> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10dd21: 85 c0 test %eax,%eax 10dd23: 74 0d je 10dd32 <_Thread_Dispatch+0xee> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10dd25: 05 d8 00 00 00 add $0xd8,%eax 10dd2a: 89 04 24 mov %eax,(%esp) 10dd2d: e8 92 0f 00 00 call 10ecc4 <_CPU_Context_save_fp> _Context_Restore_fp( &executing->fp_context ); 10dd32: 8d 86 d8 00 00 00 lea 0xd8(%esi),%eax 10dd38: 89 04 24 mov %eax,(%esp) 10dd3b: e8 8e 0f 00 00 call 10ecce <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10dd40: 89 35 78 f6 12 00 mov %esi,0x12f678 if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10dd46: 8b 35 6c f8 12 00 mov 0x12f86c,%esi _ISR_Disable( level ); 10dd4c: 9c pushf 10dd4d: fa cli 10dd4e: 58 pop %eax /* * Now determine if we need to perform a dispatch on the current CPU. */ executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10dd4f: 8a 15 78 f8 12 00 mov 0x12f878,%dl 10dd55: 84 d2 test %dl,%dl 10dd57: 74 2f je 10dd88 <_Thread_Dispatch+0x144> heir = _Thread_Heir; 10dd59: 8b 2d 70 f8 12 00 mov 0x12f870,%ebp _Thread_Dispatch_necessary = false; 10dd5f: c6 05 78 f8 12 00 00 movb $0x0,0x12f878 _Thread_Executing = heir; 10dd66: 89 2d 6c f8 12 00 mov %ebp,0x12f86c /* * When the heir and executing are the same, then we are being * requested to do the post switch dispatching. This is normally * done to dispatch signals. */ if ( heir == executing ) 10dd6c: 39 f5 cmp %esi,%ebp 10dd6e: 74 18 je 10dd88 <_Thread_Dispatch+0x144><== NEVER TAKEN */ #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 10dd70: 83 7d 78 01 cmpl $0x1,0x78(%ebp) 10dd74: 0f 85 1e ff ff ff jne 10dc98 <_Thread_Dispatch+0x54> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10dd7a: 8b 15 d8 f5 12 00 mov 0x12f5d8,%edx 10dd80: 89 55 74 mov %edx,0x74(%ebp) 10dd83: e9 10 ff ff ff jmp 10dc98 <_Thread_Dispatch+0x54> _ISR_Disable( level ); } post_switch: _ISR_Enable( level ); 10dd88: 50 push %eax 10dd89: 9d popf * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 10dd8a: a1 04 f6 12 00 mov 0x12f604,%eax 10dd8f: 48 dec %eax 10dd90: a3 04 f6 12 00 mov %eax,0x12f604 return _Thread_Dispatch_disable_level; 10dd95: a1 04 f6 12 00 mov 0x12f604,%eax _Thread_Unnest_dispatch(); _API_extensions_Run_postswitch(); 10dd9a: e8 9d e4 ff ff call 10c23c <_API_extensions_Run_postswitch> } 10dd9f: 83 c4 2c add $0x2c,%esp 10dda2: 5b pop %ebx 10dda3: 5e pop %esi 10dda4: 5f pop %edi 10dda5: 5d pop %ebp 10dda6: c3 ret =============================================================================== 00112b64 <_Thread_Handler>: * Input parameters: NONE * * Output parameters: NONE */ void _Thread_Handler( void ) { 112b64: 53 push %ebx 112b65: 83 ec 28 sub $0x28,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static bool doneConstructors; bool doCons; #endif executing = _Thread_Executing; 112b68: 8b 1d 6c f8 12 00 mov 0x12f86c,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 112b6e: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax _ISR_Set_level(level); 112b74: 85 c0 test %eax,%eax 112b76: 74 7d je 112bf5 <_Thread_Handler+0x91> 112b78: fa cli doCons = !doneConstructors && _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API; if (doCons) doneConstructors = true; #else doCons = !doneConstructors; 112b79: a0 b4 f2 12 00 mov 0x12f2b4,%al 112b7e: 88 44 24 1f mov %al,0x1f(%esp) doneConstructors = true; 112b82: c6 05 b4 f2 12 00 01 movb $0x1,0x12f2b4 #endif #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 112b89: 8b 93 d8 00 00 00 mov 0xd8(%ebx),%edx 112b8f: 85 d2 test %edx,%edx 112b91: 74 20 je 112bb3 <_Thread_Handler+0x4f> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 112b93: a1 78 f6 12 00 mov 0x12f678,%eax 112b98: 39 c3 cmp %eax,%ebx 112b9a: 74 17 je 112bb3 <_Thread_Handler+0x4f> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 112b9c: 85 c0 test %eax,%eax 112b9e: 74 0d je 112bad <_Thread_Handler+0x49> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 112ba0: 05 d8 00 00 00 add $0xd8,%eax 112ba5: 89 04 24 mov %eax,(%esp) 112ba8: e8 17 c1 ff ff call 10ecc4 <_CPU_Context_save_fp> _Thread_Allocated_fp = executing; 112bad: 89 1d 78 f6 12 00 mov %ebx,0x12f678 /* * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing ); 112bb3: 89 1c 24 mov %ebx,(%esp) 112bb6: e8 1d bc ff ff call 10e7d8 <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 112bbb: e8 e8 b1 ff ff call 10dda8 <_Thread_Enable_dispatch> /* * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (doCons) /* && (volatile void *)_init) */ { 112bc0: 80 7c 24 1f 00 cmpb $0x0,0x1f(%esp) 112bc5: 74 31 je 112bf8 <_Thread_Handler+0x94> _Thread_Enable_dispatch(); #endif } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 112bc7: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax 112bcd: 85 c0 test %eax,%eax 112bcf: 74 2e je 112bff <_Thread_Handler+0x9b> <== ALWAYS TAKEN * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 112bd1: 89 1c 24 mov %ebx,(%esp) 112bd4: e8 33 bc ff ff call 10e80c <_User_extensions_Thread_exitted> _Internal_error_Occurred( 112bd9: c7 44 24 08 05 00 00 movl $0x5,0x8(%esp) 112be0: 00 112be1: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 112be8: 00 112be9: c7 04 24 00 00 00 00 movl $0x0,(%esp) 112bf0: e8 cb 9f ff ff call 10cbc0 <_Internal_error_Occurred> /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; _ISR_Set_level(level); 112bf5: fb sti 112bf6: eb 81 jmp 112b79 <_Thread_Handler+0x15> * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (doCons) /* && (volatile void *)_init) */ { INIT_NAME (); 112bf8: e8 07 cc 00 00 call 11f804 <__start_set_sysctl_set> 112bfd: eb c8 jmp 112bc7 <_Thread_Handler+0x63> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 112bff: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax 112c05: 89 04 24 mov %eax,(%esp) 112c08: ff 93 8c 00 00 00 call *0x8c(%ebx) #endif } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { executing->Wait.return_argument = 112c0e: 89 43 28 mov %eax,0x28(%ebx) 112c11: eb be jmp 112bd1 <_Thread_Handler+0x6d> =============================================================================== 0010e06c <_Thread_Handler_initialization>: * * Output parameters: NONE */ void _Thread_Handler_initialization(void) { 10e06c: 56 push %esi 10e06d: 53 push %ebx 10e06e: 83 ec 24 sub $0x24,%esp uint32_t ticks_per_timeslice = 10e071: 8b 1d 78 b1 12 00 mov 0x12b178,%ebx rtems_configuration_get_ticks_per_timeslice(); uint32_t maximum_extensions = 10e077: 8b 35 6c b1 12 00 mov 0x12b16c,%esi rtems_configuration_get_maximum_extensions(); rtems_stack_allocate_init_hook stack_allocate_init_hook = 10e07d: a1 88 b1 12 00 mov 0x12b188,%eax #if defined(RTEMS_MULTIPROCESSING) uint32_t maximum_proxies = _Configuration_MP_table->maximum_proxies; #endif if ( rtems_configuration_get_stack_allocate_hook() == NULL || 10e082: 8b 0d 8c b1 12 00 mov 0x12b18c,%ecx 10e088: 85 c9 test %ecx,%ecx 10e08a: 0f 84 90 00 00 00 je 10e120 <_Thread_Handler_initialization+0xb4> 10e090: 8b 15 90 b1 12 00 mov 0x12b190,%edx 10e096: 85 d2 test %edx,%edx 10e098: 0f 84 82 00 00 00 je 10e120 <_Thread_Handler_initialization+0xb4><== NEVER TAKEN INTERNAL_ERROR_CORE, true, INTERNAL_ERROR_BAD_STACK_HOOK ); if ( stack_allocate_init_hook != NULL ) 10e09e: 85 c0 test %eax,%eax 10e0a0: 74 0b je 10e0ad <_Thread_Handler_initialization+0x41> (*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() ); 10e0a2: 8b 15 68 b1 12 00 mov 0x12b168,%edx 10e0a8: 89 14 24 mov %edx,(%esp) 10e0ab: ff d0 call *%eax _Thread_Dispatch_necessary = false; 10e0ad: c6 05 78 f8 12 00 00 movb $0x0,0x12f878 _Thread_Executing = NULL; 10e0b4: c7 05 6c f8 12 00 00 movl $0x0,0x12f86c 10e0bb: 00 00 00 _Thread_Heir = NULL; 10e0be: c7 05 70 f8 12 00 00 movl $0x0,0x12f870 10e0c5: 00 00 00 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10e0c8: c7 05 78 f6 12 00 00 movl $0x0,0x12f678 10e0cf: 00 00 00 #endif _Thread_Maximum_extensions = maximum_extensions; 10e0d2: 89 35 80 f6 12 00 mov %esi,0x12f680 _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10e0d8: 89 1d d8 f5 12 00 mov %ebx,0x12f5d8 #if defined(RTEMS_MULTIPROCESSING) if ( _System_state_Is_multiprocessing ) maximum_internal_threads += 1; #endif _Objects_Initialize_information( 10e0de: c7 44 24 18 08 00 00 movl $0x8,0x18(%esp) 10e0e5: 00 10e0e6: c7 44 24 14 00 00 00 movl $0x0,0x14(%esp) 10e0ed: 00 10e0ee: c7 44 24 10 f0 00 00 movl $0xf0,0x10(%esp) 10e0f5: 00 10e0f6: c7 44 24 0c 01 00 00 movl $0x1,0xc(%esp) 10e0fd: 00 10e0fe: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) 10e105: 00 10e106: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10e10d: 00 10e10e: c7 04 24 20 f7 12 00 movl $0x12f720,(%esp) 10e115: e8 6e f0 ff ff call 10d188 <_Objects_Initialize_information> false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10e11a: 83 c4 24 add $0x24,%esp 10e11d: 5b pop %ebx 10e11e: 5e pop %esi 10e11f: c3 ret _Configuration_MP_table->maximum_proxies; #endif if ( rtems_configuration_get_stack_allocate_hook() == NULL || rtems_configuration_get_stack_free_hook() == NULL) _Internal_error_Occurred( 10e120: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp) 10e127: 00 10e128: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10e12f: 00 10e130: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10e137: e8 84 ea ff ff call 10cbc0 <_Internal_error_Occurred> =============================================================================== 0010de48 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10de48: 55 push %ebp 10de49: 57 push %edi 10de4a: 56 push %esi 10de4b: 53 push %ebx 10de4c: 83 ec 2c sub $0x2c,%esp 10de4f: 8b 5c 24 44 mov 0x44(%esp),%ebx 10de53: 8b 74 24 4c mov 0x4c(%esp),%esi 10de57: 0f b6 7c 24 50 movzbl 0x50(%esp),%edi 10de5c: 8a 44 24 58 mov 0x58(%esp),%al 10de60: 88 44 24 1f mov %al,0x1f(%esp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10de64: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 10de6b: 00 00 00 10de6e: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10de75: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10de78: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) 10de7f: 00 00 00 /* * Allocate and Initialize the stack for this thread. */ #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10de82: 89 74 24 04 mov %esi,0x4(%esp) 10de86: 89 1c 24 mov %ebx,(%esp) 10de89: e8 96 07 00 00 call 10e624 <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10de8e: 85 c0 test %eax,%eax 10de90: 0f 84 5a 01 00 00 je 10dff0 <_Thread_Initialize+0x1a8> 10de96: 39 c6 cmp %eax,%esi 10de98: 0f 87 52 01 00 00 ja 10dff0 <_Thread_Initialize+0x1a8><== NEVER TAKEN Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10de9e: 8b 93 bc 00 00 00 mov 0xbc(%ebx),%edx 10dea4: 89 93 b4 00 00 00 mov %edx,0xb4(%ebx) the_stack->size = size; 10deaa: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10deb0: 89 f8 mov %edi,%eax 10deb2: 84 c0 test %al,%al 10deb4: 0f 85 46 01 00 00 jne 10e000 <_Thread_Initialize+0x1b8> extensions_area = NULL; the_thread->libc_reent = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) fp_area = NULL; 10deba: 31 f6 xor %esi,%esi fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10debc: 89 b3 d8 00 00 00 mov %esi,0xd8(%ebx) the_thread->Start.fp_context = fp_area; 10dec2: 89 b3 b8 00 00 00 mov %esi,0xb8(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10dec8: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10decf: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10ded6: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10dedd: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10dee4: a1 80 f6 12 00 mov 0x12f680,%eax 10dee9: 85 c0 test %eax,%eax 10deeb: 0f 85 2f 01 00 00 jne 10e020 <_Thread_Initialize+0x1d8> (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10def1: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10def8: 00 00 00 * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10defb: 31 ed xor %ebp,%ebp /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10defd: 8a 44 24 1f mov 0x1f(%esp),%al 10df01: 88 83 9c 00 00 00 mov %al,0x9c(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10df07: 8b 44 24 5c mov 0x5c(%esp),%eax 10df0b: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) the_thread->Start.budget_callout = budget_callout; 10df11: 8b 44 24 60 mov 0x60(%esp),%eax 10df15: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10df1b: 8b 44 24 64 mov 0x64(%esp),%eax 10df1f: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) the_thread->current_state = STATES_DORMANT; 10df25: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10df2c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10df33: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10df3a: 8b 44 24 54 mov 0x54(%esp),%eax 10df3e: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10df41: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) */ RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate( Thread_Control *the_thread ) { return _Scheduler.Operations.allocate( the_thread ); 10df47: 89 1c 24 mov %ebx,(%esp) 10df4a: ff 15 98 b2 12 00 call *0x12b298 10df50: 89 c7 mov %eax,%edi sched =_Scheduler_Allocate( the_thread ); if ( !sched ) 10df52: 85 c0 test %eax,%eax 10df54: 74 45 je 10df9b <_Thread_Initialize+0x153><== NEVER TAKEN goto failed; _Thread_Set_priority( the_thread, priority ); 10df56: 8b 44 24 54 mov 0x54(%esp),%eax 10df5a: 89 44 24 04 mov %eax,0x4(%esp) 10df5e: 89 1c 24 mov %ebx,(%esp) 10df61: e8 46 06 00 00 call 10e5ac <_Thread_Set_priority> static inline void _Timestamp64_implementation_Set_to_zero( Timestamp64_Control *_time ) { *_time = 0; 10df66: c7 83 80 00 00 00 00 movl $0x0,0x80(%ebx) 10df6d: 00 00 00 10df70: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10df77: 00 00 00 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10df7a: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10df7e: 8b 44 24 40 mov 0x40(%esp),%eax 10df82: 8b 40 1c mov 0x1c(%eax),%eax 10df85: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10df88: 8b 44 24 68 mov 0x68(%esp),%eax 10df8c: 89 43 0c mov %eax,0xc(%ebx) * enabled when we get here. We want to be able to run the * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); 10df8f: 89 1c 24 mov %ebx,(%esp) 10df92: e8 f9 08 00 00 call 10e890 <_User_extensions_Thread_create> if ( extension_status ) 10df97: 84 c0 test %al,%al 10df99: 75 61 jne 10dffc <_Thread_Initialize+0x1b4> return true; failed: _Workspace_Free( the_thread->libc_reent ); 10df9b: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 10dfa1: 89 04 24 mov %eax,(%esp) 10dfa4: e8 7f 0c 00 00 call 10ec28 <_Workspace_Free> for ( i=0 ; i <= THREAD_API_LAST ; i++ ) _Workspace_Free( the_thread->API_Extensions[i] ); 10dfa9: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax 10dfaf: 89 04 24 mov %eax,(%esp) 10dfb2: e8 71 0c 00 00 call 10ec28 <_Workspace_Free> 10dfb7: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 10dfbd: 89 04 24 mov %eax,(%esp) 10dfc0: e8 63 0c 00 00 call 10ec28 <_Workspace_Free> _Workspace_Free( extensions_area ); 10dfc5: 89 2c 24 mov %ebp,(%esp) 10dfc8: e8 5b 0c 00 00 call 10ec28 <_Workspace_Free> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 10dfcd: 89 34 24 mov %esi,(%esp) 10dfd0: e8 53 0c 00 00 call 10ec28 <_Workspace_Free> #endif _Workspace_Free( sched ); 10dfd5: 89 3c 24 mov %edi,(%esp) 10dfd8: e8 4b 0c 00 00 call 10ec28 <_Workspace_Free> _Thread_Stack_Free( the_thread ); 10dfdd: 89 1c 24 mov %ebx,(%esp) 10dfe0: e8 77 06 00 00 call 10e65c <_Thread_Stack_Free> return false; 10dfe5: 31 c0 xor %eax,%eax } 10dfe7: 83 c4 2c add $0x2c,%esp 10dfea: 5b pop %ebx 10dfeb: 5e pop %esi 10dfec: 5f pop %edi 10dfed: 5d pop %ebp 10dfee: c3 ret 10dfef: 90 nop * Allocate and Initialize the stack for this thread. */ #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ 10dff0: 31 c0 xor %eax,%eax _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10dff2: 83 c4 2c add $0x2c,%esp 10dff5: 5b pop %ebx 10dff6: 5e pop %esi 10dff7: 5f pop %edi 10dff8: 5d pop %ebp 10dff9: c3 ret 10dffa: 66 90 xchg %ax,%ax * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; 10dffc: b0 01 mov $0x1,%al 10dffe: eb f2 jmp 10dff2 <_Thread_Initialize+0x1aa> /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10e000: c7 04 24 6c 00 00 00 movl $0x6c,(%esp) 10e007: e8 f0 0b 00 00 call 10ebfc <_Workspace_Allocate> 10e00c: 89 c6 mov %eax,%esi if ( !fp_area ) 10e00e: 85 c0 test %eax,%eax 10e010: 0f 85 a6 fe ff ff jne 10debc <_Thread_Initialize+0x74> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10e016: 31 ed xor %ebp,%ebp size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 10e018: 31 ff xor %edi,%edi 10e01a: e9 7c ff ff ff jmp 10df9b <_Thread_Initialize+0x153> 10e01f: 90 nop /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10e020: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10e027: 89 04 24 mov %eax,(%esp) 10e02a: e8 cd 0b 00 00 call 10ebfc <_Workspace_Allocate> 10e02f: 89 c5 mov %eax,%ebp (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10e031: 85 c0 test %eax,%eax 10e033: 74 30 je 10e065 <_Thread_Initialize+0x21d> goto failed; } the_thread->extensions = (void **) extensions_area; 10e035: 89 83 e8 00 00 00 mov %eax,0xe8(%ebx) 10e03b: 8b 3d 80 f6 12 00 mov 0x12f680,%edi 10e041: 89 c1 mov %eax,%ecx * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10e043: 31 c0 xor %eax,%eax (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10e045: 31 d2 xor %edx,%edx 10e047: eb 09 jmp 10e052 <_Thread_Initialize+0x20a> 10e049: 8d 76 00 lea 0x0(%esi),%esi 10e04c: 8b 8b e8 00 00 00 mov 0xe8(%ebx),%ecx * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) the_thread->extensions[i] = NULL; 10e052: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4) * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10e059: 42 inc %edx 10e05a: 89 d0 mov %edx,%eax 10e05c: 39 fa cmp %edi,%edx 10e05e: 76 ec jbe 10e04c <_Thread_Initialize+0x204> 10e060: e9 98 fe ff ff jmp 10defd <_Thread_Initialize+0xb5> size_t actual_stack_size = 0; void *stack = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) void *fp_area; #endif void *sched = NULL; 10e065: 31 ff xor %edi,%edi 10e067: e9 2f ff ff ff jmp 10df9b <_Thread_Initialize+0x153> =============================================================================== 001116c0 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 1116c0: 83 ec 1c sub $0x1c,%esp 1116c3: 8b 44 24 20 mov 0x20(%esp),%eax Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 1116c7: 8b 50 44 mov 0x44(%eax),%edx * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && 1116ca: 8b 4a 30 mov 0x30(%edx),%ecx 1116cd: 85 c9 test %ecx,%ecx 1116cf: 74 08 je 1116d9 <_Thread_queue_Process_timeout+0x19> 1116d1: 3b 05 6c f8 12 00 cmp 0x12f86c,%eax 1116d7: 74 17 je 1116f0 <_Thread_queue_Process_timeout+0x30><== ALWAYS TAKEN if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 1116d9: 8b 4a 3c mov 0x3c(%edx),%ecx 1116dc: 89 48 34 mov %ecx,0x34(%eax) _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 1116df: 89 44 24 04 mov %eax,0x4(%esp) 1116e3: 89 14 24 mov %edx,(%esp) 1116e6: e8 ed fe ff ff call 1115d8 <_Thread_queue_Extract> } } 1116eb: 83 c4 1c add $0x1c,%esp 1116ee: c3 ret 1116ef: 90 nop * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 1116f0: 83 f9 03 cmp $0x3,%ecx 1116f3: 74 f6 je 1116eb <_Thread_queue_Process_timeout+0x2b> the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 1116f5: 8b 4a 3c mov 0x3c(%edx),%ecx 1116f8: 89 48 34 mov %ecx,0x34(%eax) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 1116fb: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx) 111702: eb e7 jmp 1116eb <_Thread_queue_Process_timeout+0x2b> =============================================================================== 0010e504 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10e504: 56 push %esi 10e505: 53 push %ebx 10e506: 83 ec 24 sub $0x24,%esp 10e509: 8b 5c 24 30 mov 0x30(%esp),%ebx /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10e50d: 85 db test %ebx,%ebx 10e50f: 74 06 je 10e517 <_Thread_queue_Requeue+0x13><== NEVER TAKEN /* * If queueing by FIFO, there is nothing to do. This only applies to * priority blocking discipline. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10e511: 83 7b 34 01 cmpl $0x1,0x34(%ebx) 10e515: 74 09 je 10e520 <_Thread_queue_Requeue+0x1c><== ALWAYS TAKEN _Thread_queue_Extract_priority_helper( tq, the_thread, true ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); } } 10e517: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10e51a: 5b pop %ebx <== NOT EXECUTED 10e51b: 5e pop %esi <== NOT EXECUTED 10e51c: c3 ret <== NOT EXECUTED 10e51d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10e520: 9c pushf 10e521: fa cli 10e522: 5e pop %esi if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10e523: 8b 44 24 34 mov 0x34(%esp),%eax 10e527: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) 10e52e: 75 08 jne 10e538 <_Thread_queue_Requeue+0x34><== ALWAYS TAKEN _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); 10e530: 56 push %esi 10e531: 9d popf } } 10e532: 83 c4 24 add $0x24,%esp 10e535: 5b pop %ebx 10e536: 5e pop %esi 10e537: c3 ret RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10e538: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) ISR_Level level_ignored; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 10e53f: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) 10e546: 00 10e547: 89 44 24 04 mov %eax,0x4(%esp) 10e54b: 89 1c 24 mov %ebx,(%esp) 10e54e: e8 c1 30 00 00 call 111614 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10e553: 8d 44 24 1c lea 0x1c(%esp),%eax 10e557: 89 44 24 08 mov %eax,0x8(%esp) 10e55b: 8b 44 24 34 mov 0x34(%esp),%eax 10e55f: 89 44 24 04 mov %eax,0x4(%esp) 10e563: 89 1c 24 mov %ebx,(%esp) 10e566: e8 81 fd ff ff call 10e2ec <_Thread_queue_Enqueue_priority> 10e56b: eb c3 jmp 10e530 <_Thread_queue_Requeue+0x2c> =============================================================================== 0010e570 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10e570: 83 ec 2c sub $0x2c,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10e573: 8d 44 24 1c lea 0x1c(%esp),%eax 10e577: 89 44 24 04 mov %eax,0x4(%esp) 10e57b: 8b 44 24 30 mov 0x30(%esp),%eax 10e57f: 89 04 24 mov %eax,(%esp) 10e582: e8 41 f8 ff ff call 10ddc8 <_Thread_Get> switch ( location ) { 10e587: 8b 54 24 1c mov 0x1c(%esp),%edx 10e58b: 85 d2 test %edx,%edx 10e58d: 75 18 jne 10e5a7 <_Thread_queue_Timeout+0x37><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10e58f: 89 04 24 mov %eax,(%esp) 10e592: e8 29 31 00 00 call 1116c0 <_Thread_queue_Process_timeout> * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { _Thread_Dispatch_disable_level--; 10e597: a1 04 f6 12 00 mov 0x12f604,%eax 10e59c: 48 dec %eax 10e59d: a3 04 f6 12 00 mov %eax,0x12f604 return _Thread_Dispatch_disable_level; 10e5a2: a1 04 f6 12 00 mov 0x12f604,%eax _Thread_Unnest_dispatch(); break; } } 10e5a7: 83 c4 2c add $0x2c,%esp 10e5aa: c3 ret =============================================================================== 0011bf68 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 11bf68: 55 push %ebp 11bf69: 57 push %edi 11bf6a: 56 push %esi 11bf6b: 53 push %ebx 11bf6c: 83 ec 5c sub $0x5c,%esp 11bf6f: 8b 5c 24 70 mov 0x70(%esp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 11bf73: 8d 4c 24 3c lea 0x3c(%esp),%ecx 11bf77: 89 4c 24 20 mov %ecx,0x20(%esp) 11bf7b: 89 4c 24 38 mov %ecx,0x38(%esp) head->previous = NULL; 11bf7f: c7 44 24 3c 00 00 00 movl $0x0,0x3c(%esp) 11bf86: 00 tail->previous = head; 11bf87: 8d 44 24 38 lea 0x38(%esp),%eax 11bf8b: 89 44 24 40 mov %eax,0x40(%esp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 11bf8f: 8d 7c 24 44 lea 0x44(%esp),%edi 11bf93: 8d 4c 24 48 lea 0x48(%esp),%ecx 11bf97: 89 4c 24 24 mov %ecx,0x24(%esp) 11bf9b: 89 4c 24 44 mov %ecx,0x44(%esp) head->previous = NULL; 11bf9f: c7 44 24 48 00 00 00 movl $0x0,0x48(%esp) 11bfa6: 00 tail->previous = head; 11bfa7: 89 7c 24 4c mov %edi,0x4c(%esp) 11bfab: 8d 6b 30 lea 0x30(%ebx),%ebp 11bfae: 8d 73 68 lea 0x68(%ebx),%esi 11bfb1: 8d 4b 08 lea 0x8(%ebx),%ecx 11bfb4: 89 4c 24 28 mov %ecx,0x28(%esp) 11bfb8: 8d 4b 40 lea 0x40(%ebx),%ecx 11bfbb: 89 4c 24 2c mov %ecx,0x2c(%esp) { /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; 11bfbf: 8d 44 24 38 lea 0x38(%esp),%eax 11bfc3: 89 43 78 mov %eax,0x78(%ebx) 11bfc6: 66 90 xchg %ax,%ax static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 11bfc8: a1 04 db 14 00 mov 0x14db04,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 11bfcd: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 11bfd0: 89 43 3c mov %eax,0x3c(%ebx) _Chain_Initialize_empty( &insert_chain ); _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); 11bfd3: 89 7c 24 08 mov %edi,0x8(%esp) Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 11bfd7: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 11bfd9: 89 44 24 04 mov %eax,0x4(%esp) 11bfdd: 89 2c 24 mov %ebp,(%esp) 11bfe0: e8 9b 3d 00 00 call 11fd80 <_Watchdog_Adjust_to_chain> 11bfe5: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 11bfec: 3b 11bfed: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 11bff4: 00 11bff5: a1 c0 d9 14 00 mov 0x14d9c0,%eax 11bffa: 8b 15 c4 d9 14 00 mov 0x14d9c4,%edx 11c000: 89 04 24 mov %eax,(%esp) 11c003: 89 54 24 04 mov %edx,0x4(%esp) 11c007: e8 38 40 01 00 call 130044 <__divdi3> Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 11c00c: 8b 53 74 mov 0x74(%ebx),%edx /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the watchdogs->Chain to indicate this. */ if ( snapshot > last_snapshot ) { 11c00f: 39 d0 cmp %edx,%eax 11c011: 0f 87 89 00 00 00 ja 11c0a0 <_Timer_server_Body+0x138> * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); } else if ( snapshot < last_snapshot ) { 11c017: 73 1e jae 11c037 <_Timer_server_Body+0xcf> /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; 11c019: 29 c2 sub %eax,%edx _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 11c01b: 89 54 24 08 mov %edx,0x8(%esp) 11c01f: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 11c026: 00 11c027: 89 34 24 mov %esi,(%esp) 11c02a: 89 44 24 1c mov %eax,0x1c(%esp) 11c02e: e8 dd 3c 00 00 call 11fd10 <_Watchdog_Adjust> 11c033: 8b 44 24 1c mov 0x1c(%esp),%eax } watchdogs->last_snapshot = snapshot; 11c037: 89 43 74 mov %eax,0x74(%ebx) 11c03a: 66 90 xchg %ax,%ax } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 11c03c: 8b 43 78 mov 0x78(%ebx),%eax 11c03f: 89 04 24 mov %eax,(%esp) 11c042: e8 95 08 00 00 call 11c8dc <_Chain_Get> if ( timer == NULL ) { 11c047: 85 c0 test %eax,%eax 11c049: 74 2d je 11c078 <_Timer_server_Body+0x110><== ALWAYS TAKEN static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 11c04b: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 11c04e: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 11c051: 74 39 je 11c08c <_Timer_server_Body+0x124><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 11c053: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 11c056: 75 e4 jne 11c03c <_Timer_server_Body+0xd4><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 11c058: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11c05b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 11c05f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 11c062: e8 a1 3d 00 00 call 11fe08 <_Watchdog_Insert> <== NOT EXECUTED } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 11c067: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 11c06a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 11c06d: e8 6a 08 00 00 call 11c8dc <_Chain_Get> <== NOT EXECUTED if ( timer == NULL ) { 11c072: 85 c0 test %eax,%eax <== NOT EXECUTED 11c074: 75 d5 jne 11c04b <_Timer_server_Body+0xe3><== NOT EXECUTED 11c076: 66 90 xchg %ax,%ax <== NOT EXECUTED * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 11c078: 9c pushf 11c079: fa cli 11c07a: 58 pop %eax if ( _Chain_Is_empty( insert_chain ) ) { 11c07b: 8b 4c 24 20 mov 0x20(%esp),%ecx 11c07f: 39 4c 24 38 cmp %ecx,0x38(%esp) 11c083: 74 3c je 11c0c1 <_Timer_server_Body+0x159><== ALWAYS TAKEN ts->insert_chain = NULL; _ISR_Enable( level ); break; } else { _ISR_Enable( level ); 11c085: 50 push %eax <== NOT EXECUTED 11c086: 9d popf <== NOT EXECUTED 11c087: e9 3c ff ff ff jmp 11bfc8 <_Timer_server_Body+0x60><== NOT EXECUTED Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 11c08c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11c08f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 11c093: 89 2c 24 mov %ebp,(%esp) <== NOT EXECUTED 11c096: e8 6d 3d 00 00 call 11fe08 <_Watchdog_Insert> <== NOT EXECUTED 11c09b: eb 9f jmp 11c03c <_Timer_server_Body+0xd4><== NOT EXECUTED 11c09d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Chain_Initialize_empty( &insert_chain ); _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); 11c0a0: 89 7c 24 08 mov %edi,0x8(%esp) if ( snapshot > last_snapshot ) { /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; 11c0a4: 89 c1 mov %eax,%ecx 11c0a6: 29 d1 sub %edx,%ecx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 11c0a8: 89 4c 24 04 mov %ecx,0x4(%esp) 11c0ac: 89 34 24 mov %esi,(%esp) 11c0af: 89 44 24 1c mov %eax,0x1c(%esp) 11c0b3: e8 c8 3c 00 00 call 11fd80 <_Watchdog_Adjust_to_chain> 11c0b8: 8b 44 24 1c mov 0x1c(%esp),%eax 11c0bc: e9 76 ff ff ff jmp 11c037 <_Timer_server_Body+0xcf> */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); if ( _Chain_Is_empty( insert_chain ) ) { ts->insert_chain = NULL; 11c0c1: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) _ISR_Enable( level ); 11c0c8: 50 push %eax 11c0c9: 9d popf _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); if ( !_Chain_Is_empty( &fire_chain ) ) { 11c0ca: 8b 4c 24 24 mov 0x24(%esp),%ecx 11c0ce: 39 4c 24 44 cmp %ecx,0x44(%esp) 11c0d2: 75 26 jne 11c0fa <_Timer_server_Body+0x192> 11c0d4: eb 38 jmp 11c10e <_Timer_server_Body+0x1a6> 11c0d6: 66 90 xchg %ax,%ax Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 11c0d8: 8b 10 mov (%eax),%edx head->next = new_first; 11c0da: 89 54 24 44 mov %edx,0x44(%esp) new_first->previous = head; 11c0de: 89 7a 04 mov %edi,0x4(%edx) * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 11c0e1: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 11c0e8: 51 push %ecx 11c0e9: 9d popf /* * The timer server may block here and wait for resources or time. * The system watchdogs are inactive and will remain inactive since * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); 11c0ea: 8b 50 24 mov 0x24(%eax),%edx 11c0ed: 89 54 24 04 mov %edx,0x4(%esp) 11c0f1: 8b 50 20 mov 0x20(%eax),%edx 11c0f4: 89 14 24 mov %edx,(%esp) 11c0f7: ff 50 1c call *0x1c(%eax) /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 11c0fa: 9c pushf 11c0fb: fa cli 11c0fc: 59 pop %ecx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 11c0fd: 8b 44 24 44 mov 0x44(%esp),%eax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 11c101: 3b 44 24 24 cmp 0x24(%esp),%eax 11c105: 75 d1 jne 11c0d8 <_Timer_server_Body+0x170> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 11c107: 51 push %ecx 11c108: 9d popf 11c109: e9 b1 fe ff ff jmp 11bfbf <_Timer_server_Body+0x57> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 11c10e: c6 43 7c 00 movb $0x0,0x7c(%ebx) * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 11c112: a1 04 da 14 00 mov 0x14da04,%eax 11c117: 40 inc %eax 11c118: a3 04 da 14 00 mov %eax,0x14da04 return _Thread_Dispatch_disable_level; 11c11d: a1 04 da 14 00 mov 0x14da04,%eax /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 11c122: c7 44 24 04 08 00 00 movl $0x8,0x4(%esp) 11c129: 00 11c12a: 8b 03 mov (%ebx),%eax 11c12c: 89 04 24 mov %eax,(%esp) 11c12f: e8 d0 37 00 00 call 11f904 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 11c134: 89 d8 mov %ebx,%eax 11c136: e8 3d fc ff ff call 11bd78 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 11c13b: 89 d8 mov %ebx,%eax 11c13d: e8 7e fc ff ff call 11bdc0 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 11c142: e8 1d 2f 00 00 call 11f064 <_Thread_Enable_dispatch> ts->active = true; 11c147: c6 43 7c 01 movb $0x1,0x7c(%ebx) static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 11c14b: 8b 4c 24 28 mov 0x28(%esp),%ecx 11c14f: 89 0c 24 mov %ecx,(%esp) 11c152: e8 cd 3d 00 00 call 11ff24 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 11c157: 8b 4c 24 2c mov 0x2c(%esp),%ecx 11c15b: 89 0c 24 mov %ecx,(%esp) 11c15e: e8 c1 3d 00 00 call 11ff24 <_Watchdog_Remove> 11c163: e9 57 fe ff ff jmp 11bfbf <_Timer_server_Body+0x57> =============================================================================== 0011be08 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 11be08: 55 push %ebp 11be09: 57 push %edi 11be0a: 56 push %esi 11be0b: 53 push %ebx 11be0c: 83 ec 2c sub $0x2c,%esp 11be0f: 8b 5c 24 40 mov 0x40(%esp),%ebx 11be13: 8b 74 24 44 mov 0x44(%esp),%esi if ( ts->insert_chain == NULL ) { 11be17: 8b 43 78 mov 0x78(%ebx),%eax 11be1a: 85 c0 test %eax,%eax 11be1c: 74 1a je 11be38 <_Timer_server_Schedule_operation_method+0x30><== ALWAYS TAKEN * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 11be1e: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 11be21: 89 74 24 44 mov %esi,0x44(%esp) <== NOT EXECUTED 11be25: 89 44 24 40 mov %eax,0x40(%esp) <== NOT EXECUTED } } 11be29: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 11be2c: 5b pop %ebx <== NOT EXECUTED 11be2d: 5e pop %esi <== NOT EXECUTED 11be2e: 5f pop %edi <== NOT EXECUTED 11be2f: 5d pop %ebp <== NOT EXECUTED * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 11be30: e9 83 0a 00 00 jmp 11c8b8 <_Chain_Append> <== NOT EXECUTED 11be35: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 11be38: a1 04 da 14 00 mov 0x14da04,%eax 11be3d: 40 inc %eax 11be3e: a3 04 da 14 00 mov %eax,0x14da04 return _Thread_Dispatch_disable_level; 11be43: a1 04 da 14 00 mov 0x14da04,%eax * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 11be48: 8b 46 38 mov 0x38(%esi),%eax 11be4b: 83 f8 01 cmp $0x1,%eax 11be4e: 0f 84 a8 00 00 00 je 11befc <_Timer_server_Schedule_operation_method+0xf4> _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); if ( !ts->active ) { _Timer_server_Reset_interval_system_watchdog( ts ); } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 11be54: 83 f8 03 cmp $0x3,%eax 11be57: 74 0f je 11be68 <_Timer_server_Schedule_operation_method+0x60> * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); } } 11be59: 83 c4 2c add $0x2c,%esp 11be5c: 5b pop %ebx 11be5d: 5e pop %esi 11be5e: 5f pop %edi 11be5f: 5d pop %ebp if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 11be60: e9 ff 31 00 00 jmp 11f064 <_Thread_Enable_dispatch> 11be65: 8d 76 00 lea 0x0(%esi),%esi } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 11be68: 9c pushf 11be69: fa cli 11be6a: 5f pop %edi 11be6b: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 11be72: 3b 11be73: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 11be7a: 00 11be7b: a1 c0 d9 14 00 mov 0x14d9c0,%eax 11be80: 8b 15 c4 d9 14 00 mov 0x14d9c4,%edx 11be86: 89 04 24 mov %eax,(%esp) 11be89: 89 54 24 04 mov %edx,0x4(%esp) 11be8d: e8 b2 41 01 00 call 130044 <__divdi3> snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); last_snapshot = ts->TOD_watchdogs.last_snapshot; 11be92: 8b 53 74 mov 0x74(%ebx),%edx 11be95: 89 54 24 1c mov %edx,0x1c(%esp) */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 11be99: 8b 53 68 mov 0x68(%ebx),%edx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 11be9c: 8d 6b 6c lea 0x6c(%ebx),%ebp if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 11be9f: 39 ea cmp %ebp,%edx 11bea1: 74 28 je 11becb <_Timer_server_Schedule_operation_method+0xc3> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 11bea3: 8b 6a 10 mov 0x10(%edx),%ebp if ( snapshot > last_snapshot ) { 11bea6: 3b 44 24 1c cmp 0x1c(%esp),%eax 11beaa: 0f 86 a4 00 00 00 jbe 11bf54 <_Timer_server_Schedule_operation_method+0x14c> /* * We advanced in time. */ delta = snapshot - last_snapshot; 11beb0: 89 c1 mov %eax,%ecx 11beb2: 2b 4c 24 1c sub 0x1c(%esp),%ecx 11beb6: 89 4c 24 1c mov %ecx,0x1c(%esp) if (delta_interval > delta) { 11beba: 39 cd cmp %ecx,%ebp 11bebc: 0f 86 9f 00 00 00 jbe 11bf61 <_Timer_server_Schedule_operation_method+0x159><== NEVER TAKEN delta_interval -= delta; 11bec2: 89 e9 mov %ebp,%ecx 11bec4: 2b 4c 24 1c sub 0x1c(%esp),%ecx * Someone put us in the past. */ delta = last_snapshot - snapshot; delta_interval += delta; } first_watchdog->delta_interval = delta_interval; 11bec8: 89 4a 10 mov %ecx,0x10(%edx) } ts->TOD_watchdogs.last_snapshot = snapshot; 11becb: 89 43 74 mov %eax,0x74(%ebx) _ISR_Enable( level ); 11bece: 57 push %edi 11becf: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 11bed0: 83 c6 10 add $0x10,%esi 11bed3: 89 74 24 04 mov %esi,0x4(%esp) 11bed7: 8d 43 68 lea 0x68(%ebx),%eax 11beda: 89 04 24 mov %eax,(%esp) 11bedd: e8 26 3f 00 00 call 11fe08 <_Watchdog_Insert> if ( !ts->active ) { 11bee2: 8a 43 7c mov 0x7c(%ebx),%al 11bee5: 84 c0 test %al,%al 11bee7: 0f 85 6c ff ff ff jne 11be59 <_Timer_server_Schedule_operation_method+0x51> _Timer_server_Reset_tod_system_watchdog( ts ); 11beed: 89 d8 mov %ebx,%eax 11beef: e8 cc fe ff ff call 11bdc0 <_Timer_server_Reset_tod_system_watchdog> 11bef4: e9 60 ff ff ff jmp 11be59 <_Timer_server_Schedule_operation_method+0x51> 11bef9: 8d 76 00 lea 0x0(%esi),%esi if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 11befc: 9c pushf 11befd: fa cli 11befe: 5d pop %ebp snapshot = _Watchdog_Ticks_since_boot; 11beff: 8b 15 04 db 14 00 mov 0x14db04,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 11bf05: 8b 7b 3c mov 0x3c(%ebx),%edi */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 11bf08: 8b 43 30 mov 0x30(%ebx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 11bf0b: 8d 4b 34 lea 0x34(%ebx),%ecx if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 11bf0e: 39 c8 cmp %ecx,%eax 11bf10: 74 10 je 11bf22 <_Timer_server_Schedule_operation_method+0x11a> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 11bf12: 89 d1 mov %edx,%ecx 11bf14: 29 f9 sub %edi,%ecx delta_interval = first_watchdog->delta_interval; 11bf16: 8b 78 10 mov 0x10(%eax),%edi if (delta_interval > delta) { 11bf19: 39 f9 cmp %edi,%ecx 11bf1b: 73 33 jae 11bf50 <_Timer_server_Schedule_operation_method+0x148> delta_interval -= delta; 11bf1d: 29 cf sub %ecx,%edi } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 11bf1f: 89 78 10 mov %edi,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 11bf22: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 11bf25: 55 push %ebp 11bf26: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 11bf27: 83 c6 10 add $0x10,%esi 11bf2a: 89 74 24 04 mov %esi,0x4(%esp) 11bf2e: 8d 43 30 lea 0x30(%ebx),%eax 11bf31: 89 04 24 mov %eax,(%esp) 11bf34: e8 cf 3e 00 00 call 11fe08 <_Watchdog_Insert> if ( !ts->active ) { 11bf39: 8a 43 7c mov 0x7c(%ebx),%al 11bf3c: 84 c0 test %al,%al 11bf3e: 0f 85 15 ff ff ff jne 11be59 <_Timer_server_Schedule_operation_method+0x51> _Timer_server_Reset_interval_system_watchdog( ts ); 11bf44: 89 d8 mov %ebx,%eax 11bf46: e8 2d fe ff ff call 11bd78 <_Timer_server_Reset_interval_system_watchdog> 11bf4b: e9 09 ff ff ff jmp 11be59 <_Timer_server_Schedule_operation_method+0x51> delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 11bf50: 31 ff xor %edi,%edi 11bf52: eb cb jmp 11bf1f <_Timer_server_Schedule_operation_method+0x117> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 11bf54: 8b 4c 24 1c mov 0x1c(%esp),%ecx 11bf58: 01 e9 add %ebp,%ecx delta_interval += delta; 11bf5a: 29 c1 sub %eax,%ecx 11bf5c: e9 67 ff ff ff jmp 11bec8 <_Timer_server_Schedule_operation_method+0xc0> */ delta = snapshot - last_snapshot; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 11bf61: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 11bf63: e9 60 ff ff ff jmp 11bec8 <_Timer_server_Schedule_operation_method+0xc0><== NOT EXECUTED =============================================================================== 0010ec00 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 10ec00: 56 push %esi 10ec01: 53 push %ebx 10ec02: 8b 74 24 0c mov 0xc(%esp),%esi 10ec06: 8b 4c 24 10 mov 0x10(%esp),%ecx uint32_t seconds = add->tv_sec; 10ec0a: 8b 01 mov (%ecx),%eax /* Add the basics */ time->tv_sec += add->tv_sec; 10ec0c: 01 06 add %eax,(%esi) time->tv_nsec += add->tv_nsec; 10ec0e: 8b 56 04 mov 0x4(%esi),%edx 10ec11: 03 51 04 add 0x4(%ecx),%edx 10ec14: 89 56 04 mov %edx,0x4(%esi) /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10ec17: 81 fa ff c9 9a 3b cmp $0x3b9ac9ff,%edx 10ec1d: 76 1c jbe 10ec3b <_Timespec_Add_to+0x3b> 10ec1f: 8b 0e mov (%esi),%ecx 10ec21: 41 inc %ecx * * This routines adds two timespecs. The second argument is added * to the first. */ uint32_t _Timespec_Add_to( 10ec22: 29 c1 sub %eax,%ecx time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10ec24: 81 ea 00 ca 9a 3b sub $0x3b9aca00,%edx * * This routines adds two timespecs. The second argument is added * to the first. */ uint32_t _Timespec_Add_to( 10ec2a: 8d 1c 01 lea (%ecx,%eax,1),%ebx /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; time->tv_sec++; seconds++; 10ec2d: 40 inc %eax /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10ec2e: 81 fa ff c9 9a 3b cmp $0x3b9ac9ff,%edx 10ec34: 77 ee ja 10ec24 <_Timespec_Add_to+0x24> <== NEVER TAKEN 10ec36: 89 56 04 mov %edx,0x4(%esi) 10ec39: 89 1e mov %ebx,(%esi) time->tv_sec++; seconds++; } return seconds; } 10ec3b: 5b pop %ebx 10ec3c: 5e pop %esi 10ec3d: c3 ret =============================================================================== 0010fd90 <_Timestamp64_Divide>: const Timestamp64_Control *_lhs, const Timestamp64_Control *_rhs, uint32_t *_ival_percentage, uint32_t *_fval_percentage ) { 10fd90: 57 push %edi 10fd91: 56 push %esi 10fd92: 53 push %ebx 10fd93: 83 ec 10 sub $0x10,%esp 10fd96: 8b 54 24 20 mov 0x20(%esp),%edx 10fd9a: 8b 44 24 24 mov 0x24(%esp),%eax Timestamp64_Control answer; if ( *_rhs == 0 ) { 10fd9e: 8b 18 mov (%eax),%ebx 10fda0: 8b 48 04 mov 0x4(%eax),%ecx 10fda3: 89 c8 mov %ecx,%eax 10fda5: 09 d8 or %ebx,%eax 10fda7: 74 73 je 10fe1c <_Timestamp64_Divide+0x8c><== NEVER TAKEN * This looks odd but gives the results the proper precision. * * TODO: Rounding on the last digit of the fval. */ answer = (*_lhs * 100000) / *_rhs; 10fda9: 69 72 04 a0 86 01 00 imul $0x186a0,0x4(%edx),%esi 10fdb0: b8 a0 86 01 00 mov $0x186a0,%eax 10fdb5: f7 22 mull (%edx) 10fdb7: 01 f2 add %esi,%edx 10fdb9: 89 5c 24 08 mov %ebx,0x8(%esp) 10fdbd: 89 4c 24 0c mov %ecx,0xc(%esp) 10fdc1: 89 04 24 mov %eax,(%esp) 10fdc4: 89 54 24 04 mov %edx,0x4(%esp) 10fdc8: e8 db 0d 01 00 call 120ba8 <__divdi3> 10fdcd: 89 c6 mov %eax,%esi 10fdcf: 89 d7 mov %edx,%edi *_ival_percentage = answer / 1000; 10fdd1: c7 44 24 08 e8 03 00 movl $0x3e8,0x8(%esp) 10fdd8: 00 10fdd9: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 10fde0: 00 10fde1: 89 04 24 mov %eax,(%esp) 10fde4: 89 54 24 04 mov %edx,0x4(%esp) 10fde8: e8 bb 0d 01 00 call 120ba8 <__divdi3> 10fded: 8b 4c 24 28 mov 0x28(%esp),%ecx 10fdf1: 89 01 mov %eax,(%ecx) *_fval_percentage = answer % 1000; 10fdf3: c7 44 24 08 e8 03 00 movl $0x3e8,0x8(%esp) 10fdfa: 00 10fdfb: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 10fe02: 00 10fe03: 89 34 24 mov %esi,(%esp) 10fe06: 89 7c 24 04 mov %edi,0x4(%esp) 10fe0a: e8 ed 0e 01 00 call 120cfc <__moddi3> 10fe0f: 8b 4c 24 2c mov 0x2c(%esp),%ecx 10fe13: 89 01 mov %eax,(%ecx) } 10fe15: 83 c4 10 add $0x10,%esp 10fe18: 5b pop %ebx 10fe19: 5e pop %esi 10fe1a: 5f pop %edi 10fe1b: c3 ret ) { Timestamp64_Control answer; if ( *_rhs == 0 ) { *_ival_percentage = 0; 10fe1c: 8b 4c 24 28 mov 0x28(%esp),%ecx <== NOT EXECUTED 10fe20: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED *_fval_percentage = 0; 10fe26: 8b 4c 24 2c mov 0x2c(%esp),%ecx <== NOT EXECUTED 10fe2a: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED answer = (*_lhs * 100000) / *_rhs; *_ival_percentage = answer / 1000; *_fval_percentage = answer % 1000; } 10fe30: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fe33: 5b pop %ebx <== NOT EXECUTED 10fe34: 5e pop %esi <== NOT EXECUTED 10fe35: 5f pop %edi <== NOT EXECUTED 10fe36: c3 ret <== NOT EXECUTED =============================================================================== 0010e844 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10e844: 55 push %ebp 10e845: 57 push %edi 10e846: 56 push %esi 10e847: 53 push %ebx 10e848: 83 ec 1c sub $0x1c,%esp 10e84b: 8b 74 24 30 mov 0x30(%esp),%esi 10e84f: 8b 7c 24 38 mov 0x38(%esp),%edi 10e853: 8a 44 24 34 mov 0x34(%esp),%al 10e857: 8b 1d f4 f7 12 00 mov 0x12f7f4,%ebx Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e85d: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx 10e863: 74 22 je 10e887 <_User_extensions_Fatal+0x43><== NEVER TAKEN the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10e865: 0f b6 e8 movzbl %al,%ebp !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 10e868: 8b 43 30 mov 0x30(%ebx),%eax 10e86b: 85 c0 test %eax,%eax 10e86d: 74 0d je 10e87c <_User_extensions_Fatal+0x38> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10e86f: 89 7c 24 08 mov %edi,0x8(%esp) 10e873: 89 6c 24 04 mov %ebp,0x4(%esp) 10e877: 89 34 24 mov %esi,(%esp) 10e87a: ff d0 call *%eax Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10e87c: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e87f: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx 10e885: 75 e1 jne 10e868 <_User_extensions_Fatal+0x24> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10e887: 83 c4 1c add $0x1c,%esp 10e88a: 5b pop %ebx 10e88b: 5e pop %esi 10e88c: 5f pop %edi 10e88d: 5d pop %ebp 10e88e: c3 ret =============================================================================== 0010e728 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10e728: 55 push %ebp 10e729: 57 push %edi 10e72a: 56 push %esi 10e72b: 53 push %ebx 10e72c: 83 ec 2c sub $0x2c,%esp User_extensions_Control *extension; uint32_t i; uint32_t number_of_extensions; User_extensions_Table *initial_extensions; number_of_extensions = Configuration.number_of_initial_extensions; 10e72f: 8b 15 a4 b1 12 00 mov 0x12b1a4,%edx 10e735: 89 54 24 1c mov %edx,0x1c(%esp) initial_extensions = Configuration.User_extension_table; 10e739: 8b 2d a8 b1 12 00 mov 0x12b1a8,%ebp ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10e73f: c7 05 ec f7 12 00 f0 movl $0x12f7f0,0x12f7ec 10e746: f7 12 00 head->previous = NULL; 10e749: c7 05 f0 f7 12 00 00 movl $0x0,0x12f7f0 10e750: 00 00 00 tail->previous = head; 10e753: c7 05 f4 f7 12 00 ec movl $0x12f7ec,0x12f7f4 10e75a: f7 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10e75d: c7 05 08 f6 12 00 0c movl $0x12f60c,0x12f608 10e764: f6 12 00 head->previous = NULL; 10e767: c7 05 0c f6 12 00 00 movl $0x0,0x12f60c 10e76e: 00 00 00 tail->previous = head; 10e771: c7 05 10 f6 12 00 08 movl $0x12f608,0x12f610 10e778: f6 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10e77b: 85 ed test %ebp,%ebp 10e77d: 74 4e je 10e7cd <_User_extensions_Handler_initialization+0xa5><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10e77f: 8d 04 52 lea (%edx,%edx,2),%eax 10e782: 8d 34 82 lea (%edx,%eax,4),%esi 10e785: c1 e6 02 shl $0x2,%esi _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { extension = (User_extensions_Control *) 10e788: 89 34 24 mov %esi,(%esp) 10e78b: e8 b4 04 00 00 call 10ec44 <_Workspace_Allocate_or_fatal_error> 10e790: 89 c3 mov %eax,%ebx _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10e792: 31 c0 xor %eax,%eax 10e794: 89 df mov %ebx,%edi 10e796: 89 f1 mov %esi,%ecx 10e798: f3 aa rep stos %al,%es:(%edi) extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10e79a: 8b 44 24 1c mov 0x1c(%esp),%eax 10e79e: 85 c0 test %eax,%eax 10e7a0: 74 2b je 10e7cd <_User_extensions_Handler_initialization+0xa5><== NEVER TAKEN 10e7a2: 89 6c 24 18 mov %ebp,0x18(%esp) 10e7a6: 31 ed xor %ebp,%ebp RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 10e7a8: 8d 7b 14 lea 0x14(%ebx),%edi 10e7ab: 8b 74 24 18 mov 0x18(%esp),%esi 10e7af: b9 08 00 00 00 mov $0x8,%ecx 10e7b4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10e7b6: 89 1c 24 mov %ebx,(%esp) 10e7b9: e8 6a 2f 00 00 call 111728 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10e7be: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10e7c1: 45 inc %ebp 10e7c2: 83 44 24 18 20 addl $0x20,0x18(%esp) 10e7c7: 3b 6c 24 1c cmp 0x1c(%esp),%ebp 10e7cb: 75 db jne 10e7a8 <_User_extensions_Handler_initialization+0x80> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10e7cd: 83 c4 2c add $0x2c,%esp 10e7d0: 5b pop %ebx 10e7d1: 5e pop %esi 10e7d2: 5f pop %edi 10e7d3: 5d pop %ebp 10e7d4: c3 ret =============================================================================== 0010e7d8 <_User_extensions_Thread_begin>: #include void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10e7d8: 56 push %esi 10e7d9: 53 push %ebx 10e7da: 83 ec 14 sub $0x14,%esp 10e7dd: 8b 74 24 20 mov 0x20(%esp),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10e7e1: 8b 1d ec f7 12 00 mov 0x12f7ec,%ebx Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e7e7: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx 10e7ed: 74 17 je 10e806 <_User_extensions_Thread_begin+0x2e><== NEVER TAKEN 10e7ef: 90 nop !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) 10e7f0: 8b 43 28 mov 0x28(%ebx),%eax 10e7f3: 85 c0 test %eax,%eax 10e7f5: 74 05 je 10e7fc <_User_extensions_Thread_begin+0x24> (*the_extension->Callouts.thread_begin)( executing ); 10e7f7: 89 34 24 mov %esi,(%esp) 10e7fa: ff d0 call *%eax Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10e7fc: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e7fe: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx 10e804: 75 ea jne 10e7f0 <_User_extensions_Thread_begin+0x18> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) (*the_extension->Callouts.thread_begin)( executing ); } } 10e806: 83 c4 14 add $0x14,%esp 10e809: 5b pop %ebx 10e80a: 5e pop %esi 10e80b: c3 ret =============================================================================== 0010e890 <_User_extensions_Thread_create>: #include bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10e890: 56 push %esi 10e891: 53 push %ebx 10e892: 83 ec 14 sub $0x14,%esp 10e895: 8b 74 24 20 mov 0x20(%esp),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10e899: 8b 1d ec f7 12 00 mov 0x12f7ec,%ebx Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10e89f: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx 10e8a5: 74 25 je 10e8cc <_User_extensions_Thread_create+0x3c><== NEVER TAKEN 10e8a7: 90 nop !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 10e8a8: 8b 43 14 mov 0x14(%ebx),%eax 10e8ab: 85 c0 test %eax,%eax 10e8ad: 74 13 je 10e8c2 <_User_extensions_Thread_create+0x32> status = (*the_extension->Callouts.thread_create)( 10e8af: 89 74 24 04 mov %esi,0x4(%esp) 10e8b3: 8b 15 6c f8 12 00 mov 0x12f86c,%edx 10e8b9: 89 14 24 mov %edx,(%esp) 10e8bc: ff d0 call *%eax _Thread_Executing, the_thread ); if ( !status ) 10e8be: 84 c0 test %al,%al 10e8c0: 74 0c je 10e8ce <_User_extensions_Thread_create+0x3e> User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10e8c2: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10e8c4: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx 10e8ca: 75 dc jne 10e8a8 <_User_extensions_Thread_create+0x18> if ( !status ) return false; } } return true; 10e8cc: b0 01 mov $0x1,%al } 10e8ce: 83 c4 14 add $0x14,%esp 10e8d1: 5b pop %ebx 10e8d2: 5e pop %esi 10e8d3: c3 ret =============================================================================== 0010e8d4 <_User_extensions_Thread_delete>: #include void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10e8d4: 56 push %esi 10e8d5: 53 push %ebx 10e8d6: 83 ec 14 sub $0x14,%esp 10e8d9: 8b 74 24 20 mov 0x20(%esp),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 10e8dd: 8b 1d f4 f7 12 00 mov 0x12f7f4,%ebx Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e8e3: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx 10e8e9: 74 22 je 10e90d <_User_extensions_Thread_delete+0x39><== NEVER TAKEN 10e8eb: 90 nop !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) 10e8ec: 8b 43 20 mov 0x20(%ebx),%eax 10e8ef: 85 c0 test %eax,%eax 10e8f1: 74 0f je 10e902 <_User_extensions_Thread_delete+0x2e> (*the_extension->Callouts.thread_delete)( 10e8f3: 89 74 24 04 mov %esi,0x4(%esp) 10e8f7: 8b 15 6c f8 12 00 mov 0x12f86c,%edx 10e8fd: 89 14 24 mov %edx,(%esp) 10e900: ff d0 call *%eax Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10e902: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e905: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx 10e90b: 75 df jne 10e8ec <_User_extensions_Thread_delete+0x18> (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10e90d: 83 c4 14 add $0x14,%esp 10e910: 5b pop %ebx 10e911: 5e pop %esi 10e912: c3 ret =============================================================================== 0010e80c <_User_extensions_Thread_exitted>: void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10e80c: 56 push %esi 10e80d: 53 push %ebx 10e80e: 83 ec 14 sub $0x14,%esp 10e811: 8b 74 24 20 mov 0x20(%esp),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 10e815: 8b 1d f4 f7 12 00 mov 0x12f7f4,%ebx Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e81b: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx 10e821: 74 18 je 10e83b <_User_extensions_Thread_exitted+0x2f><== NEVER TAKEN 10e823: 90 nop !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 10e824: 8b 43 2c mov 0x2c(%ebx),%eax 10e827: 85 c0 test %eax,%eax 10e829: 74 05 je 10e830 <_User_extensions_Thread_exitted+0x24> (*the_extension->Callouts.thread_exitted)( executing ); 10e82b: 89 34 24 mov %esi,(%esp) 10e82e: ff d0 call *%eax Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10e830: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10e833: 81 fb ec f7 12 00 cmp $0x12f7ec,%ebx 10e839: 75 e9 jne 10e824 <_User_extensions_Thread_exitted+0x18> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) (*the_extension->Callouts.thread_exitted)( executing ); } } 10e83b: 83 c4 14 add $0x14,%esp 10e83e: 5b pop %ebx 10e83f: 5e pop %esi 10e840: c3 ret =============================================================================== 0010f114 <_User_extensions_Thread_restart>: #include void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10f114: 56 push %esi 10f115: 53 push %ebx 10f116: 83 ec 14 sub $0x14,%esp 10f119: 8b 74 24 20 mov 0x20(%esp),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10f11d: 8b 1d 2c 08 13 00 mov 0x13082c,%ebx Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10f123: 81 fb 30 08 13 00 cmp $0x130830,%ebx 10f129: 74 21 je 10f14c <_User_extensions_Thread_restart+0x38><== NEVER TAKEN 10f12b: 90 nop !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) 10f12c: 8b 43 1c mov 0x1c(%ebx),%eax 10f12f: 85 c0 test %eax,%eax 10f131: 74 0f je 10f142 <_User_extensions_Thread_restart+0x2e> (*the_extension->Callouts.thread_restart)( 10f133: 89 74 24 04 mov %esi,0x4(%esp) 10f137: 8b 15 ac 08 13 00 mov 0x1308ac,%edx 10f13d: 89 14 24 mov %edx,(%esp) 10f140: ff d0 call *%eax Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10f142: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10f144: 81 fb 30 08 13 00 cmp $0x130830,%ebx 10f14a: 75 e0 jne 10f12c <_User_extensions_Thread_restart+0x18> (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10f14c: 83 c4 14 add $0x14,%esp 10f14f: 5b pop %ebx 10f150: 5e pop %esi 10f151: c3 ret =============================================================================== 0010e914 <_User_extensions_Thread_start>: #include void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10e914: 56 push %esi 10e915: 53 push %ebx 10e916: 83 ec 14 sub $0x14,%esp 10e919: 8b 74 24 20 mov 0x20(%esp),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10e91d: 8b 1d ec f7 12 00 mov 0x12f7ec,%ebx Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e923: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx 10e929: 74 21 je 10e94c <_User_extensions_Thread_start+0x38><== NEVER TAKEN 10e92b: 90 nop !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) 10e92c: 8b 43 18 mov 0x18(%ebx),%eax 10e92f: 85 c0 test %eax,%eax 10e931: 74 0f je 10e942 <_User_extensions_Thread_start+0x2e> (*the_extension->Callouts.thread_start)( 10e933: 89 74 24 04 mov %esi,0x4(%esp) 10e937: 8b 15 6c f8 12 00 mov 0x12f86c,%edx 10e93d: 89 14 24 mov %edx,(%esp) 10e940: ff d0 call *%eax Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10e942: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e944: 81 fb f0 f7 12 00 cmp $0x12f7f0,%ebx 10e94a: 75 e0 jne 10e92c <_User_extensions_Thread_start+0x18> (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10e94c: 83 c4 14 add $0x14,%esp 10e94f: 5b pop %ebx 10e950: 5e pop %esi 10e951: c3 ret =============================================================================== 0010e954 <_User_extensions_Thread_switch>: void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10e954: 57 push %edi 10e955: 56 push %esi 10e956: 53 push %ebx 10e957: 83 ec 10 sub $0x10,%esp 10e95a: 8b 7c 24 20 mov 0x20(%esp),%edi 10e95e: 8b 74 24 24 mov 0x24(%esp),%esi 10e962: 8b 1d 08 f6 12 00 mov 0x12f608,%ebx Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 10e968: 81 fb 0c f6 12 00 cmp $0x12f60c,%ebx 10e96e: 74 14 je 10e984 <_User_extensions_Thread_switch+0x30><== NEVER TAKEN !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); 10e970: 89 74 24 04 mov %esi,0x4(%esp) 10e974: 89 3c 24 mov %edi,(%esp) 10e977: ff 53 08 call *0x8(%ebx) Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { 10e97a: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 10e97c: 81 fb 0c f6 12 00 cmp $0x12f60c,%ebx 10e982: 75 ec jne 10e970 <_User_extensions_Thread_switch+0x1c> the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10e984: 83 c4 10 add $0x10,%esp 10e987: 5b pop %ebx 10e988: 5e pop %esi 10e989: 5f pop %edi 10e98a: c3 ret =============================================================================== 001100d8 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 1100d8: 57 push %edi 1100d9: 56 push %esi 1100da: 53 push %ebx 1100db: 83 ec 10 sub $0x10,%esp 1100de: 8b 74 24 20 mov 0x20(%esp),%esi 1100e2: 8b 4c 24 24 mov 0x24(%esp),%ecx 1100e6: 8b 5c 24 28 mov 0x28(%esp),%ebx ISR_Level level; _ISR_Disable( level ); 1100ea: 9c pushf 1100eb: fa cli 1100ec: 5a pop %edx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 1100ed: 8b 06 mov (%esi),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 1100ef: 8d 7e 04 lea 0x4(%esi),%edi * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 1100f2: 39 f8 cmp %edi,%eax 1100f4: 74 39 je 11012f <_Watchdog_Adjust+0x57> switch ( direction ) { 1100f6: 85 c9 test %ecx,%ecx 1100f8: 75 3e jne 110138 <_Watchdog_Adjust+0x60> case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 1100fa: 85 db test %ebx,%ebx 1100fc: 74 31 je 11012f <_Watchdog_Adjust+0x57> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 1100fe: 8b 48 10 mov 0x10(%eax),%ecx 110101: 39 cb cmp %ecx,%ebx 110103: 73 0e jae 110113 <_Watchdog_Adjust+0x3b> <== ALWAYS TAKEN 110105: eb 39 jmp 110140 <_Watchdog_Adjust+0x68> <== NOT EXECUTED 110107: 90 nop <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 110108: 85 db test %ebx,%ebx 11010a: 74 23 je 11012f <_Watchdog_Adjust+0x57> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 11010c: 8b 48 10 mov 0x10(%eax),%ecx 11010f: 39 d9 cmp %ebx,%ecx 110111: 77 2d ja 110140 <_Watchdog_Adjust+0x68> _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; 110113: 29 cb sub %ecx,%ebx _Watchdog_First( header )->delta_interval = 1; 110115: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) _ISR_Enable( level ); 11011c: 52 push %edx 11011d: 9d popf _Watchdog_Tickle( header ); 11011e: 89 34 24 mov %esi,(%esp) 110121: e8 aa 01 00 00 call 1102d0 <_Watchdog_Tickle> _ISR_Disable( level ); 110126: 9c pushf 110127: fa cli 110128: 5a pop %edx */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 110129: 8b 06 mov (%esi),%eax if ( _Chain_Is_empty( header ) ) 11012b: 39 c7 cmp %eax,%edi 11012d: 75 d9 jne 110108 <_Watchdog_Adjust+0x30> } break; } } _ISR_Enable( level ); 11012f: 52 push %edx 110130: 9d popf } 110131: 83 c4 10 add $0x10,%esp 110134: 5b pop %ebx 110135: 5e pop %esi 110136: 5f pop %edi 110137: c3 ret * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 110138: 49 dec %ecx 110139: 75 f4 jne 11012f <_Watchdog_Adjust+0x57> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 11013b: 01 58 10 add %ebx,0x10(%eax) break; 11013e: eb ef jmp 11012f <_Watchdog_Adjust+0x57> case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 110140: 29 d9 sub %ebx,%ecx 110142: 89 48 10 mov %ecx,0x10(%eax) break; 110145: eb e8 jmp 11012f <_Watchdog_Adjust+0x57> =============================================================================== 0010eaa8 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10eaa8: 56 push %esi 10eaa9: 53 push %ebx 10eaaa: 8b 54 24 0c mov 0xc(%esp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10eaae: 9c pushf 10eaaf: fa cli 10eab0: 59 pop %ecx previous_state = the_watchdog->state; 10eab1: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10eab4: 83 f8 01 cmp $0x1,%eax 10eab7: 74 4f je 10eb08 <_Watchdog_Remove+0x60> 10eab9: 73 11 jae 10eacc <_Watchdog_Remove+0x24> _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10eabb: 8b 1d 04 f7 12 00 mov 0x12f704,%ebx 10eac1: 89 5a 18 mov %ebx,0x18(%edx) _ISR_Enable( level ); 10eac4: 51 push %ecx 10eac5: 9d popf return( previous_state ); } 10eac6: 5b pop %ebx 10eac7: 5e pop %esi 10eac8: c3 ret 10eac9: 8d 76 00 lea 0x0(%esi),%esi Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 10eacc: 83 f8 03 cmp $0x3,%eax 10eacf: 77 ea ja 10eabb <_Watchdog_Remove+0x13> <== NEVER TAKEN break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10ead1: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; _ISR_Enable( level ); return( previous_state ); } 10ead8: 8b 1a mov (%edx),%ebx case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10eada: 8b 33 mov (%ebx),%esi 10eadc: 85 f6 test %esi,%esi 10eade: 74 06 je 10eae6 <_Watchdog_Remove+0x3e> next_watchdog->delta_interval += the_watchdog->delta_interval; 10eae0: 8b 72 10 mov 0x10(%edx),%esi 10eae3: 01 73 10 add %esi,0x10(%ebx) if ( _Watchdog_Sync_count ) 10eae6: 8b 35 00 f7 12 00 mov 0x12f700,%esi 10eaec: 85 f6 test %esi,%esi 10eaee: 74 0c je 10eafc <_Watchdog_Remove+0x54> _Watchdog_Sync_level = _ISR_Nest_level; 10eaf0: 8b 35 68 f8 12 00 mov 0x12f868,%esi 10eaf6: 89 35 94 f6 12 00 mov %esi,0x12f694 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10eafc: 8b 72 04 mov 0x4(%edx),%esi next->previous = previous; 10eaff: 89 73 04 mov %esi,0x4(%ebx) previous->next = next; 10eb02: 89 1e mov %ebx,(%esi) 10eb04: eb b5 jmp 10eabb <_Watchdog_Remove+0x13> 10eb06: 66 90 xchg %ax,%ax /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 10eb08: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10eb0f: eb aa jmp 10eabb <_Watchdog_Remove+0x13> =============================================================================== 0010fab4 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10fab4: 55 push %ebp 10fab5: 57 push %edi 10fab6: 56 push %esi 10fab7: 53 push %ebx 10fab8: 83 ec 1c sub $0x1c,%esp 10fabb: 8b 7c 24 30 mov 0x30(%esp),%edi 10fabf: 8b 74 24 34 mov 0x34(%esp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10fac3: 9c pushf 10fac4: fa cli 10fac5: 5d pop %ebp printk( "Watchdog Chain: %s %p\n", name, header ); 10fac6: 89 74 24 08 mov %esi,0x8(%esp) 10faca: 89 7c 24 04 mov %edi,0x4(%esp) 10face: c7 04 24 2b 33 12 00 movl $0x12332b,(%esp) 10fad5: e8 3e 96 ff ff call 109118 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10fada: 8b 1e mov (%esi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10fadc: 83 c6 04 add $0x4,%esi if ( !_Chain_Is_empty( header ) ) { 10fadf: 39 f3 cmp %esi,%ebx 10fae1: 74 31 je 10fb14 <_Watchdog_Report_chain+0x60> 10fae3: 90 nop node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10fae4: 89 5c 24 04 mov %ebx,0x4(%esp) 10fae8: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10faef: e8 30 00 00 00 call 10fb24 <_Watchdog_Report> _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; node != _Chain_Tail(header) ; node = node->next ) 10faf4: 8b 1b mov (%ebx),%ebx Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; 10faf6: 39 f3 cmp %esi,%ebx 10faf8: 75 ea jne 10fae4 <_Watchdog_Report_chain+0x30><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10fafa: 89 7c 24 04 mov %edi,0x4(%esp) 10fafe: c7 04 24 42 33 12 00 movl $0x123342,(%esp) 10fb05: e8 0e 96 ff ff call 109118 } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); 10fb0a: 55 push %ebp 10fb0b: 9d popf } 10fb0c: 83 c4 1c add $0x1c,%esp 10fb0f: 5b pop %ebx 10fb10: 5e pop %esi 10fb11: 5f pop %edi 10fb12: 5d pop %ebp 10fb13: c3 ret _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); 10fb14: c7 04 24 51 33 12 00 movl $0x123351,(%esp) 10fb1b: e8 f8 95 ff ff call 109118 10fb20: eb e8 jmp 10fb0a <_Watchdog_Report_chain+0x56> =============================================================================== 0010eb14 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10eb14: 55 push %ebp 10eb15: 57 push %edi 10eb16: 56 push %esi 10eb17: 53 push %ebx 10eb18: 83 ec 1c sub $0x1c,%esp 10eb1b: 8b 7c 24 30 mov 0x30(%esp),%edi * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 10eb1f: 9c pushf 10eb20: fa cli 10eb21: 5e pop %esi */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 10eb22: 8b 1f mov (%edi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10eb24: 8d 6f 04 lea 0x4(%edi),%ebp if ( _Chain_Is_empty( header ) ) 10eb27: 39 eb cmp %ebp,%ebx 10eb29: 74 11 je 10eb3c <_Watchdog_Tickle+0x28> * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 10eb2b: 8b 43 10 mov 0x10(%ebx),%eax 10eb2e: 85 c0 test %eax,%eax 10eb30: 74 34 je 10eb66 <_Watchdog_Tickle+0x52> the_watchdog->delta_interval--; 10eb32: 48 dec %eax 10eb33: 89 43 10 mov %eax,0x10(%ebx) if ( the_watchdog->delta_interval != 0 ) 10eb36: 85 c0 test %eax,%eax 10eb38: 74 2c je 10eb66 <_Watchdog_Tickle+0x52> 10eb3a: 66 90 xchg %ax,%ax the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10eb3c: 56 push %esi 10eb3d: 9d popf } 10eb3e: 83 c4 1c add $0x1c,%esp 10eb41: 5b pop %ebx 10eb42: 5e pop %esi 10eb43: 5f pop %edi 10eb44: 5d pop %ebp 10eb45: c3 ret _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10eb46: 8b 43 24 mov 0x24(%ebx),%eax 10eb49: 89 44 24 04 mov %eax,0x4(%esp) 10eb4d: 8b 43 20 mov 0x20(%ebx),%eax 10eb50: 89 04 24 mov %eax,(%esp) 10eb53: ff 53 1c call *0x1c(%ebx) case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10eb56: 9c pushf 10eb57: fa cli 10eb58: 5e pop %esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10eb59: 8b 1f mov (%edi),%ebx the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10eb5b: 39 dd cmp %ebx,%ebp 10eb5d: 74 dd je 10eb3c <_Watchdog_Tickle+0x28> } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 10eb5f: 8b 43 10 mov 0x10(%ebx),%eax 10eb62: 85 c0 test %eax,%eax 10eb64: 75 d6 jne 10eb3c <_Watchdog_Tickle+0x28> if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10eb66: 89 1c 24 mov %ebx,(%esp) 10eb69: e8 3a ff ff ff call 10eaa8 <_Watchdog_Remove> _ISR_Enable( level ); 10eb6e: 56 push %esi 10eb6f: 9d popf switch( watchdog_state ) { 10eb70: 83 f8 02 cmp $0x2,%eax 10eb73: 75 e1 jne 10eb56 <_Watchdog_Tickle+0x42> <== NEVER TAKEN 10eb75: eb cf jmp 10eb46 <_Watchdog_Tickle+0x32> =============================================================================== 0010eb78 <_Workspace_Handler_initialization>: /* * _Workspace_Handler_initialization */ void _Workspace_Handler_initialization(void) { 10eb78: 57 push %edi 10eb79: 53 push %ebx 10eb7a: 83 ec 14 sub $0x14,%esp uintptr_t memory_available = 0; void *starting_address = rtems_configuration_get_work_space_start(); 10eb7d: 8b 15 60 b1 12 00 mov 0x12b160,%edx uintptr_t size = rtems_configuration_get_work_space_size(); 10eb83: a1 64 b1 12 00 mov 0x12b164,%eax 10eb88: 80 3d 96 b1 12 00 00 cmpb $0x0,0x12b196 10eb8f: 75 37 jne 10ebc8 <_Workspace_Handler_initialization+0x50> 10eb91: 8b 1d 68 b1 12 00 mov 0x12b168,%ebx 10eb97: 01 c3 add %eax,%ebx if ( rtems_configuration_get_do_zero_of_workspace() ) 10eb99: 80 3d 94 b1 12 00 00 cmpb $0x0,0x12b194 10eba0: 75 33 jne 10ebd5 <_Workspace_Handler_initialization+0x5d> memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10eba2: c7 44 24 0c 04 00 00 movl $0x4,0xc(%esp) 10eba9: 00 10ebaa: 89 5c 24 08 mov %ebx,0x8(%esp) 10ebae: 89 54 24 04 mov %edx,0x4(%esp) 10ebb2: c7 04 24 20 f6 12 00 movl $0x12f620,(%esp) 10ebb9: e8 fa dd ff ff call 10c9b8 <_Heap_Initialize> starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10ebbe: 85 c0 test %eax,%eax 10ebc0: 74 1d je 10ebdf <_Workspace_Handler_initialization+0x67> _Internal_error_Occurred( INTERNAL_ERROR_CORE, true, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10ebc2: 83 c4 14 add $0x14,%esp 10ebc5: 5b pop %ebx 10ebc6: 5f pop %edi 10ebc7: c3 ret */ void _Workspace_Handler_initialization(void) { uintptr_t memory_available = 0; void *starting_address = rtems_configuration_get_work_space_start(); uintptr_t size = rtems_configuration_get_work_space_size(); 10ebc8: 31 db xor %ebx,%ebx 10ebca: 01 c3 add %eax,%ebx if ( rtems_configuration_get_do_zero_of_workspace() ) 10ebcc: 80 3d 94 b1 12 00 00 cmpb $0x0,0x12b194 10ebd3: 74 cd je 10eba2 <_Workspace_Handler_initialization+0x2a><== ALWAYS TAKEN memset( starting_address, 0, size ); 10ebd5: 31 c0 xor %eax,%eax 10ebd7: 89 d7 mov %edx,%edi 10ebd9: 89 d9 mov %ebx,%ecx 10ebdb: f3 aa rep stos %al,%es:(%edi) 10ebdd: eb c3 jmp 10eba2 <_Workspace_Handler_initialization+0x2a> size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10ebdf: c7 44 24 08 02 00 00 movl $0x2,0x8(%esp) 10ebe6: 00 10ebe7: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10ebee: 00 10ebef: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ebf6: e8 c5 df ff ff call 10cbc0 <_Internal_error_Occurred> =============================================================================== 0010eea4 <_Workspace_String_duplicate>: char *_Workspace_String_duplicate( const char *string, size_t len ) { 10eea4: 57 push %edi 10eea5: 56 push %esi 10eea6: 53 push %ebx 10eea7: 83 ec 10 sub $0x10,%esp 10eeaa: 8b 5c 24 24 mov 0x24(%esp),%ebx char *dup = _Workspace_Allocate(len + 1); 10eeae: 8d 43 01 lea 0x1(%ebx),%eax 10eeb1: 89 04 24 mov %eax,(%esp) 10eeb4: e8 57 ff ff ff call 10ee10 <_Workspace_Allocate> if (dup != NULL) { 10eeb9: 85 c0 test %eax,%eax 10eebb: 74 0e je 10eecb <_Workspace_String_duplicate+0x27><== NEVER TAKEN dup [len] = '\0'; 10eebd: c6 04 18 00 movb $0x0,(%eax,%ebx,1) memcpy(dup, string, len); 10eec1: 89 c7 mov %eax,%edi 10eec3: 8b 74 24 20 mov 0x20(%esp),%esi 10eec7: 89 d9 mov %ebx,%ecx 10eec9: f3 a4 rep movsb %ds:(%esi),%es:(%edi) } return dup; } 10eecb: 83 c4 10 add $0x10,%esp 10eece: 5b pop %ebx 10eecf: 5e pop %esi 10eed0: 5f pop %edi 10eed1: c3 ret =============================================================================== 0011f588 <__kill>: #endif int __kill( pid_t pid, int sig ) { return 0; } 11f588: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f58a: c3 ret <== NOT EXECUTED =============================================================================== 00107a74 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 107a74: e9 43 ff ff ff jmp 1079bc <== NOT EXECUTED =============================================================================== 0010582c <_lstat_r>: int _STAT_R_NAME( struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { 10582c: 8b 44 24 08 mov 0x8(%esp),%eax <== NOT EXECUTED return _STAT_NAME( path, buf ); 105830: 8b 54 24 0c mov 0xc(%esp),%edx <== NOT EXECUTED 105834: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED 105838: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10583c: e9 93 ff ff ff jmp 1057d4 <== NOT EXECUTED =============================================================================== 001089f4 <_stat_r>: int _STAT_R_NAME( struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { 1089f4: 8b 44 24 08 mov 0x8(%esp),%eax <== NOT EXECUTED return _STAT_NAME( path, buf ); 1089f8: 8b 54 24 0c mov 0xc(%esp),%edx <== NOT EXECUTED 1089fc: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED 108a00: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 108a04: e9 93 ff ff ff jmp 10899c <== NOT EXECUTED =============================================================================== 0010c844 : rtems_chain_control *free_chain, rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { 10c844: 57 push %edi 10c845: 56 push %esi 10c846: 53 push %ebx 10c847: 83 ec 10 sub $0x10,%esp 10c84a: 8b 5c 24 20 mov 0x20(%esp),%ebx if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 10c84e: 83 fb f8 cmp $0xfffffff8,%ebx 10c851: 74 37 je 10c88a */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 10c853: 8b 33 mov (%ebx),%esi 10c855: 85 f6 test %esi,%esi 10c857: 74 47 je 10c8a0 if (b->begin < a->begin) { 10c859: 8b 79 18 mov 0x18(%ecx),%edi 10c85c: 39 7b 18 cmp %edi,0x18(%ebx) 10c85f: 72 33 jb 10c894 a = b; b = t; } a->size += b->size; 10c861: 8b 7b 1c mov 0x1c(%ebx),%edi 10c864: 01 79 1c add %edi,0x1c(%ecx) { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10c867: 8b 4b 04 mov 0x4(%ebx),%ecx next->previous = previous; 10c86a: 89 4e 04 mov %ecx,0x4(%esi) previous->next = next; 10c86d: 89 31 mov %esi,(%ecx) Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10c86f: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10c872: 8b 08 mov (%eax),%ecx after_node->next = the_node; 10c874: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10c876: 89 0b mov %ecx,(%ebx) before_node->previous = the_node; 10c878: 89 59 04 mov %ebx,0x4(%ecx) rtems_chain_extract_unprotected(&b->chain_node); add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); 10c87b: 83 c3 08 add $0x8,%ebx 10c87e: 89 5c 24 04 mov %ebx,0x4(%esp) 10c882: 89 14 24 mov %edx,(%esp) 10c885: e8 72 18 00 00 call 10e0fc <_RBTree_Extract_unprotected> } } 10c88a: 83 c4 10 add $0x10,%esp 10c88d: 5b pop %ebx 10c88e: 5e pop %esi 10c88f: 5f pop %edi 10c890: c3 ret 10c891: 8d 76 00 lea 0x0(%esi),%esi 10c894: 8b 31 mov (%ecx),%esi rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { if (b->begin < a->begin) { 10c896: 89 cf mov %ecx,%edi 10c898: 89 d9 mov %ebx,%ecx 10c89a: 89 fb mov %edi,%ebx 10c89c: eb c3 jmp 10c861 10c89e: 66 90 xchg %ax,%ax */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 10c8a0: 8b 7b 04 mov 0x4(%ebx),%edi 10c8a3: 85 ff test %edi,%edi 10c8a5: 75 b2 jne 10c859 <== NEVER TAKEN 10c8a7: eb e1 jmp 10c88a =============================================================================== 00105470 : #include #include int chroot( const char *path ) { 105470: 56 push %esi 105471: 53 push %ebx 105472: 81 ec 84 00 00 00 sub $0x84,%esp /* * We use the global environment for path evaluation. This makes it possible * to escape from a chroot environment referencing an unmounted file system. */ rtems_filesystem_eval_path_start_with_root_and_current( 105478: c7 44 24 10 c0 9d 12 movl $0x129dc0,0x10(%esp) 10547f: 00 105480: c7 44 24 0c c4 9d 12 movl $0x129dc4,0xc(%esp) 105487: 00 105488: c7 44 24 08 19 00 00 movl $0x19,0x8(%esp) 10548f: 00 105490: 8b 84 24 90 00 00 00 mov 0x90(%esp),%eax 105497: 89 44 24 04 mov %eax,0x4(%esp) 10549b: 8d 74 24 48 lea 0x48(%esp),%esi 10549f: 89 34 24 mov %esi,(%esp) 1054a2: e8 e5 13 00 00 call 10688c 1054a7: 8d 44 24 60 lea 0x60(%esp),%eax 1054ab: 89 44 24 04 mov %eax,0x4(%esp) eval_flags, &rtems_global_user_env.root_directory, &rtems_global_user_env.current_directory ); rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc ); 1054af: 8d 5c 24 30 lea 0x30(%esp),%ebx 1054b3: 89 1c 24 mov %ebx,(%esp) 1054b6: e8 f5 17 00 00 call 106cb0 new_current_loc = rtems_filesystem_location_transform_to_global( &loc ); 1054bb: 89 1c 24 mov %ebx,(%esp) 1054be: e8 89 19 00 00 call 106e4c 1054c3: 89 44 24 2c mov %eax,0x2c(%esp) if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) { 1054c7: 81 78 10 00 ef 11 00 cmpl $0x11ef00,0x10(%eax) 1054ce: 74 3a je 10550a rtems_filesystem_global_location_t *new_root_loc = rtems_filesystem_global_location_obtain( &new_current_loc ); 1054d0: 8d 44 24 2c lea 0x2c(%esp),%eax 1054d4: 89 04 24 mov %eax,(%esp) ); rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc ); new_current_loc = rtems_filesystem_location_transform_to_global( &loc ); if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) { rtems_filesystem_global_location_t *new_root_loc = 1054d7: e8 e8 18 00 00 call 106dc4 1054dc: 89 c3 mov %eax,%ebx rtems_filesystem_global_location_obtain( &new_current_loc ); rtems_filesystem_node_types_t type = (*new_root_loc->location.mt_entry->ops->node_type_h)( 1054de: 8b 40 14 mov 0x14(%eax),%eax 1054e1: 8b 40 0c mov 0xc(%eax),%eax rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc ); new_current_loc = rtems_filesystem_location_transform_to_global( &loc ); if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) { rtems_filesystem_global_location_t *new_root_loc = rtems_filesystem_global_location_obtain( &new_current_loc ); rtems_filesystem_node_types_t type = 1054e4: 89 1c 24 mov %ebx,(%esp) 1054e7: ff 50 14 call *0x14(%eax) (*new_root_loc->location.mt_entry->ops->node_type_h)( &new_root_loc->location ); if ( type == RTEMS_FILESYSTEM_DIRECTORY ) { 1054ea: 85 c0 test %eax,%eax 1054ec: 74 3e je 10552c static inline void rtems_filesystem_location_error( const rtems_filesystem_location_info_t *loc, int eno ) { if ( !rtems_filesystem_location_is_null( loc ) ) { 1054ee: 81 7b 10 00 ef 11 00 cmpl $0x11ef00,0x10(%ebx) 1054f5: 74 0b je 105502 <== NEVER TAKEN errno = eno; 1054f7: e8 c0 6d 00 00 call 10c2bc <__errno> 1054fc: c7 00 14 00 00 00 movl $0x14,(%eax) rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR ); rv = -1; } if ( rv != 0 ) { rtems_filesystem_global_location_release( new_root_loc ); 105502: 89 1c 24 mov %ebx,(%esp) 105505: e8 62 18 00 00 call 106d6c } } else { rv = -1; } rtems_filesystem_eval_path_cleanup( &ctx ); 10550a: 89 34 24 mov %esi,(%esp) 10550d: e8 a2 14 00 00 call 1069b4 if ( rv != 0 ) { rtems_filesystem_global_location_release( new_current_loc ); 105512: 8b 44 24 2c mov 0x2c(%esp),%eax 105516: 89 04 24 mov %eax,(%esp) 105519: e8 4e 18 00 00 call 106d6c 10551e: b8 ff ff ff ff mov $0xffffffff,%eax } return rv; } 105523: 81 c4 84 00 00 00 add $0x84,%esp 105529: 5b pop %ebx 10552a: 5e pop %esi 10552b: c3 ret (*new_root_loc->location.mt_entry->ops->node_type_h)( &new_root_loc->location ); if ( type == RTEMS_FILESYSTEM_DIRECTORY ) { sc = rtems_libio_set_private_env(); 10552c: e8 f3 0c 00 00 call 106224 if (sc == RTEMS_SUCCESSFUL) { 105531: 85 c0 test %eax,%eax 105533: 74 13 je 105548 rtems_filesystem_global_location_assign( &rtems_filesystem_current, new_current_loc ); } else { if (sc != RTEMS_UNSATISFIED) { 105535: 83 f8 0d cmp $0xd,%eax 105538: 74 c8 je 105502 <== NEVER TAKEN errno = ENOMEM; 10553a: e8 7d 6d 00 00 call 10c2bc <__errno> 10553f: c7 00 0c 00 00 00 movl $0xc,(%eax) 105545: eb bb jmp 105502 105547: 90 nop ); if ( type == RTEMS_FILESYSTEM_DIRECTORY ) { sc = rtems_libio_set_private_env(); if (sc == RTEMS_SUCCESSFUL) { rtems_filesystem_global_location_assign( 105548: 89 5c 24 04 mov %ebx,0x4(%esp) 10554c: a1 a0 9d 12 00 mov 0x129da0,%eax 105551: 83 c0 04 add $0x4,%eax 105554: 89 04 24 mov %eax,(%esp) 105557: e8 4c 18 00 00 call 106da8 &rtems_filesystem_root, new_root_loc ); rtems_filesystem_global_location_assign( 10555c: 8b 44 24 2c mov 0x2c(%esp),%eax 105560: 89 44 24 04 mov %eax,0x4(%esp) 105564: a1 a0 9d 12 00 mov 0x129da0,%eax 105569: 89 04 24 mov %eax,(%esp) 10556c: e8 37 18 00 00 call 106da8 } } else { rv = -1; } rtems_filesystem_eval_path_cleanup( &ctx ); 105571: 89 34 24 mov %esi,(%esp) 105574: e8 3b 14 00 00 call 1069b4 105579: 31 c0 xor %eax,%eax if ( rv != 0 ) { rtems_filesystem_global_location_release( new_current_loc ); } return rv; } 10557b: 81 c4 84 00 00 00 add $0x84,%esp 105581: 5b pop %ebx 105582: 5e pop %esi 105583: c3 ret =============================================================================== 001095cc : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) 1095cc: 53 push %ebx 1095cd: 83 ec 18 sub $0x18,%esp 1095d0: 89 c3 mov %eax,%ebx 1095d2: eb 2e jmp 109602 rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { rtems_interrupt_disable (level); while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { tty->rawOutBufState = rob_wait; 1095d4: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 1095db: 00 00 00 rtems_interrupt_enable (level); 1095de: 50 push %eax 1095df: 9d popf sc = rtems_semaphore_obtain( 1095e0: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 1095e7: 00 1095e8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 1095ef: 00 1095f0: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 1095f6: 89 04 24 mov %eax,(%esp) 1095f9: e8 7e 23 00 00 call 10b97c tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1095fe: 85 c0 test %eax,%eax 109600: 75 1a jne 10961c <== NEVER TAKEN { rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { rtems_interrupt_disable (level); 109602: 9c pushf 109603: fa cli 109604: 58 pop %eax while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 109605: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx 10960b: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 109611: 39 d1 cmp %edx,%ecx 109613: 75 bf jne 1095d4 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } rtems_interrupt_enable (level); 109615: 50 push %eax 109616: 9d popf } } 109617: 83 c4 18 add $0x18,%esp 10961a: 5b pop %ebx 10961b: c3 ret tty->rawOutBufState = rob_wait; rtems_interrupt_enable (level); sc = rtems_semaphore_obtain( tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 10961c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10961f: e8 8c 2a 00 00 call 10c0b0 <== NOT EXECUTED =============================================================================== 00107ef4 : int dup2( int fildes, int fildes2 ) { 107ef4: 57 push %edi 107ef5: 56 push %esi 107ef6: 53 push %ebx 107ef7: 83 ec 60 sub $0x60,%esp 107efa: 8b 74 24 70 mov 0x70(%esp),%esi 107efe: 8b 7c 24 74 mov 0x74(%esp),%edi /* * If fildes is not valid, then fildes2 should not be closed. */ status = fstat( fildes, &buf ); 107f02: 8d 5c 24 18 lea 0x18(%esp),%ebx 107f06: 89 5c 24 04 mov %ebx,0x4(%esp) 107f0a: 89 34 24 mov %esi,(%esp) 107f0d: e8 fe 05 00 00 call 108510 if ( status == -1 ) 107f12: 40 inc %eax 107f13: 74 2b je 107f40 /* * If fildes2 is not valid, then we should not do anything either. */ status = fstat( fildes2, &buf ); 107f15: 89 5c 24 04 mov %ebx,0x4(%esp) 107f19: 89 3c 24 mov %edi,(%esp) 107f1c: e8 ef 05 00 00 call 108510 if ( status == -1 ) 107f21: 40 inc %eax 107f22: 74 1c je 107f40 <== NEVER TAKEN /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 107f24: 89 7c 24 08 mov %edi,0x8(%esp) 107f28: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 107f2f: 00 107f30: 89 34 24 mov %esi,(%esp) 107f33: e8 50 02 00 00 call 108188 } 107f38: 83 c4 60 add $0x60,%esp 107f3b: 5b pop %ebx 107f3c: 5e pop %esi 107f3d: 5f pop %edi 107f3e: c3 ret 107f3f: 90 nop * If fildes is not valid, then fildes2 should not be closed. */ status = fstat( fildes, &buf ); if ( status == -1 ) return -1; 107f40: b8 ff ff ff ff mov $0xffffffff,%eax 107f45: eb f1 jmp 107f38 =============================================================================== 0010a2dc : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 10a2dc: 53 push %ebx 10a2dd: 83 ec 38 sub $0x38,%esp if ((tty->termios.c_lflag & ECHOCTL) && 10a2e0: f6 42 3d 02 testb $0x2,0x3d(%edx) 10a2e4: 74 1a je 10a300 <== NEVER TAKEN iscntrl(c) && (c != '\t') && (c != '\n')) { 10a2e6: 0f b6 c8 movzbl %al,%ecx * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { if ((tty->termios.c_lflag & ECHOCTL) && 10a2e9: 8b 1d 08 d4 12 00 mov 0x12d408,%ebx 10a2ef: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1) 10a2f4: 74 0a je 10a300 iscntrl(c) && (c != '\t') && (c != '\n')) { 10a2f6: 3c 09 cmp $0x9,%al 10a2f8: 74 06 je 10a300 10a2fa: 3c 0a cmp $0xa,%al 10a2fc: 75 12 jne 10a310 10a2fe: 66 90 xchg %ax,%ax echobuf[0] = '^'; echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); tty->column += 2; } else { oproc (c, tty); 10a300: 0f b6 c0 movzbl %al,%eax 10a303: e8 88 fe ff ff call 10a190 } } 10a308: 83 c4 38 add $0x38,%esp 10a30b: 5b pop %ebx 10a30c: c3 ret 10a30d: 8d 76 00 lea 0x0(%esi),%esi { if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { char echobuf[2]; echobuf[0] = '^'; 10a310: c6 44 24 2e 5e movb $0x5e,0x2e(%esp) echobuf[1] = c ^ 0x40; 10a315: 83 f0 40 xor $0x40,%eax 10a318: 88 44 24 2f mov %al,0x2f(%esp) rtems_termios_puts (echobuf, 2, tty); 10a31c: 89 54 24 08 mov %edx,0x8(%esp) 10a320: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp) 10a327: 00 10a328: 8d 44 24 2e lea 0x2e(%esp),%eax 10a32c: 89 04 24 mov %eax,(%esp) 10a32f: 89 54 24 1c mov %edx,0x1c(%esp) 10a333: e8 14 fd ff ff call 10a04c tty->column += 2; 10a338: 8b 54 24 1c mov 0x1c(%esp),%edx 10a33c: 83 42 28 02 addl $0x2,0x28(%edx) } else { oproc (c, tty); } } 10a340: 83 c4 38 add $0x38,%esp 10a343: 5b pop %ebx 10a344: c3 ret =============================================================================== 0012957c : void endgrent(void) { if (group_fp != NULL) 12957c: a1 28 ab 17 00 mov 0x17ab28,%eax 129581: 85 c0 test %eax,%eax 129583: 74 0e je 129593 <== NEVER TAKEN fclose(group_fp); group_fp = fopen("/etc/group", "r"); } void endgrent(void) { 129585: 83 ec 1c sub $0x1c,%esp if (group_fp != NULL) fclose(group_fp); 129588: 89 04 24 mov %eax,(%esp) 12958b: e8 64 1e 01 00 call 13b3f4 } 129590: 83 c4 1c add $0x1c,%esp 129593: c3 ret =============================================================================== 00129410 : void endpwent(void) { if (passwd_fp != NULL) 129410: a1 48 aa 17 00 mov 0x17aa48,%eax 129415: 85 c0 test %eax,%eax 129417: 74 0e je 129427 <== NEVER TAKEN fclose(passwd_fp); passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { 129419: 83 ec 1c sub $0x1c,%esp if (passwd_fp != NULL) fclose(passwd_fp); 12941c: 89 04 24 mov %eax,(%esp) 12941f: e8 d0 1f 01 00 call 13b3f4 } 129424: 83 c4 1c add $0x1c,%esp 129427: c3 ret =============================================================================== 0010a348 : * Erase a character or line * FIXME: Needs support for WERASE and ECHOPRT. * FIXME: Some of the tests should check for IEXTEN, too. */ static void erase (struct rtems_termios_tty *tty, int lineFlag) 10a348: 55 push %ebp 10a349: 57 push %edi 10a34a: 56 push %esi 10a34b: 53 push %ebx 10a34c: 83 ec 2c sub $0x2c,%esp 10a34f: 89 c5 mov %eax,%ebp 10a351: 89 d7 mov %edx,%edi 10a353: eb 13 jmp 10a368 10a355: 8d 76 00 lea 0x0(%esi),%esi rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 10a358: 80 e6 02 and $0x2,%dh <== NOT EXECUTED 10a35b: 0f 85 0f 01 00 00 jne 10a470 <== NOT EXECUTED 10a361: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (tty->column) tty->column--; } } } if (!lineFlag) 10a364: 85 ff test %edi,%edi 10a366: 74 60 je 10a3c8 <== NEVER TAKEN echo ('\n', tty); return; } } while (tty->ccount) { 10a368: 8b 4d 20 mov 0x20(%ebp),%ecx 10a36b: 85 c9 test %ecx,%ecx 10a36d: 74 59 je 10a3c8 unsigned char c = tty->cbuf[--tty->ccount]; 10a36f: 8b 75 1c mov 0x1c(%ebp),%esi 10a372: 49 dec %ecx 10a373: 89 4d 20 mov %ecx,0x20(%ebp) 10a376: 0f b6 04 0e movzbl (%esi,%ecx,1),%eax if (tty->termios.c_lflag & ECHO) { 10a37a: 8b 55 3c mov 0x3c(%ebp),%edx 10a37d: f6 c2 08 test $0x8,%dl 10a380: 74 e2 je 10a364 <== NEVER TAKEN if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 10a382: 85 ff test %edi,%edi 10a384: 75 09 jne 10a38f 10a386: f6 c2 10 test $0x10,%dl 10a389: 0f 84 cd 00 00 00 je 10a45c <== NEVER TAKEN echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { 10a38f: 3c 09 cmp $0x9,%al 10a391: 74 3d je 10a3d0 rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 10a393: 8d 58 01 lea 0x1(%eax),%ebx 10a396: a1 08 d4 12 00 mov 0x12d408,%eax 10a39b: f6 04 18 20 testb $0x20,(%eax,%ebx,1) 10a39f: 75 b7 jne 10a358 <== NEVER TAKEN rtems_termios_puts ("\b \b", 3, tty); if (tty->column) tty->column--; } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { rtems_termios_puts ("\b \b", 3, tty); 10a3a1: 89 6c 24 08 mov %ebp,0x8(%esp) 10a3a5: c7 44 24 04 03 00 00 movl $0x3,0x4(%esp) 10a3ac: 00 10a3ad: c7 04 24 5e 16 12 00 movl $0x12165e,(%esp) 10a3b4: e8 93 fc ff ff call 10a04c if (tty->column) 10a3b9: 8b 45 28 mov 0x28(%ebp),%eax 10a3bc: 85 c0 test %eax,%eax 10a3be: 74 a4 je 10a364 <== NEVER TAKEN tty->column--; 10a3c0: 48 dec %eax 10a3c1: 89 45 28 mov %eax,0x28(%ebp) } } } if (!lineFlag) 10a3c4: 85 ff test %edi,%edi 10a3c6: 75 a0 jne 10a368 break; } } 10a3c8: 83 c4 2c add $0x2c,%esp 10a3cb: 5b pop %ebx 10a3cc: 5e pop %esi 10a3cd: 5f pop %edi 10a3ce: 5d pop %ebp 10a3cf: c3 ret if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { int col = tty->read_start_column; 10a3d0: 8b 5d 2c mov 0x2c(%ebp),%ebx int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 10a3d3: 85 c9 test %ecx,%ecx 10a3d5: 74 4a je 10a421 c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 10a3d7: a1 08 d4 12 00 mov 0x12d408,%eax 10a3dc: 89 44 24 18 mov %eax,0x18(%esp) if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { int col = tty->read_start_column; int i = 0; 10a3e0: 31 c0 xor %eax,%eax while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { if (tty->termios.c_lflag & ECHOCTL) 10a3e2: 81 e2 00 02 00 00 and $0x200,%edx 10a3e8: 89 54 24 14 mov %edx,0x14(%esp) 10a3ec: 89 6c 24 1c mov %ebp,0x1c(%esp) 10a3f0: 8b 6c 24 18 mov 0x18(%esp),%ebp 10a3f4: eb 11 jmp 10a407 10a3f6: 66 90 xchg %ax,%ax 10a3f8: 8b 54 24 14 mov 0x14(%esp),%edx <== NOT EXECUTED 10a3fc: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3fe: 74 03 je 10a403 <== NOT EXECUTED col += 2; 10a400: 83 c3 02 add $0x2,%ebx <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 10a403: 39 c1 cmp %eax,%ecx 10a405: 74 16 je 10a41d <== NEVER TAKEN c = tty->cbuf[i++]; 10a407: 0f b6 14 06 movzbl (%esi,%eax,1),%edx 10a40b: 40 inc %eax if (c == '\t') { 10a40c: 80 fa 09 cmp $0x9,%dl 10a40f: 74 43 je 10a454 col = (col | 7) + 1; } else if (iscntrl (c)) { 10a411: f6 44 15 01 20 testb $0x20,0x1(%ebp,%edx,1) 10a416: 75 e0 jne 10a3f8 <== NEVER TAKEN if (tty->termios.c_lflag & ECHOCTL) col += 2; } else { col++; 10a418: 43 inc %ebx int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 10a419: 39 c1 cmp %eax,%ecx 10a41b: 75 ea jne 10a407 10a41d: 8b 6c 24 1c mov 0x1c(%esp),%ebp } /* * Back up over the tab */ while (tty->column > col) { 10a421: 39 5d 28 cmp %ebx,0x28(%ebp) 10a424: 0f 8e 3a ff ff ff jle 10a364 <== NEVER TAKEN 10a42a: 66 90 xchg %ax,%ax rtems_termios_puts ("\b", 1, tty); 10a42c: 89 6c 24 08 mov %ebp,0x8(%esp) 10a430: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10a437: 00 10a438: c7 04 24 60 16 12 00 movl $0x121660,(%esp) 10a43f: e8 08 fc ff ff call 10a04c tty->column--; 10a444: 8b 45 28 mov 0x28(%ebp),%eax 10a447: 48 dec %eax 10a448: 89 45 28 mov %eax,0x28(%ebp) } /* * Back up over the tab */ while (tty->column > col) { 10a44b: 39 d8 cmp %ebx,%eax 10a44d: 7f dd jg 10a42c 10a44f: e9 10 ff ff ff jmp 10a364 * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; 10a454: 83 cb 07 or $0x7,%ebx 10a457: 43 inc %ebx 10a458: eb a9 jmp 10a403 10a45a: 66 90 xchg %ax,%ax while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); 10a45c: 0f b6 45 43 movzbl 0x43(%ebp),%eax <== NOT EXECUTED 10a460: 89 ea mov %ebp,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 10a462: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 10a465: 5b pop %ebx <== NOT EXECUTED 10a466: 5e pop %esi <== NOT EXECUTED 10a467: 5f pop %edi <== NOT EXECUTED 10a468: 5d pop %ebp <== NOT EXECUTED while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); 10a469: e9 6e fe ff ff jmp 10a2dc <== NOT EXECUTED 10a46e: 66 90 xchg %ax,%ax <== NOT EXECUTED tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { rtems_termios_puts ("\b \b", 3, tty); 10a470: 89 6c 24 08 mov %ebp,0x8(%esp) <== NOT EXECUTED 10a474: c7 44 24 04 03 00 00 movl $0x3,0x4(%esp) <== NOT EXECUTED 10a47b: 00 10a47c: c7 04 24 5e 16 12 00 movl $0x12165e,(%esp) <== NOT EXECUTED 10a483: e8 c4 fb ff ff call 10a04c <== NOT EXECUTED if (tty->column) 10a488: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED 10a48b: 85 c0 test %eax,%eax <== NOT EXECUTED 10a48d: 75 21 jne 10a4b0 <== NOT EXECUTED tty->column--; } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 10a48f: a1 08 d4 12 00 mov 0x12d408,%eax <== NOT EXECUTED 10a494: f6 04 18 20 testb $0x20,(%eax,%ebx,1) <== NOT EXECUTED 10a498: 0f 84 03 ff ff ff je 10a3a1 <== NOT EXECUTED 10a49e: f6 45 3d 02 testb $0x2,0x3d(%ebp) <== NOT EXECUTED 10a4a2: 0f 85 f9 fe ff ff jne 10a3a1 <== NOT EXECUTED 10a4a8: e9 b7 fe ff ff jmp 10a364 <== NOT EXECUTED 10a4ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { rtems_termios_puts ("\b \b", 3, tty); if (tty->column) tty->column--; 10a4b0: 48 dec %eax <== NOT EXECUTED 10a4b1: 89 45 28 mov %eax,0x28(%ebp) <== NOT EXECUTED 10a4b4: eb d9 jmp 10a48f <== NOT EXECUTED =============================================================================== 00108bcc : size_t pathlen, int eval_flags, rtems_filesystem_global_location_t *const *global_root_ptr, rtems_filesystem_global_location_t *const *global_current_ptr ) { 108bcc: 55 push %ebp 108bcd: 57 push %edi 108bce: 56 push %esi 108bcf: 53 push %ebx 108bd0: 83 ec 3c sub $0x3c,%esp 108bd3: 89 c6 mov %eax,%esi 108bd5: 89 cd mov %ecx,%ebp memset(ctx, 0, sizeof(*ctx)); 108bd7: b9 38 00 00 00 mov $0x38,%ecx 108bdc: 31 c0 xor %eax,%eax 108bde: 89 f7 mov %esi,%edi 108be0: f3 aa rep stos %al,%es:(%edi) ctx->path = path; 108be2: 89 16 mov %edx,(%esi) ctx->pathlen = pathlen; 108be4: 89 6e 04 mov %ebp,0x4(%esi) ctx->flags = eval_flags; 108be7: 8b 44 24 50 mov 0x50(%esp),%eax 108beb: 89 46 10 mov %eax,0x10(%esi) rtems_filesystem_eval_path_context_t *ctx, rtems_filesystem_global_location_t *const *global_root_ptr, rtems_filesystem_global_location_t *const *global_current_ptr ) { if (ctx->pathlen > 0) { 108bee: 85 ed test %ebp,%ebp 108bf0: 74 36 je 108c28 char c = ctx->path [0]; 108bf2: 8a 1a mov (%edx),%bl ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr); 108bf4: 8b 44 24 54 mov 0x54(%esp),%eax 108bf8: 89 04 24 mov %eax,(%esp) 108bfb: e8 9c 05 00 00 call 10919c 108c00: 89 46 30 mov %eax,0x30(%esi) gid_t node_gid ); static inline bool rtems_filesystem_is_delimiter(char c) { return c == '/' || c == '\\'; 108c03: 80 fb 2f cmp $0x2f,%bl 108c06: 0f 84 8c 00 00 00 je 108c98 108c0c: 80 fb 5c cmp $0x5c,%bl 108c0f: 0f 84 83 00 00 00 je 108c98 <== NEVER TAKEN --ctx->pathlen; ctx->startloc = rtems_filesystem_global_location_obtain( &ctx->rootloc ); } else { ctx->startloc = rtems_filesystem_global_location_obtain( 108c15: 8b 44 24 58 mov 0x58(%esp),%eax 108c19: 89 04 24 mov %eax,(%esp) 108c1c: e8 7b 05 00 00 call 10919c 108c21: 89 46 34 mov %eax,0x34(%esi) 108c24: eb 3a jmp 108c60 108c26: 66 90 xchg %ax,%ax ); static inline rtems_filesystem_global_location_t * rtems_filesystem_global_location_obtain_null(void) { rtems_filesystem_global_location_t *global_loc = NULL; 108c28: c7 44 24 2c 00 00 00 movl $0x0,0x2c(%esp) 108c2f: 00 return rtems_filesystem_global_location_obtain( &global_loc ); 108c30: 8d 5c 24 2c lea 0x2c(%esp),%ebx 108c34: 89 1c 24 mov %ebx,(%esp) 108c37: e8 60 05 00 00 call 10919c global_current_ptr ); } } else { ctx->rootloc = rtems_filesystem_global_location_obtain_null(); 108c3c: 89 46 30 mov %eax,0x30(%esi) ); static inline rtems_filesystem_global_location_t * rtems_filesystem_global_location_obtain_null(void) { rtems_filesystem_global_location_t *global_loc = NULL; 108c3f: c7 44 24 2c 00 00 00 movl $0x0,0x2c(%esp) 108c46: 00 return rtems_filesystem_global_location_obtain( &global_loc ); 108c47: 89 1c 24 mov %ebx,(%esp) 108c4a: e8 4d 05 00 00 call 10919c ctx->startloc = rtems_filesystem_global_location_obtain_null(); 108c4f: 89 46 34 mov %eax,0x34(%esi) errno = ENOENT; 108c52: e8 a1 a0 00 00 call 112cf8 <__errno> 108c57: c7 00 02 00 00 00 movl $0x2,(%eax) 108c5d: 8b 46 34 mov 0x34(%esi),%eax &ctx->startloc, rtems_filesystem_global_location_obtain(newstartloc_ptr) ); rtems_filesystem_instance_lock(&ctx->startloc->location); rtems_filesystem_location_clone(&ctx->currentloc, &ctx->startloc->location); } 108c60: 8b 40 14 mov 0x14(%eax),%eax const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; (*mt_entry->ops->lock_h)( mt_entry ); 108c63: 8b 50 0c mov 0xc(%eax),%edx 108c66: 89 04 24 mov %eax,(%esp) 108c69: ff 12 call *(%edx) set_startloc(ctx, global_root_ptr, global_current_ptr); rtems_filesystem_instance_lock(&ctx->startloc->location); rtems_filesystem_location_clone( 108c6b: 8d 46 18 lea 0x18(%esi),%eax 108c6e: 8b 56 34 mov 0x34(%esi),%edx 108c71: 89 54 24 04 mov %edx,0x4(%esp) 108c75: 89 04 24 mov %eax,(%esp) 108c78: 89 44 24 1c mov %eax,0x1c(%esp) 108c7c: e8 0b 6f 00 00 call 10fb8c &ctx->currentloc, &ctx->startloc->location ); rtems_filesystem_eval_path_continue(ctx); 108c81: 89 34 24 mov %esi,(%esp) 108c84: e8 bf fe ff ff call 108b48 108c89: 8b 44 24 1c mov 0x1c(%esp),%eax return &ctx->currentloc; } 108c8d: 83 c4 3c add $0x3c,%esp 108c90: 5b pop %ebx 108c91: 5e pop %esi 108c92: 5f pop %edi 108c93: 5d pop %ebp 108c94: c3 ret 108c95: 8d 76 00 lea 0x0(%esi),%esi char c = ctx->path [0]; ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr); if (rtems_filesystem_is_delimiter(c)) { ++ctx->path; 108c98: ff 06 incl (%esi) --ctx->pathlen; 108c9a: ff 4e 04 decl 0x4(%esi) ctx->startloc = rtems_filesystem_global_location_obtain( &ctx->rootloc 108c9d: 8d 46 30 lea 0x30(%esi),%eax 108ca0: 89 04 24 mov %eax,(%esp) ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr); if (rtems_filesystem_is_delimiter(c)) { ++ctx->path; --ctx->pathlen; ctx->startloc = rtems_filesystem_global_location_obtain( 108ca3: e8 f4 04 00 00 call 10919c 108ca8: 89 46 34 mov %eax,0x34(%esi) 108cab: eb b3 jmp 108c60 =============================================================================== 00136cc8 : #include #include int fchdir( int fd ) { 136cc8: 56 push %esi 136cc9: 53 push %ebx 136cca: 81 ec 84 00 00 00 sub $0x84,%esp 136cd0: 8b 84 24 90 00 00 00 mov 0x90(%esp),%eax int rv = 0; rtems_libio_t *iop; struct stat st; rtems_filesystem_location_info_t loc; st.st_mode = 0; 136cd7: c7 44 24 44 00 00 00 movl $0x0,0x44(%esp) 136cde: 00 st.st_uid = 0; 136cdf: 66 c7 44 24 4a 00 00 movw $0x0,0x4a(%esp) st.st_gid = 0; 136ce6: 66 c7 44 24 4c 00 00 movw $0x0,0x4c(%esp) rtems_libio_check_fd( fd ); 136ced: 3b 05 20 36 17 00 cmp 0x173620,%eax 136cf3: 0f 83 c7 00 00 00 jae 136dc0 iop = rtems_libio_iop( fd ); 136cf9: 8d 1c 40 lea (%eax,%eax,2),%ebx 136cfc: c1 e3 04 shl $0x4,%ebx 136cff: 03 1d 34 b0 17 00 add 0x17b034,%ebx rtems_libio_check_is_open( iop ); 136d05: f6 43 0d 01 testb $0x1,0xd(%ebx) 136d09: 0f 84 b1 00 00 00 je 136dc0 if ( rv == 0 ) { rv = rtems_filesystem_chdir( &loc ); } return rv; } 136d0f: 8b 43 24 mov 0x24(%ebx),%eax const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; (*mt_entry->ops->lock_h)( mt_entry ); 136d12: 8b 50 0c mov 0xc(%eax),%edx 136d15: 89 04 24 mov %eax,(%esp) 136d18: ff 12 call *(%edx) rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_filesystem_instance_lock( &iop->pathinfo ); rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st ); 136d1a: 8d 73 10 lea 0x10(%ebx),%esi 136d1d: 8b 43 20 mov 0x20(%ebx),%eax 136d20: 8d 54 24 38 lea 0x38(%esp),%edx 136d24: 89 54 24 04 mov %edx,0x4(%esp) 136d28: 89 34 24 mov %esi,(%esp) 136d2b: ff 50 18 call *0x18(%eax) if ( rv == 0 ) { 136d2e: 85 c0 test %eax,%eax 136d30: 74 1e je 136d50 <== ALWAYS TAKEN if ( rv == 0 ) { rv = rtems_filesystem_chdir( &loc ); } return rv; } 136d32: 8b 53 24 mov 0x24(%ebx),%edx const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; (*mt_entry->ops->unlock_h)( mt_entry ); 136d35: 8b 4a 0c mov 0xc(%edx),%ecx 136d38: 89 14 24 mov %edx,(%esp) 136d3b: 89 44 24 1c mov %eax,0x1c(%esp) 136d3f: ff 51 04 call *0x4(%ecx) 136d42: 8b 44 24 1c mov 0x1c(%esp),%eax 136d46: 81 c4 84 00 00 00 add $0x84,%esp 136d4c: 5b pop %ebx 136d4d: 5e pop %esi 136d4e: c3 ret 136d4f: 90 nop rtems_libio_check_is_open( iop ); rtems_filesystem_instance_lock( &iop->pathinfo ); rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st ); if ( rv == 0 ) { bool access_ok = rtems_filesystem_check_access( 136d50: 0f b7 44 24 4c movzwl 0x4c(%esp),%eax 136d55: 89 44 24 0c mov %eax,0xc(%esp) 136d59: 0f b7 44 24 4a movzwl 0x4a(%esp),%eax 136d5e: 89 44 24 08 mov %eax,0x8(%esp) 136d62: 8b 44 24 44 mov 0x44(%esp),%eax 136d66: 89 44 24 04 mov %eax,0x4(%esp) 136d6a: c7 04 24 01 00 00 00 movl $0x1,(%esp) 136d71: e8 52 b5 fd ff call 1122c8 st.st_mode, st.st_uid, st.st_gid ); if ( access_ok ) { 136d76: 84 c0 test %al,%al 136d78: 74 2e je 136da8 rtems_filesystem_location_clone( &loc, &iop->pathinfo ); 136d7a: 89 74 24 04 mov %esi,0x4(%esp) 136d7e: 8d 74 24 20 lea 0x20(%esp),%esi 136d82: 89 34 24 mov %esi,(%esp) 136d85: e8 fa af fd ff call 111d84 if ( rv == 0 ) { rv = rtems_filesystem_chdir( &loc ); } return rv; } 136d8a: 8b 43 24 mov 0x24(%ebx),%eax 136d8d: 8b 50 0c mov 0xc(%eax),%edx 136d90: 89 04 24 mov %eax,(%esp) 136d93: ff 52 04 call *0x4(%edx) } } rtems_filesystem_instance_unlock( &iop->pathinfo ); if ( rv == 0 ) { rv = rtems_filesystem_chdir( &loc ); 136d96: 89 34 24 mov %esi,(%esp) 136d99: e8 0e 1a ff ff call 1287ac } return rv; } 136d9e: 81 c4 84 00 00 00 add $0x84,%esp 136da4: 5b pop %ebx 136da5: 5e pop %esi 136da6: c3 ret 136da7: 90 nop ); if ( access_ok ) { rtems_filesystem_location_clone( &loc, &iop->pathinfo ); } else { errno = EACCES; 136da8: e8 2b 45 00 00 call 13b2d8 <__errno> 136dad: c7 00 0d 00 00 00 movl $0xd,(%eax) rv = -1; 136db3: b8 ff ff ff ff mov $0xffffffff,%eax 136db8: e9 75 ff ff ff jmp 136d32 136dbd: 8d 76 00 lea 0x0(%esi),%esi st.st_uid = 0; st.st_gid = 0; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); 136dc0: e8 13 45 00 00 call 13b2d8 <__errno> 136dc5: c7 00 09 00 00 00 movl $0x9,(%eax) 136dcb: b8 ff ff ff ff mov $0xffffffff,%eax 136dd0: e9 71 ff ff ff jmp 136d46 =============================================================================== 00128aac : #include #include int fchmod( int fd, mode_t mode ) { 128aac: 53 push %ebx 128aad: 83 ec 28 sub $0x28,%esp 128ab0: 8b 44 24 30 mov 0x30(%esp),%eax int rv; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 128ab4: 3b 05 20 36 17 00 cmp 0x173620,%eax 128aba: 73 68 jae 128b24 iop = rtems_libio_iop( fd ); 128abc: 8d 1c 40 lea (%eax,%eax,2),%ebx 128abf: c1 e3 04 shl $0x4,%ebx 128ac2: 03 1d 34 b0 17 00 add 0x17b034,%ebx rtems_libio_check_is_open(iop); 128ac8: f6 43 0d 01 testb $0x1,0xd(%ebx) 128acc: 74 56 je 128b24 if (iop->pathinfo.mt_entry->writeable) { 128ace: 8b 43 24 mov 0x24(%ebx),%eax 128ad1: 80 78 29 00 cmpb $0x0,0x29(%eax) 128ad5: 75 15 jne 128aec <== ALWAYS TAKEN rtems_filesystem_instance_lock( &iop->pathinfo ); rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode ); rtems_filesystem_instance_unlock( &iop->pathinfo ); } else { errno = EROFS; 128ad7: e8 fc 27 01 00 call 13b2d8 <__errno> <== NOT EXECUTED 128adc: c7 00 1e 00 00 00 movl $0x1e,(%eax) <== NOT EXECUTED rv = -1; 128ae2: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } return rv; } 128ae7: 83 c4 28 add $0x28,%esp 128aea: 5b pop %ebx 128aeb: c3 ret const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; (*mt_entry->ops->lock_h)( mt_entry ); 128aec: 8b 50 0c mov 0xc(%eax),%edx 128aef: 89 04 24 mov %eax,(%esp) 128af2: ff 12 call *(%edx) iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); if (iop->pathinfo.mt_entry->writeable) { rtems_filesystem_instance_lock( &iop->pathinfo ); rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode ); 128af4: 8b 43 24 mov 0x24(%ebx),%eax 128af7: 8b 40 0c mov 0xc(%eax),%eax 128afa: 8b 54 24 34 mov 0x34(%esp),%edx 128afe: 89 54 24 04 mov %edx,0x4(%esp) 128b02: 8d 53 10 lea 0x10(%ebx),%edx 128b05: 89 14 24 mov %edx,(%esp) 128b08: ff 50 20 call *0x20(%eax) errno = EROFS; rv = -1; } return rv; } 128b0b: 8b 53 24 mov 0x24(%ebx),%edx const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; (*mt_entry->ops->unlock_h)( mt_entry ); 128b0e: 8b 4a 0c mov 0xc(%edx),%ecx 128b11: 89 14 24 mov %edx,(%esp) 128b14: 89 44 24 1c mov %eax,0x1c(%esp) 128b18: ff 51 04 call *0x4(%ecx) 128b1b: 8b 44 24 1c mov 0x1c(%esp),%eax 128b1f: 83 c4 28 add $0x28,%esp 128b22: 5b pop %ebx 128b23: c3 ret int rv; rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 128b24: e8 af 27 01 00 call 13b2d8 <__errno> 128b29: c7 00 09 00 00 00 movl $0x9,(%eax) 128b2f: b8 ff ff ff ff mov $0xffffffff,%eax 128b34: eb b1 jmp 128ae7 =============================================================================== 00128b38 : #include #include int fchown( int fd, uid_t owner, gid_t group ) { 128b38: 57 push %edi 128b39: 56 push %esi 128b3a: 53 push %ebx 128b3b: 83 ec 20 sub $0x20,%esp 128b3e: 8b 44 24 30 mov 0x30(%esp),%eax 128b42: 0f b7 74 24 34 movzwl 0x34(%esp),%esi 128b47: 0f b7 7c 24 38 movzwl 0x38(%esp),%edi int rv = 0; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 128b4c: 3b 05 20 36 17 00 cmp 0x173620,%eax 128b52: 73 70 jae 128bc4 iop = rtems_libio_iop( fd ); 128b54: 8d 1c 40 lea (%eax,%eax,2),%ebx 128b57: c1 e3 04 shl $0x4,%ebx 128b5a: 03 1d 34 b0 17 00 add 0x17b034,%ebx rtems_libio_check_is_open(iop); 128b60: f6 43 0d 01 testb $0x1,0xd(%ebx) 128b64: 74 5e je 128bc4 if (iop->pathinfo.mt_entry->writeable) { 128b66: 8b 43 24 mov 0x24(%ebx),%eax 128b69: 80 78 29 00 cmpb $0x0,0x29(%eax) 128b6d: 75 19 jne 128b88 <== ALWAYS TAKEN owner, group ); rtems_filesystem_instance_unlock( &iop->pathinfo ); } else { errno = EROFS; 128b6f: e8 64 27 01 00 call 13b2d8 <__errno> <== NOT EXECUTED 128b74: c7 00 1e 00 00 00 movl $0x1e,(%eax) <== NOT EXECUTED rv = -1; 128b7a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } return rv; } 128b7f: 83 c4 20 add $0x20,%esp 128b82: 5b pop %ebx 128b83: 5e pop %esi 128b84: 5f pop %edi 128b85: c3 ret 128b86: 66 90 xchg %ax,%ax const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; (*mt_entry->ops->lock_h)( mt_entry ); 128b88: 8b 50 0c mov 0xc(%eax),%edx 128b8b: 89 04 24 mov %eax,(%esp) 128b8e: ff 12 call *(%edx) iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); if (iop->pathinfo.mt_entry->writeable) { rtems_filesystem_instance_lock( &iop->pathinfo ); rv = (*iop->pathinfo.mt_entry->ops->chown_h)( 128b90: 8b 43 24 mov 0x24(%ebx),%eax 128b93: 8b 40 0c mov 0xc(%eax),%eax 128b96: 89 7c 24 08 mov %edi,0x8(%esp) 128b9a: 89 74 24 04 mov %esi,0x4(%esp) &iop->pathinfo, 128b9e: 8d 53 10 lea 0x10(%ebx),%edx 128ba1: 89 14 24 mov %edx,(%esp) iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); if (iop->pathinfo.mt_entry->writeable) { rtems_filesystem_instance_lock( &iop->pathinfo ); rv = (*iop->pathinfo.mt_entry->ops->chown_h)( 128ba4: ff 50 24 call *0x24(%eax) errno = EROFS; rv = -1; } return rv; } 128ba7: 8b 53 24 mov 0x24(%ebx),%edx const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; (*mt_entry->ops->unlock_h)( mt_entry ); 128baa: 8b 4a 0c mov 0xc(%edx),%ecx 128bad: 89 14 24 mov %edx,(%esp) 128bb0: 89 44 24 1c mov %eax,0x1c(%esp) 128bb4: ff 51 04 call *0x4(%ecx) 128bb7: 8b 44 24 1c mov 0x1c(%esp),%eax 128bbb: 83 c4 20 add $0x20,%esp 128bbe: 5b pop %ebx 128bbf: 5e pop %esi 128bc0: 5f pop %edi 128bc1: c3 ret 128bc2: 66 90 xchg %ax,%ax int rv = 0; rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 128bc4: e8 0f 27 01 00 call 13b2d8 <__errno> 128bc9: c7 00 09 00 00 00 movl $0x9,(%eax) 128bcf: b8 ff ff ff ff mov $0xffffffff,%eax 128bd4: eb a9 jmp 128b7f =============================================================================== 00132280 : int fcntl( int fd, int cmd, ... ) { 132280: 55 push %ebp 132281: 57 push %edi 132282: 56 push %esi 132283: 53 push %ebx 132284: 83 ec 2c sub $0x2c,%esp 132287: 8b 44 24 40 mov 0x40(%esp),%eax 13228b: 8b 7c 24 44 mov 0x44(%esp),%edi int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 13228f: 3b 05 e0 52 14 00 cmp 0x1452e0,%eax 132295: 0f 83 91 01 00 00 jae 13242c <== NEVER TAKEN iop = rtems_libio_iop( fd ); 13229b: 8d 1c 40 lea (%eax,%eax,2),%ebx 13229e: c1 e3 04 shl $0x4,%ebx 1322a1: 03 1d 74 96 15 00 add 0x159674,%ebx rtems_libio_check_is_open(iop); 1322a7: 8b 73 0c mov 0xc(%ebx),%esi 1322aa: f7 c6 00 01 00 00 test $0x100,%esi 1322b0: 0f 84 76 01 00 00 je 13242c <== NEVER TAKEN /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 1322b6: 83 ff 09 cmp $0x9,%edi 1322b9: 76 0d jbe 1322c8 errno = ENOTSUP; ret = -1; break; default: errno = EINVAL; 1322bb: e8 8c 2c ff ff call 124f4c <__errno> 1322c0: c7 00 16 00 00 00 movl $0x16,(%eax) 1322c6: eb 13 jmp 1322db /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 1322c8: ff 24 bd c4 93 13 00 jmp *0x1393c4(,%edi,4) 1322cf: 90 nop errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 1322d0: e8 77 2c ff ff call 124f4c <__errno> 1322d5: c7 00 86 00 00 00 movl $0x86,(%eax) int mask; int ret = 0; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 1322db: be ff ff ff ff mov $0xffffffff,%esi va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 1322e0: 89 f0 mov %esi,%eax 1322e2: 83 c4 2c add $0x2c,%esp 1322e5: 5b pop %ebx 1322e6: 5e pop %esi 1322e7: 5f pop %edi 1322e8: 5d pop %ebp 1322e9: c3 ret 1322ea: 66 90 xchg %ax,%ax case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 1322ec: 8b 44 24 48 mov 0x48(%esp),%eax 1322f0: 89 04 24 mov %eax,(%esp) 1322f3: e8 14 a1 fd ff call 10c40c /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 1322f8: 25 01 02 00 00 and $0x201,%eax 1322fd: 8b 53 0c mov 0xc(%ebx),%edx 132300: 81 e2 fe fd ff ff and $0xfffffdfe,%edx 132306: 09 d0 or %edx,%eax 132308: 89 43 0c mov %eax,0xc(%ebx) { rtems_libio_t *iop; int fd2; int flags; int mask; int ret = 0; 13230b: 31 f6 xor %esi,%esi * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd ); 13230d: 8b 43 20 mov 0x20(%ebx),%eax 132310: 89 7c 24 04 mov %edi,0x4(%esp) 132314: 89 1c 24 mov %ebx,(%esp) 132317: ff 50 28 call *0x28(%eax) 13231a: 89 c3 mov %eax,%ebx if (err) { 13231c: 85 c0 test %eax,%eax 13231e: 74 c0 je 1322e0 <== ALWAYS TAKEN errno = err; 132320: e8 27 2c ff ff call 124f4c <__errno> <== NOT EXECUTED 132325: 89 18 mov %ebx,(%eax) <== NOT EXECUTED ret = -1; 132327: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 13232c: 89 f0 mov %esi,%eax <== NOT EXECUTED 13232e: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 132331: 5b pop %ebx <== NOT EXECUTED 132332: 5e pop %esi <== NOT EXECUTED 132333: 5f pop %edi <== NOT EXECUTED 132334: 5d pop %ebp <== NOT EXECUTED 132335: c3 ret <== NOT EXECUTED 132336: 66 90 xchg %ax,%ax <== NOT EXECUTED else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 132338: 89 34 24 mov %esi,(%esp) 13233b: e8 08 a1 fd ff call 10c448 132340: 89 c6 mov %eax,%esi /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 132342: 85 f6 test %esi,%esi 132344: 79 c7 jns 13230d <== ALWAYS TAKEN 132346: eb 98 jmp 1322e0 <== NOT EXECUTED * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) 132348: 8b 44 24 48 mov 0x48(%esp),%eax 13234c: 85 c0 test %eax,%eax 13234e: 0f 84 c8 00 00 00 je 13241c iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 132354: 81 ce 00 08 00 00 or $0x800,%esi 13235a: 89 73 0c mov %esi,0xc(%ebx) { rtems_libio_t *iop; int fd2; int flags; int mask; int ret = 0; 13235d: 31 f6 xor %esi,%esi 13235f: eb ac jmp 13230d 132361: 8d 76 00 lea 0x0(%esi),%esi fd2 = va_arg( ap, int ); ret = duplicate_iop( iop, fd2 ); break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 132364: c1 ee 0b shr $0xb,%esi 132367: 83 e6 01 and $0x1,%esi 13236a: eb a1 jmp 13230d /* * FIXME: We ignore the start value fd2 for the file descriptor search. This * is not POSIX conform. */ rtems_libio_t *diop = rtems_libio_allocate(); 13236c: e8 17 a1 fd ff call 10c488 132371: 89 c5 mov %eax,%ebp if (diop != NULL) { 132373: 85 c0 test %eax,%eax 132375: 0f 84 60 ff ff ff je 1322db int oflag = rtems_libio_to_fcntl_flags( iop->flags ); 13237b: 8b 43 0c mov 0xc(%ebx),%eax 13237e: 89 04 24 mov %eax,(%esp) 132381: e8 c2 a0 fd ff call 10c448 132386: 89 c6 mov %eax,%esi oflag &= ~O_CREAT; 132388: 81 e6 ff fd ff ff and $0xfffffdff,%esi diop->flags |= rtems_libio_fcntl_flags( oflag ); 13238e: 8b 45 0c mov 0xc(%ebp),%eax 132391: 89 44 24 1c mov %eax,0x1c(%esp) 132395: 89 34 24 mov %esi,(%esp) 132398: e8 6f a0 fd ff call 10c40c 13239d: 0b 44 24 1c or 0x1c(%esp),%eax 1323a1: 89 45 0c mov %eax,0xc(%ebp) int cmd, int arg ) { return fcntl( fd, cmd, arg ); } 1323a4: 8b 43 24 mov 0x24(%ebx),%eax const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; (*mt_entry->ops->lock_h)( mt_entry ); 1323a7: 8b 48 0c mov 0xc(%eax),%ecx 1323aa: 89 04 24 mov %eax,(%esp) 1323ad: ff 11 call *(%ecx) oflag &= ~O_CREAT; diop->flags |= rtems_libio_fcntl_flags( oflag ); rtems_filesystem_instance_lock( &iop->pathinfo ); rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo ); 1323af: 8d 43 10 lea 0x10(%ebx),%eax 1323b2: 89 44 24 04 mov %eax,0x4(%esp) 1323b6: 8d 45 10 lea 0x10(%ebp),%eax 1323b9: 89 04 24 mov %eax,(%esp) 1323bc: e8 7b 84 fe ff call 11a83c int cmd, int arg ) { return fcntl( fd, cmd, arg ); } 1323c1: 8b 43 24 mov 0x24(%ebx),%eax const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; (*mt_entry->ops->unlock_h)( mt_entry ); 1323c4: 8b 48 0c mov 0xc(%eax),%ecx 1323c7: 89 04 24 mov %eax,(%esp) 1323ca: ff 51 04 call *0x4(%ecx) /* * XXX: We call the open handler here to have a proper open and close pair. * * FIXME: What to do with the path? */ rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 ); 1323cd: 8b 45 20 mov 0x20(%ebp),%eax 1323d0: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 1323d7: 00 1323d8: 89 74 24 08 mov %esi,0x8(%esp) 1323dc: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 1323e3: 00 1323e4: 89 2c 24 mov %ebp,(%esp) 1323e7: ff 10 call *(%eax) 1323e9: 89 c6 mov %eax,%esi if ( rv == 0 ) { 1323eb: 85 c0 test %eax,%eax 1323ed: 75 55 jne 132444 <== NEVER TAKEN rv = diop - rtems_libio_iops; 1323ef: 2b 2d 74 96 15 00 sub 0x159674,%ebp 1323f5: c1 fd 04 sar $0x4,%ebp 1323f8: 8d 44 ad 00 lea 0x0(%ebp,%ebp,4),%eax 1323fc: 8d 44 85 00 lea 0x0(%ebp,%eax,4),%eax 132400: 8d 44 85 00 lea 0x0(%ebp,%eax,4),%eax 132404: 89 c2 mov %eax,%edx 132406: c1 e2 08 shl $0x8,%edx 132409: 01 d0 add %edx,%eax 13240b: 89 c2 mov %eax,%edx 13240d: c1 e2 10 shl $0x10,%edx 132410: 01 d0 add %edx,%eax 132412: 8d 74 45 00 lea 0x0(%ebp,%eax,2),%esi 132416: e9 27 ff ff ff jmp 132342 13241b: 90 nop */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 13241c: 81 e6 ff f7 ff ff and $0xfffff7ff,%esi 132422: 89 73 0c mov %esi,0xc(%ebx) { rtems_libio_t *iop; int fd2; int flags; int mask; int ret = 0; 132425: 31 f6 xor %esi,%esi 132427: e9 e1 fe ff ff jmp 13230d rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 13242c: e8 1b 2b ff ff call 124f4c <__errno> 132431: c7 00 09 00 00 00 movl $0x9,(%eax) 132437: be ff ff ff ff mov $0xffffffff,%esi 13243c: e9 9f fe ff ff jmp 1322e0 132441: 8d 76 00 lea 0x0(%esi),%esi */ rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 ); if ( rv == 0 ) { rv = diop - rtems_libio_iops; } else { rtems_libio_free( diop ); 132444: 89 2c 24 mov %ebp,(%esp) <== NOT EXECUTED 132447: e8 98 a0 fd ff call 10c4e4 <== NOT EXECUTED 13244c: e9 f1 fe ff ff jmp 132342 <== NOT EXECUTED =============================================================================== 0010ace4 : long fpathconf( int fd, int name ) { 10ace4: 83 ec 0c sub $0xc,%esp 10ace7: 8b 44 24 10 mov 0x10(%esp),%eax long return_value; rtems_libio_t *iop; const rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); 10aceb: 3b 05 5c 94 12 00 cmp 0x12945c,%eax 10acf1: 0f 83 a1 00 00 00 jae 10ad98 <== ALWAYS TAKEN iop = rtems_libio_iop(fd); 10acf7: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10acfa: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10acfd: 03 05 30 d6 12 00 add 0x12d630,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 10ad03: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 10ad07: 0f 84 8b 00 00 00 je 10ad98 <== NOT EXECUTED /* * Now process the information request. */ the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options; 10ad0d: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 10ad10: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED switch ( name ) { 10ad13: 83 7c 24 14 0b cmpl $0xb,0x14(%esp) <== NOT EXECUTED 10ad18: 76 16 jbe 10ad30 <== NOT EXECUTED break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10ad1a: e8 9d 15 00 00 call 10c2bc <__errno> <== NOT EXECUTED 10ad1f: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ad25: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ad2a: 66 90 xchg %ax,%ax <== NOT EXECUTED break; } return return_value; } 10ad2c: 83 c4 0c add $0xc,%esp 10ad2f: c3 ret * Now process the information request. */ the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { 10ad30: 8b 54 24 14 mov 0x14(%esp),%edx <== NOT EXECUTED 10ad34: ff 24 95 6c f2 11 00 jmp *0x11f26c(,%edx,4) <== NOT EXECUTED 10ad3b: 90 nop <== NOT EXECUTED break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 10ad3c: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED break; 10ad3f: eb eb jmp 10ad2c <== NOT EXECUTED 10ad41: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 10ad44: 8b 40 18 mov 0x18(%eax),%eax <== NOT EXECUTED break; 10ad47: eb e3 jmp 10ad2c <== NOT EXECUTED 10ad49: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 10ad4c: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED break; 10ad4f: eb db jmp 10ad2c <== NOT EXECUTED 10ad51: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 10ad54: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED break; 10ad57: eb d3 jmp 10ad2c <== NOT EXECUTED 10ad59: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 10ad5c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED break; 10ad5f: eb cb jmp 10ad2c <== NOT EXECUTED 10ad61: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_PATH_MAX: return_value = the_limits->path_max; break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 10ad64: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED break; 10ad67: eb c3 jmp 10ad2c <== NOT EXECUTED 10ad69: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_NAME_MAX: return_value = the_limits->name_max; break; case _PC_PATH_MAX: return_value = the_limits->path_max; 10ad6c: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED break; 10ad6f: eb bb jmp 10ad2c <== NOT EXECUTED 10ad71: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_MAX_INPUT: return_value = the_limits->max_input; break; case _PC_NAME_MAX: return_value = the_limits->name_max; 10ad74: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED break; 10ad77: eb b3 jmp 10ad2c <== NOT EXECUTED 10ad79: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_MAX_CANON: return_value = the_limits->max_canon; break; case _PC_MAX_INPUT: return_value = the_limits->max_input; 10ad7c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED break; 10ad7f: eb ab jmp 10ad2c <== NOT EXECUTED 10ad81: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED switch ( name ) { case _PC_LINK_MAX: return_value = the_limits->link_max; break; case _PC_MAX_CANON: return_value = the_limits->max_canon; 10ad84: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED break; 10ad87: eb a3 jmp 10ad2c <== NOT EXECUTED 10ad89: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { case _PC_LINK_MAX: return_value = the_limits->link_max; 10ad8c: 8b 00 mov (%eax),%eax <== NOT EXECUTED break; 10ad8e: eb 9c jmp 10ad2c <== NOT EXECUTED break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 10ad90: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED break; 10ad93: eb 97 jmp 10ad2c <== NOT EXECUTED 10ad95: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED rtems_libio_t *iop; const rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); iop = rtems_libio_iop(fd); rtems_libio_check_is_open(iop); 10ad98: e8 1f 15 00 00 call 10c2bc <__errno> 10ad9d: c7 00 09 00 00 00 movl $0x9,(%eax) 10ada3: b8 ff ff ff ff mov $0xffffffff,%eax 10ada8: eb 82 jmp 10ad2c =============================================================================== 0010793c : #include void free( void *ptr ) { 10793c: 53 push %ebx 10793d: 83 ec 18 sub $0x18,%esp 107940: 8b 5c 24 20 mov 0x20(%esp),%ebx MSBUMP(free_calls, 1); 107944: ff 05 0c f5 12 00 incl 0x12f50c if ( !ptr ) 10794a: 85 db test %ebx,%ebx 10794c: 74 50 je 10799e return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 10794e: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760 107955: 74 4d je 1079a4 <== ALWAYS TAKEN } /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107957: a1 48 d9 12 00 mov 0x12d948,%eax 10795c: 85 c0 test %eax,%eax 10795e: 74 06 je 107966 (*rtems_malloc_statistics_helpers->at_free)(ptr); 107960: 89 1c 24 mov %ebx,(%esp) 107963: ff 50 08 call *0x8(%eax) if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { 107966: 89 5c 24 04 mov %ebx,0x4(%esp) 10796a: a1 6c b2 12 00 mov 0x12b26c,%eax 10796f: 89 04 24 mov %eax,(%esp) 107972: e8 81 5a 00 00 call 10d3f8 <_Protected_heap_Free> 107977: 84 c0 test %al,%al 107979: 75 23 jne 10799e printk( "Program heap: free of bad pointer %p -- range %p - %p \n", ptr, RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end 10797b: a1 6c b2 12 00 mov 0x12b26c,%eax */ if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_free)(ptr); if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { printk( "Program heap: free of bad pointer %p -- range %p - %p \n", 107980: 8b 50 1c mov 0x1c(%eax),%edx 107983: 89 54 24 0c mov %edx,0xc(%esp) 107987: 8b 40 18 mov 0x18(%eax),%eax 10798a: 89 44 24 08 mov %eax,0x8(%esp) 10798e: 89 5c 24 04 mov %ebx,0x4(%esp) 107992: c7 04 24 48 14 12 00 movl $0x121448,(%esp) 107999: e8 ca 0e 00 00 call 108868 RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 10799e: 83 c4 18 add $0x18,%esp 1079a1: 5b pop %ebx 1079a2: c3 ret 1079a3: 90 nop /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && !malloc_is_system_state_OK() ) { 1079a4: e8 83 01 00 00 call 107b2c return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 1079a9: 84 c0 test %al,%al 1079ab: 75 aa jne 107957 !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 1079ad: 89 5c 24 20 mov %ebx,0x20(%esp) RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 1079b1: 83 c4 18 add $0x18,%esp 1079b4: 5b pop %ebx /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 1079b5: e9 ce 01 00 00 jmp 107b88 =============================================================================== 0011f4d8 : int fstat( int fd, struct stat *sbuf ) { 11f4d8: 57 push %edi 11f4d9: 53 push %ebx 11f4da: 53 push %ebx 11f4db: 8b 44 24 10 mov 0x10(%esp),%eax 11f4df: 8b 5c 24 14 mov 0x14(%esp),%ebx rtems_libio_t *iop; /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 11f4e3: 85 db test %ebx,%ebx 11f4e5: 74 51 je 11f538 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EFAULT ); /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 11f4e7: 3b 05 c0 b2 12 00 cmp 0x12b2c0,%eax 11f4ed: 73 35 jae 11f524 11f4ef: 8d 14 40 lea (%eax,%eax,2),%edx 11f4f2: c1 e2 04 shl $0x4,%edx 11f4f5: 03 15 d4 f4 12 00 add 0x12f4d4,%edx rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 11f4fb: f6 42 0d 01 testb $0x1,0xd(%edx) 11f4ff: 74 23 je 11f524 /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 11f501: b9 48 00 00 00 mov $0x48,%ecx 11f506: 31 c0 xor %eax,%eax 11f508: 89 df mov %ebx,%edi 11f50a: f3 aa rep stos %al,%es:(%edi) return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf ); 11f50c: 8b 42 20 mov 0x20(%edx),%eax 11f50f: 89 5c 24 14 mov %ebx,0x14(%esp) 11f513: 83 c2 10 add $0x10,%edx 11f516: 89 54 24 10 mov %edx,0x10(%esp) 11f51a: 8b 40 18 mov 0x18(%eax),%eax } 11f51d: 59 pop %ecx 11f51e: 5b pop %ebx 11f51f: 5f pop %edi * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf ); 11f520: ff e0 jmp *%eax 11f522: 66 90 xchg %ax,%ax /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 11f524: e8 cf 37 ff ff call 112cf8 <__errno> 11f529: c7 00 09 00 00 00 movl $0x9,(%eax) * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf ); } 11f52f: b8 ff ff ff ff mov $0xffffffff,%eax 11f534: 5a pop %edx 11f535: 5b pop %ebx 11f536: 5f pop %edi 11f537: c3 ret /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) rtems_set_errno_and_return_minus_one( EFAULT ); 11f538: e8 bb 37 ff ff call 112cf8 <__errno> <== NOT EXECUTED 11f53d: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 11f543: eb ea jmp 11f52f <== NOT EXECUTED =============================================================================== 00132484 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 132484: 57 push %edi 132485: 56 push %esi 132486: 53 push %ebx 132487: 83 ec 10 sub $0x10,%esp 13248a: 8b 44 24 20 mov 0x20(%esp),%eax 13248e: 8b 74 24 24 mov 0x24(%esp),%esi 132492: 8b 7c 24 28 mov 0x28(%esp),%edi rtems_filesystem_node_types_t type; /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 132496: 3b 05 e0 52 14 00 cmp 0x1452e0,%eax 13249c: 73 36 jae 1324d4 <== NEVER TAKEN 13249e: 8d 1c 40 lea (%eax,%eax,2),%ebx 1324a1: c1 e3 04 shl $0x4,%ebx 1324a4: 03 1d 74 96 15 00 add 0x159674,%ebx /* * Make sure we are working on a directory */ type = rtems_filesystem_node_type( &iop->pathinfo ); 1324aa: 8d 43 10 lea 0x10(%ebx),%eax 1324ad: 89 04 24 mov %eax,(%esp) 1324b0: e8 9b bb fd ff call 10e050 if ( type != RTEMS_FILESYSTEM_DIRECTORY ) 1324b5: 85 c0 test %eax,%eax 1324b7: 75 1f jne 1324d8 /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len ); 1324b9: 8b 43 20 mov 0x20(%ebx),%eax 1324bc: 89 7c 24 28 mov %edi,0x28(%esp) 1324c0: 89 74 24 24 mov %esi,0x24(%esp) 1324c4: 89 5c 24 20 mov %ebx,0x20(%esp) 1324c8: 8b 40 08 mov 0x8(%eax),%eax } 1324cb: 83 c4 10 add $0x10,%esp 1324ce: 5b pop %ebx 1324cf: 5e pop %esi 1324d0: 5f pop %edi /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len ); 1324d1: ff e0 jmp *%eax 1324d3: 90 nop rtems_filesystem_node_types_t type; /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 1324d4: 31 db xor %ebx,%ebx <== NOT EXECUTED 1324d6: eb d2 jmp 1324aa <== NOT EXECUTED /* * Make sure we are working on a directory */ type = rtems_filesystem_node_type( &iop->pathinfo ); if ( type != RTEMS_FILESYSTEM_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 1324d8: e8 6f 2a ff ff call 124f4c <__errno> 1324dd: c7 00 14 00 00 00 movl $0x14,(%eax) /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len ); } 1324e3: b8 ff ff ff ff mov $0xffffffff,%eax 1324e8: 83 c4 10 add $0x10,%esp 1324eb: 5b pop %ebx 1324ec: 5e pop %esi 1324ed: 5f pop %edi 1324ee: c3 ret =============================================================================== 001079bc : */ int gettimeofday( struct timeval *tp, void * __tz __attribute__((unused)) ) { 1079bc: 55 push %ebp 1079bd: 57 push %edi 1079be: 56 push %esi 1079bf: 53 push %ebx 1079c0: 83 ec 3c sub $0x3c,%esp 1079c3: 8b 5c 24 50 mov 0x50(%esp),%ebx /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) 1079c7: 85 db test %ebx,%ebx 1079c9: 74 7d je 107a48 <== NEVER TAKEN { ISR_Level level; struct timespec now; suseconds_t useconds; _ISR_Disable(level); 1079cb: 9c pushf 1079cc: fa cli 1079cd: 5d pop %ebp struct timespec *tod_as_timespec ) { Timestamp_Control tod_as_timestamp; _TOD_Get_as_timestamp( &tod_as_timestamp ); 1079ce: 8d 44 24 28 lea 0x28(%esp),%eax 1079d2: 89 04 24 mov %eax,(%esp) 1079d5: e8 ca 4d 00 00 call 10c7a4 <_TOD_Get_as_timestamp> _Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec ); 1079da: 8b 74 24 28 mov 0x28(%esp),%esi 1079de: 8b 7c 24 2c mov 0x2c(%esp),%edi _TOD_Get( &now ); _ISR_Enable(level); 1079e2: 55 push %ebp 1079e3: 9d popf static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 1079e4: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 1079eb: 3b 1079ec: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 1079f3: 00 1079f4: 89 34 24 mov %esi,(%esp) 1079f7: 89 7c 24 04 mov %edi,0x4(%esp) 1079fb: e8 48 75 01 00 call 11ef48 <__divdi3> 107a00: 89 03 mov %eax,(%ebx) _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 107a02: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 107a09: 3b 107a0a: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 107a11: 00 107a12: 89 34 24 mov %esi,(%esp) 107a15: 89 7c 24 04 mov %edi,0x4(%esp) 107a19: e8 7e 76 01 00 call 11f09c <__moddi3> 107a1e: 89 c6 mov %eax,%esi useconds = (suseconds_t)now.tv_nsec; useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; 107a20: b9 d3 4d 62 10 mov $0x10624dd3,%ecx 107a25: f7 e9 imul %ecx 107a27: 89 44 24 18 mov %eax,0x18(%esp) 107a2b: 89 54 24 1c mov %edx,0x1c(%esp) 107a2f: 8b 54 24 1c mov 0x1c(%esp),%edx 107a33: c1 fa 06 sar $0x6,%edx 107a36: c1 fe 1f sar $0x1f,%esi 107a39: 29 f2 sub %esi,%edx 107a3b: 89 53 04 mov %edx,0x4(%ebx) * Timezone information ignored by the OS proper. Per email * with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X * do it. This puts us in good company. */ return 0; 107a3e: 31 c0 xor %eax,%eax } 107a40: 83 c4 3c add $0x3c,%esp 107a43: 5b pop %ebx 107a44: 5e pop %esi 107a45: 5f pop %edi 107a46: 5d pop %ebp 107a47: c3 ret void * __tz __attribute__((unused)) ) { /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) rtems_set_errno_and_return_minus_one( EFAULT ); 107a48: e8 ab b2 00 00 call 112cf8 <__errno> <== NOT EXECUTED 107a4d: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 107a53: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 107a58: eb e6 jmp 107a40 <== NOT EXECUTED =============================================================================== 0012905c : void init_etc_passwd_group(void) { FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 12905c: 80 3d 60 a9 17 00 00 cmpb $0x0,0x17a960 129063: 74 03 je 129068 fprintf( fp, "root:x:0:root\n" "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); } } 129065: c3 ret 129066: 66 90 xchg %ax,%ax /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 129068: 53 push %ebx 129069: 83 ec 18 sub $0x18,%esp FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) return; etc_passwd_initted = 1; 12906c: c6 05 60 a9 17 00 01 movb $0x1,0x17a960 mkdir("/etc", 0777); 129073: c7 44 24 04 ff 01 00 movl $0x1ff,0x4(%esp) 12907a: 00 12907b: c7 04 24 6f b1 15 00 movl $0x15b16f,(%esp) 129082: e8 19 ea fd ff call 107aa0 /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 129087: c7 44 24 04 55 6b 15 movl $0x156b55,0x4(%esp) 12908e: 00 12908f: c7 04 24 74 b1 15 00 movl $0x15b174,(%esp) 129096: e8 d1 2b 01 00 call 13bc6c 12909b: 85 c0 test %eax,%eax 12909d: 74 71 je 129110 fclose(fp); 12909f: 89 04 24 mov %eax,(%esp) 1290a2: e8 4d 23 01 00 call 13b3f4 } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 1290a7: c7 44 24 04 55 6b 15 movl $0x156b55,0x4(%esp) 1290ae: 00 1290af: c7 04 24 80 b1 15 00 movl $0x15b180,(%esp) 1290b6: e8 b1 2b 01 00 call 13bc6c 1290bb: 85 c0 test %eax,%eax 1290bd: 74 0d je 1290cc fclose(fp); 1290bf: 89 04 24 mov %eax,(%esp) 1290c2: e8 2d 23 01 00 call 13b3f4 fprintf( fp, "root:x:0:root\n" "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); } } 1290c7: 83 c4 18 add $0x18,%esp 1290ca: 5b pop %ebx 1290cb: c3 ret * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/group", "w")) != NULL) { 1290cc: c7 44 24 04 30 6b 15 movl $0x156b30,0x4(%esp) 1290d3: 00 1290d4: c7 04 24 80 b1 15 00 movl $0x15b180,(%esp) 1290db: e8 8c 2b 01 00 call 13bc6c 1290e0: 89 c3 mov %eax,%ebx 1290e2: 85 c0 test %eax,%eax 1290e4: 74 e1 je 1290c7 <== NEVER TAKEN fprintf( fp, "root:x:0:root\n" 1290e6: 89 44 24 0c mov %eax,0xc(%esp) 1290ea: c7 44 24 08 2a 00 00 movl $0x2a,0x8(%esp) 1290f1: 00 1290f2: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 1290f9: 00 1290fa: c7 04 24 f4 b1 15 00 movl $0x15b1f4,(%esp) 129101: e8 9a 3e 01 00 call 13cfa0 "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 129106: 89 1c 24 mov %ebx,(%esp) 129109: e8 e6 22 01 00 call 13b3f4 12910e: eb b7 jmp 1290c7 * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 129110: c7 44 24 04 30 6b 15 movl $0x156b30,0x4(%esp) 129117: 00 129118: c7 04 24 74 b1 15 00 movl $0x15b174,(%esp) 12911f: e8 48 2b 01 00 call 13bc6c 129124: 89 c3 mov %eax,%ebx 129126: 85 c0 test %eax,%eax 129128: 0f 84 79 ff ff ff je 1290a7 <== NEVER TAKEN fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 12912e: 89 44 24 0c mov %eax,0xc(%esp) 129132: c7 44 24 08 66 00 00 movl $0x66,0x8(%esp) 129139: 00 12913a: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 129141: 00 129142: c7 04 24 8c b1 15 00 movl $0x15b18c,(%esp) 129149: e8 52 3e 01 00 call 13cfa0 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 12914e: 89 1c 24 mov %ebx,(%esp) 129151: e8 9e 22 01 00 call 13b3f4 129156: e9 4c ff ff ff jmp 1290a7 =============================================================================== 0010a4b8 : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 10a4b8: 56 push %esi 10a4b9: 53 push %ebx 10a4ba: 53 push %ebx 10a4bb: 89 d6 mov %edx,%esi 10a4bd: 88 c3 mov %al,%bl if (tty->termios.c_iflag & ISTRIP) 10a4bf: 8b 42 30 mov 0x30(%edx),%eax 10a4c2: a8 20 test $0x20,%al 10a4c4: 74 03 je 10a4c9 <== ALWAYS TAKEN c &= 0x7f; 10a4c6: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 10a4c9: f6 c4 02 test $0x2,%ah 10a4cc: 74 18 je 10a4e6 c = tolower (c); 10a4ce: 0f b6 db movzbl %bl,%ebx 10a4d1: 8b 15 08 d4 12 00 mov 0x12d408,%edx 10a4d7: 8a 54 1a 01 mov 0x1(%edx,%ebx,1),%dl 10a4db: 83 e2 03 and $0x3,%edx 10a4de: fe ca dec %dl 10a4e0: 0f 84 aa 00 00 00 je 10a590 if (c == '\r') { 10a4e6: 80 fb 0d cmp $0xd,%bl 10a4e9: 74 4d je 10a538 if (tty->termios.c_iflag & IGNCR) return 0; if (tty->termios.c_iflag & ICRNL) c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 10a4eb: 80 fb 0a cmp $0xa,%bl 10a4ee: 0f 84 94 00 00 00 je 10a588 c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 10a4f4: 84 db test %bl,%bl 10a4f6: 75 4c jne 10a544 <== ALWAYS TAKEN } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 10a4f8: 8b 46 20 mov 0x20(%esi),%eax 10a4fb: 8b 15 3c d2 12 00 mov 0x12d23c,%edx 10a501: 4a dec %edx 10a502: 39 d0 cmp %edx,%eax 10a504: 73 2a jae 10a530 <== NEVER TAKEN if (tty->termios.c_lflag & ECHO) 10a506: f6 46 3c 08 testb $0x8,0x3c(%esi) 10a50a: 0f 85 88 00 00 00 jne 10a598 <== ALWAYS TAKEN echo (c, tty); tty->cbuf[tty->ccount++] = c; 10a510: 8b 56 1c mov 0x1c(%esi),%edx 10a513: 88 1c 02 mov %bl,(%edx,%eax,1) 10a516: 40 inc %eax 10a517: 89 46 20 mov %eax,0x20(%esi) } return 0; 10a51a: 31 c0 xor %eax,%eax } 10a51c: 59 pop %ecx 10a51d: 5b pop %ebx 10a51e: 5e pop %esi 10a51f: c3 ret * FIXME: Some of the tests should check for IEXTEN, too. */ static void erase (struct rtems_termios_tty *tty, int lineFlag) { if (tty->ccount == 0) 10a520: 8b 4e 20 mov 0x20(%esi),%ecx 10a523: 85 c9 test %ecx,%ecx 10a525: 74 09 je 10a530 10a527: 31 d2 xor %edx,%edx 10a529: 89 f0 mov %esi,%eax 10a52b: e8 18 fe ff ff call 10a348 } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { if (c == tty->termios.c_cc[VERASE]) { erase (tty, 0); return 0; 10a530: 31 c0 xor %eax,%eax if (tty->termios.c_lflag & ECHO) echo (c, tty); tty->cbuf[tty->ccount++] = c; } return 0; } 10a532: 59 pop %ecx 10a533: 5b pop %ebx 10a534: 5e pop %esi 10a535: c3 ret 10a536: 66 90 xchg %ax,%ax if (tty->termios.c_iflag & IUCLC) c = tolower (c); if (c == '\r') { if (tty->termios.c_iflag & IGNCR) 10a538: a8 80 test $0x80,%al 10a53a: 75 f4 jne 10a530 <== NEVER TAKEN return 0; if (tty->termios.c_iflag & ICRNL) 10a53c: f6 c4 01 test $0x1,%ah 10a53f: 74 03 je 10a544 <== NEVER TAKEN c = '\n'; 10a541: b3 0a mov $0xa,%bl 10a543: 90 nop } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 10a544: 8b 46 3c mov 0x3c(%esi),%eax 10a547: a8 02 test $0x2,%al 10a549: 74 ad je 10a4f8 if (c == tty->termios.c_cc[VERASE]) { 10a54b: 38 5e 43 cmp %bl,0x43(%esi) 10a54e: 74 d0 je 10a520 erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { 10a550: 38 5e 44 cmp %bl,0x44(%esi) 10a553: 74 63 je 10a5b8 erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { 10a555: 38 5e 45 cmp %bl,0x45(%esi) 10a558: 0f 84 aa 00 00 00 je 10a608 <== NEVER TAKEN return 1; } else if (c == '\n') { 10a55e: 80 fb 0a cmp $0xa,%bl 10a561: 74 7d je 10a5e0 if (tty->termios.c_lflag & (ECHO | ECHONL)) echo (c, tty); tty->cbuf[tty->ccount++] = c; return 1; } else if ((c == tty->termios.c_cc[VEOL]) || 10a563: 38 5e 4c cmp %bl,0x4c(%esi) 10a566: 74 05 je 10a56d <== NEVER TAKEN 10a568: 38 5e 51 cmp %bl,0x51(%esi) 10a56b: 75 8b jne 10a4f8 <== ALWAYS TAKEN (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 10a56d: a8 08 test $0x8,%al <== NOT EXECUTED 10a56f: 75 3b jne 10a5ac <== NOT EXECUTED echo (c, tty); tty->cbuf[tty->ccount++] = c; 10a571: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 10a574: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 10a577: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED 10a57a: 40 inc %eax <== NOT EXECUTED 10a57b: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED return 1; 10a57e: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a583: eb 97 jmp 10a51c <== NOT EXECUTED 10a585: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (c == '\r') { if (tty->termios.c_iflag & IGNCR) return 0; if (tty->termios.c_iflag & ICRNL) c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 10a588: a8 40 test $0x40,%al 10a58a: 74 b8 je 10a544 <== ALWAYS TAKEN c = '\r'; 10a58c: b3 0d mov $0xd,%bl <== NOT EXECUTED 10a58e: eb b4 jmp 10a544 <== NOT EXECUTED { if (tty->termios.c_iflag & ISTRIP) c &= 0x7f; if (tty->termios.c_iflag & IUCLC) c = tolower (c); 10a590: 83 c3 20 add $0x20,%ebx 10a593: e9 4e ff ff ff jmp 10a4e6 /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); 10a598: 0f b6 c3 movzbl %bl,%eax 10a59b: 89 f2 mov %esi,%edx 10a59d: e8 3a fd ff ff call 10a2dc 10a5a2: 8b 46 20 mov 0x20(%esi),%eax 10a5a5: e9 66 ff ff ff jmp 10a510 10a5aa: 66 90 xchg %ax,%ax tty->cbuf[tty->ccount++] = c; return 1; } else if ((c == tty->termios.c_cc[VEOL]) || (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) echo (c, tty); 10a5ac: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10a5af: 89 f2 mov %esi,%edx <== NOT EXECUTED 10a5b1: e8 26 fd ff ff call 10a2dc <== NOT EXECUTED 10a5b6: eb b9 jmp 10a571 <== NOT EXECUTED * FIXME: Some of the tests should check for IEXTEN, too. */ static void erase (struct rtems_termios_tty *tty, int lineFlag) { if (tty->ccount == 0) 10a5b8: 8b 56 20 mov 0x20(%esi),%edx 10a5bb: 85 d2 test %edx,%edx 10a5bd: 0f 84 6d ff ff ff je 10a530 <== NEVER TAKEN return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { 10a5c3: a8 08 test $0x8,%al 10a5c5: 74 4b je 10a612 <== NEVER TAKEN tty->ccount = 0; return; } if (!(tty->termios.c_lflag & ECHOE)) { 10a5c7: a8 10 test $0x10,%al 10a5c9: 74 55 je 10a620 <== NEVER TAKEN 10a5cb: ba 01 00 00 00 mov $0x1,%edx 10a5d0: 89 f0 mov %esi,%eax 10a5d2: e8 71 fd ff ff call 10a348 erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); return 0; 10a5d7: 31 c0 xor %eax,%eax 10a5d9: e9 3e ff ff ff jmp 10a51c 10a5de: 66 90 xchg %ax,%ax } else if (c == tty->termios.c_cc[VEOF]) { return 1; } else if (c == '\n') { if (tty->termios.c_lflag & (ECHO | ECHONL)) 10a5e0: a8 48 test $0x48,%al 10a5e2: 74 0c je 10a5f0 <== NEVER TAKEN echo (c, tty); 10a5e4: 89 f2 mov %esi,%edx 10a5e6: b8 0a 00 00 00 mov $0xa,%eax 10a5eb: e8 ec fc ff ff call 10a2dc tty->cbuf[tty->ccount++] = c; 10a5f0: 8b 46 20 mov 0x20(%esi),%eax 10a5f3: 8b 56 1c mov 0x1c(%esi),%edx 10a5f6: c6 04 02 0a movb $0xa,(%edx,%eax,1) 10a5fa: 40 inc %eax 10a5fb: 89 46 20 mov %eax,0x20(%esi) return 1; 10a5fe: b8 01 00 00 00 mov $0x1,%eax 10a603: e9 14 ff ff ff jmp 10a51c else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { return 1; 10a608: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a60d: e9 0a ff ff ff jmp 10a51c <== NOT EXECUTED { if (tty->ccount == 0) return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { tty->ccount = 0; 10a612: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); return 0; 10a619: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a61b: e9 fc fe ff ff jmp 10a51c <== NOT EXECUTED if (!(tty->termios.c_lflag & ECHO)) { tty->ccount = 0; return; } if (!(tty->termios.c_lflag & ECHOE)) { tty->ccount = 0; 10a620: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 10a627: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10a62a: 89 f2 mov %esi,%edx <== NOT EXECUTED 10a62c: e8 ab fc ff ff call 10a2dc <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 10a631: f6 46 3c 20 testb $0x20,0x3c(%esi) <== NOT EXECUTED 10a635: 0f 84 f5 fe ff ff je 10a530 <== NOT EXECUTED echo ('\n', tty); 10a63b: 89 f2 mov %esi,%edx <== NOT EXECUTED 10a63d: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10a642: e8 95 fc ff ff call 10a2dc <== NOT EXECUTED erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); return 0; 10a647: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a649: e9 ce fe ff ff jmp 10a51c <== NOT EXECUTED =============================================================================== 0011f580 : #if !defined(RTEMS_POSIX_API) int kill( pid_t pid, int sig ) { return 0; } 11f580: 31 c0 xor %eax,%eax <== NOT EXECUTED 11f582: c3 ret <== NOT EXECUTED =============================================================================== 001081d0 : /* * In case RTEMS is already down, don't do this. It could be * dangerous. */ if (!_System_state_Is_up(_System_state_Get())) 1081d0: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760 1081d7: 74 03 je 1081dc <== ALWAYS TAKEN */ fclose (stdin); fclose (stdout); fclose (stderr); } 1081d9: c3 ret <== NOT EXECUTED 1081da: 66 90 xchg %ax,%ax <== NOT EXECUTED extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 1081dc: 53 push %ebx 1081dd: 83 ec 18 sub $0x18,%esp /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != _global_impure_ptr) { 1081e0: 8b 1d 20 20 12 00 mov 0x122020,%ebx 1081e6: 39 1d 20 d4 12 00 cmp %ebx,0x12d420 1081ec: 74 0e je 1081fc _wrapup_reent(_global_impure_ptr); 1081ee: 89 1c 24 mov %ebx,(%esp) 1081f1: e8 56 b5 00 00 call 11374c <_wrapup_reent> /* Don't reclaim this one, just in case we do printfs * on the way out to ROM. */ _reclaim_reent(&libc_global_reent); #endif _REENT = _global_impure_ptr; 1081f6: 89 1d 20 d4 12 00 mov %ebx,0x12d420 * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 1081fc: 8b 43 04 mov 0x4(%ebx),%eax 1081ff: 89 04 24 mov %eax,(%esp) 108202: e8 0d ac 00 00 call 112e14 fclose (stdout); 108207: a1 20 d4 12 00 mov 0x12d420,%eax 10820c: 8b 40 08 mov 0x8(%eax),%eax 10820f: 89 04 24 mov %eax,(%esp) 108212: e8 fd ab 00 00 call 112e14 fclose (stderr); 108217: a1 20 d4 12 00 mov 0x12d420,%eax 10821c: 8b 40 0c mov 0xc(%eax),%eax 10821f: 89 04 24 mov %eax,(%esp) 108222: e8 ed ab 00 00 call 112e14 } 108227: 83 c4 18 add $0x18,%esp 10822a: 5b pop %ebx 10822b: c3 ret =============================================================================== 00107c50 : #include "malloc_p.h" void *malloc( size_t size ) { 107c50: 56 push %esi 107c51: 53 push %ebx 107c52: 83 ec 14 sub $0x14,%esp 107c55: 8b 74 24 20 mov 0x20(%esp),%esi void *return_this; MSBUMP(malloc_calls, 1); 107c59: ff 05 04 f5 12 00 incl 0x12f504 /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 107c5f: e8 00 ff ff ff call 107b64 /* * Validate the parameters */ if ( !size ) 107c64: 85 f6 test %esi,%esi 107c66: 74 65 je 107ccd return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 107c68: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760 107c6f: 74 53 je 107cc4 RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 107c71: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 107c78: 00 107c79: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 107c80: 00 107c81: 89 74 24 04 mov %esi,0x4(%esp) 107c85: a1 6c b2 12 00 mov 0x12b26c,%eax 107c8a: 89 04 24 mov %eax,(%esp) 107c8d: e8 16 57 00 00 call 10d3a8 <_Protected_heap_Allocate_aligned_with_boundary> 107c92: 89 c3 mov %eax,%ebx * If this fails then return a NULL pointer. */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { 107c94: 85 c0 test %eax,%eax 107c96: 74 40 je 107cd8 } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 107c98: a1 40 d9 12 00 mov 0x12d940,%eax 107c9d: 85 c0 test %eax,%eax 107c9f: 74 09 je 107caa (*rtems_malloc_dirty_helper)( return_this, size ); 107ca1: 89 74 24 04 mov %esi,0x4(%esp) 107ca5: 89 1c 24 mov %ebx,(%esp) 107ca8: ff d0 call *%eax /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107caa: a1 48 d9 12 00 mov 0x12d948,%eax 107caf: 85 c0 test %eax,%eax 107cb1: 74 06 je 107cb9 (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 107cb3: 89 1c 24 mov %ebx,(%esp) 107cb6: ff 50 04 call *0x4(%eax) return return_this; } 107cb9: 89 d8 mov %ebx,%eax 107cbb: 83 c4 14 add $0x14,%esp 107cbe: 5b pop %ebx 107cbf: 5e pop %esi 107cc0: c3 ret 107cc1: 8d 76 00 lea 0x0(%esi),%esi /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && !malloc_is_system_state_OK() ) 107cc4: e8 63 fe ff ff call 107b2c return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 107cc9: 84 c0 test %al,%al 107ccb: 75 a4 jne 107c71 <== ALWAYS TAKEN /* * Validate the parameters */ if ( !size ) return (void *) 0; 107ccd: 31 db xor %ebx,%ebx */ if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_malloc)(return_this); return return_this; } 107ccf: 89 d8 mov %ebx,%eax 107cd1: 83 c4 14 add $0x14,%esp 107cd4: 5b pop %ebx 107cd5: 5e pop %esi 107cd6: c3 ret 107cd7: 90 nop */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { if (rtems_malloc_sbrk_helpers) 107cd8: a1 44 d9 12 00 mov 0x12d944,%eax 107cdd: 85 c0 test %eax,%eax 107cdf: 74 0f je 107cf0 return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 107ce1: 89 34 24 mov %esi,(%esp) 107ce4: ff 50 04 call *0x4(%eax) if ( !return_this ) { 107ce7: 85 c0 test %eax,%eax 107ce9: 74 05 je 107cf0 107ceb: 89 c3 mov %eax,%ebx 107ced: eb a9 jmp 107c98 107cef: 90 nop errno = ENOMEM; 107cf0: e8 03 b0 00 00 call 112cf8 <__errno> 107cf5: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 107cfb: eb bc jmp 107cb9 =============================================================================== 00107cd8 : } static void *malloc_sbrk_extend_and_allocate( size_t size ) { 107cd8: 56 push %esi 107cd9: 53 push %ebx 107cda: 83 ec 14 sub $0x14,%esp 107cdd: 8b 74 24 20 mov 0x20(%esp),%esi * Round to the "requested sbrk amount" so hopefully we won't have * to grow again for a while. This effectively does sbrk() calls * in "page" amounts. */ sbrk_amount = RTEMS_Malloc_Sbrk_amount; 107ce1: 8b 0d ec 06 13 00 mov 0x1306ec,%ecx if ( sbrk_amount == 0 ) 107ce7: 85 c9 test %ecx,%ecx 107ce9: 74 76 je 107d61 <== NEVER TAKEN return (void *) 0; the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount); 107ceb: 8d 04 0e lea (%esi,%ecx,1),%eax 107cee: 31 d2 xor %edx,%edx 107cf0: f7 f1 div %ecx 107cf2: 89 c3 mov %eax,%ebx 107cf4: 0f af d9 imul %ecx,%ebx starting_address = (void *) sbrk(the_size); 107cf7: 89 1c 24 mov %ebx,(%esp) 107cfa: e8 3d 87 ff ff call 10043c if ( starting_address == (void*) -1 ) 107cff: 83 f8 ff cmp $0xffffffff,%eax 107d02: 74 5d je 107d61 return (void *) 0; if ( !_Protected_heap_Extend( 107d04: 89 5c 24 08 mov %ebx,0x8(%esp) 107d08: 89 44 24 04 mov %eax,0x4(%esp) 107d0c: a1 cc c2 12 00 mov 0x12c2cc,%eax 107d11: 89 04 24 mov %eax,(%esp) 107d14: e8 c3 56 00 00 call 10d3dc <_Protected_heap_Extend> 107d19: 84 c0 test %al,%al 107d1b: 74 2f je 107d4c sbrk(-the_size); errno = ENOMEM; return (void *) 0; } MSBUMP(space_available, the_size); 107d1d: 01 1d c0 06 13 00 add %ebx,0x1306c0 107d23: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 107d2a: 00 107d2b: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 107d32: 00 107d33: 89 74 24 04 mov %esi,0x4(%esp) 107d37: a1 cc c2 12 00 mov 0x12c2cc,%eax 107d3c: 89 04 24 mov %eax,(%esp) 107d3f: e8 48 56 00 00 call 10d38c <_Protected_heap_Allocate_aligned_with_boundary> return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); return return_this; } 107d44: 83 c4 14 add $0x14,%esp 107d47: 5b pop %ebx 107d48: 5e pop %esi 107d49: c3 ret 107d4a: 66 90 xchg %ax,%ax if ( starting_address == (void*) -1 ) return (void *) 0; if ( !_Protected_heap_Extend( RTEMS_Malloc_Heap, starting_address, the_size) ) { sbrk(-the_size); 107d4c: f7 db neg %ebx 107d4e: 89 1c 24 mov %ebx,(%esp) 107d51: e8 e6 86 ff ff call 10043c errno = ENOMEM; 107d56: e8 a9 b2 00 00 call 113004 <__errno> 107d5b: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 107d61: 31 c0 xor %eax,%eax MSBUMP(space_available, the_size); return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); return return_this; } 107d63: 83 c4 14 add $0x14,%esp 107d66: 5b pop %ebx 107d67: 5e pop %esi 107d68: c3 ret =============================================================================== 00107d6c : static void *malloc_sbrk_initialize( void *starting_address, size_t length ) { 107d6c: 83 ec 1c sub $0x1c,%esp 107d6f: 8b 44 24 20 mov 0x20(%esp),%eax 107d73: 8b 54 24 24 mov 0x24(%esp),%edx uintptr_t old_address; uintptr_t uaddress; RTEMS_Malloc_Sbrk_amount = length; 107d77: 89 15 ec 06 13 00 mov %edx,0x1306ec * If the starting address is 0 then we are to attempt to * get length worth of memory using sbrk. Make sure we * align the address that we get back. */ if (!starting_address) { 107d7d: 85 c0 test %eax,%eax 107d7f: 74 07 je 107d88 } starting_address = (void *)uaddress; } return starting_address; } 107d81: 83 c4 1c add $0x1c,%esp 107d84: c3 ret 107d85: 8d 76 00 lea 0x0(%esi),%esi * get length worth of memory using sbrk. Make sure we * align the address that we get back. */ if (!starting_address) { uaddress = (uintptr_t)sbrk(length); 107d88: 89 14 24 mov %edx,(%esp) 107d8b: e8 ac 86 ff ff call 10043c if (uaddress == (uintptr_t) -1) { 107d90: 83 f8 ff cmp $0xffffffff,%eax 107d93: 74 0c je 107da1 <== ALWAYS TAKEN rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); /* DOES NOT RETURN!!! */ } if (uaddress & (CPU_HEAP_ALIGNMENT-1)) { 107d95: a8 03 test $0x3,%al <== NOT EXECUTED 107d97: 74 e8 je 107d81 <== NOT EXECUTED old_address = uaddress; uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1); 107d99: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 107d9c: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 107d9f: eb e0 jmp 107d81 <== NOT EXECUTED if (!starting_address) { uaddress = (uintptr_t)sbrk(length); if (uaddress == (uintptr_t) -1) { rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); 107da1: c7 04 24 1a 00 00 00 movl $0x1a,(%esp) 107da8: e8 67 43 00 00 call 10c114 =============================================================================== 00107e60 : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 107e60: 55 push %ebp 107e61: 57 push %edi 107e62: 56 push %esi 107e63: 53 push %ebx 107e64: 83 ec 7c sub $0x7c,%esp 107e67: 8b b4 24 98 00 00 00 mov 0x98(%esp),%esi int rv = 0; if ( 107e6e: 83 bc 24 9c 00 00 00 cmpl $0x1,0x9c(%esp) 107e75: 01 107e76: 0f 87 6c 02 00 00 ja 1080e8 options == RTEMS_FILESYSTEM_READ_ONLY || options == RTEMS_FILESYSTEM_READ_WRITE ) { rtems_filesystem_fsmount_me_t fsmount_me_h = 107e7c: 89 34 24 mov %esi,(%esp) 107e7f: e8 6c 80 00 00 call 10fef0 107e84: 89 c5 mov %eax,%ebp rtems_filesystem_get_mount_handler( filesystemtype ); if ( fsmount_me_h != NULL ) { 107e86: 85 c0 test %eax,%eax 107e88: 0f 84 5a 02 00 00 je 1080e8 const char *target_or_null, const char *filesystemtype, size_t *target_length_ptr ) { const char *target = target_or_null != NULL ? target_or_null : "/"; 107e8e: 8b 9c 24 94 00 00 00 mov 0x94(%esp),%ebx 107e95: 85 db test %ebx,%ebx 107e97: 0f 84 33 02 00 00 je 1080d0 } return rv; } int mount( 107e9d: 31 c0 xor %eax,%eax 107e9f: b9 ff ff ff ff mov $0xffffffff,%ecx 107ea4: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi 107eab: f2 ae repnz scas %es:(%edi),%al 107ead: f7 d1 not %ecx 107eaf: 89 4c 24 14 mov %ecx,0x14(%esp) 107eb3: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi 107eba: 89 7c 24 1c mov %edi,0x1c(%esp) const char *filesystemtype, size_t *target_length_ptr ) { const char *target = target_or_null != NULL ? target_or_null : "/"; size_t filesystemtype_size = strlen( filesystemtype ) + 1; 107ebe: bb ff ff ff ff mov $0xffffffff,%ebx 107ec3: 31 c0 xor %eax,%eax 107ec5: 89 d9 mov %ebx,%ecx 107ec7: 89 f7 mov %esi,%edi 107ec9: f2 ae repnz scas %es:(%edi),%al 107ecb: f7 d1 not %ecx 107ecd: 89 4c 24 10 mov %ecx,0x10(%esp) 107ed1: 89 ca mov %ecx,%edx 107ed3: 4a dec %edx size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; 107ed4: 8b 8c 24 90 00 00 00 mov 0x90(%esp),%ecx 107edb: 85 c9 test %ecx,%ecx 107edd: 0f 84 dd 01 00 00 je 1080c0 107ee3: 89 d9 mov %ebx,%ecx 107ee5: 8b bc 24 90 00 00 00 mov 0x90(%esp),%edi 107eec: f2 ae repnz scas %es:(%edi),%al 107eee: f7 d1 not %ecx 107ef0: 89 4c 24 18 mov %ecx,0x18(%esp) size_t target_size = strlen( target ) + 1; size_t size = sizeof( rtems_filesystem_mount_table_entry_t ) + filesystemtype_size + source_size + target_size 107ef4: 8b 4c 24 14 mov 0x14(%esp),%ecx 107ef8: 8d 44 11 65 lea 0x65(%ecx,%edx,1),%eax const char *target = target_or_null != NULL ? target_or_null : "/"; size_t filesystemtype_size = strlen( filesystemtype ) + 1; size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; size_t target_size = strlen( target ) + 1; size_t size = sizeof( rtems_filesystem_mount_table_entry_t ) 107efc: 03 44 24 18 add 0x18(%esp),%eax + filesystemtype_size + source_size + target_size + sizeof( rtems_filesystem_global_location_t ); rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 107f00: 89 44 24 04 mov %eax,0x4(%esp) 107f04: c7 04 24 01 00 00 00 movl $0x1,(%esp) 107f0b: e8 d8 f7 ff ff call 1076e8 107f10: 89 c3 mov %eax,%ebx if ( mt_entry != NULL ) { 107f12: 85 c0 test %eax,%eax 107f14: 0f 84 8a 01 00 00 je 1080a4 <== NEVER TAKEN rtems_filesystem_global_location_t *mt_fs_root = 107f1a: 8d 50 40 lea 0x40(%eax),%edx (rtems_filesystem_global_location_t *) ((char *) mt_entry + sizeof( *mt_entry )); char *str = (char *) mt_fs_root + sizeof( *mt_fs_root ); 107f1d: 8d 40 64 lea 0x64(%eax),%eax memcpy( str, filesystemtype, filesystemtype_size ); 107f20: 89 c7 mov %eax,%edi 107f22: 8b 4c 24 10 mov 0x10(%esp),%ecx 107f26: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 107f28: 89 7c 24 10 mov %edi,0x10(%esp) mt_entry->type = str; 107f2c: 89 43 34 mov %eax,0x34(%ebx) str += filesystemtype_size; memcpy( str, source_or_null, source_size ); 107f2f: 8b b4 24 90 00 00 00 mov 0x90(%esp),%esi 107f36: 8b 4c 24 18 mov 0x18(%esp),%ecx 107f3a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 107f3c: 89 f8 mov %edi,%eax mt_entry->dev = str; 107f3e: 8b 7c 24 10 mov 0x10(%esp),%edi 107f42: 89 7b 38 mov %edi,0x38(%ebx) str += source_size; memcpy( str, target, target_size ); 107f45: 89 c7 mov %eax,%edi 107f47: 8b 74 24 1c mov 0x1c(%esp),%esi 107f4b: 8b 4c 24 14 mov 0x14(%esp),%ecx 107f4f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) mt_entry->target = str; 107f51: 89 43 30 mov %eax,0x30(%ebx) str += target_size; mt_entry->mounted = true; 107f54: c6 43 28 01 movb $0x1,0x28(%ebx) mt_entry->mt_fs_root = mt_fs_root; 107f58: 89 53 24 mov %edx,0x24(%ebx) mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf; 107f5b: c7 43 2c a0 14 12 00 movl $0x1214a0,0x2c(%ebx) mt_fs_root->location.mt_entry = mt_entry; 107f62: 89 5b 54 mov %ebx,0x54(%ebx) mt_fs_root->reference_count = 1; 107f65: c7 43 58 01 00 00 00 movl $0x1,0x58(%ebx) void *starting_address, size_t number_nodes, size_t node_size ) { _Chain_Initialize( the_chain, starting_address, number_nodes, node_size ); 107f6c: c7 44 24 0c 24 00 00 movl $0x24,0xc(%esp) 107f73: 00 107f74: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) 107f7b: 00 107f7c: 89 54 24 04 mov %edx,0x4(%esp) rtems_chain_initialize( 107f80: 8d 43 14 lea 0x14(%ebx),%eax 107f83: 89 04 24 mov %eax,(%esp) 107f86: e8 41 44 00 00 call 10c3cc <_Chain_Initialize> filesystemtype, &target_length ); if ( mt_entry != NULL ) { mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE; 107f8b: 8a 84 24 9c 00 00 00 mov 0x9c(%esp),%al 107f92: 88 43 29 mov %al,0x29(%ebx) 107f95: 80 63 29 01 andb $0x1,0x29(%ebx) rv = (*fsmount_me_h)( mt_entry, data ); 107f99: 8b 84 24 a0 00 00 00 mov 0xa0(%esp),%eax 107fa0: 89 44 24 04 mov %eax,0x4(%esp) 107fa4: 89 1c 24 mov %ebx,(%esp) 107fa7: ff d5 call *%ebp 107fa9: 89 c6 mov %eax,%esi if ( rv == 0 ) { 107fab: 85 c0 test %eax,%eax 107fad: 0f 85 99 00 00 00 jne 10804c if ( target != NULL ) { 107fb3: 8b 84 24 94 00 00 00 mov 0x94(%esp),%eax 107fba: 85 c0 test %eax,%eax 107fbc: 0f 84 42 01 00 00 je 108104 { int rv = 0; rtems_filesystem_eval_path_context_t ctx; int eval_flags = RTEMS_FS_PERMS_RWX | RTEMS_FS_FOLLOW_LINK; rtems_filesystem_location_info_t *currentloc = 107fc2: c7 44 24 08 1f 00 00 movl $0x1f,0x8(%esp) 107fc9: 00 107fca: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi 107fd1: 89 7c 24 04 mov %edi,0x4(%esp) rtems_filesystem_eval_path_start( &ctx, target, eval_flags ); 107fd5: 8d 6c 24 38 lea 0x38(%esp),%ebp 107fd9: 89 2c 24 mov %ebp,(%esp) { int rv = 0; rtems_filesystem_eval_path_context_t ctx; int eval_flags = RTEMS_FS_PERMS_RWX | RTEMS_FS_FOLLOW_LINK; rtems_filesystem_location_info_t *currentloc = 107fdc: e8 0b 0d 00 00 call 108cec static inline bool rtems_filesystem_location_is_root( const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; 107fe1: 8b 50 14 mov 0x14(%eax),%edx return (*mt_entry->ops->are_nodes_equal_h)( 107fe4: 8b 4a 0c mov 0xc(%edx),%ecx 107fe7: 8b 52 24 mov 0x24(%edx),%edx 107fea: 89 54 24 04 mov %edx,0x4(%esp) 107fee: 89 04 24 mov %eax,(%esp) 107ff1: ff 51 10 call *0x10(%ecx) rtems_filesystem_eval_path_start( &ctx, target, eval_flags ); if ( !rtems_filesystem_location_is_root( currentloc ) ) { 107ff4: 84 c0 test %al,%al 107ff6: 0f 85 95 01 00 00 jne 108191 static inline void rtems_filesystem_eval_path_extract_currentloc( rtems_filesystem_eval_path_context_t *ctx, rtems_filesystem_location_info_t *get ) { rtems_filesystem_location_copy_and_detach( 107ffc: 8d 44 24 50 lea 0x50(%esp),%eax 108000: 89 44 24 04 mov %eax,0x4(%esp) rtems_filesystem_location_info_t targetloc; rtems_filesystem_global_location_t *mt_point_node; rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc ); 108004: 8d 74 24 20 lea 0x20(%esp),%esi 108008: 89 34 24 mov %esi,(%esp) 10800b: e8 78 10 00 00 call 109088 mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc ); 108010: 89 34 24 mov %esi,(%esp) 108013: e8 0c 12 00 00 call 109224 108018: 89 c7 mov %eax,%edi mt_entry->mt_point_node = mt_point_node; 10801a: 89 43 20 mov %eax,0x20(%ebx) rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry ); 10801d: 8b 40 14 mov 0x14(%eax),%eax 108020: 8b 40 0c mov 0xc(%eax),%eax 108023: 89 1c 24 mov %ebx,(%esp) 108026: ff 50 30 call *0x30(%eax) 108029: 89 c6 mov %eax,%esi if ( rv == 0 ) { 10802b: 85 c0 test %eax,%eax 10802d: 74 31 je 108060 &rtems_filesystem_mount_table, &mt_entry->mt_node ); rtems_filesystem_mt_unlock(); } else { rtems_filesystem_global_location_release( mt_point_node ); 10802f: 89 3c 24 mov %edi,(%esp) 108032: e8 0d 11 00 00 call 109144 } else { rtems_filesystem_eval_path_error( &ctx, EBUSY ); rv = -1; } rtems_filesystem_eval_path_cleanup( &ctx ); 108037: 89 2c 24 mov %ebp,(%esp) 10803a: e8 99 0d 00 00 call 108dd8 rv = register_subordinate_file_system( mt_entry, target ); } else { rv = register_root_file_system( mt_entry ); } if ( rv != 0 ) { 10803f: 85 f6 test %esi,%esi 108041: 74 11 je 108054 (*mt_entry->ops->fsunmount_me_h)( mt_entry ); 108043: 8b 43 0c mov 0xc(%ebx),%eax 108046: 89 1c 24 mov %ebx,(%esp) 108049: ff 50 3c call *0x3c(%eax) } } if ( rv != 0 ) { free( mt_entry ); 10804c: 89 1c 24 mov %ebx,(%esp) 10804f: e8 e8 f8 ff ff call 10793c errno = EINVAL; rv = -1; } return rv; } 108054: 89 f0 mov %esi,%eax 108056: 83 c4 7c add $0x7c,%esp 108059: 5b pop %ebx 10805a: 5e pop %esi 10805b: 5f pop %edi 10805c: 5d pop %ebp 10805d: c3 ret 10805e: 66 90 xchg %ax,%ax */ #include static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 108060: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 108067: 00 108068: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10806f: 00 108070: a1 dc f4 12 00 mov 0x12f4dc,%eax 108075: 89 04 24 mov %eax,(%esp) 108078: e8 ff 38 00 00 call 10b97c Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10807d: a1 2c d2 12 00 mov 0x12d22c,%eax the_node->next = tail; 108082: c7 03 28 d2 12 00 movl $0x12d228,(%ebx) tail->previous = the_node; 108088: 89 1d 2c d2 12 00 mov %ebx,0x12d22c old_last->next = the_node; 10808e: 89 18 mov %ebx,(%eax) the_node->previous = old_last; 108090: 89 43 04 mov %eax,0x4(%ebx) } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 108093: a1 dc f4 12 00 mov 0x12f4dc,%eax 108098: 89 04 24 mov %eax,(%esp) 10809b: e8 08 3a 00 00 call 10baa8 1080a0: eb 95 jmp 108037 1080a2: 66 90 xchg %ax,%ax if ( rv != 0 ) { free( mt_entry ); } } else { errno = ENOMEM; 1080a4: e8 4f ac 00 00 call 112cf8 <__errno> <== NOT EXECUTED 1080a9: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED rv = -1; 1080af: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED errno = EINVAL; rv = -1; } return rv; } 1080b4: 89 f0 mov %esi,%eax <== NOT EXECUTED 1080b6: 83 c4 7c add $0x7c,%esp <== NOT EXECUTED 1080b9: 5b pop %ebx <== NOT EXECUTED 1080ba: 5e pop %esi <== NOT EXECUTED 1080bb: 5f pop %edi <== NOT EXECUTED 1080bc: 5d pop %ebp <== NOT EXECUTED 1080bd: c3 ret <== NOT EXECUTED 1080be: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { const char *target = target_or_null != NULL ? target_or_null : "/"; size_t filesystemtype_size = strlen( filesystemtype ) + 1; size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; 1080c0: c7 44 24 18 00 00 00 movl $0x0,0x18(%esp) 1080c7: 00 1080c8: e9 27 fe ff ff jmp 107ef4 1080cd: 8d 76 00 lea 0x0(%esi),%esi const char *target_or_null, const char *filesystemtype, size_t *target_length_ptr ) { const char *target = target_or_null != NULL ? target_or_null : "/"; 1080d0: c7 44 24 14 02 00 00 movl $0x2,0x14(%esp) 1080d7: 00 1080d8: c7 44 24 1c 80 14 12 movl $0x121480,0x1c(%esp) 1080df: 00 1080e0: e9 d9 fd ff ff jmp 107ebe 1080e5: 8d 76 00 lea 0x0(%esi),%esi } else { errno = EINVAL; rv = -1; } } else { errno = EINVAL; 1080e8: e8 0b ac 00 00 call 112cf8 <__errno> 1080ed: c7 00 16 00 00 00 movl $0x16,(%eax) rv = -1; 1080f3: be ff ff ff ff mov $0xffffffff,%esi } return rv; } 1080f8: 89 f0 mov %esi,%eax 1080fa: 83 c4 7c add $0x7c,%esp 1080fd: 5b pop %ebx 1080fe: 5e pop %esi 1080ff: 5f pop %edi 108100: 5d pop %ebp 108101: c3 ret 108102: 66 90 xchg %ax,%ax */ #include static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 108104: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10810b: 00 10810c: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 108113: 00 108114: a1 dc f4 12 00 mov 0x12f4dc,%eax 108119: 89 04 24 mov %eax,(%esp) 10811c: e8 5b 38 00 00 call 10b97c ) { int rv = 0; rtems_filesystem_mt_lock(); if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) { 108121: 81 3d 24 d2 12 00 28 cmpl $0x12d228,0x12d224 108128: d2 12 00 10812b: 75 7e jne 1081ab <== NEVER TAKEN Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10812d: a1 2c d2 12 00 mov 0x12d22c,%eax the_node->next = tail; 108132: c7 03 28 d2 12 00 movl $0x12d228,(%ebx) tail->previous = the_node; 108138: 89 1d 2c d2 12 00 mov %ebx,0x12d22c old_last->next = the_node; 10813e: 89 18 mov %ebx,(%eax) the_node->previous = old_last; 108140: 89 43 04 mov %eax,0x4(%ebx) } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 108143: a1 dc f4 12 00 mov 0x12f4dc,%eax 108148: 89 04 24 mov %eax,(%esp) 10814b: e8 58 39 00 00 call 10baa8 } rtems_filesystem_mt_unlock(); if ( rv == 0 ) { rtems_filesystem_global_location_t *new_fs_root = rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root ); 108150: 83 c3 24 add $0x24,%ebx rv = -1; } rtems_filesystem_mt_unlock(); if ( rv == 0 ) { rtems_filesystem_global_location_t *new_fs_root = 108153: 89 1c 24 mov %ebx,(%esp) 108156: e8 41 10 00 00 call 10919c 10815b: 89 c7 mov %eax,%edi rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root ); rtems_filesystem_global_location_t *new_fs_current = 10815d: 89 1c 24 mov %ebx,(%esp) 108160: e8 37 10 00 00 call 10919c 108165: 89 c3 mov %eax,%ebx rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root ); rtems_filesystem_global_location_assign( 108167: 89 7c 24 04 mov %edi,0x4(%esp) 10816b: a1 60 d2 12 00 mov 0x12d260,%eax 108170: 83 c0 04 add $0x4,%eax 108173: 89 04 24 mov %eax,(%esp) 108176: e8 05 10 00 00 call 109180 &rtems_filesystem_root, new_fs_root ); rtems_filesystem_global_location_assign( 10817b: 89 5c 24 04 mov %ebx,0x4(%esp) 10817f: a1 60 d2 12 00 mov 0x12d260,%eax 108184: 89 04 24 mov %eax,(%esp) 108187: e8 f4 0f 00 00 call 109180 10818c: e9 c3 fe ff ff jmp 108054 rtems_filesystem_mt_unlock(); } else { rtems_filesystem_global_location_release( mt_point_node ); } } else { rtems_filesystem_eval_path_error( &ctx, EBUSY ); 108191: c7 44 24 04 10 00 00 movl $0x10,0x4(%esp) 108198: 00 108199: 89 2c 24 mov %ebp,(%esp) 10819c: e8 93 08 00 00 call 108a34 rv = -1; 1081a1: be ff ff ff ff mov $0xffffffff,%esi 1081a6: e9 8c fe ff ff jmp 108037 rtems_chain_append_unprotected( &rtems_filesystem_mount_table, &mt_entry->mt_node ); } else { errno = EINVAL; 1081ab: e8 48 ab 00 00 call 112cf8 <__errno> <== NOT EXECUTED 1081b0: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1081b6: a1 dc f4 12 00 mov 0x12f4dc,%eax <== NOT EXECUTED 1081bb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1081be: e8 e5 38 00 00 call 10baa8 <== NOT EXECUTED rv = -1; 1081c3: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 1081c8: e9 76 fe ff ff jmp 108043 <== NOT EXECUTED =============================================================================== 0010c8fc : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 10c8fc: 55 push %ebp 10c8fd: 57 push %edi 10c8fe: 56 push %esi 10c8ff: 53 push %ebx 10c900: 83 ec 2c sub $0x2c,%esp 10c903: 8b 44 24 40 mov 0x40(%esp),%eax 10c907: 89 44 24 1c mov %eax,0x1c(%esp) 10c90b: 8b 5c 24 44 mov 0x44(%esp),%ebx 10c90f: 8b 74 24 48 mov 0x48(%esp),%esi 10c913: 8b 7c 24 4c mov 0x4c(%esp),%edi 10c917: 8b 6c 24 50 mov 0x50(%esp),%ebp int rv = -1; if (target != NULL) { 10c91b: 85 db test %ebx,%ebx 10c91d: 74 41 je 10c960 rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); 10c91f: c7 44 24 04 ff 01 00 movl $0x1ff,0x4(%esp) 10c926: 00 10c927: 89 1c 24 mov %ebx,(%esp) 10c92a: e8 ad 0c 00 00 call 10d5dc if (rv == 0) { 10c92f: 85 c0 test %eax,%eax 10c931: 74 09 je 10c93c <== ALWAYS TAKEN } else { errno = EINVAL; } return rv; } 10c933: 83 c4 2c add $0x2c,%esp 10c936: 5b pop %ebx 10c937: 5e pop %esi 10c938: 5f pop %edi 10c939: 5d pop %ebp 10c93a: c3 ret 10c93b: 90 nop int rv = -1; if (target != NULL) { rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); if (rv == 0) { rv = mount( 10c93c: 89 6c 24 50 mov %ebp,0x50(%esp) 10c940: 89 7c 24 4c mov %edi,0x4c(%esp) 10c944: 89 74 24 48 mov %esi,0x48(%esp) 10c948: 89 5c 24 44 mov %ebx,0x44(%esp) 10c94c: 8b 44 24 1c mov 0x1c(%esp),%eax 10c950: 89 44 24 40 mov %eax,0x40(%esp) } else { errno = EINVAL; } return rv; } 10c954: 83 c4 2c add $0x2c,%esp 10c957: 5b pop %ebx 10c958: 5e pop %esi 10c959: 5f pop %edi 10c95a: 5d pop %ebp int rv = -1; if (target != NULL) { rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); if (rv == 0) { rv = mount( 10c95b: e9 14 00 00 00 jmp 10c974 options, data ); } } else { errno = EINVAL; 10c960: e8 e7 85 01 00 call 124f4c <__errno> 10c965: c7 00 16 00 00 00 movl $0x16,(%eax) const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { int rv = -1; 10c96b: b8 ff ff ff ff mov $0xffffffff,%eax 10c970: eb c1 jmp 10c933 =============================================================================== 00108518 : void newlib_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 108518: 56 push %esi 108519: 53 push %ebx 10851a: 83 ec 14 sub $0x14,%esp 10851d: 8b 5c 24 24 mov 0x24(%esp),%ebx /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 108521: 39 5c 24 20 cmp %ebx,0x20(%esp) 108525: 74 51 je 108578 ptr = _REENT; } else { ptr = deleted_task->libc_reent; 108527: 8b b3 dc 00 00 00 mov 0xdc(%ebx),%esi } if (ptr && ptr != _global_impure_ptr) { 10852d: 85 f6 test %esi,%esi 10852f: 74 20 je 108551 <== NEVER TAKEN 108531: 3b 35 20 20 12 00 cmp 0x122020,%esi 108537: 74 18 je 108551 _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 108539: c7 44 24 04 4c 82 10 movl $0x10824c,0x4(%esp) 108540: 00 108541: 89 34 24 mov %esi,(%esp) 108544: e8 03 af 00 00 call 11344c <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 108549: 89 34 24 mov %esi,(%esp) 10854c: e8 d7 66 00 00 call 10ec28 <_Workspace_Free> #endif } deleted_task->libc_reent = NULL; 108551: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) 108558: 00 00 00 /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 10855b: 39 5c 24 20 cmp %ebx,0x20(%esp) 10855f: 74 07 je 108568 _REENT = 0; } } 108561: 83 c4 14 add $0x14,%esp 108564: 5b pop %ebx 108565: 5e pop %esi 108566: c3 ret 108567: 90 nop /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { _REENT = 0; 108568: c7 05 20 d4 12 00 00 movl $0x0,0x12d420 10856f: 00 00 00 } } 108572: 83 c4 14 add $0x14,%esp 108575: 5b pop %ebx 108576: 5e pop %esi 108577: c3 ret /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { ptr = _REENT; 108578: 8b 35 20 d4 12 00 mov 0x12d420,%esi 10857e: eb ad jmp 10852d =============================================================================== 0010824c : */ int newlib_free_buffers( FILE *fp ) { 10824c: 53 push %ebx 10824d: 83 ec 18 sub $0x18,%esp 108250: 8b 5c 24 20 mov 0x20(%esp),%ebx switch ( fileno(fp) ) { 108254: 89 1c 24 mov %ebx,(%esp) 108257: e8 40 ae 00 00 call 11309c 10825c: 83 f8 02 cmp $0x2,%eax 10825f: 76 0f jbe 108270 <== ALWAYS TAKEN fp->_flags &= ~__SMBF; fp->_bf._base = fp->_p = (unsigned char *) NULL; } break; default: fclose(fp); 108261: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 108264: e8 ab ab 00 00 call 112e14 <== NOT EXECUTED } return 0; } 108269: 31 c0 xor %eax,%eax 10826b: 83 c4 18 add $0x18,%esp 10826e: 5b pop %ebx 10826f: c3 ret { switch ( fileno(fp) ) { case 0: case 1: case 2: if (fp->_flags & __SMBF) { 108270: f6 43 0c 80 testb $0x80,0xc(%ebx) 108274: 74 f3 je 108269 <== ALWAYS TAKEN free( fp->_bf._base ); 108276: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 108279: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10827c: e8 bb f6 ff ff call 10793c <== NOT EXECUTED fp->_flags &= ~__SMBF; 108281: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED fp->_bf._base = fp->_p = (unsigned char *) NULL; 108287: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 10828d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED break; default: fclose(fp); } return 0; } 108294: 31 c0 xor %eax,%eax <== NOT EXECUTED 108296: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 108299: 5b pop %ebx <== NOT EXECUTED 10829a: c3 ret <== NOT EXECUTED =============================================================================== 0010af64 : rtems_filesystem_mount_table_entry_t *mt_entry, const void *data ) { return -1; } 10af64: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10af69: c3 ret <== NOT EXECUTED =============================================================================== 0010af74 : static void null_op_fsunmount_me( rtems_filesystem_mount_table_entry_t *mt_entry ) { 10af74: c3 ret <== NOT EXECUTED =============================================================================== 0010af3c : const char *name, size_t namelen ) { return -1; } 10af3c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10af41: c3 ret <== NOT EXECUTED =============================================================================== 0010af5c : static int null_op_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { return -1; } 10af5c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10af61: c3 ret <== NOT EXECUTED =============================================================================== 0010af88 : char *buf, size_t bufsize ) { return -1; } 10af88: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10af8d: c3 ret <== NOT EXECUTED =============================================================================== 0010af90 : const char *name, size_t namelen ) { return -1; } 10af90: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10af95: c3 ret <== NOT EXECUTED =============================================================================== 0010a190 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 10a190: 56 push %esi 10a191: 53 push %ebx 10a192: 83 ec 24 sub $0x24,%esp 10a195: 88 44 24 1c mov %al,0x1c(%esp) int i; if (tty->termios.c_oflag & OPOST) { 10a199: 8b 4a 34 mov 0x34(%edx),%ecx 10a19c: f6 c1 01 test $0x1,%cl 10a19f: 74 4b je 10a1ec <== NEVER TAKEN switch (c) { 10a1a1: 3c 09 cmp $0x9,%al 10a1a3: 0f 84 b3 00 00 00 je 10a25c 10a1a9: 76 61 jbe 10a20c <== NEVER TAKEN 10a1ab: 3c 0a cmp $0xa,%al 10a1ad: 74 71 je 10a220 10a1af: 3c 0d cmp $0xd,%al 10a1b1: 0f 84 cd 00 00 00 je 10a284 <== NEVER TAKEN if (tty->column > 0) tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) 10a1b7: 83 e1 02 and $0x2,%ecx c = toupper(c); 10a1ba: 8b 0d 08 d4 12 00 mov 0x12d408,%ecx if (tty->column > 0) tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) 10a1c0: 74 1b je 10a1dd <== ALWAYS TAKEN c = toupper(c); 10a1c2: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10a1c5: 8a 5c 01 01 mov 0x1(%ecx,%eax,1),%bl <== NOT EXECUTED 10a1c9: 83 e3 03 and $0x3,%ebx <== NOT EXECUTED 10a1cc: 80 fb 02 cmp $0x2,%bl <== NOT EXECUTED 10a1cf: 0f 84 df 00 00 00 je 10a2b4 <== NOT EXECUTED 10a1d5: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a1d7: 88 d8 mov %bl,%al <== NOT EXECUTED 10a1d9: 88 5c 24 1c mov %bl,0x1c(%esp) <== NOT EXECUTED if (!iscntrl(c)) 10a1dd: 0f b6 c0 movzbl %al,%eax 10a1e0: f6 44 01 01 20 testb $0x20,0x1(%ecx,%eax,1) 10a1e5: 75 05 jne 10a1ec <== NEVER TAKEN tty->column++; 10a1e7: ff 42 28 incl 0x28(%edx) 10a1ea: 66 90 xchg %ax,%ax break; } } rtems_termios_puts (&c, 1, tty); 10a1ec: 89 54 24 08 mov %edx,0x8(%esp) 10a1f0: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10a1f7: 00 10a1f8: 8d 44 24 1c lea 0x1c(%esp),%eax 10a1fc: 89 04 24 mov %eax,(%esp) 10a1ff: e8 48 fe ff ff call 10a04c } 10a204: 83 c4 24 add $0x24,%esp 10a207: 5b pop %ebx 10a208: 5e pop %esi 10a209: c3 ret 10a20a: 66 90 xchg %ax,%ax oproc (unsigned char c, struct rtems_termios_tty *tty) { int i; if (tty->termios.c_oflag & OPOST) { switch (c) { 10a20c: 3c 08 cmp $0x8,%al <== NOT EXECUTED 10a20e: 75 a7 jne 10a1b7 <== NOT EXECUTED } tty->column += i; break; case '\b': if (tty->column > 0) 10a210: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10a213: 85 c0 test %eax,%eax <== NOT EXECUTED 10a215: 7e d5 jle 10a1ec <== NOT EXECUTED tty->column--; 10a217: 48 dec %eax <== NOT EXECUTED 10a218: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED 10a21b: eb cf jmp 10a1ec <== NOT EXECUTED 10a21d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED int i; if (tty->termios.c_oflag & OPOST) { switch (c) { case '\n': if (tty->termios.c_oflag & ONLRET) 10a220: f6 c1 20 test $0x20,%cl 10a223: 74 07 je 10a22c <== ALWAYS TAKEN tty->column = 0; 10a225: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 10a22c: 83 e1 04 and $0x4,%ecx 10a22f: 74 bb je 10a1ec <== NEVER TAKEN rtems_termios_puts ("\r", 1, tty); 10a231: 89 54 24 08 mov %edx,0x8(%esp) 10a235: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10a23c: 00 10a23d: c7 04 24 5c 16 12 00 movl $0x12165c,(%esp) 10a244: 89 54 24 18 mov %edx,0x18(%esp) 10a248: e8 ff fd ff ff call 10a04c tty->column = 0; 10a24d: 8b 54 24 18 mov 0x18(%esp),%edx 10a251: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) 10a258: eb 92 jmp 10a1ec 10a25a: 66 90 xchg %ax,%ax } tty->column = 0; break; case '\t': i = 8 - (tty->column & 7); 10a25c: 8b 5a 28 mov 0x28(%edx),%ebx 10a25f: 89 de mov %ebx,%esi 10a261: 83 e6 07 and $0x7,%esi 10a264: b8 08 00 00 00 mov $0x8,%eax 10a269: 29 f0 sub %esi,%eax if ((tty->termios.c_oflag & TABDLY) == XTABS) { 10a26b: 81 e1 00 18 00 00 and $0x1800,%ecx 10a271: 81 f9 00 18 00 00 cmp $0x1800,%ecx 10a277: 74 43 je 10a2bc <== ALWAYS TAKEN tty->column += i; rtems_termios_puts ( " ", i, tty); return; } tty->column += i; 10a279: 01 d8 add %ebx,%eax <== NOT EXECUTED 10a27b: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED break; 10a27e: e9 69 ff ff ff jmp 10a1ec <== NOT EXECUTED 10a283: 90 nop <== NOT EXECUTED tty->column = 0; } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 10a284: f6 c1 10 test $0x10,%cl <== NOT EXECUTED 10a287: 74 0b je 10a294 <== NOT EXECUTED 10a289: 8b 5a 28 mov 0x28(%edx),%ebx <== NOT EXECUTED 10a28c: 85 db test %ebx,%ebx <== NOT EXECUTED 10a28e: 0f 84 70 ff ff ff je 10a204 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 10a294: f6 c1 08 test $0x8,%cl <== NOT EXECUTED 10a297: 74 0e je 10a2a7 <== NOT EXECUTED c = '\n'; 10a299: c6 44 24 1c 0a movb $0xa,0x1c(%esp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 10a29e: 83 e1 20 and $0x20,%ecx <== NOT EXECUTED 10a2a1: 0f 84 45 ff ff ff je 10a1ec <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 10a2a7: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED break; 10a2ae: e9 39 ff ff ff jmp 10a1ec <== NOT EXECUTED 10a2b3: 90 nop <== NOT EXECUTED tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) c = toupper(c); 10a2b4: 8d 58 e0 lea -0x20(%eax),%ebx <== NOT EXECUTED 10a2b7: e9 1b ff ff ff jmp 10a1d7 <== NOT EXECUTED break; case '\t': i = 8 - (tty->column & 7); if ((tty->termios.c_oflag & TABDLY) == XTABS) { tty->column += i; 10a2bc: 01 c3 add %eax,%ebx 10a2be: 89 5a 28 mov %ebx,0x28(%edx) rtems_termios_puts ( " ", i, tty); 10a2c1: 89 54 24 08 mov %edx,0x8(%esp) 10a2c5: 89 44 24 04 mov %eax,0x4(%esp) 10a2c9: c7 04 24 70 0a 12 00 movl $0x120a70,(%esp) 10a2d0: e8 77 fd ff ff call 10a04c return; 10a2d5: e9 2a ff ff ff jmp 10a204 =============================================================================== 0010614c : long pathconf( const char *path, int name ) { 10614c: 56 push %esi 10614d: 53 push %ebx 10614e: 83 ec 14 sub $0x14,%esp int status; int fd; fd = open( path, O_RDONLY ); 106151: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 106158: 00 106159: 8b 44 24 20 mov 0x20(%esp),%eax 10615d: 89 04 24 mov %eax,(%esp) 106160: e8 7b fd ff ff call 105ee0 106165: 89 c3 mov %eax,%ebx if ( fd == -1 ) 106167: 83 f8 ff cmp $0xffffffff,%eax 10616a: 74 24 je 106190 <== ALWAYS TAKEN return -1; status = fpathconf( fd, name ); 10616c: 8b 44 24 24 mov 0x24(%esp),%eax <== NOT EXECUTED 106170: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 106174: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 106177: e8 68 4b 00 00 call 10ace4 <== NOT EXECUTED 10617c: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) close( fd ); 10617e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 106181: e8 fa 4a 00 00 call 10ac80 <== NOT EXECUTED return status; } 106186: 89 f0 mov %esi,%eax 106188: 83 c4 14 add $0x14,%esp 10618b: 5b pop %ebx 10618c: 5e pop %esi 10618d: c3 ret 10618e: 66 90 xchg %ax,%ax int status; int fd; fd = open( path, O_RDONLY ); if ( fd == -1 ) return -1; 106190: be ff ff ff ff mov $0xffffffff,%esi 106195: eb ef jmp 106186 =============================================================================== 0010b7c8 : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 10b7c8: 53 push %ebx 10b7c9: 8b 44 24 0c mov 0xc(%esp),%eax /* * Update call statistics */ MSBUMP(memalign_calls, 1); 10b7cd: ff 05 c8 72 13 00 incl 0x1372c8 if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 10b7d3: 8d 50 ff lea -0x1(%eax),%edx 10b7d6: 85 c2 test %eax,%edx 10b7d8: 74 0a je 10b7e4 <== ALWAYS TAKEN /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 10b7da: b8 16 00 00 00 mov $0x16,%eax 10b7df: 5b pop %ebx 10b7e0: c3 ret 10b7e1: 8d 76 00 lea 0x0(%esi),%esi /* * Update call statistics */ MSBUMP(memalign_calls, 1); if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 10b7e4: 83 f8 03 cmp $0x3,%eax 10b7e7: 76 f1 jbe 10b7da /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 10b7e9: 5b pop %ebx /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 10b7ea: e9 b9 01 00 00 jmp 10b9a8 =============================================================================== 0011f628 : ssize_t read( int fd, void *buffer, size_t count ) { 11f628: 53 push %ebx 11f629: 83 ec 08 sub $0x8,%esp 11f62c: 8b 44 24 10 mov 0x10(%esp),%eax 11f630: 8b 54 24 14 mov 0x14(%esp),%edx 11f634: 8b 4c 24 18 mov 0x18(%esp),%ecx rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11f638: 3b 05 c0 b2 12 00 cmp 0x12b2c0,%eax 11f63e: 73 44 jae 11f684 iop = rtems_libio_iop( fd ); 11f640: 8d 04 40 lea (%eax,%eax,2),%eax 11f643: c1 e0 04 shl $0x4,%eax 11f646: 03 05 d4 f4 12 00 add 0x12f4d4,%eax rtems_libio_check_is_open( iop ); 11f64c: 8b 58 0c mov 0xc(%eax),%ebx 11f64f: f6 c7 01 test $0x1,%bh 11f652: 74 30 je 11f684 rtems_libio_check_buffer( buffer ); 11f654: 85 d2 test %edx,%edx 11f656: 74 3e je 11f696 <== NEVER TAKEN rtems_libio_check_count( count ); 11f658: 85 c9 test %ecx,%ecx 11f65a: 74 20 je 11f67c rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); 11f65c: 83 e3 02 and $0x2,%ebx 11f65f: 74 23 je 11f684 /* * Now process the read(). */ return (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11f661: 8b 58 20 mov 0x20(%eax),%ebx 11f664: 89 4c 24 18 mov %ecx,0x18(%esp) 11f668: 89 54 24 14 mov %edx,0x14(%esp) 11f66c: 89 44 24 10 mov %eax,0x10(%esp) 11f670: 8b 43 08 mov 0x8(%ebx),%eax } 11f673: 83 c4 08 add $0x8,%esp 11f676: 5b pop %ebx rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); /* * Now process the read(). */ return (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11f677: ff e0 jmp *%eax 11f679: 8d 76 00 lea 0x0(%esi),%esi rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); 11f67c: 31 c0 xor %eax,%eax /* * Now process the read(). */ return (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); } 11f67e: 83 c4 08 add $0x8,%esp 11f681: 5b pop %ebx 11f682: c3 ret 11f683: 90 nop rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); 11f684: e8 6f 36 ff ff call 112cf8 <__errno> 11f689: c7 00 09 00 00 00 movl $0x9,(%eax) 11f68f: b8 ff ff ff ff mov $0xffffffff,%eax 11f694: eb e8 jmp 11f67e rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); 11f696: e8 5d 36 ff ff call 112cf8 <__errno> <== NOT EXECUTED 11f69b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11f6a1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 11f6a6: eb d6 jmp 11f67e <== NOT EXECUTED =============================================================================== 0010940c : ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) { 10940c: 55 push %ebp 10940d: 57 push %edi 10940e: 56 push %esi 10940f: 53 push %ebx 109410: 83 ec 2c sub $0x2c,%esp 109413: 8b 54 24 40 mov 0x40(%esp),%edx 109417: 8b 5c 24 44 mov 0x44(%esp),%ebx 10941b: 8b 44 24 48 mov 0x48(%esp),%eax int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd ); 10941f: 3b 15 c0 c2 12 00 cmp 0x12c2c0,%edx 109425: 0f 83 bf 00 00 00 jae 1094ea iop = rtems_libio_iop( fd ); 10942b: 8d 3c 52 lea (%edx,%edx,2),%edi 10942e: c1 e7 04 shl $0x4,%edi 109431: 03 3d d4 04 13 00 add 0x1304d4,%edi rtems_libio_check_is_open( iop ); 109437: 8b 57 0c mov 0xc(%edi),%edx 10943a: f6 c6 01 test $0x1,%dh 10943d: 0f 84 a7 00 00 00 je 1094ea rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); 109443: 83 e2 02 and $0x2,%edx 109446: 0f 84 9e 00 00 00 je 1094ea <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 10944c: 85 db test %ebx,%ebx 10944e: 74 4c je 10949c rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 109450: 85 c0 test %eax,%eax 109452: 7e 48 jle 10949c rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 109454: 3d 00 04 00 00 cmp $0x400,%eax 109459: 7f 41 jg 10949c <== NEVER TAKEN #include #include #include ssize_t readv( 10945b: 8d 34 c3 lea (%ebx,%eax,8),%esi 10945e: 89 d8 mov %ebx,%eax 109460: c6 44 24 1f 01 movb $0x1,0x1f(%esp) 109465: 31 d2 xor %edx,%edx 109467: eb 05 jmp 10946e 109469: 8d 76 00 lea 0x0(%esi),%esi if ( iov[v].iov_base == 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 10946c: 89 ea mov %ebp,%edx /* * iov[v].iov_len cannot be less than 0 because size_t is unsigned. * So we only check for zero. */ if ( iov[v].iov_base == 0 ) 10946e: 8b 08 mov (%eax),%ecx 109470: 85 c9 test %ecx,%ecx 109472: 74 28 je 10949c rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 109474: 8b 48 04 mov 0x4(%eax),%ecx 109477: 8d 2c 11 lea (%ecx,%edx,1),%ebp if ( total < old ) 10947a: 39 d5 cmp %edx,%ebp 10947c: 7c 1e jl 10949c rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len ) 10947e: 85 c9 test %ecx,%ecx 109480: 74 05 je 109487 all_zeros = false; 109482: c6 44 24 1f 00 movb $0x0,0x1f(%esp) 109487: 83 c0 08 add $0x8,%eax * are obvious errors in the iovec. So this extra loop ensures * that we do not do anything if there is an argument error. */ all_zeros = true; for ( total=0, v=0 ; v < iovcnt ; v++ ) { 10948a: 39 f0 cmp %esi,%eax 10948c: 75 de jne 10946c * A readv with all zeros logically has no effect. Even though * OpenGroup didn't address this case as they did with writev(), * we will handle it the same way for symmetry. */ if ( all_zeros == true ) { return 0; 10948e: 31 ed xor %ebp,%ebp /* * A readv with all zeros logically has no effect. Even though * OpenGroup didn't address this case as they did with writev(), * we will handle it the same way for symmetry. */ if ( all_zeros == true ) { 109490: 80 7c 24 1f 00 cmpb $0x0,0x1f(%esp) 109495: 74 31 je 1094c8 109497: eb 13 jmp 1094ac 109499: 8d 76 00 lea 0x0(%esi),%esi /* check for wrap */ old = total; total += iov[v].iov_len; if ( total < old ) rtems_set_errno_and_return_minus_one( EINVAL ); 10949c: e8 7b a3 00 00 call 11381c <__errno> 1094a1: c7 00 16 00 00 00 movl $0x16,(%eax) 1094a7: bd ff ff ff ff mov $0xffffffff,%ebp if (bytes != iov[ v ].iov_len) break; } return total; } 1094ac: 89 e8 mov %ebp,%eax 1094ae: 83 c4 2c add $0x2c,%esp 1094b1: 5b pop %ebx 1094b2: 5e pop %esi 1094b3: 5f pop %edi 1094b4: 5d pop %ebp 1094b5: c3 ret 1094b6: 66 90 xchg %ax,%ax ); if ( bytes < 0 ) return -1; if ( bytes > 0 ) { 1094b8: 74 02 je 1094bc <== NEVER TAKEN total += bytes; 1094ba: 01 c5 add %eax,%ebp } if (bytes != iov[ v ].iov_len) 1094bc: 3b 43 04 cmp 0x4(%ebx),%eax 1094bf: 75 eb jne 1094ac <== NEVER TAKEN 1094c1: 83 c3 08 add $0x8,%ebx } /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 1094c4: 39 f3 cmp %esi,%ebx 1094c6: 74 e4 je 1094ac bytes = (*iop->pathinfo.handlers->read_h)( 1094c8: 8b 47 20 mov 0x20(%edi),%eax 1094cb: 8b 53 04 mov 0x4(%ebx),%edx 1094ce: 89 54 24 08 mov %edx,0x8(%esp) 1094d2: 8b 13 mov (%ebx),%edx 1094d4: 89 54 24 04 mov %edx,0x4(%esp) 1094d8: 89 3c 24 mov %edi,(%esp) 1094db: ff 50 08 call *0x8(%eax) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 1094de: 83 f8 00 cmp $0x0,%eax 1094e1: 7d d5 jge 1094b8 <== ALWAYS TAKEN return -1; 1094e3: bd ff ff ff ff mov $0xffffffff,%ebp <== NOT EXECUTED 1094e8: eb c2 jmp 1094ac <== NOT EXECUTED bool all_zeros; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); 1094ea: e8 2d a3 00 00 call 11381c <__errno> 1094ef: c7 00 09 00 00 00 movl $0x9,(%eax) 1094f5: bd ff ff ff ff mov $0xffffffff,%ebp 1094fa: eb b0 jmp 1094ac =============================================================================== 00108884 : void *realloc( void *ptr, size_t size ) { 108884: 55 push %ebp 108885: 57 push %edi 108886: 56 push %esi 108887: 53 push %ebx 108888: 83 ec 2c sub $0x2c,%esp 10888b: 8b 5c 24 40 mov 0x40(%esp),%ebx 10888f: 8b 74 24 44 mov 0x44(%esp),%esi uintptr_t old_size; char *new_area; MSBUMP(realloc_calls, 1); 108893: ff 05 10 f5 12 00 incl 0x12f510 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 108899: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760 1088a0: 0f 84 8e 00 00 00 je 108934 } /* * Continue with realloc(). */ if ( !ptr ) 1088a6: 85 db test %ebx,%ebx 1088a8: 0f 84 de 00 00 00 je 10898c return malloc( size ); if ( !size ) { 1088ae: 85 f6 test %esi,%esi 1088b0: 0f 84 b6 00 00 00 je 10896c <== NEVER TAKEN free( ptr ); return (void *) 0; } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 1088b6: 8d 44 24 1c lea 0x1c(%esp),%eax 1088ba: 89 44 24 08 mov %eax,0x8(%esp) 1088be: 89 5c 24 04 mov %ebx,0x4(%esp) 1088c2: a1 6c b2 12 00 mov 0x12b26c,%eax 1088c7: 89 04 24 mov %eax,(%esp) 1088ca: e8 69 4b 00 00 call 10d438 <_Protected_heap_Get_block_size> 1088cf: 84 c0 test %al,%al 1088d1: 0f 84 a5 00 00 00 je 10897c } /* * Now resize it. */ if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) { 1088d7: 89 74 24 08 mov %esi,0x8(%esp) 1088db: 89 5c 24 04 mov %ebx,0x4(%esp) 1088df: a1 6c b2 12 00 mov 0x12b26c,%eax 1088e4: 89 04 24 mov %eax,(%esp) 1088e7: e8 9c 4b 00 00 call 10d488 <_Protected_heap_Resize_block> 1088ec: 84 c0 test %al,%al 1088ee: 74 0c je 1088fc memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 1088f0: 89 d8 mov %ebx,%eax 1088f2: 83 c4 2c add $0x2c,%esp 1088f5: 5b pop %ebx 1088f6: 5e pop %esi 1088f7: 5f pop %edi 1088f8: 5d pop %ebp 1088f9: c3 ret 1088fa: 66 90 xchg %ax,%ax * There used to be a free on this error case but it is wrong to * free the memory per OpenGroup Single UNIX Specification V2 * and the C Standard. */ new_area = malloc( size ); 1088fc: 89 34 24 mov %esi,(%esp) 1088ff: e8 4c f3 ff ff call 107c50 108904: 89 c5 mov %eax,%ebp MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 108906: ff 0d 04 f5 12 00 decl 0x12f504 if ( !new_area ) { 10890c: 85 c0 test %eax,%eax 10890e: 74 3c je 10894c return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 108910: 8b 44 24 1c mov 0x1c(%esp),%eax 108914: 89 f1 mov %esi,%ecx 108916: 39 c6 cmp %eax,%esi 108918: 77 3e ja 108958 <== ALWAYS TAKEN 10891a: 89 ef mov %ebp,%edi <== NOT EXECUTED 10891c: 89 de mov %ebx,%esi <== NOT EXECUTED 10891e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED free( ptr ); 108920: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 108923: e8 14 f0 ff ff call 10793c <== NOT EXECUTED 108928: 89 eb mov %ebp,%ebx <== NOT EXECUTED return new_area; } 10892a: 89 d8 mov %ebx,%eax 10892c: 83 c4 2c add $0x2c,%esp 10892f: 5b pop %ebx 108930: 5e pop %esi 108931: 5f pop %edi 108932: 5d pop %ebp 108933: c3 ret * This routine returns true if thread dispatch indicates * that we are in a critical section. */ RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void) { if ( _Thread_Dispatch_disable_level == 0 ) 108934: a1 04 f6 12 00 mov 0x12f604,%eax 108939: 85 c0 test %eax,%eax 10893b: 75 0f jne 10894c <== NEVER TAKEN if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_in_critical_section()) return (void *) 0; if (_ISR_Nest_level > 0) 10893d: a1 68 f8 12 00 mov 0x12f868,%eax 108942: 85 c0 test %eax,%eax 108944: 0f 84 5c ff ff ff je 1088a6 <== ALWAYS TAKEN 10894a: 66 90 xchg %ax,%ax return (void *) 0; } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { errno = EINVAL; return (void *) 0; 10894c: 31 db xor %ebx,%ebx memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 10894e: 89 d8 mov %ebx,%eax 108950: 83 c4 2c add $0x2c,%esp 108953: 5b pop %ebx 108954: 5e pop %esi 108955: 5f pop %edi 108956: 5d pop %ebp 108957: c3 ret if ( !new_area ) { return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 108958: 89 c1 mov %eax,%ecx 10895a: 89 ef mov %ebp,%edi 10895c: 89 de mov %ebx,%esi 10895e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 108960: 89 1c 24 mov %ebx,(%esp) 108963: e8 d4 ef ff ff call 10793c 108968: 89 eb mov %ebp,%ebx 10896a: eb be jmp 10892a */ if ( !ptr ) return malloc( size ); if ( !size ) { free( ptr ); 10896c: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10896f: e8 c8 ef ff ff call 10793c <== NOT EXECUTED return (void *) 0; 108974: 31 db xor %ebx,%ebx <== NOT EXECUTED 108976: e9 75 ff ff ff jmp 1088f0 <== NOT EXECUTED 10897b: 90 nop <== NOT EXECUTED } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { errno = EINVAL; 10897c: e8 77 a3 00 00 call 112cf8 <__errno> 108981: c7 00 16 00 00 00 movl $0x16,(%eax) return (void *) 0; 108987: 31 db xor %ebx,%ebx 108989: eb c3 jmp 10894e 10898b: 90 nop /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 10898c: 89 74 24 40 mov %esi,0x40(%esp) memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 108990: 83 c4 2c add $0x2c,%esp 108993: 5b pop %ebx 108994: 5e pop %esi 108995: 5f pop %edi 108996: 5d pop %ebp /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 108997: e9 b4 f2 ff ff jmp 107c50 =============================================================================== 00112650 : uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) { 112650: 55 push %ebp 112651: 57 push %edi 112652: 56 push %esi 112653: 53 push %ebx 112654: 83 ec 1c sub $0x1c,%esp 112657: 8b 74 24 34 mov 0x34(%esp),%esi 11265b: bd 20 00 00 00 mov $0x20,%ebp uint32_t b; uint32_t local_value = 0; 112660: 31 ff xor %edi,%edi for (b = 1; b; b <<= 1) { 112662: bb 01 00 00 00 mov $0x1,%ebx 112667: eb 08 jmp 112671 112669: 8d 76 00 lea 0x0(%esi),%esi 11266c: d1 e3 shl %ebx 11266e: 4d dec %ebp 11266f: 74 1b je 11268c if (b & remote_value) 112671: 85 f3 test %esi,%ebx 112673: 74 f7 je 11266c local_value |= rtems_assoc_local_by_remote(ap, b); 112675: 89 5c 24 04 mov %ebx,0x4(%esp) 112679: 8b 44 24 30 mov 0x30(%esp),%eax 11267d: 89 04 24 mov %eax,(%esp) 112680: e8 f7 d3 ff ff call 10fa7c 112685: 09 c7 or %eax,%edi ) { uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 112687: d1 e3 shl %ebx 112689: 4d dec %ebp 11268a: 75 e5 jne 112671 <== ALWAYS TAKEN if (b & remote_value) local_value |= rtems_assoc_local_by_remote(ap, b); } return local_value; } 11268c: 89 f8 mov %edi,%eax 11268e: 83 c4 1c add $0x1c,%esp 112691: 5b pop %ebx 112692: 5e pop %esi 112693: 5f pop %edi 112694: 5d pop %ebp 112695: c3 ret =============================================================================== 0010fadc : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10fadc: 57 push %edi 10fadd: 56 push %esi 10fade: 53 push %ebx 10fadf: 8b 44 24 10 mov 0x10(%esp),%eax 10fae3: 8b 54 24 14 mov 0x14(%esp),%edx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10fae7: 8b 30 mov (%eax),%esi 10fae9: 85 f6 test %esi,%esi 10faeb: 74 3f je 10fb2c 10faed: bf 2c 1c 12 00 mov $0x121c2c,%edi 10faf2: b9 0a 00 00 00 mov $0xa,%ecx 10faf7: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10faf9: 74 19 je 10fb14 const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { const rtems_assoc_t *default_ap = 0; 10fafb: 31 c9 xor %ecx,%ecx 10fafd: eb 0a jmp 10fb09 10faff: 90 nop if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10fb00: 83 c0 0c add $0xc,%eax 10fb03: 8b 18 mov (%eax),%ebx 10fb05: 85 db test %ebx,%ebx 10fb07: 74 1b je 10fb24 if (ap->local_value == local_value) 10fb09: 39 50 04 cmp %edx,0x4(%eax) 10fb0c: 75 f2 jne 10fb00 return ap; return default_ap; } 10fb0e: 5b pop %ebx 10fb0f: 5e pop %esi 10fb10: 5f pop %edi 10fb11: c3 ret 10fb12: 66 90 xchg %ax,%ax ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 10fb14: 8d 58 0c lea 0xc(%eax),%ebx for ( ; ap->name; ap++) 10fb17: 8b 70 0c mov 0xc(%eax),%esi 10fb1a: 85 f6 test %esi,%esi 10fb1c: 74 f0 je 10fb0e <== NEVER TAKEN 10fb1e: 89 c1 mov %eax,%ecx ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 10fb20: 89 d8 mov %ebx,%eax 10fb22: eb e5 jmp 10fb09 for ( ; ap->name; ap++) 10fb24: 89 c8 mov %ecx,%eax if (ap->local_value == local_value) return ap; return default_ap; } 10fb26: 5b pop %ebx 10fb27: 5e pop %esi 10fb28: 5f pop %edi 10fb29: c3 ret 10fb2a: 66 90 xchg %ax,%ax const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { const rtems_assoc_t *default_ap = 0; 10fb2c: 31 c0 xor %eax,%eax for ( ; ap->name; ap++) if (ap->local_value == local_value) return ap; return default_ap; } 10fb2e: 5b pop %ebx 10fb2f: 5e pop %esi 10fb30: 5f pop %edi 10fb31: c3 ret =============================================================================== 001081d4 : const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) { 1081d4: 55 push %ebp 1081d5: 57 push %edi 1081d6: 56 push %esi 1081d7: 53 push %ebx 1081d8: 83 ec 1c sub $0x1c,%esp 1081db: 8b 5c 24 30 mov 0x30(%esp),%ebx 1081df: 8b 6c 24 34 mov 0x34(%esp),%ebp const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 1081e3: 8b 03 mov (%ebx),%eax 1081e5: 85 c0 test %eax,%eax 1081e7: 74 57 je 108240 1081e9: bf 42 0a 12 00 mov $0x120a42,%edi 1081ee: b9 0a 00 00 00 mov $0xa,%ecx 1081f3: 89 c6 mov %eax,%esi 1081f5: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 1081f7: 74 2b je 108224 const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) { const rtems_assoc_t *default_ap = 0; 1081f9: 31 f6 xor %esi,%esi 1081fb: eb 0c jmp 108209 1081fd: 8d 76 00 lea 0x0(%esi),%esi if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 108200: 83 c3 0c add $0xc,%ebx 108203: 8b 03 mov (%ebx),%eax 108205: 85 c0 test %eax,%eax 108207: 74 2b je 108234 if (strcmp(ap->name, name) == 0) 108209: 89 6c 24 04 mov %ebp,0x4(%esp) 10820d: 89 04 24 mov %eax,(%esp) 108210: e8 57 c3 00 00 call 11456c 108215: 85 c0 test %eax,%eax 108217: 75 e7 jne 108200 return ap; return default_ap; } 108219: 89 d8 mov %ebx,%eax 10821b: 83 c4 1c add $0x1c,%esp 10821e: 5b pop %ebx 10821f: 5e pop %esi 108220: 5f pop %edi 108221: 5d pop %ebp 108222: c3 ret 108223: 90 nop ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 108224: 8d 53 0c lea 0xc(%ebx),%edx for ( ; ap->name; ap++) 108227: 8b 43 0c mov 0xc(%ebx),%eax 10822a: 85 c0 test %eax,%eax 10822c: 74 eb je 108219 <== NEVER TAKEN 10822e: 89 de mov %ebx,%esi ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 108230: 89 d3 mov %edx,%ebx 108232: eb d5 jmp 108209 for ( ; ap->name; ap++) 108234: 89 f3 mov %esi,%ebx if (strcmp(ap->name, name) == 0) return ap; return default_ap; } 108236: 89 d8 mov %ebx,%eax 108238: 83 c4 1c add $0x1c,%esp 10823b: 5b pop %ebx 10823c: 5e pop %esi 10823d: 5f pop %edi 10823e: 5d pop %ebp 10823f: c3 ret const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) { const rtems_assoc_t *default_ap = 0; 108240: 31 db xor %ebx,%ebx for ( ; ap->name; ap++) if (strcmp(ap->name, name) == 0) return ap; return default_ap; } 108242: 89 d8 mov %ebx,%eax 108244: 83 c4 1c add $0x1c,%esp 108247: 5b pop %ebx 108248: 5e pop %esi 108249: 5f pop %edi 10824a: 5d pop %ebp 10824b: c3 ret =============================================================================== 0010fb34 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fb34: 57 push %edi 10fb35: 56 push %esi 10fb36: 53 push %ebx 10fb37: 8b 44 24 10 mov 0x10(%esp),%eax 10fb3b: 8b 54 24 14 mov 0x14(%esp),%edx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10fb3f: 8b 30 mov (%eax),%esi 10fb41: 85 f6 test %esi,%esi 10fb43: 74 3f je 10fb84 10fb45: bf 2c 1c 12 00 mov $0x121c2c,%edi 10fb4a: b9 0a 00 00 00 mov $0xa,%ecx 10fb4f: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10fb51: 74 19 je 10fb6c const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { const rtems_assoc_t *default_ap = 0; 10fb53: 31 c9 xor %ecx,%ecx 10fb55: eb 0a jmp 10fb61 10fb57: 90 nop if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10fb58: 83 c0 0c add $0xc,%eax 10fb5b: 8b 18 mov (%eax),%ebx 10fb5d: 85 db test %ebx,%ebx 10fb5f: 74 1b je 10fb7c if (ap->remote_value == remote_value) 10fb61: 39 50 08 cmp %edx,0x8(%eax) 10fb64: 75 f2 jne 10fb58 return ap; return default_ap; } 10fb66: 5b pop %ebx 10fb67: 5e pop %esi 10fb68: 5f pop %edi 10fb69: c3 ret 10fb6a: 66 90 xchg %ax,%ax ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 10fb6c: 8d 58 0c lea 0xc(%eax),%ebx for ( ; ap->name; ap++) 10fb6f: 8b 70 0c mov 0xc(%eax),%esi 10fb72: 85 f6 test %esi,%esi 10fb74: 74 f0 je 10fb66 <== NEVER TAKEN 10fb76: 89 c1 mov %eax,%ecx ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 10fb78: 89 d8 mov %ebx,%eax 10fb7a: eb e5 jmp 10fb61 for ( ; ap->name; ap++) 10fb7c: 89 c8 mov %ecx,%eax if (ap->remote_value == remote_value) return ap; return default_ap; } 10fb7e: 5b pop %ebx 10fb7f: 5e pop %esi 10fb80: 5f pop %edi 10fb81: c3 ret 10fb82: 66 90 xchg %ax,%ax const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { const rtems_assoc_t *default_ap = 0; 10fb84: 31 c0 xor %eax,%eax for ( ; ap->name; ap++) if (ap->remote_value == remote_value) return ap; return default_ap; } 10fb86: 5b pop %ebx 10fb87: 5e pop %esi 10fb88: 5f pop %edi 10fb89: c3 ret =============================================================================== 001082a4 : uint32_t rtems_assoc_remote_by_local_bitfield( const rtems_assoc_t *ap, uint32_t local_value ) { 1082a4: 55 push %ebp 1082a5: 57 push %edi 1082a6: 56 push %esi 1082a7: 53 push %ebx 1082a8: 83 ec 1c sub $0x1c,%esp 1082ab: 8b 74 24 34 mov 0x34(%esp),%esi 1082af: bd 20 00 00 00 mov $0x20,%ebp uint32_t b; uint32_t remote_value = 0; 1082b4: 31 ff xor %edi,%edi for (b = 1; b; b <<= 1) 1082b6: bb 01 00 00 00 mov $0x1,%ebx 1082bb: eb 08 jmp 1082c5 1082bd: 8d 76 00 lea 0x0(%esi),%esi 1082c0: d1 e3 shl %ebx 1082c2: 4d dec %ebp 1082c3: 74 1b je 1082e0 if (b & local_value) 1082c5: 85 f3 test %esi,%ebx 1082c7: 74 f7 je 1082c0 remote_value |= rtems_assoc_remote_by_local(ap, b); 1082c9: 89 5c 24 04 mov %ebx,0x4(%esp) 1082cd: 8b 44 24 30 mov 0x30(%esp),%eax 1082d1: 89 04 24 mov %eax,(%esp) 1082d4: e8 13 00 00 00 call 1082ec 1082d9: 09 c7 or %eax,%edi ) { uint32_t b; uint32_t remote_value = 0; for (b = 1; b; b <<= 1) 1082db: d1 e3 shl %ebx 1082dd: 4d dec %ebp 1082de: 75 e5 jne 1082c5 <== ALWAYS TAKEN if (b & local_value) remote_value |= rtems_assoc_remote_by_local(ap, b); return remote_value; } 1082e0: 89 f8 mov %edi,%eax 1082e2: 83 c4 1c add $0x1c,%esp 1082e5: 5b pop %ebx 1082e6: 5e pop %esi 1082e7: 5f pop %edi 1082e8: 5d pop %ebp 1082e9: c3 ret =============================================================================== 0010744c : const char *rtems_bsp_cmdline_get_param( const char *name, char *value, size_t length ) { 10744c: 55 push %ebp 10744d: 57 push %edi 10744e: 56 push %esi 10744f: 53 push %ebx 107450: 83 ec 1c sub $0x1c,%esp 107453: 8b 44 24 30 mov 0x30(%esp),%eax 107457: 8b 5c 24 34 mov 0x34(%esp),%ebx 10745b: 8b 6c 24 38 mov 0x38(%esp),%ebp const char *p; if ( !name ) 10745f: 85 c0 test %eax,%eax 107461: 74 59 je 1074bc return NULL; if ( !value ) 107463: 85 db test %ebx,%ebx 107465: 74 55 je 1074bc return NULL; if ( !length ) 107467: 85 ed test %ebp,%ebp 107469: 74 51 je 1074bc return NULL; value[0] = '\0'; 10746b: c6 03 00 movb $0x0,(%ebx) p = rtems_bsp_cmdline_get_param_raw( name ); 10746e: 89 04 24 mov %eax,(%esp) 107471: e8 52 00 00 00 call 1074c8 if ( !p ) 107476: 85 c0 test %eax,%eax 107478: 74 42 je 1074bc int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i<== NEVER TAKEN 107480: 83 fd 01 cmp $0x1,%ebp 107483: 74 39 je 1074be <== NEVER TAKEN value[i] = '\0'; } } const char *rtems_bsp_cmdline_get_param( 107485: 4d dec %ebp 107486: 31 d2 xor %edx,%edx int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i 10748e: 66 90 xchg %ax,%ax quotes=0; for (i=0 ; *p && i 107498: 80 f9 20 cmp $0x20,%cl 10749b: 74 21 je 1074be break; value[i++] = *p++; 10749d: 88 0c 33 mov %cl,(%ebx,%esi,1) 1074a0: 42 inc %edx value[i] = '\0'; 1074a1: 89 d6 mov %edx,%esi 1074a3: c6 04 13 00 movb $0x0,(%ebx,%edx,1) int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i 1074ae: 39 ea cmp %ebp,%edx 1074b0: 74 0c je 1074be if ( *p == '\"' ) { 1074b2: 80 f9 22 cmp $0x22,%cl 1074b5: 75 d9 jne 107490 quotes++; 1074b7: 47 inc %edi 1074b8: eb e3 jmp 10749d 1074ba: 66 90 xchg %ax,%ax ) { const char *p; if ( !name ) return NULL; 1074bc: 31 db xor %ebx,%ebx return NULL; copy_string( p, value, length ); return value; } 1074be: 89 d8 mov %ebx,%eax 1074c0: 83 c4 1c add $0x1c,%esp 1074c3: 5b pop %ebx 1074c4: 5e pop %esi 1074c5: 5f pop %edi 1074c6: 5d pop %ebp 1074c7: c3 ret =============================================================================== 0010c56c : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10c56c: 55 push %ebp 10c56d: 57 push %edi 10c56e: 56 push %esi 10c56f: 53 push %ebx 10c570: 83 ec 2c sub $0x2c,%esp 10c573: 8b 5c 24 40 mov 0x40(%esp),%ebx 10c577: 8b 6c 24 44 mov 0x44(%esp),%ebp while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 10c57b: 8d 74 24 1c lea 0x1c(%esp),%esi 10c57f: 90 nop */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10c580: 89 1c 24 mov %ebx,(%esp) 10c583: e8 5c 05 00 00 call 10cae4 <_Chain_Get> 10c588: 89 c7 mov %eax,%edi rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10c58a: 85 c0 test %eax,%eax 10c58c: 75 2e jne 10c5bc ) { rtems_event_set out; sc = rtems_event_receive( 10c58e: 89 74 24 0c mov %esi,0xc(%esp) 10c592: 8b 44 24 48 mov 0x48(%esp),%eax 10c596: 89 44 24 08 mov %eax,0x8(%esp) 10c59a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10c5a1: 00 10c5a2: 89 2c 24 mov %ebp,(%esp) 10c5a5: e8 7e f3 ff ff call 10b928 ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10c5aa: 85 c0 test %eax,%eax 10c5ac: 74 d2 je 10c580 <== NEVER TAKEN timeout, &out ); } *node_ptr = node; 10c5ae: 8b 4c 24 4c mov 0x4c(%esp),%ecx 10c5b2: 89 39 mov %edi,(%ecx) return sc; } 10c5b4: 83 c4 2c add $0x2c,%esp 10c5b7: 5b pop %ebx 10c5b8: 5e pop %esi 10c5b9: 5f pop %edi 10c5ba: 5d pop %ebp 10c5bb: c3 ret rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10c5bc: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10c5be: 8b 4c 24 4c mov 0x4c(%esp),%ecx 10c5c2: 89 39 mov %edi,(%ecx) return sc; } 10c5c4: 83 c4 2c add $0x2c,%esp 10c5c7: 5b pop %ebx 10c5c8: 5e pop %esi 10c5c9: 5f pop %edi 10c5ca: 5d pop %ebp 10c5cb: c3 ret =============================================================================== 00107bf4 : */ void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 107bf4: 55 push %ebp 107bf5: 57 push %edi 107bf6: 56 push %esi 107bf7: 53 push %ebx 107bf8: 83 ec 7c sub $0x7c,%esp uint32_t seconds, nanoseconds; #else uint32_t total_units = 0; #endif if ( !print ) 107bfb: 8b 84 24 94 00 00 00 mov 0x94(%esp),%eax 107c02: 85 c0 test %eax,%eax 107c04: 0f 84 a6 02 00 00 je 107eb0 <== NEVER TAKEN static inline void _Timestamp64_implementation_Set_to_zero( Timestamp64_Control *_time ) { *_time = 0; 107c0a: c7 44 24 50 00 00 00 movl $0x0,0x50(%esp) 107c11: 00 107c12: c7 44 24 54 00 00 00 movl $0x0,0x54(%esp) 107c19: 00 * the number of "ticks" we gave credit for to give the user a rough * guideline as to what each number means proportionally. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &total ); uptime_at_last_reset = CPU_usage_Uptime_at_last_reset; 107c1a: 8b 35 40 2d 13 00 mov 0x132d40,%esi 107c20: 8b 3d 44 2d 13 00 mov 0x132d44,%edi 107c26: 89 74 24 30 mov %esi,0x30(%esp) 107c2a: 89 7c 24 34 mov %edi,0x34(%esp) } } } #endif (*print)( 107c2e: c7 44 24 04 30 2e 12 movl $0x122e30,0x4(%esp) 107c35: 00 107c36: 8b bc 24 90 00 00 00 mov 0x90(%esp),%edi 107c3d: 89 3c 24 mov %edi,(%esp) 107c40: 8b 8c 24 94 00 00 00 mov 0x94(%esp),%ecx 107c47: ff d1 call *%ecx " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 107c49: c7 44 24 3c 01 00 00 movl $0x1,0x3c(%esp) 107c50: 00 #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) 107c51: 8b 74 24 3c mov 0x3c(%esp),%esi 107c55: 8b 04 b5 fc 29 13 00 mov 0x1329fc(,%esi,4),%eax 107c5c: 85 c0 test %eax,%eax 107c5e: 0f 84 c0 01 00 00 je 107e24 continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 107c64: 8b 68 04 mov 0x4(%eax),%ebp if ( information ) { 107c67: 85 ed test %ebp,%ebp 107c69: 0f 84 b5 01 00 00 je 107e24 <== NEVER TAKEN for ( i=1 ; i <= information->maximum ; i++ ) { 107c6f: 66 83 7d 10 00 cmpw $0x0,0x10(%ebp) 107c74: 0f 84 aa 01 00 00 je 107e24 <== NEVER TAKEN 107c7a: bb 01 00 00 00 mov $0x1,%ebx 107c7f: e9 ea 00 00 00 jmp 107d6e Timestamp_Control used; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( &last, &uptime, &used ); _Timestamp_Add_to( &ran, &used ); } else { _TOD_Get_uptime( &uptime ); 107c84: 8d 44 24 48 lea 0x48(%esp),%eax 107c88: 89 04 24 mov %eax,(%esp) 107c8b: e8 c4 5f 00 00 call 10dc54 <_TOD_Get_uptime> 107c90: 8b 44 24 48 mov 0x48(%esp),%eax 107c94: 8b 54 24 4c mov 0x4c(%esp),%edx const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 107c98: 2b 44 24 30 sub 0x30(%esp),%eax 107c9c: 1b 54 24 34 sbb 0x34(%esp),%edx 107ca0: 89 44 24 50 mov %eax,0x50(%esp) 107ca4: 89 54 24 54 mov %edx,0x54(%esp) } _Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total ); _Timestamp_Divide( &ran, &total, &ival, &fval ); 107ca8: 8d 44 24 44 lea 0x44(%esp),%eax 107cac: 89 44 24 0c mov %eax,0xc(%esp) 107cb0: 8d 44 24 40 lea 0x40(%esp),%eax 107cb4: 89 44 24 08 mov %eax,0x8(%esp) 107cb8: 8d 44 24 50 lea 0x50(%esp),%eax 107cbc: 89 44 24 04 mov %eax,0x4(%esp) 107cc0: 8d 44 24 58 lea 0x58(%esp),%eax 107cc4: 89 04 24 mov %eax,(%esp) 107cc7: e8 c4 80 00 00 call 10fd90 <_Timestamp64_Divide> /* * Print the information */ seconds = _Timestamp_Get_seconds( &ran ); 107ccc: 8b 74 24 58 mov 0x58(%esp),%esi 107cd0: 8b 7c 24 5c mov 0x5c(%esp),%edi nanoseconds = _Timestamp_Get_nanoseconds( &ran ) / TOD_NANOSECONDS_PER_MICROSECOND; (*print)( context, 107cd4: 8b 44 24 44 mov 0x44(%esp),%eax 107cd8: 89 44 24 14 mov %eax,0x14(%esp) 107cdc: 8b 44 24 40 mov 0x40(%esp),%eax 107ce0: 89 44 24 10 mov %eax,0x10(%esp) static inline uint32_t _Timestamp64_implementation_Get_nanoseconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time % 1000000000L); 107ce4: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 107ceb: 3b 107cec: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 107cf3: 00 107cf4: 89 34 24 mov %esi,(%esp) 107cf7: 89 7c 24 04 mov %edi,0x4(%esp) 107cfb: e8 fc 8f 01 00 call 120cfc <__moddi3> /* * Print the information */ seconds = _Timestamp_Get_seconds( &ran ); nanoseconds = _Timestamp_Get_nanoseconds( &ran ) / 107d00: ba d3 4d 62 10 mov $0x10624dd3,%edx 107d05: f7 e2 mul %edx 107d07: c1 ea 06 shr $0x6,%edx TOD_NANOSECONDS_PER_MICROSECOND; (*print)( context, 107d0a: 89 54 24 0c mov %edx,0xc(%esp) static inline uint32_t _Timestamp64_implementation_Get_seconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time / 1000000000L); 107d0e: 8b 44 24 08 mov 0x8(%esp),%eax 107d12: 8b 54 24 0c mov 0xc(%esp),%edx 107d16: 89 44 24 28 mov %eax,0x28(%esp) 107d1a: 89 54 24 2c mov %edx,0x2c(%esp) 107d1e: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 107d25: 3b 107d26: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 107d2d: 00 107d2e: 89 34 24 mov %esi,(%esp) 107d31: 89 7c 24 04 mov %edi,0x4(%esp) 107d35: e8 6e 8e 01 00 call 120ba8 <__divdi3> 107d3a: 8b 7c 24 2c mov 0x2c(%esp),%edi 107d3e: 89 7c 24 0c mov %edi,0xc(%esp) 107d42: 89 44 24 08 mov %eax,0x8(%esp) 107d46: c7 44 24 04 a3 30 12 movl $0x1230a3,0x4(%esp) 107d4d: 00 107d4e: 8b bc 24 90 00 00 00 mov 0x90(%esp),%edi 107d55: 89 3c 24 mov %edi,(%esp) 107d58: 8b 8c 24 94 00 00 00 mov 0x94(%esp),%ecx 107d5f: ff d1 call *%ecx continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 107d61: 43 inc %ebx 107d62: 0f b7 45 10 movzwl 0x10(%ebp),%eax 107d66: 39 d8 cmp %ebx,%eax 107d68: 0f 82 b6 00 00 00 jb 107e24 the_thread = (Thread_Control *)information->local_table[ i ]; 107d6e: 8b 45 1c mov 0x1c(%ebp),%eax 107d71: 8b 34 98 mov (%eax,%ebx,4),%esi if ( !the_thread ) 107d74: 85 f6 test %esi,%esi 107d76: 74 e9 je 107d61 <== NEVER TAKEN continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 107d78: 8d 7c 24 63 lea 0x63(%esp),%edi 107d7c: 89 7c 24 08 mov %edi,0x8(%esp) 107d80: c7 44 24 04 0d 00 00 movl $0xd,0x4(%esp) 107d87: 00 107d88: 8b 46 08 mov 0x8(%esi),%eax 107d8b: 89 04 24 mov %eax,(%esp) 107d8e: e8 45 4b 00 00 call 10c8d8 (*print)( context, " 0x%08" PRIx32 " | %-38s |", the_thread->Object.id, name 107d93: 8d 44 24 63 lea 0x63(%esp),%eax 107d97: 89 44 24 0c mov %eax,0xc(%esp) if ( !the_thread ) continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); (*print)( 107d9b: 8b 46 08 mov 0x8(%esi),%eax 107d9e: 89 44 24 08 mov %eax,0x8(%esp) 107da2: c7 44 24 04 90 30 12 movl $0x123090,0x4(%esp) 107da9: 00 107daa: 8b 8c 24 90 00 00 00 mov 0x90(%esp),%ecx 107db1: 89 0c 24 mov %ecx,(%esp) 107db4: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi 107dbb: ff d7 call *%edi /* * If this is the currently executing thread, account for time * since the last context switch. */ ran = the_thread->cpu_time_used; 107dbd: 8b 86 80 00 00 00 mov 0x80(%esi),%eax 107dc3: 8b 96 84 00 00 00 mov 0x84(%esi),%edx 107dc9: 89 44 24 58 mov %eax,0x58(%esp) 107dcd: 89 54 24 5c mov %edx,0x5c(%esp) Thread_Control *the_thread, Timestamp_Control *time_of_context_switch ) { #ifndef RTEMS_SMP if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 107dd1: a1 cc 2c 13 00 mov 0x132ccc,%eax 107dd6: 8b 50 08 mov 0x8(%eax),%edx 107dd9: 39 56 08 cmp %edx,0x8(%esi) 107ddc: 0f 85 a2 fe ff ff jne 107c84 *time_of_context_switch = _Thread_Time_of_last_context_switch; 107de2: 8b 35 dc 2c 13 00 mov 0x132cdc,%esi 107de8: 8b 3d e0 2c 13 00 mov 0x132ce0,%edi 107dee: 89 74 24 28 mov %esi,0x28(%esp) 107df2: 89 7c 24 2c mov %edi,0x2c(%esp) * since the last context switch. */ ran = the_thread->cpu_time_used; if ( is_executing_on_a_core( the_thread, &last ) ) { Timestamp_Control used; _TOD_Get_uptime( &uptime ); 107df6: 8d 7c 24 48 lea 0x48(%esp),%edi 107dfa: 89 3c 24 mov %edi,(%esp) 107dfd: e8 52 5e 00 00 call 10dc54 <_TOD_Get_uptime> _Timestamp_Subtract( &last, &uptime, &used ); 107e02: 8b 44 24 48 mov 0x48(%esp),%eax 107e06: 8b 54 24 4c mov 0x4c(%esp),%edx const Timestamp64_Control *_start, const Timestamp64_Control *_end, Timestamp64_Control *_result ) { *_result = *_end - *_start; 107e0a: 89 c6 mov %eax,%esi 107e0c: 89 d7 mov %edx,%edi 107e0e: 2b 74 24 28 sub 0x28(%esp),%esi 107e12: 1b 7c 24 2c sbb 0x2c(%esp),%edi static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 107e16: 01 74 24 58 add %esi,0x58(%esp) 107e1a: 11 7c 24 5c adc %edi,0x5c(%esp) 107e1e: e9 75 fe ff ff jmp 107c98 107e23: 90 nop " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 107e24: ff 44 24 3c incl 0x3c(%esp) 107e28: 83 7c 24 3c 04 cmpl $0x4,0x3c(%esp) 107e2d: 0f 85 1e fe ff ff jne 107c51 } } } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ seconds = _Timestamp_Get_seconds( &total ); 107e33: 8b 74 24 50 mov 0x50(%esp),%esi 107e37: 8b 7c 24 54 mov 0x54(%esp),%edi static inline uint32_t _Timestamp64_implementation_Get_nanoseconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time % 1000000000L); 107e3b: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 107e42: 3b 107e43: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 107e4a: 00 107e4b: 89 34 24 mov %esi,(%esp) 107e4e: 89 7c 24 04 mov %edi,0x4(%esp) 107e52: e8 a5 8e 01 00 call 120cfc <__moddi3> nanoseconds = _Timestamp_Get_nanoseconds( &total ) / 107e57: ba d3 4d 62 10 mov $0x10624dd3,%edx 107e5c: f7 e2 mul %edx 107e5e: c1 ea 06 shr $0x6,%edx TOD_NANOSECONDS_PER_MICROSECOND; (*print)( 107e61: 89 54 24 0c mov %edx,0xc(%esp) static inline uint32_t _Timestamp64_implementation_Get_seconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time / 1000000000L); 107e65: 8b 4c 24 08 mov 0x8(%esp),%ecx 107e69: 8b 5c 24 0c mov 0xc(%esp),%ebx 107e6d: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 107e74: 3b 107e75: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 107e7c: 00 107e7d: 89 34 24 mov %esi,(%esp) 107e80: 89 7c 24 04 mov %edi,0x4(%esp) 107e84: 89 4c 24 24 mov %ecx,0x24(%esp) 107e88: e8 1b 8d 01 00 call 120ba8 <__divdi3> 107e8d: 89 5c 24 0c mov %ebx,0xc(%esp) 107e91: 89 44 24 08 mov %eax,0x8(%esp) 107e95: c7 44 24 04 a4 2f 12 movl $0x122fa4,0x4(%esp) 107e9c: 00 107e9d: 8b b4 24 90 00 00 00 mov 0x90(%esp),%esi 107ea4: 89 34 24 mov %esi,(%esp) 107ea7: 8b bc 24 94 00 00 00 mov 0x94(%esp),%edi 107eae: ff d7 call *%edi "-------------------------------------------------------------------------------\n", _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset, total_units ); #endif } 107eb0: 83 c4 7c add $0x7c,%esp 107eb3: 5b pop %ebx 107eb4: 5e pop %esi 107eb5: 5f pop %edi 107eb6: 5d pop %ebp 107eb7: c3 ret =============================================================================== 00112c78 : [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { 112c78: 53 push %ebx 112c79: 83 ec 08 sub $0x8,%esp 112c7c: 8b 54 24 10 mov 0x10(%esp),%edx if (sc == RTEMS_SUCCESSFUL) { return 0; 112c80: 31 c0 xor %eax,%eax [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) { 112c82: 85 d2 test %edx,%edx 112c84: 75 06 jne 112c8c errno = eno; return -1; } } 112c86: 83 c4 08 add $0x8,%esp 112c89: 5b pop %ebx 112c8a: c3 ret 112c8b: 90 nop if (sc == RTEMS_SUCCESSFUL) { return 0; } else { int eno = EINVAL; if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 112c8c: 83 fa 1c cmp $0x1c,%edx 112c8f: 77 17 ja 112ca8 <== NEVER TAKEN eno = status_code_to_errno [sc]; 112c91: 8b 1c 95 00 1d 12 00 mov 0x121d00(,%edx,4),%ebx } errno = eno; 112c98: e8 5b 00 00 00 call 112cf8 <__errno> 112c9d: 89 18 mov %ebx,(%eax) return -1; 112c9f: b8 ff ff ff ff mov $0xffffffff,%eax 112ca4: eb e0 jmp 112c86 112ca6: 66 90 xchg %ax,%ax int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) { return 0; } else { int eno = EINVAL; 112ca8: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED 112cad: eb e9 jmp 112c98 <== NOT EXECUTED =============================================================================== 001100d0 : int eval_flags, mode_t node_mode, uid_t node_uid, gid_t node_gid ) { 1100d0: 57 push %edi 1100d1: 56 push %esi 1100d2: 53 push %ebx 1100d3: 8b 5c 24 10 mov 0x10(%esp),%ebx 1100d7: 8b 74 24 18 mov 0x18(%esp),%esi 1100db: 8b 7c 24 1c mov 0x1c(%esp),%edi mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX; 1100df: 83 e3 07 and $0x7,%ebx uid_t task_uid = geteuid(); 1100e2: e8 f1 25 00 00 call 1126d8 if (task_uid == 0 || task_uid == node_uid) { 1100e7: 66 85 c0 test %ax,%ax 1100ea: 74 24 je 110110 1100ec: 66 39 f0 cmp %si,%ax 1100ef: 74 1f je 110110 perm_flags <<= RTEMS_FS_USR_SHIFT; } else { gid_t task_gid = getegid(); 1100f1: e8 d6 25 00 00 call 1126cc if (task_gid == 0 || task_gid == node_gid) { 1100f6: 66 85 c0 test %ax,%ax 1100f9: 75 29 jne 110124 perm_flags <<= RTEMS_FS_GRP_SHIFT; 1100fb: c1 e3 03 shl $0x3,%ebx } else { perm_flags <<= RTEMS_FS_OTH_SHIFT; } } return (perm_flags & node_mode) == perm_flags; 1100fe: 8b 44 24 14 mov 0x14(%esp),%eax 110102: 21 d8 and %ebx,%eax 110104: 39 d8 cmp %ebx,%eax 110106: 0f 94 c0 sete %al } 110109: 5b pop %ebx 11010a: 5e pop %esi 11010b: 5f pop %edi 11010c: c3 ret 11010d: 8d 76 00 lea 0x0(%esi),%esi { mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX; uid_t task_uid = geteuid(); if (task_uid == 0 || task_uid == node_uid) { perm_flags <<= RTEMS_FS_USR_SHIFT; 110110: c1 e3 06 shl $0x6,%ebx } else { perm_flags <<= RTEMS_FS_OTH_SHIFT; } } return (perm_flags & node_mode) == perm_flags; 110113: 8b 44 24 14 mov 0x14(%esp),%eax 110117: 21 d8 and %ebx,%eax 110119: 39 d8 cmp %ebx,%eax 11011b: 0f 94 c0 sete %al } 11011e: 5b pop %ebx 11011f: 5e pop %esi 110120: 5f pop %edi 110121: c3 ret 110122: 66 90 xchg %ax,%ax if (task_uid == 0 || task_uid == node_uid) { perm_flags <<= RTEMS_FS_USR_SHIFT; } else { gid_t task_gid = getegid(); if (task_gid == 0 || task_gid == node_gid) { 110124: 66 39 f8 cmp %di,%ax 110127: 74 d2 je 1100fb <== NEVER TAKEN } else { perm_flags <<= RTEMS_FS_OTH_SHIFT; } } return (perm_flags & node_mode) == perm_flags; 110129: 8b 44 24 14 mov 0x14(%esp),%eax 11012d: 21 d8 and %ebx,%eax 11012f: 39 d8 cmp %ebx,%eax 110131: 0f 94 c0 sete %al } 110134: 5b pop %ebx 110135: 5e pop %esi 110136: 5f pop %edi 110137: c3 ret =============================================================================== 00108fa4 : } void rtems_filesystem_do_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 108fa4: 53 push %ebx 108fa5: 83 ec 18 sub $0x18,%esp 108fa8: 8b 5c 24 20 mov 0x20(%esp),%ebx */ #include static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 108fac: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 108fb3: 00 108fb4: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 108fbb: 00 108fbc: a1 dc f4 12 00 mov 0x12f4dc,%eax 108fc1: 89 04 24 mov %eax,(%esp) 108fc4: e8 b3 29 00 00 call 10b97c ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 108fc9: 8b 13 mov (%ebx),%edx previous = the_node->previous; 108fcb: 8b 43 04 mov 0x4(%ebx),%eax next->previous = previous; 108fce: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 108fd1: 89 10 mov %edx,(%eax) } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 108fd3: a1 dc f4 12 00 mov 0x12f4dc,%eax 108fd8: 89 04 24 mov %eax,(%esp) 108fdb: e8 c8 2a 00 00 call 10baa8 rtems_filesystem_mt_lock(); rtems_chain_extract_unprotected(&mt_entry->mt_node); rtems_filesystem_mt_unlock(); rtems_filesystem_global_location_release(mt_entry->mt_point_node); 108fe0: 8b 43 20 mov 0x20(%ebx),%eax 108fe3: 89 04 24 mov %eax,(%esp) 108fe6: e8 59 01 00 00 call 109144 (*mt_entry->ops->fsunmount_me_h)(mt_entry); 108feb: 8b 43 0c mov 0xc(%ebx),%eax 108fee: 89 1c 24 mov %ebx,(%esp) 108ff1: ff 50 3c call *0x3c(%eax) if (mt_entry->unmount_task != 0) { 108ff4: 8b 43 3c mov 0x3c(%ebx),%eax 108ff7: 85 c0 test %eax,%eax 108ff9: 74 14 je 10900f <== NEVER TAKEN rtems_status_code sc = 108ffb: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp) 109002: 00 109003: 89 04 24 mov %eax,(%esp) 109006: e8 e5 24 00 00 call 10b4f0 rtems_event_send(mt_entry->unmount_task, RTEMS_FILESYSTEM_UNMOUNT_EVENT); if (sc != RTEMS_SUCCESSFUL) { 10900b: 85 c0 test %eax,%eax 10900d: 75 0d jne 10901c <== NEVER TAKEN rtems_fatal_error_occurred(0xdeadbeef); } } free(mt_entry); 10900f: 89 5c 24 20 mov %ebx,0x20(%esp) } 109013: 83 c4 18 add $0x18,%esp 109016: 5b pop %ebx if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(0xdeadbeef); } } free(mt_entry); 109017: e9 20 e9 ff ff jmp 10793c if (mt_entry->unmount_task != 0) { rtems_status_code sc = rtems_event_send(mt_entry->unmount_task, RTEMS_FILESYSTEM_UNMOUNT_EVENT); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(0xdeadbeef); 10901c: c7 04 24 ef be ad de movl $0xdeadbeef,(%esp) <== NOT EXECUTED 109023: e8 88 30 00 00 call 10c0b0 <== NOT EXECUTED =============================================================================== 00110188 : void rtems_filesystem_eval_path_generic( rtems_filesystem_eval_path_context_t *ctx, void *arg, const rtems_filesystem_eval_path_generic_config *config ) { 110188: 55 push %ebp 110189: 57 push %edi 11018a: 56 push %esi 11018b: 53 push %ebx 11018c: 83 ec 2c sub $0x2c,%esp 11018f: 8b 5c 24 40 mov 0x40(%esp),%ebx 110193: 8b 7c 24 44 mov 0x44(%esp),%edi 110197: 8b 54 24 48 mov 0x48(%esp),%edx 11019b: 89 54 24 18 mov %edx,0x18(%esp) rtems_filesystem_eval_path_error(ctx, EINVAL); status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } else if (rtems_filesystem_is_parent_directory(token, tokenlen)) { rtems_filesystem_location_info_t *currentloc = 11019f: 8d 53 18 lea 0x18(%ebx),%edx 1101a2: 89 54 24 1c mov %edx,0x1c(%esp) rtems_filesystem_eval_path_context_t *ctx, const char **token, size_t *tokenlen ) { rtems_filesystem_eval_path_next_token(ctx); 1101a6: 89 1c 24 mov %ebx,(%esp) 1101a9: e8 da 01 00 00 call 110388 *token = ctx->token; 1101ae: 8b 6b 08 mov 0x8(%ebx),%ebp *tokenlen = ctx->tokenlen; 1101b1: 8b 73 0c mov 0xc(%ebx),%esi const char *token; size_t tokenlen; rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen); if (tokenlen > 0) { 1101b4: 85 f6 test %esi,%esi 1101b6: 75 08 jne 1101c0 } } else { status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } 1101b8: 83 c4 2c add $0x2c,%esp 1101bb: 5b pop %ebx 1101bc: 5e pop %esi 1101bd: 5f pop %edi 1101be: 5d pop %ebp 1101bf: c3 ret size_t tokenlen; rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen); if (tokenlen > 0) { if ((*config->is_directory)(ctx, arg)) { 1101c0: 89 7c 24 04 mov %edi,0x4(%esp) 1101c4: 89 1c 24 mov %ebx,(%esp) 1101c7: 8b 54 24 18 mov 0x18(%esp),%edx 1101cb: ff 12 call *(%edx) 1101cd: 84 c0 test %al,%al 1101cf: 74 2f je 110200 static inline bool rtems_filesystem_is_current_directory( const char *token, size_t tokenlen ) { return tokenlen == 1 && token [0] == '.'; 1101d1: 83 fe 01 cmp $0x1,%esi 1101d4: 74 76 je 11024c static inline bool rtems_filesystem_is_parent_directory( const char *token, size_t tokenlen ) { return tokenlen == 2 && token [0] == '.' && token [1] == '.'; 1101d6: 83 fe 02 cmp $0x2,%esi 1101d9: 0f 84 a1 00 00 00 je 110280 } } else { status = (*config->eval_token)(ctx, arg, "..", 2); } } else { status = (*config->eval_token)(ctx, arg, token, tokenlen); 1101df: 89 74 24 0c mov %esi,0xc(%esp) 1101e3: 89 6c 24 08 mov %ebp,0x8(%esp) 1101e7: 89 7c 24 04 mov %edi,0x4(%esp) 1101eb: 89 1c 24 mov %ebx,(%esp) 1101ee: 8b 54 24 18 mov 0x18(%esp),%edx 1101f2: ff 52 04 call *0x4(%edx) } if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) { 1101f5: 83 f8 02 cmp $0x2,%eax 1101f8: 74 1e je 110218 ) { rtems_filesystem_eval_path_generic_status status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE; while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) { 1101fa: 85 c0 test %eax,%eax 1101fc: 74 a8 je 1101a6 1101fe: eb b8 jmp 1101b8 rtems_filesystem_eval_path_error(ctx, ENOENT); } } } } else { rtems_filesystem_eval_path_error(ctx, ENOTDIR); 110200: c7 44 24 44 14 00 00 movl $0x14,0x44(%esp) 110207: 00 110208: 89 5c 24 40 mov %ebx,0x40(%esp) } } else { status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } 11020c: 83 c4 2c add $0x2c,%esp 11020f: 5b pop %ebx 110210: 5e pop %esi 110211: 5f pop %edi 110212: 5d pop %ebp rtems_filesystem_eval_path_error(ctx, ENOENT); } } } } else { rtems_filesystem_eval_path_error(ctx, ENOTDIR); 110213: e9 1c 88 ff ff jmp 108a34 } else { status = (*config->eval_token)(ctx, arg, token, tokenlen); } if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) { if (rtems_filesystem_eval_path_has_path(ctx)) { 110218: 8b 4b 04 mov 0x4(%ebx),%ecx 11021b: 85 c9 test %ecx,%ecx 11021d: 74 99 je 1101b8 int eval_flags; rtems_filesystem_eval_path_eat_delimiter(ctx); 11021f: 89 1c 24 mov %ebx,(%esp) 110222: e8 29 01 00 00 call 110350 eval_flags = rtems_filesystem_eval_path_get_flags(ctx); if ( 110227: f6 43 10 80 testb $0x80,0x10(%ebx) 11022b: 74 07 je 110234 (eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0 || rtems_filesystem_eval_path_has_path(ctx) 11022d: 8b 53 04 mov 0x4(%ebx),%edx 110230: 85 d2 test %edx,%edx 110232: 74 84 je 1101b8 ) { rtems_filesystem_eval_path_error(ctx, ENOENT); 110234: c7 44 24 44 02 00 00 movl $0x2,0x44(%esp) 11023b: 00 } } } } else { rtems_filesystem_eval_path_error(ctx, ENOTDIR); 11023c: 89 5c 24 40 mov %ebx,0x40(%esp) } } else { status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } 110240: 83 c4 2c add $0x2c,%esp 110243: 5b pop %ebx 110244: 5e pop %esi 110245: 5f pop %edi 110246: 5d pop %ebp rtems_filesystem_eval_path_error(ctx, ENOENT); } } } } else { rtems_filesystem_eval_path_error(ctx, ENOTDIR); 110247: e9 e8 87 ff ff jmp 108a34 static inline bool rtems_filesystem_is_current_directory( const char *token, size_t tokenlen ) { return tokenlen == 1 && token [0] == '.'; 11024c: 80 7d 00 2e cmpb $0x2e,0x0(%ebp) 110250: 75 8d jne 1101df rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen); if (tokenlen > 0) { if ((*config->is_directory)(ctx, arg)) { if (rtems_filesystem_is_current_directory(token, tokenlen)) { if (rtems_filesystem_eval_path_has_path(ctx)) { 110252: 8b 43 04 mov 0x4(%ebx),%eax 110255: 85 c0 test %eax,%eax 110257: 0f 85 8f 00 00 00 jne 1102ec status = (*config->eval_token)(ctx, arg, ".", 1); } else { int eval_flags = rtems_filesystem_eval_path_get_flags(ctx); if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) { 11025d: f6 43 11 01 testb $0x1,0x11(%ebx) 110261: 0f 84 85 00 00 00 je 1102ec status = (*config->eval_token)(ctx, arg, ".", 1); } else { rtems_filesystem_eval_path_error(ctx, EINVAL); 110267: c7 44 24 44 16 00 00 movl $0x16,0x44(%esp) 11026e: 00 rtems_filesystem_eval_path_error(ctx, ENOENT); } } } } else { rtems_filesystem_eval_path_error(ctx, ENOTDIR); 11026f: 89 5c 24 40 mov %ebx,0x40(%esp) } } else { status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } 110273: 83 c4 2c add $0x2c,%esp 110276: 5b pop %ebx 110277: 5e pop %esi 110278: 5f pop %edi 110279: 5d pop %ebp rtems_filesystem_eval_path_error(ctx, ENOENT); } } } } else { rtems_filesystem_eval_path_error(ctx, ENOTDIR); 11027a: e9 b5 87 ff ff jmp 108a34 11027f: 90 nop static inline bool rtems_filesystem_is_parent_directory( const char *token, size_t tokenlen ) { return tokenlen == 2 && token [0] == '.' && token [1] == '.'; 110280: 80 7d 00 2e cmpb $0x2e,0x0(%ebp) 110284: 0f 85 55 ff ff ff jne 1101df 11028a: 80 7d 01 2e cmpb $0x2e,0x1(%ebp) 11028e: 0f 85 4b ff ff ff jne 1101df <== NEVER TAKEN } } else { status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } 110294: 8b 53 30 mov 0x30(%ebx),%edx static bool is_eval_path_root( const rtems_filesystem_eval_path_context_t *ctx, const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; 110297: 8b 43 2c mov 0x2c(%ebx),%eax const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location; return mt_entry == rootloc->mt_entry && (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc ); 11029a: 3b 42 14 cmp 0x14(%edx),%eax 11029d: 0f 84 8f 00 00 00 je 110332 { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; const rtems_filesystem_location_info_t *mt_fs_root = &mt_entry->mt_fs_root->location; return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root ); 1102a3: 8b 50 0c mov 0xc(%eax),%edx 1102a6: 8b 40 24 mov 0x24(%eax),%eax 1102a9: 89 44 24 04 mov %eax,0x4(%esp) 1102ad: 8b 44 24 1c mov 0x1c(%esp),%eax 1102b1: 89 04 24 mov %eax,(%esp) 1102b4: ff 52 10 call *0x10(%edx) rtems_filesystem_eval_path_get_currentloc( ctx ); if (is_eval_path_root(ctx, currentloc)) { /* This prevents the escape from a chroot() environment */ status = (*config->eval_token)(ctx, arg, ".", 1); } else if (is_fs_root(currentloc)) { 1102b7: 84 c0 test %al,%al 1102b9: 74 54 je 11030f if (currentloc->mt_entry->mt_point_node != NULL) { 1102bb: 8b 43 2c mov 0x2c(%ebx),%eax 1102be: 8b 70 20 mov 0x20(%eax),%esi 1102c1: 85 f6 test %esi,%esi 1102c3: 74 27 je 1102ec <== NEVER TAKEN static inline void rtems_filesystem_eval_path_put_back_token( rtems_filesystem_eval_path_context_t *ctx ) { size_t tokenlen = ctx->tokenlen; 1102c5: 8b 53 0c mov 0xc(%ebx),%edx ctx->path -= tokenlen; 1102c8: 29 13 sub %edx,(%ebx) ctx->pathlen += tokenlen; 1102ca: 01 53 04 add %edx,0x4(%ebx) ctx->tokenlen = 0; 1102cd: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) rtems_filesystem_eval_path_put_back_token(ctx); rtems_filesystem_eval_path_restart( 1102d4: 83 c0 20 add $0x20,%eax 1102d7: 89 44 24 44 mov %eax,0x44(%esp) 1102db: 89 5c 24 40 mov %ebx,0x40(%esp) } } else { status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE; } } } 1102df: 83 c4 2c add $0x2c,%esp 1102e2: 5b pop %ebx 1102e3: 5e pop %esi 1102e4: 5f pop %edi 1102e5: 5d pop %ebp /* This prevents the escape from a chroot() environment */ status = (*config->eval_token)(ctx, arg, ".", 1); } else if (is_fs_root(currentloc)) { if (currentloc->mt_entry->mt_point_node != NULL) { rtems_filesystem_eval_path_put_back_token(ctx); rtems_filesystem_eval_path_restart( 1102e6: e9 49 8b ff ff jmp 108e34 1102eb: 90 nop rtems_filesystem_location_info_t *currentloc = rtems_filesystem_eval_path_get_currentloc( ctx ); if (is_eval_path_root(ctx, currentloc)) { /* This prevents the escape from a chroot() environment */ status = (*config->eval_token)(ctx, arg, ".", 1); 1102ec: c7 44 24 0c 01 00 00 movl $0x1,0xc(%esp) 1102f3: 00 1102f4: c7 44 24 08 d1 1c 12 movl $0x121cd1,0x8(%esp) 1102fb: 00 1102fc: 89 7c 24 04 mov %edi,0x4(%esp) 110300: 89 1c 24 mov %ebx,(%esp) 110303: 8b 54 24 18 mov 0x18(%esp),%edx 110307: ff 52 04 call *0x4(%edx) 11030a: e9 e6 fe ff ff jmp 1101f5 } else { /* This is the root file system */ status = (*config->eval_token)(ctx, arg, ".", 1); } } else { status = (*config->eval_token)(ctx, arg, "..", 2); 11030f: c7 44 24 0c 02 00 00 movl $0x2,0xc(%esp) 110316: 00 110317: c7 44 24 08 d0 1c 12 movl $0x121cd0,0x8(%esp) 11031e: 00 11031f: 89 7c 24 04 mov %edi,0x4(%esp) 110323: 89 1c 24 mov %ebx,(%esp) 110326: 8b 54 24 18 mov 0x18(%esp),%edx 11032a: ff 52 04 call *0x4(%edx) 11032d: e9 c3 fe ff ff jmp 1101f5 { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location; return mt_entry == rootloc->mt_entry && (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc ); 110332: 8b 40 0c mov 0xc(%eax),%eax 110335: 89 54 24 04 mov %edx,0x4(%esp) 110339: 8b 54 24 1c mov 0x1c(%esp),%edx 11033d: 89 14 24 mov %edx,(%esp) 110340: ff 50 10 call *0x10(%eax) 110343: 84 c0 test %al,%al 110345: 75 a5 jne 1102ec 110347: 8b 43 2c mov 0x2c(%ebx),%eax 11034a: e9 54 ff ff ff jmp 1102a3 =============================================================================== 00110388 : } void rtems_filesystem_eval_path_next_token( rtems_filesystem_eval_path_context_t *ctx ) { 110388: 57 push %edi 110389: 56 push %esi 11038a: 53 push %ebx 11038b: 52 push %edx 11038c: 8b 74 24 14 mov 0x14(%esp),%esi rtems_filesystem_eval_path_eat_delimiter(ctx); 110390: 89 34 24 mov %esi,(%esp) 110393: e8 b8 ff ff ff call 110350 ctx->pathlen = (size_t) (end - current); } static void next_token(rtems_filesystem_eval_path_context_t *ctx) { const char *begin = ctx->path; 110398: 8b 0e mov (%esi),%ecx const char *end = begin + ctx->pathlen; 11039a: 8b 5e 04 mov 0x4(%esi),%ebx 11039d: 01 cb add %ecx,%ebx const char *current = begin; while (current != end && !rtems_filesystem_is_delimiter(*current)) { 11039f: 39 d9 cmp %ebx,%ecx 1103a1: 74 2d je 1103d0 1103a3: 8a 01 mov (%ecx),%al 1103a5: 3c 2f cmp $0x2f,%al 1103a7: 74 27 je 1103d0 <== NEVER TAKEN 1103a9: 3c 5c cmp $0x5c,%al 1103ab: 74 23 je 1103d0 <== NEVER TAKEN 1103ad: 89 c8 mov %ecx,%eax 1103af: eb 08 jmp 1103b9 1103b1: 8d 76 00 lea 0x0(%esi),%esi 1103b4: 80 fa 5c cmp $0x5c,%dl 1103b7: 74 0c je 1103c5 ++current; 1103b9: 40 inc %eax { const char *begin = ctx->path; const char *end = begin + ctx->pathlen; const char *current = begin; while (current != end && !rtems_filesystem_is_delimiter(*current)) { 1103ba: 39 c3 cmp %eax,%ebx 1103bc: 74 2e je 1103ec 1103be: 8a 10 mov (%eax),%dl 1103c0: 80 fa 2f cmp $0x2f,%dl 1103c3: 75 ef jne 1103b4 1103c5: 89 c7 mov %eax,%edi 1103c7: 89 c2 mov %eax,%edx 1103c9: 29 ca sub %ecx,%edx 1103cb: eb 0b jmp 1103d8 1103cd: 8d 76 00 lea 0x0(%esi),%esi 1103d0: 89 cf mov %ecx,%edi 1103d2: 89 c8 mov %ecx,%eax 1103d4: 31 d2 xor %edx,%edx 1103d6: 66 90 xchg %ax,%ax ++current; } ctx->path = current; 1103d8: 89 06 mov %eax,(%esi) ctx->pathlen = (size_t) (end - current); 1103da: 29 fb sub %edi,%ebx 1103dc: 89 5e 04 mov %ebx,0x4(%esi) ctx->token = begin; 1103df: 89 4e 08 mov %ecx,0x8(%esi) ctx->tokenlen = (size_t) (current - begin); 1103e2: 89 56 0c mov %edx,0xc(%esi) rtems_filesystem_eval_path_context_t *ctx ) { rtems_filesystem_eval_path_eat_delimiter(ctx); next_token(ctx); } 1103e5: 58 pop %eax 1103e6: 5b pop %ebx 1103e7: 5e pop %esi 1103e8: 5f pop %edi 1103e9: c3 ret 1103ea: 66 90 xchg %ax,%ax 1103ec: 89 df mov %ebx,%edi 1103ee: 89 da mov %ebx,%edx 1103f0: 29 ca sub %ecx,%edx 1103f2: eb e4 jmp 1103d8 =============================================================================== 00108e98 : void rtems_filesystem_eval_path_recursive( rtems_filesystem_eval_path_context_t *ctx, const char *path, size_t pathlen ) { 108e98: 55 push %ebp 108e99: 57 push %edi 108e9a: 56 push %esi 108e9b: 53 push %ebx 108e9c: 83 ec 2c sub $0x2c,%esp 108e9f: 8b 5c 24 40 mov 0x40(%esp),%ebx 108ea3: 8b 54 24 44 mov 0x44(%esp),%edx 108ea7: 8b 6c 24 48 mov 0x48(%esp),%ebp if (pathlen > 0) { 108eab: 85 ed test %ebp,%ebp 108ead: 74 5d je 108f0c <== NEVER TAKEN if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) { 108eaf: 83 7b 14 1f cmpl $0x1f,0x14(%ebx) 108eb3: 7f 6f jg 108f24 const char *saved_path = ctx->path; 108eb5: 8b 33 mov (%ebx),%esi size_t saved_pathlen = ctx->pathlen; 108eb7: 8b 7b 04 mov 0x4(%ebx),%edi if (rtems_filesystem_is_delimiter(path [0])) { 108eba: 8a 02 mov (%edx),%al gid_t node_gid ); static inline bool rtems_filesystem_is_delimiter(char c) { return c == '/' || c == '\\'; 108ebc: 3c 2f cmp $0x2f,%al 108ebe: 74 30 je 108ef0 108ec0: 3c 5c cmp $0x5c,%al 108ec2: 74 2c je 108ef0 <== NEVER TAKEN rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc); } ctx->path = path; 108ec4: 89 13 mov %edx,(%ebx) ctx->pathlen = pathlen; 108ec6: 89 6b 04 mov %ebp,0x4(%ebx) ++ctx->recursionlevel; 108ec9: ff 43 14 incl 0x14(%ebx) while (ctx->pathlen > 0) { (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx); 108ecc: 8b 43 2c mov 0x2c(%ebx),%eax 108ecf: 8b 40 0c mov 0xc(%eax),%eax 108ed2: 89 1c 24 mov %ebx,(%esp) 108ed5: ff 50 08 call *0x8(%eax) ctx->path = path; ctx->pathlen = pathlen; ++ctx->recursionlevel; while (ctx->pathlen > 0) { 108ed8: 8b 43 04 mov 0x4(%ebx),%eax 108edb: 85 c0 test %eax,%eax 108edd: 75 ed jne 108ecc (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx); } --ctx->recursionlevel; 108edf: ff 4b 14 decl 0x14(%ebx) ctx->path = saved_path; 108ee2: 89 33 mov %esi,(%ebx) ctx->pathlen = saved_pathlen; 108ee4: 89 7b 04 mov %edi,0x4(%ebx) rtems_filesystem_eval_path_error(ctx, ELOOP); } } else { rtems_filesystem_eval_path_error(ctx, ENOENT); } } 108ee7: 83 c4 2c add $0x2c,%esp 108eea: 5b pop %ebx 108eeb: 5e pop %esi 108eec: 5f pop %edi 108eed: 5d pop %ebp 108eee: c3 ret 108eef: 90 nop if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) { const char *saved_path = ctx->path; size_t saved_pathlen = ctx->pathlen; if (rtems_filesystem_is_delimiter(path [0])) { rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc); 108ef0: 8d 43 30 lea 0x30(%ebx),%eax 108ef3: 89 44 24 04 mov %eax,0x4(%esp) 108ef7: 89 1c 24 mov %ebx,(%esp) 108efa: 89 54 24 1c mov %edx,0x1c(%esp) 108efe: e8 31 ff ff ff call 108e34 108f03: 8b 54 24 1c mov 0x1c(%esp),%edx 108f07: eb bb jmp 108ec4 108f09: 8d 76 00 lea 0x0(%esi),%esi ctx->pathlen = saved_pathlen; } else { rtems_filesystem_eval_path_error(ctx, ELOOP); } } else { rtems_filesystem_eval_path_error(ctx, ENOENT); 108f0c: c7 44 24 44 02 00 00 movl $0x2,0x44(%esp) <== NOT EXECUTED 108f13: 00 108f14: 89 5c 24 40 mov %ebx,0x40(%esp) <== NOT EXECUTED } } 108f18: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 108f1b: 5b pop %ebx <== NOT EXECUTED 108f1c: 5e pop %esi <== NOT EXECUTED 108f1d: 5f pop %edi <== NOT EXECUTED 108f1e: 5d pop %ebp <== NOT EXECUTED ctx->pathlen = saved_pathlen; } else { rtems_filesystem_eval_path_error(ctx, ELOOP); } } else { rtems_filesystem_eval_path_error(ctx, ENOENT); 108f1f: e9 10 fb ff ff jmp 108a34 <== NOT EXECUTED --ctx->recursionlevel; ctx->path = saved_path; ctx->pathlen = saved_pathlen; } else { rtems_filesystem_eval_path_error(ctx, ELOOP); 108f24: c7 44 24 44 5c 00 00 movl $0x5c,0x44(%esp) 108f2b: 00 } } else { rtems_filesystem_eval_path_error(ctx, ENOENT); 108f2c: 89 5c 24 40 mov %ebx,0x40(%esp) } } 108f30: 83 c4 2c add $0x2c,%esp 108f33: 5b pop %ebx 108f34: 5e pop %esi 108f35: 5f pop %edi 108f36: 5d pop %ebp ctx->pathlen = saved_pathlen; } else { rtems_filesystem_eval_path_error(ctx, ELOOP); } } else { rtems_filesystem_eval_path_error(ctx, ENOENT); 108f37: e9 f8 fa ff ff jmp 108a34 =============================================================================== 00108d20 : const char *path, int eval_flags, rtems_filesystem_location_info_t *parentloc, int parent_eval_flags ) { 108d20: 57 push %edi 108d21: 56 push %esi 108d22: 53 push %ebx 108d23: 83 ec 10 sub $0x10,%esp 108d26: 8b 5c 24 20 mov 0x20(%esp),%ebx 108d2a: 8b 54 24 24 mov 0x24(%esp),%edx size_t pathlen = strlen(path); 108d2e: 31 c0 xor %eax,%eax 108d30: b9 ff ff ff ff mov $0xffffffff,%ecx 108d35: 89 d7 mov %edx,%edi 108d37: f2 ae repnz scas %es:(%edi),%al 108d39: f7 d1 not %ecx #include static size_t get_parentpathlen(const char *path, size_t pathlen) { while (pathlen > 0) { 108d3b: 89 cf mov %ecx,%edi 108d3d: 4f dec %edi 108d3e: 0f 84 8c 00 00 00 je 108dd0 size_t i = pathlen - 1; 108d44: 83 e9 02 sub $0x2,%ecx if (rtems_filesystem_is_delimiter(path [i])) { 108d47: 8a 04 0a mov (%edx,%ecx,1),%al gid_t node_gid ); static inline bool rtems_filesystem_is_delimiter(char c) { return c == '/' || c == '\\'; 108d4a: 3c 2f cmp $0x2f,%al 108d4c: 74 04 je 108d52 108d4e: 3c 5c cmp $0x5c,%al 108d50: 75 0c jne 108d5e <== ALWAYS TAKEN 108d52: 89 f9 mov %edi,%ecx 108d54: 31 f6 xor %esi,%esi 108d56: eb 18 jmp 108d70 108d58: 3c 5c cmp $0x5c,%al 108d5a: 74 10 je 108d6c <== NEVER TAKEN #include static size_t get_parentpathlen(const char *path, size_t pathlen) { while (pathlen > 0) { size_t i = pathlen - 1; 108d5c: 89 f1 mov %esi,%ecx #include static size_t get_parentpathlen(const char *path, size_t pathlen) { while (pathlen > 0) { 108d5e: 85 c9 test %ecx,%ecx 108d60: 74 5e je 108dc0 size_t i = pathlen - 1; 108d62: 8d 71 ff lea -0x1(%ecx),%esi if (rtems_filesystem_is_delimiter(path [i])) { 108d65: 8a 04 32 mov (%edx,%esi,1),%al 108d68: 3c 2f cmp $0x2f,%al 108d6a: 75 ec jne 108d58 108d6c: 89 fe mov %edi,%esi 108d6e: 29 ce sub %ecx,%esi parentpath = "."; parentpathlen = 1; name = path; namelen = pathlen; } else { name = path + parentpathlen; 108d70: 8d 3c 0a lea (%edx,%ecx,1),%edi ctx, parentpath, parentpathlen, parent_eval_flags, &rtems_filesystem_root, &rtems_filesystem_current 108d73: a1 60 d2 12 00 mov 0x12d260,%eax name = path + parentpathlen; namelen = pathlen - parentpathlen; } } currentloc = eval_path_start( 108d78: 89 44 24 08 mov %eax,0x8(%esp) ctx, parentpath, parentpathlen, parent_eval_flags, &rtems_filesystem_root, 108d7c: 83 c0 04 add $0x4,%eax 108d7f: 89 44 24 04 mov %eax,0x4(%esp) name = path + parentpathlen; namelen = pathlen - parentpathlen; } } currentloc = eval_path_start( 108d83: 8b 44 24 30 mov 0x30(%esp),%eax 108d87: 89 04 24 mov %eax,(%esp) 108d8a: 89 d8 mov %ebx,%eax 108d8c: e8 3b fe ff ff call 108bcc parent_eval_flags, &rtems_filesystem_root, &rtems_filesystem_current ); rtems_filesystem_location_clone(parentloc, currentloc); 108d91: 89 44 24 04 mov %eax,0x4(%esp) 108d95: 8b 44 24 2c mov 0x2c(%esp),%eax 108d99: 89 04 24 mov %eax,(%esp) 108d9c: e8 eb 6d 00 00 call 10fb8c ctx->path = name; 108da1: 89 3b mov %edi,(%ebx) ctx->pathlen = namelen; 108da3: 89 73 04 mov %esi,0x4(%ebx) ctx->flags = eval_flags; 108da6: 8b 44 24 28 mov 0x28(%esp),%eax 108daa: 89 43 10 mov %eax,0x10(%ebx) rtems_filesystem_eval_path_continue(ctx); 108dad: 89 1c 24 mov %ebx,(%esp) 108db0: e8 93 fd ff ff call 108b48 return &ctx->currentloc; 108db5: 8d 43 18 lea 0x18(%ebx),%eax } 108db8: 83 c4 10 add $0x10,%esp 108dbb: 5b pop %ebx 108dbc: 5e pop %esi 108dbd: 5f pop %edi 108dbe: c3 ret 108dbf: 90 nop #include static size_t get_parentpathlen(const char *path, size_t pathlen) { while (pathlen > 0) { 108dc0: 89 fe mov %edi,%esi if (pathlen > 0) { if (parentpathlen == 0) { parentpath = "."; parentpathlen = 1; name = path; 108dc2: 89 d7 mov %edx,%edi const rtems_filesystem_location_info_t *currentloc = NULL; if (pathlen > 0) { if (parentpathlen == 0) { parentpath = "."; parentpathlen = 1; 108dc4: b1 01 mov $0x1,%cl size_t namelen = 0; const rtems_filesystem_location_info_t *currentloc = NULL; if (pathlen > 0) { if (parentpathlen == 0) { parentpath = "."; 108dc6: ba d1 1c 12 00 mov $0x121cd1,%edx 108dcb: eb a6 jmp 108d73 108dcd: 8d 76 00 lea 0x0(%esi),%esi { size_t pathlen = strlen(path); const char *parentpath = path; size_t parentpathlen = get_parentpathlen(path, pathlen); const char *name = NULL; size_t namelen = 0; 108dd0: 31 f6 xor %esi,%esi ) { size_t pathlen = strlen(path); const char *parentpath = path; size_t parentpathlen = get_parentpathlen(path, pathlen); const char *name = NULL; 108dd2: 31 ff xor %edi,%edi } pathlen = i; } return 0; 108dd4: 31 c9 xor %ecx,%ecx 108dd6: eb 9b jmp 108d73 =============================================================================== 0010fef0 : rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) { 10fef0: 83 ec 2c sub $0x2c,%esp 10fef3: 8b 44 24 30 mov 0x30(%esp),%eax find_arg fa = { 10fef7: 89 44 24 18 mov %eax,0x18(%esp) 10fefb: c7 44 24 1c 00 00 00 movl $0x0,0x1c(%esp) 10ff02: 00 .type = type, .mount_h = NULL }; if ( type != NULL ) { 10ff03: 85 c0 test %eax,%eax 10ff05: 74 1d je 10ff24 <== NEVER TAKEN rtems_filesystem_iterate( find_handler, &fa ); 10ff07: 8d 44 24 18 lea 0x18(%esp),%eax 10ff0b: 89 44 24 04 mov %eax,0x4(%esp) 10ff0f: c7 04 24 10 fe 10 00 movl $0x10fe10,(%esp) 10ff16: e8 2d ff ff ff call 10fe48 10ff1b: 8b 44 24 1c mov 0x1c(%esp),%eax } return fa.mount_h; } 10ff1f: 83 c4 2c add $0x2c,%esp 10ff22: c3 ret 10ff23: 90 nop find_arg fa = { .type = type, .mount_h = NULL }; if ( type != NULL ) { 10ff24: 31 c0 xor %eax,%eax <== NOT EXECUTED rtems_filesystem_iterate( find_handler, &fa ); } return fa.mount_h; } 10ff26: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 10ff29: c3 ret <== NOT EXECUTED =============================================================================== 0010767c : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 10767c: 83 ec 2c sub $0x2c,%esp int rv = 0; const rtems_filesystem_mount_configuration *root_config = &rtems_filesystem_root_configuration; rv = mount( 10767f: a1 58 f9 11 00 mov 0x11f958,%eax 107684: 89 44 24 10 mov %eax,0x10(%esp) 107688: a1 54 f9 11 00 mov 0x11f954,%eax 10768d: 89 44 24 0c mov %eax,0xc(%esp) 107691: a1 50 f9 11 00 mov 0x11f950,%eax 107696: 89 44 24 08 mov %eax,0x8(%esp) 10769a: a1 4c f9 11 00 mov 0x11f94c,%eax 10769f: 89 44 24 04 mov %eax,0x4(%esp) 1076a3: a1 48 f9 11 00 mov 0x11f948,%eax 1076a8: 89 04 24 mov %eax,(%esp) 1076ab: e8 b0 07 00 00 call 107e60 root_config->target, root_config->filesystemtype, root_config->options, root_config->data ); if ( rv != 0 ) 1076b0: 85 c0 test %eax,%eax 1076b2: 75 1c jne 1076d0 <== NEVER TAKEN * * NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually * created that way by the IMFS. */ rv = mkdir( "/dev", 0777); 1076b4: c7 44 24 04 ff 01 00 movl $0x1ff,0x4(%esp) 1076bb: 00 1076bc: c7 04 24 c4 0f 12 00 movl $0x120fc4,(%esp) 1076c3: e8 38 06 00 00 call 107d00 if ( rv != 0 ) 1076c8: 85 c0 test %eax,%eax 1076ca: 75 10 jne 1076dc <== NEVER TAKEN * it will be mounted onto is created. Moreover, if it is going to * use a device, then it is REALLY unfair to attempt this * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ } 1076cc: 83 c4 2c add $0x2c,%esp 1076cf: c3 ret root_config->filesystemtype, root_config->options, root_config->data ); if ( rv != 0 ) rtems_fatal_error_occurred( 0xABCD0002 ); 1076d0: c7 04 24 02 00 cd ab movl $0xabcd0002,(%esp) <== NOT EXECUTED 1076d7: e8 d4 49 00 00 call 10c0b0 <== NOT EXECUTED * created that way by the IMFS. */ rv = mkdir( "/dev", 0777); if ( rv != 0 ) rtems_fatal_error_occurred( 0xABCD0003 ); 1076dc: c7 04 24 03 00 cd ab movl $0xabcd0003,(%esp) <== NOT EXECUTED 1076e3: e8 c8 49 00 00 call 10c0b0 <== NOT EXECUTED =============================================================================== 0010fe48 : bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { 10fe48: 57 push %edi 10fe49: 56 push %esi 10fe4a: 53 push %ebx 10fe4b: 83 ec 20 sub $0x20,%esp 10fe4e: 8b 74 24 30 mov 0x30(%esp),%esi 10fe52: 8b 7c 24 34 mov 0x34(%esp),%edi const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 10fe56: bb 5c f9 11 00 mov $0x11f95c,%ebx 10fe5b: 8b 15 5c f9 11 00 mov 0x11f95c,%edx 10fe61: 85 d2 test %edx,%edx 10fe63: 75 07 jne 10fe6c <== ALWAYS TAKEN 10fe65: eb 1d jmp 10fe84 <== NOT EXECUTED 10fe67: 90 nop <== NOT EXECUTED 10fe68: 84 d2 test %dl,%dl 10fe6a: 75 79 jne 10fee5 stop = (*routine)( table_entry, routine_arg ); 10fe6c: 89 7c 24 04 mov %edi,0x4(%esp) 10fe70: 89 1c 24 mov %ebx,(%esp) 10fe73: ff d6 call *%esi 10fe75: 88 c2 mov %al,%dl ++table_entry; 10fe77: 83 c3 08 add $0x8,%ebx { const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 10fe7a: 8b 03 mov (%ebx),%eax 10fe7c: 85 c0 test %eax,%eax 10fe7e: 75 e8 jne 10fe68 stop = (*routine)( table_entry, routine_arg ); ++table_entry; } if ( !stop ) { 10fe80: 84 d2 test %dl,%dl 10fe82: 75 61 jne 10fee5 */ #include static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10fe84: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10fe8b: 00 10fe8c: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10fe93: 00 10fe94: a1 dc f4 12 00 mov 0x12f4dc,%eax 10fe99: 89 04 24 mov %eax,(%esp) 10fe9c: e8 db ba ff ff call 10b97c */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10fea1: 8b 1d 48 d3 12 00 mov 0x12d348,%ebx rtems_libio_lock(); for ( 10fea7: 31 d2 xor %edx,%edx 10fea9: 81 fb 4c d3 12 00 cmp $0x12d34c,%ebx 10feaf: 75 07 jne 10feb8 10feb1: eb 1d jmp 10fed0 10feb3: 90 nop node = rtems_chain_first( &filesystem_chain ); !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; 10feb4: 84 c0 test %al,%al 10feb6: 75 18 jne 10fed0 <== NEVER TAKEN node = rtems_chain_next( node ) ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); 10feb8: 89 7c 24 04 mov %edi,0x4(%esp) 10febc: 8d 43 08 lea 0x8(%ebx),%eax 10febf: 89 04 24 mov %eax,(%esp) 10fec2: ff d6 call *%esi 10fec4: 88 c2 mov %al,%dl } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10fec6: 8b 1b mov (%ebx),%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10fec8: 81 fb 4c d3 12 00 cmp $0x12d34c,%ebx 10fece: 75 e4 jne 10feb4 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10fed0: a1 dc f4 12 00 mov 0x12f4dc,%eax 10fed5: 89 04 24 mov %eax,(%esp) 10fed8: 88 54 24 1c mov %dl,0x1c(%esp) 10fedc: e8 c7 bb ff ff call 10baa8 10fee1: 8a 54 24 1c mov 0x1c(%esp),%dl } rtems_libio_unlock(); } return stop; } 10fee5: 88 d0 mov %dl,%al 10fee7: 83 c4 20 add $0x20,%esp 10feea: 5b pop %ebx 10feeb: 5e pop %esi 10feec: 5f pop %edi 10feed: c3 ret =============================================================================== 00109028 : } void rtems_filesystem_location_remove_from_mt_entry( rtems_filesystem_location_info_t *loc ) { 109028: 56 push %esi 109029: 53 push %ebx 10902a: 8b 44 24 0c mov 0xc(%esp),%eax rtems_filesystem_mt_entry_declare_lock_context(lock_context); bool do_unmount; rtems_filesystem_mt_entry_lock(lock_context); 10902e: 9c pushf 10902f: fa cli 109030: 5b pop %ebx ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 109031: 8b 08 mov (%eax),%ecx previous = the_node->previous; 109033: 8b 50 04 mov 0x4(%eax),%edx next->previous = previous; 109036: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 109039: 89 0a mov %ecx,(%edx) rtems_chain_extract_unprotected(&loc->mt_entry_node); do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry); 10903b: 8b 50 14 mov 0x14(%eax),%edx rtems_filesystem_mount_table_entry_t *mt_entry ) { bool ready = !mt_entry->mounted && rtems_chain_has_only_one_node( &mt_entry->location_chain ) && mt_entry->mt_fs_root->reference_count == 1; 10903e: 80 7a 28 00 cmpb $0x0,0x28(%edx) 109042: 75 08 jne 10904c static inline bool rtems_filesystem_is_ready_for_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { bool ready = !mt_entry->mounted && rtems_chain_has_only_one_node( &mt_entry->location_chain ) 109044: 8b 4a 1c mov 0x1c(%edx),%ecx 109047: 39 4a 14 cmp %ecx,0x14(%edx) 10904a: 74 1c je 109068 static inline bool rtems_filesystem_is_ready_for_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { bool ready = !mt_entry->mounted 10904c: 31 d2 xor %edx,%edx rtems_filesystem_mt_entry_unlock(lock_context); 10904e: 53 push %ebx 10904f: 9d popf if (do_unmount) { 109050: 84 d2 test %dl,%dl 109052: 75 04 jne 109058 <== NEVER TAKEN rtems_filesystem_do_unmount(loc->mt_entry); } } 109054: 5b pop %ebx 109055: 5e pop %esi 109056: c3 ret 109057: 90 nop rtems_chain_extract_unprotected(&loc->mt_entry_node); do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry); rtems_filesystem_mt_entry_unlock(lock_context); if (do_unmount) { rtems_filesystem_do_unmount(loc->mt_entry); 109058: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10905b: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED } } 10905f: 5b pop %ebx <== NOT EXECUTED 109060: 5e pop %esi <== NOT EXECUTED rtems_chain_extract_unprotected(&loc->mt_entry_node); do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry); rtems_filesystem_mt_entry_unlock(lock_context); if (do_unmount) { rtems_filesystem_do_unmount(loc->mt_entry); 109061: e9 3e ff ff ff jmp 108fa4 <== NOT EXECUTED 109066: 66 90 xchg %ax,%ax <== NOT EXECUTED && rtems_chain_has_only_one_node( &mt_entry->location_chain ) && mt_entry->mt_fs_root->reference_count == 1; 109068: 8b 4a 24 mov 0x24(%edx),%ecx 10906b: 83 79 18 01 cmpl $0x1,0x18(%ecx) 10906f: 75 db jne 10904c <== ALWAYS TAKEN RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 109071: 8d 4a 14 lea 0x14(%edx),%ecx <== NOT EXECUTED 109074: 8d 72 18 lea 0x18(%edx),%esi <== NOT EXECUTED 109077: 89 72 14 mov %esi,0x14(%edx) <== NOT EXECUTED head->next = tail; head->previous = NULL; 10907a: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 109081: 89 4a 1c mov %ecx,0x1c(%edx) <== NOT EXECUTED static inline bool rtems_filesystem_is_ready_for_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { bool ready = !mt_entry->mounted 109084: b2 01 mov $0x1,%dl <== NOT EXECUTED 109086: eb c6 jmp 10904e <== NOT EXECUTED =============================================================================== 00109224 : } rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global( rtems_filesystem_location_info_t *loc ) { 109224: 56 push %esi 109225: 53 push %ebx 109226: 83 ec 24 sub $0x24,%esp 109229: 8b 74 24 30 mov 0x30(%esp),%esi rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc)); 10922d: c7 04 24 24 00 00 00 movl $0x24,(%esp) 109234: e8 17 ea ff ff call 107c50 109239: 89 c3 mov %eax,%ebx if (global_loc != NULL) { 10923b: 85 c0 test %eax,%eax 10923d: 74 31 je 109270 <== NEVER TAKEN global_loc->reference_count = 1; 10923f: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax) global_loc->deferred_released_next = NULL; 109246: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) global_loc->deferred_released_count = 0; 10924d: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) rtems_filesystem_location_copy(&global_loc->location, loc); 109254: 89 74 24 04 mov %esi,0x4(%esp) 109258: 89 04 24 mov %eax,(%esp) 10925b: e8 dc fc ff ff call 108f3c rtems_filesystem_location_remove_from_mt_entry(loc); 109260: 89 34 24 mov %esi,(%esp) 109263: e8 c0 fd ff ff call 109028 global_loc = rtems_filesystem_global_location_obtain_null(); errno = ENOMEM; } return global_loc; } 109268: 89 d8 mov %ebx,%eax 10926a: 83 c4 24 add $0x24,%esp 10926d: 5b pop %ebx 10926e: 5e pop %esi 10926f: c3 ret global_loc->deferred_released_next = NULL; global_loc->deferred_released_count = 0; rtems_filesystem_location_copy(&global_loc->location, loc); rtems_filesystem_location_remove_from_mt_entry(loc); } else { rtems_filesystem_location_free(loc); 109270: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 109273: e8 64 69 00 00 call 10fbdc <== NOT EXECUTED ); static inline rtems_filesystem_global_location_t * rtems_filesystem_global_location_obtain_null(void) { rtems_filesystem_global_location_t *global_loc = NULL; 109278: c7 44 24 1c 00 00 00 movl $0x0,0x1c(%esp) <== NOT EXECUTED 10927f: 00 return rtems_filesystem_global_location_obtain( &global_loc ); 109280: 8d 44 24 1c lea 0x1c(%esp),%eax <== NOT EXECUTED 109284: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 109287: e8 10 ff ff ff call 10919c <== NOT EXECUTED 10928c: 89 c3 mov %eax,%ebx <== NOT EXECUTED global_loc = rtems_filesystem_global_location_obtain_null(); errno = ENOMEM; 10928e: e8 65 9a 00 00 call 112cf8 <__errno> <== NOT EXECUTED 109293: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED } return global_loc; } 109299: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10929b: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10929e: 5b pop %ebx <== NOT EXECUTED 10929f: 5e pop %esi <== NOT EXECUTED 1092a0: c3 ret <== NOT EXECUTED =============================================================================== 00107d30 : const char *name, size_t namelen, mode_t mode, dev_t dev ) { 107d30: 55 push %ebp 107d31: 57 push %edi 107d32: 56 push %esi 107d33: 53 push %ebx 107d34: 83 ec 0c sub $0xc,%esp 107d37: 8b 74 24 20 mov 0x20(%esp),%esi 107d3b: 8b 7c 24 24 mov 0x24(%esp),%edi 107d3f: 8b 6c 24 28 mov 0x28(%esp),%ebp 107d43: 8b 44 24 30 mov 0x30(%esp),%eax 107d47: 8b 54 24 34 mov 0x34(%esp),%edx int rv = 0; mode &= ~rtems_filesystem_umask; 107d4b: 8b 0d 60 d2 12 00 mov 0x12d260,%ecx 107d51: 8b 49 08 mov 0x8(%ecx),%ecx 107d54: f7 d1 not %ecx 107d56: 23 4c 24 2c and 0x2c(%esp),%ecx switch (mode & S_IFMT) { 107d5a: 89 cb mov %ecx,%ebx 107d5c: 81 e3 00 f0 00 00 and $0xf000,%ebx 107d62: 81 fb 00 40 00 00 cmp $0x4000,%ebx 107d68: 74 3a je 107da4 107d6a: 76 28 jbe 107d94 107d6c: 81 fb 00 60 00 00 cmp $0x6000,%ebx 107d72: 74 30 je 107da4 107d74: 81 fb 00 80 00 00 cmp $0x8000,%ebx 107d7a: 74 28 je 107da4 <== ALWAYS TAKEN case S_IFDIR: case S_IFIFO: case S_IFREG: break; default: errno = EINVAL; 107d7c: e8 77 af 00 00 call 112cf8 <__errno> 107d81: c7 00 16 00 00 00 movl $0x16,(%eax) rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev ); } return rv; } 107d87: b8 ff ff ff ff mov $0xffffffff,%eax 107d8c: 83 c4 0c add $0xc,%esp 107d8f: 5b pop %ebx 107d90: 5e pop %esi 107d91: 5f pop %edi 107d92: 5d pop %ebp 107d93: c3 ret { int rv = 0; mode &= ~rtems_filesystem_umask; switch (mode & S_IFMT) { 107d94: 81 fb 00 10 00 00 cmp $0x1000,%ebx 107d9a: 74 08 je 107da4 107d9c: 81 fb 00 20 00 00 cmp $0x2000,%ebx 107da2: 75 d8 jne 107d7c rv = -1; break; } if ( rv == 0 ) { const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops; 107da4: 8b 5e 14 mov 0x14(%esi),%ebx rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev ); 107da7: 8b 5b 0c mov 0xc(%ebx),%ebx 107daa: 89 44 24 30 mov %eax,0x30(%esp) 107dae: 89 54 24 34 mov %edx,0x34(%esp) 107db2: 89 4c 24 2c mov %ecx,0x2c(%esp) 107db6: 89 6c 24 28 mov %ebp,0x28(%esp) 107dba: 89 7c 24 24 mov %edi,0x24(%esp) 107dbe: 89 74 24 20 mov %esi,0x20(%esp) 107dc2: 8b 43 18 mov 0x18(%ebx),%eax } return rv; } 107dc5: 83 c4 0c add $0xc,%esp 107dc8: 5b pop %ebx 107dc9: 5e pop %esi 107dca: 5f pop %edi 107dcb: 5d pop %ebp } if ( rv == 0 ) { const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops; rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev ); 107dcc: ff e0 jmp *%eax =============================================================================== 00110004 : int rtems_filesystem_unregister( const char *type ) { 110004: 56 push %esi 110005: 53 push %ebx 110006: 83 ec 14 sub $0x14,%esp 110009: 8b 74 24 20 mov 0x20(%esp),%esi rtems_chain_node *node = NULL; if ( type == NULL ) { 11000d: 85 f6 test %esi,%esi 11000f: 0f 84 96 00 00 00 je 1100ab */ #include static inline void rtems_libio_lock( void ) { rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 110015: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 11001c: 00 11001d: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 110024: 00 110025: a1 dc f4 12 00 mov 0x12f4dc,%eax 11002a: 89 04 24 mov %eax,(%esp) 11002d: e8 4a b9 ff ff call 10b97c 110032: 8b 1d 48 d3 12 00 mov 0x12d348,%ebx rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_lock(); for ( 110038: 81 fb 4c d3 12 00 cmp $0x12d34c,%ebx 11003e: 75 0e jne 11004e 110040: eb 46 jmp 110088 110042: 66 90 xchg %ax,%ax } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 110044: 8b 1b mov (%ebx),%ebx if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_lock(); for ( 110046: 81 fb 4c d3 12 00 cmp $0x12d34c,%ebx 11004c: 74 3a je 110088 <== ALWAYS TAKEN !rtems_chain_is_tail( &filesystem_chain, node ); node = rtems_chain_next( node ) ) { filesystem_node *fsn = (filesystem_node *) node; if ( strcmp( fsn->entry.type, type ) == 0 ) { 11004e: 89 74 24 04 mov %esi,0x4(%esp) 110052: 8b 43 08 mov 0x8(%ebx),%eax 110055: 89 04 24 mov %eax,(%esp) 110058: e8 3f 3a 00 00 call 113a9c 11005d: 85 c0 test %eax,%eax 11005f: 75 e3 jne 110044 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 110061: 89 1c 24 mov %ebx,(%esp) 110064: e8 73 0b 00 00 call 110bdc <_Chain_Extract> rtems_chain_extract( node ); free( fsn ); 110069: 89 1c 24 mov %ebx,(%esp) 11006c: e8 cb 78 ff ff call 10793c } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 110071: a1 dc f4 12 00 mov 0x12f4dc,%eax 110076: 89 04 24 mov %eax,(%esp) 110079: e8 2a ba ff ff call 10baa8 rtems_libio_unlock(); return 0; 11007e: 31 c0 xor %eax,%eax } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 110080: 83 c4 14 add $0x14,%esp 110083: 5b pop %ebx 110084: 5e pop %esi 110085: c3 ret 110086: 66 90 xchg %ax,%ax 110088: a1 dc f4 12 00 mov 0x12f4dc,%eax 11008d: 89 04 24 mov %eax,(%esp) 110090: e8 13 ba ff ff call 10baa8 return 0; } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); 110095: e8 5e 2c 00 00 call 112cf8 <__errno> 11009a: c7 00 02 00 00 00 movl $0x2,(%eax) 1100a0: b8 ff ff ff ff mov $0xffffffff,%eax } 1100a5: 83 c4 14 add $0x14,%esp 1100a8: 5b pop %ebx 1100a9: 5e pop %esi 1100aa: c3 ret ) { rtems_chain_node *node = NULL; if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); 1100ab: e8 48 2c 00 00 call 112cf8 <__errno> 1100b0: c7 00 16 00 00 00 movl $0x16,(%eax) 1100b6: b8 ff ff ff ff mov $0xffffffff,%eax 1100bb: eb e8 jmp 1100a5 =============================================================================== 00108150 : int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) { 108150: 56 push %esi 108151: 53 push %ebx 108152: 83 ec 14 sub $0x14,%esp 108155: 8b 74 24 24 mov 0x24(%esp),%esi * pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) ); 108159: c7 04 24 08 00 00 00 movl $0x8,(%esp) 108160: e8 13 04 00 00 call 108578 108165: 89 c3 mov %eax,%ebx *key = new_key; 108167: 8b 44 24 20 mov 0x20(%esp),%eax 10816b: 89 18 mov %ebx,(%eax) new_key->val = NULL; 10816d: c7 03 00 00 00 00 movl $0x0,(%ebx) new_key->dtor = dtor; 108173: 89 73 04 mov %esi,0x4(%ebx) "gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key ); #endif /* register with RTEMS the buffer that will hold the key values */ status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor ); 108176: 89 74 24 08 mov %esi,0x8(%esp) 10817a: 89 5c 24 04 mov %ebx,0x4(%esp) 10817e: c7 04 24 00 00 00 00 movl $0x0,(%esp) 108185: e8 66 47 00 00 call 10c8f0 if ( status == RTEMS_SUCCESSFUL ) 10818a: 85 c0 test %eax,%eax 10818c: 75 0a jne 108198 <== NEVER TAKEN return 0; 10818e: 31 c0 xor %eax,%eax free( new_key ); return -1; } 108190: 83 c4 14 add $0x14,%esp 108193: 5b pop %ebx 108194: 5e pop %esi 108195: c3 ret 108196: 66 90 xchg %ax,%ax /* register with RTEMS the buffer that will hold the key values */ status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor ); if ( status == RTEMS_SUCCESSFUL ) return 0; free( new_key ); 108198: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10819b: e8 ec fd ff ff call 107f8c <== NOT EXECUTED return -1; 1081a0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1081a5: eb e9 jmp 108190 <== NOT EXECUTED =============================================================================== 001081b8 : int rtems_gxx_key_delete (__gthread_key_t key) { 1081b8: 53 push %ebx 1081b9: 83 ec 18 sub $0x18,%esp 1081bc: 8b 5c 24 20 mov 0x20(%esp),%ebx #ifdef DEBUG_GXX_WRAPPERS printk( "gxx_wrappers: delete key=%x\n", key ); #endif /* register with RTEMS the buffer that will hold the key values */ status = rtems_task_variable_delete( RTEMS_SELF, (void **)key ); 1081c0: 89 5c 24 04 mov %ebx,0x4(%esp) 1081c4: c7 04 24 00 00 00 00 movl $0x0,(%esp) 1081cb: e8 d0 47 00 00 call 10c9a0 if ( status == RTEMS_SUCCESSFUL ) { 1081d0: 85 c0 test %eax,%eax 1081d2: 75 0e jne 1081e2 <== NEVER TAKEN /* Hmm - hopefully all tasks using this key have gone away... */ if ( key ) free( *(void **)key ); 1081d4: 85 db test %ebx,%ebx 1081d6: 74 0a je 1081e2 <== NEVER TAKEN 1081d8: 8b 03 mov (%ebx),%eax 1081da: 89 04 24 mov %eax,(%esp) 1081dd: e8 aa fd ff ff call 107f8c return 0; } key = NULL; return 0; } 1081e2: 31 c0 xor %eax,%eax 1081e4: 83 c4 18 add $0x18,%esp 1081e7: 5b pop %ebx 1081e8: c3 ret =============================================================================== 001080cc : /* uncomment this if you need to debug this interface */ /*#define DEBUG_GXX_WRAPPERS 1*/ int rtems_gxx_once(__gthread_once_t *once, void (*func) (void)) { 1080cc: 56 push %esi 1080cd: 53 push %ebx 1080ce: 83 ec 24 sub $0x24,%esp 1080d1: 8b 5c 24 30 mov 0x30(%esp),%ebx #ifdef DEBUG_GXX_WRAPPERS printk( "gxx_wrappers: once=%x, func=%x\n", *once, func ); #endif if ( *(volatile __gthread_once_t *)once == 0 ) { 1080d5: 8b 03 mov (%ebx),%eax 1080d7: 85 c0 test %eax,%eax 1080d9: 74 09 je 1080e4 rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); if ( o == 0 ) (*func)(); } return 0; } 1080db: 31 c0 xor %eax,%eax 1080dd: 83 c4 24 add $0x24,%esp 1080e0: 5b pop %ebx 1080e1: 5e pop %esi 1080e2: c3 ret 1080e3: 90 nop if ( *(volatile __gthread_once_t *)once == 0 ) { rtems_mode saveMode; __gthread_once_t o; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 1080e4: 8d 74 24 1c lea 0x1c(%esp),%esi 1080e8: 89 74 24 08 mov %esi,0x8(%esp) 1080ec: c7 44 24 04 00 01 00 movl $0x100,0x4(%esp) 1080f3: 00 1080f4: c7 04 24 00 01 00 00 movl $0x100,(%esp) 1080fb: e8 08 46 00 00 call 10c708 if ( (o = *(volatile __gthread_once_t *)once) == 0 ) { 108100: 8b 03 mov (%ebx),%eax 108102: 85 c0 test %eax,%eax 108104: 75 2a jne 108130 <== NEVER TAKEN *(volatile __gthread_once_t *)once = 1; 108106: c7 03 01 00 00 00 movl $0x1,(%ebx) } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10810c: 89 74 24 08 mov %esi,0x8(%esp) 108110: c7 44 24 04 00 01 00 movl $0x100,0x4(%esp) 108117: 00 108118: 8b 44 24 1c mov 0x1c(%esp),%eax 10811c: 89 04 24 mov %eax,(%esp) 10811f: e8 e4 45 00 00 call 10c708 if ( o == 0 ) (*func)(); 108124: ff 54 24 34 call *0x34(%esp) } return 0; } 108128: 31 c0 xor %eax,%eax 10812a: 83 c4 24 add $0x24,%esp 10812d: 5b pop %ebx 10812e: 5e pop %esi 10812f: c3 ret rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); if ( (o = *(volatile __gthread_once_t *)once) == 0 ) { *(volatile __gthread_once_t *)once = 1; } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 108130: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED 108134: c7 44 24 04 00 01 00 movl $0x100,0x4(%esp) <== NOT EXECUTED 10813b: 00 10813c: 8b 44 24 1c mov 0x1c(%esp),%eax <== NOT EXECUTED 108140: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 108143: e8 c0 45 00 00 call 10c708 <== NOT EXECUTED if ( o == 0 ) (*func)(); } return 0; } 108148: 31 c0 xor %eax,%eax <== NOT EXECUTED 10814a: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10814d: 5b pop %ebx <== NOT EXECUTED 10814e: 5e pop %esi <== NOT EXECUTED 10814f: c3 ret <== NOT EXECUTED =============================================================================== 00108268 : #endif return p; } int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) { 108268: 53 push %ebx 108269: 83 ec 18 sub $0x18,%esp 10826c: 8b 5c 24 20 mov 0x20(%esp),%ebx rtems_task_self() ); #endif /* register with RTEMS the buffer that will hold the key values */ status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor ); 108270: 8b 43 04 mov 0x4(%ebx),%eax 108273: 89 44 24 08 mov %eax,0x8(%esp) 108277: 89 5c 24 04 mov %ebx,0x4(%esp) 10827b: c7 04 24 00 00 00 00 movl $0x0,(%esp) 108282: e8 69 46 00 00 call 10c8f0 if ( status == RTEMS_SUCCESSFUL ) { 108287: 85 c0 test %eax,%eax 108289: 75 0d jne 108298 <== NEVER TAKEN /* now let's set the proper value */ key->val = (void *)ptr; 10828b: 8b 44 24 24 mov 0x24(%esp),%eax 10828f: 89 03 mov %eax,(%ebx) return 0; 108291: 31 c0 xor %eax,%eax } return -1; } 108293: 83 c4 18 add $0x18,%esp 108296: 5b pop %ebx 108297: c3 ret if ( status == RTEMS_SUCCESSFUL ) { /* now let's set the proper value */ key->val = (void *)ptr; return 0; } return -1; 108298: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10829d: eb f4 jmp 108293 <== NOT EXECUTED =============================================================================== 0010b95c : void *rtems_heap_allocate_aligned_with_boundary( size_t size, uintptr_t alignment, uintptr_t boundary ) { 10b95c: 83 ec 1c sub $0x1c,%esp if ( 10b95f: 83 3d 20 75 13 00 03 cmpl $0x3,0x137520 10b966: 74 30 je 10b998 <== ALWAYS TAKEN && !malloc_is_system_state_OK() ) { return NULL; } malloc_deferred_frees_process(); 10b968: e8 37 ef ff ff call 10a8a4 /* FIXME: Statistics, boundary checks */ return _Protected_heap_Allocate_aligned_with_boundary( 10b96d: 8b 44 24 28 mov 0x28(%esp),%eax 10b971: 89 44 24 0c mov %eax,0xc(%esp) 10b975: 8b 44 24 24 mov 0x24(%esp),%eax 10b979: 89 44 24 08 mov %eax,0x8(%esp) 10b97d: 8b 44 24 20 mov 0x20(%esp),%eax 10b981: 89 44 24 04 mov %eax,0x4(%esp) 10b985: a1 50 27 13 00 mov 0x132750,%eax 10b98a: 89 04 24 mov %eax,(%esp) 10b98d: e8 de 58 00 00 call 111270 <_Protected_heap_Allocate_aligned_with_boundary> RTEMS_Malloc_Heap, size, alignment, boundary ); } 10b992: 83 c4 1c add $0x1c,%esp 10b995: c3 ret 10b996: 66 90 xchg %ax,%ax uintptr_t boundary ) { if ( _System_state_Is_up( _System_state_Get() ) && !malloc_is_system_state_OK() 10b998: e8 cf ee ff ff call 10a86c 10b99d: 84 c0 test %al,%al 10b99f: 75 c7 jne 10b968 ) { return NULL; 10b9a1: 31 c0 xor %eax,%eax 10b9a3: eb ed jmp 10b992 =============================================================================== 0010d56c : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 10d56c: 57 push %edi 10d56d: 56 push %esi 10d56e: 53 push %ebx 10d56f: 8b 5c 24 10 mov 0x10(%esp),%ebx 10d573: 8b 74 24 14 mov 0x14(%esp),%esi 10d577: 8b 44 24 18 mov 0x18(%esp),%eax rtems_device_major_number major_limit = _IO_Number_of_drivers; 10d57b: 8b 15 c0 49 13 00 mov 0x1349c0,%edx if ( rtems_interrupt_is_in_progress() ) 10d581: 8b 0d e8 48 13 00 mov 0x1348e8,%ecx 10d587: 85 c9 test %ecx,%ecx 10d589: 74 09 je 10d594 return RTEMS_CALLED_FROM_ISR; 10d58b: b8 12 00 00 00 mov $0x12,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10d590: 5b pop %ebx 10d591: 5e pop %esi 10d592: 5f pop %edi 10d593: c3 ret rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10d594: 85 c0 test %eax,%eax 10d596: 74 24 je 10d5bc return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10d598: 89 10 mov %edx,(%eax) if ( driver_table == NULL ) 10d59a: 85 f6 test %esi,%esi 10d59c: 74 1e je 10d5bc static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10d59e: 8b 3e mov (%esi),%edi 10d5a0: 85 ff test %edi,%edi 10d5a2: 74 10 je 10d5b4 return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10d5a4: 39 da cmp %ebx,%edx 10d5a6: 77 20 ja 10d5c8 return RTEMS_INVALID_NUMBER; 10d5a8: b8 0a 00 00 00 mov $0xa,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10d5ad: 5b pop %ebx 10d5ae: 5e pop %esi 10d5af: 5f pop %edi 10d5b0: c3 ret 10d5b1: 8d 76 00 lea 0x0(%esi),%esi static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10d5b4: 8b 4e 04 mov 0x4(%esi),%ecx 10d5b7: 85 c9 test %ecx,%ecx 10d5b9: 75 e9 jne 10d5a4 10d5bb: 90 nop if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10d5bc: b8 09 00 00 00 mov $0x9,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10d5c1: 5b pop %ebx 10d5c2: 5e pop %esi 10d5c3: 5f pop %edi 10d5c4: c3 ret 10d5c5: 8d 76 00 lea 0x0(%esi),%esi * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 10d5c8: 8b 15 84 46 13 00 mov 0x134684,%edx 10d5ce: 42 inc %edx 10d5cf: 89 15 84 46 13 00 mov %edx,0x134684 return _Thread_Dispatch_disable_level; 10d5d5: 8b 15 84 46 13 00 mov 0x134684,%edx if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10d5db: 85 db test %ebx,%ebx 10d5dd: 74 1e je 10d5fd _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 10d5df: 8d 14 5b lea (%ebx,%ebx,2),%edx 10d5e2: 8b 3d c4 49 13 00 mov 0x1349c4,%edi 10d5e8: 8d 14 d7 lea (%edi,%edx,8),%edx static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10d5eb: 8b 0a mov (%edx),%ecx 10d5ed: 85 c9 test %ecx,%ecx 10d5ef: 74 7d je 10d66e major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); 10d5f1: e8 8a 1c 00 00 call 10f280 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10d5f6: b8 0c 00 00 00 mov $0xc,%eax 10d5fb: eb 93 jmp 10d590 static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10d5fd: 8b 0d c0 49 13 00 mov 0x1349c0,%ecx rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10d603: 85 c9 test %ecx,%ecx 10d605: 74 76 je 10d67d <== NEVER TAKEN 10d607: 8b 3d c4 49 13 00 mov 0x1349c4,%edi 10d60d: 89 fa mov %edi,%edx 10d60f: eb 0b jmp 10d61c 10d611: 8d 76 00 lea 0x0(%esi),%esi 10d614: 43 inc %ebx 10d615: 83 c2 18 add $0x18,%edx 10d618: 39 cb cmp %ecx,%ebx 10d61a: 74 41 je 10d65d static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10d61c: 83 3a 00 cmpl $0x0,(%edx) 10d61f: 75 f3 jne 10d614 10d621: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10d625: 75 ed jne 10d614 if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10d627: 89 18 mov %ebx,(%eax) if ( m != n ) 10d629: 39 d9 cmp %ebx,%ecx 10d62b: 74 32 je 10d65f <== NEVER TAKEN } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 10d62d: 8d 04 5b lea (%ebx,%ebx,2),%eax 10d630: 8d 04 c7 lea (%edi,%eax,8),%eax 10d633: b9 06 00 00 00 mov $0x6,%ecx 10d638: 89 c7 mov %eax,%edi 10d63a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10d63c: e8 3f 1c 00 00 call 10f280 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10d641: c7 44 24 18 00 00 00 movl $0x0,0x18(%esp) 10d648: 00 10d649: c7 44 24 14 00 00 00 movl $0x0,0x14(%esp) 10d650: 00 10d651: 89 5c 24 10 mov %ebx,0x10(%esp) } 10d655: 5b pop %ebx 10d656: 5e pop %esi 10d657: 5f pop %edi _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10d658: e9 0b 75 00 00 jmp 114b68 if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10d65d: 89 18 mov %ebx,(%eax) if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10d65f: e8 1c 1c 00 00 call 10f280 <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10d664: b8 05 00 00 00 mov $0x5,%eax if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); return sc; 10d669: e9 22 ff ff ff jmp 10d590 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10d66e: 8b 52 04 mov 0x4(%edx),%edx 10d671: 85 d2 test %edx,%edx 10d673: 0f 85 78 ff ff ff jne 10d5f1 if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } *registered_major = major; 10d679: 89 18 mov %ebx,(%eax) 10d67b: eb b0 jmp 10d62d if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10d67d: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10d683: eb da jmp 10d65f <== NOT EXECUTED =============================================================================== 0010e1f8 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10e1f8: 55 push %ebp 10e1f9: 57 push %edi 10e1fa: 56 push %esi 10e1fb: 53 push %ebx 10e1fc: 83 ec 1c sub $0x1c,%esp 10e1ff: 8b 74 24 30 mov 0x30(%esp),%esi uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10e203: bf 01 00 00 00 mov $0x1,%edi 10e208: 85 f6 test %esi,%esi 10e20a: 74 3e je 10e24a <== NEVER TAKEN return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) 10e20c: 8b 04 bd fc 29 13 00 mov 0x1329fc(,%edi,4),%eax 10e213: 85 c0 test %eax,%eax 10e215: 74 2d je 10e244 continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10e217: 8b 68 04 mov 0x4(%eax),%ebp if ( !information ) 10e21a: 85 ed test %ebp,%ebp 10e21c: 74 26 je 10e244 continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10e21e: 66 83 7d 10 00 cmpw $0x0,0x10(%ebp) 10e223: 74 1f je 10e244 <== NEVER TAKEN 10e225: bb 01 00 00 00 mov $0x1,%ebx 10e22a: 66 90 xchg %ax,%ax the_thread = (Thread_Control *)information->local_table[ i ]; 10e22c: 8b 45 1c mov 0x1c(%ebp),%eax 10e22f: 8b 04 98 mov (%eax,%ebx,4),%eax if ( !the_thread ) 10e232: 85 c0 test %eax,%eax 10e234: 74 05 je 10e23b <== NEVER TAKEN continue; (*routine)(the_thread); 10e236: 89 04 24 mov %eax,(%esp) 10e239: ff d6 call *%esi information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10e23b: 43 inc %ebx 10e23c: 0f b7 45 10 movzwl 0x10(%ebp),%eax 10e240: 39 d8 cmp %ebx,%eax 10e242: 73 e8 jae 10e22c Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10e244: 47 inc %edi 10e245: 83 ff 04 cmp $0x4,%edi 10e248: 75 c2 jne 10e20c (*routine)(the_thread); } } } 10e24a: 83 c4 1c add $0x1c,%esp 10e24d: 5b pop %ebx 10e24e: 5e pop %esi 10e24f: 5f pop %edi 10e250: 5d pop %ebp 10e251: c3 ret =============================================================================== 00107a7c : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 107a7c: 53 push %ebx 107a7d: 83 ec 28 sub $0x28,%esp rtems_status_code rc; uint32_t i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 107a80: 8b 1d c0 b2 12 00 mov 0x12b2c0,%ebx 107a86: 85 db test %ebx,%ebx 107a88: 74 45 je 107acf <== NEVER TAKEN { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 107a8a: c7 44 24 04 30 00 00 movl $0x30,0x4(%esp) 107a91: 00 107a92: 89 1c 24 mov %ebx,(%esp) 107a95: e8 4e fc ff ff call 1076e8 107a9a: a3 d4 f4 12 00 mov %eax,0x12f4d4 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 107a9f: 85 c0 test %eax,%eax 107aa1: 74 7a je 107b1d rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; 107aa3: a3 d8 f4 12 00 mov %eax,0x12f4d8 for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 107aa8: 83 fb 01 cmp $0x1,%ebx 107aab: 76 1b jbe 107ac8 107aad: 89 c2 mov %eax,%edx 107aaf: b9 01 00 00 00 mov $0x1,%ecx iop->data1 = iop + 1; 107ab4: 83 c2 30 add $0x30,%edx 107ab7: 89 52 fc mov %edx,-0x4(%edx) sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 107aba: 41 inc %ecx 107abb: 39 d9 cmp %ebx,%ecx 107abd: 75 f5 jne 107ab4 * rtems_libio_init * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) 107abf: 8d 54 49 fd lea -0x3(%ecx,%ecx,2),%edx 107ac3: c1 e2 04 shl $0x4,%edx 107ac6: 01 d0 add %edx,%eax rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) iop->data1 = iop + 1; iop->data1 = NULL; 107ac8: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 107acf: c7 44 24 10 dc f4 12 movl $0x12f4dc,0x10(%esp) 107ad6: 00 107ad7: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 107ade: 00 107adf: c7 44 24 08 54 00 00 movl $0x54,0x8(%esp) 107ae6: 00 107ae7: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 107aee: 00 107aef: c7 04 24 4f 49 42 4c movl $0x4c42494f,(%esp) 107af6: e8 cd 3b 00 00 call 10b6c8 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 107afb: 85 c0 test %eax,%eax 107afd: 75 16 jne 107b15 <== NEVER TAKEN /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) 107aff: a1 c4 b2 12 00 mov 0x12b2c4,%eax 107b04: 85 c0 test %eax,%eax 107b06: 74 08 je 107b10 (* rtems_fs_init_helper)(); } 107b08: 83 c4 28 add $0x28,%esp 107b0b: 5b pop %ebx /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) (* rtems_fs_init_helper)(); 107b0c: ff e0 jmp *%eax 107b0e: 66 90 xchg %ax,%ax } 107b10: 83 c4 28 add $0x28,%esp 107b13: 5b pop %ebx 107b14: c3 ret RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) rtems_fatal_error_occurred( rc ); 107b15: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 107b18: e8 93 45 00 00 call 10c0b0 <== NOT EXECUTED if (rtems_libio_number_iops > 0) { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 107b1d: c7 04 24 1a 00 00 00 movl $0x1a,(%esp) 107b24: e8 87 45 00 00 call 10c0b0 =============================================================================== 00106224 : } rtems_status_code rtems_libio_set_private_env(void) { 106224: 55 push %ebp 106225: 57 push %edi 106226: 56 push %esi 106227: 53 push %ebx 106228: 83 ec 2c sub $0x2c,%esp rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id self_task_id = rtems_task_self(); 10622b: e8 f4 18 00 00 call 107b24 106230: 89 c2 mov %eax,%edx rtems_user_env_t *old_env = rtems_current_user_env; 106232: 8b 2d a0 9d 12 00 mov 0x129da0,%ebp bool uses_global_env = old_env == &rtems_global_user_env; bool uses_shared_env = old_env->task_id != self_task_id; 106238: 8b 45 24 mov 0x24(%ebp),%eax if (uses_global_env || uses_shared_env) { 10623b: 81 fd c0 9d 12 00 cmp $0x129dc0,%ebp 106241: 74 08 je 10624b 106243: 39 c2 cmp %eax,%edx 106245: 0f 84 bd 00 00 00 je 106308 rtems_user_env_t *new_env = calloc(1, sizeof(*new_env)); 10624b: c7 44 24 04 2c 00 00 movl $0x2c,0x4(%esp) 106252: 00 106253: c7 04 24 01 00 00 00 movl $0x1,(%esp) 10625a: 89 54 24 1c mov %edx,0x1c(%esp) 10625e: e8 95 49 00 00 call 10abf8 106263: 89 c3 mov %eax,%ebx if (new_env != NULL) { 106265: 85 c0 test %eax,%eax 106267: 8b 54 24 1c mov 0x1c(%esp),%edx 10626b: 74 7b je 1062e8 *new_env = *old_env; 10626d: b9 0b 00 00 00 mov $0xb,%ecx 106272: 89 c7 mov %eax,%edi 106274: 89 ee mov %ebp,%esi 106276: f3 a5 rep movsl %ds:(%esi),%es:(%edi) new_env->reference_count = 1; 106278: c7 40 28 01 00 00 00 movl $0x1,0x28(%eax) new_env->task_id = self_task_id; 10627f: 89 50 24 mov %edx,0x24(%eax) new_env->root_directory = rtems_filesystem_global_location_obtain(&old_env->root_directory); 106282: 8d 45 04 lea 0x4(%ebp),%eax 106285: 89 04 24 mov %eax,(%esp) 106288: e8 37 0b 00 00 call 106dc4 if (new_env != NULL) { *new_env = *old_env; new_env->reference_count = 1; new_env->task_id = self_task_id; new_env->root_directory = 10628d: 89 43 04 mov %eax,0x4(%ebx) rtems_filesystem_global_location_obtain(&old_env->root_directory); new_env->current_directory = rtems_filesystem_global_location_obtain(&old_env->current_directory); 106290: 89 2c 24 mov %ebp,(%esp) 106293: e8 2c 0b 00 00 call 106dc4 *new_env = *old_env; new_env->reference_count = 1; new_env->task_id = self_task_id; new_env->root_directory = rtems_filesystem_global_location_obtain(&old_env->root_directory); new_env->current_directory = 106298: 89 03 mov %eax,(%ebx) rtems_fatal_error_occurred(0xdeadbeef); } rtems_current_user_env = &rtems_global_user_env; } } 10629a: 8b 53 04 mov 0x4(%ebx),%edx new_env->root_directory = rtems_filesystem_global_location_obtain(&old_env->root_directory); new_env->current_directory = rtems_filesystem_global_location_obtain(&old_env->current_directory); if ( 10629d: 81 7a 10 00 ef 11 00 cmpl $0x11ef00,0x10(%edx) 1062a4: 74 6e je 106314 !rtems_filesystem_global_location_is_null(new_env->root_directory) && !rtems_filesystem_global_location_is_null(new_env->current_directory) 1062a6: 81 78 10 00 ef 11 00 cmpl $0x11ef00,0x10(%eax) 1062ad: 74 65 je 106314 <== NEVER TAKEN ) { sc = rtems_task_variable_add( 1062af: c7 44 24 08 b4 61 10 movl $0x1061b4,0x8(%esp) 1062b6: 00 1062b7: c7 44 24 04 a0 9d 12 movl $0x129da0,0x4(%esp) 1062be: 00 1062bf: c7 04 24 00 00 00 00 movl $0x0,(%esp) 1062c6: e8 e5 18 00 00 call 107bb0 1062cb: 89 c6 mov %eax,%esi RTEMS_SELF, (void **) &rtems_current_user_env, free_user_env ); if (sc == RTEMS_SUCCESSFUL) { 1062cd: 85 c0 test %eax,%eax 1062cf: 74 27 je 1062f8 free_user_env_protected(old_env); rtems_current_user_env = new_env; } else { sc = RTEMS_TOO_MANY; 1062d1: be 05 00 00 00 mov $0x5,%esi } else { sc = RTEMS_UNSATISFIED; } if (sc != RTEMS_SUCCESSFUL) { free_user_env(new_env); 1062d6: 89 1c 24 mov %ebx,(%esp) 1062d9: e8 d6 fe ff ff call 1061b4 sc = RTEMS_NO_MEMORY; } } return sc; } 1062de: 89 f0 mov %esi,%eax 1062e0: 83 c4 2c add $0x2c,%esp 1062e3: 5b pop %ebx 1062e4: 5e pop %esi 1062e5: 5f pop %edi 1062e6: 5d pop %ebp 1062e7: c3 ret if (sc != RTEMS_SUCCESSFUL) { free_user_env(new_env); } } else { sc = RTEMS_NO_MEMORY; 1062e8: be 1a 00 00 00 mov $0x1a,%esi } } return sc; } 1062ed: 89 f0 mov %esi,%eax 1062ef: 83 c4 2c add $0x2c,%esp 1062f2: 5b pop %ebx 1062f3: 5e pop %esi 1062f4: 5f pop %edi 1062f5: 5d pop %ebp 1062f6: c3 ret 1062f7: 90 nop RTEMS_SELF, (void **) &rtems_current_user_env, free_user_env ); if (sc == RTEMS_SUCCESSFUL) { free_user_env_protected(old_env); 1062f8: 89 e8 mov %ebp,%eax 1062fa: e8 fd fe ff ff call 1061fc rtems_current_user_env = new_env; 1062ff: 89 1d a0 9d 12 00 mov %ebx,0x129da0 106305: eb e6 jmp 1062ed 106307: 90 nop _Thread_Enable_dispatch(); } rtems_status_code rtems_libio_set_private_env(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; 106308: 31 f6 xor %esi,%esi sc = RTEMS_NO_MEMORY; } } return sc; } 10630a: 89 f0 mov %esi,%eax 10630c: 83 c4 2c add $0x2c,%esp 10630f: 5b pop %ebx 106310: 5e pop %esi 106311: 5f pop %edi 106312: 5d pop %ebp 106313: c3 ret rtems_current_user_env = new_env; } else { sc = RTEMS_TOO_MANY; } } else { sc = RTEMS_UNSATISFIED; 106314: be 0d 00 00 00 mov $0xd,%esi 106319: eb bb jmp 1062d6 =============================================================================== 0010631c : return sc; } rtems_status_code rtems_libio_share_private_env(rtems_id task_id) { 10631c: 53 push %ebx 10631d: 83 ec 28 sub $0x28,%esp 106320: 8b 5c 24 30 mov 0x30(%esp),%ebx rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id self_task_id = rtems_task_self(); 106324: e8 fb 17 00 00 call 107b24 if (task_id != RTEMS_SELF && self_task_id != task_id) { 106329: 85 db test %ebx,%ebx 10632b: 74 73 je 1063a0 10632d: 39 d8 cmp %ebx,%eax 10632f: 74 6f je 1063a0 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 106331: a1 24 d7 12 00 mov 0x12d724,%eax 106336: 40 inc %eax 106337: a3 24 d7 12 00 mov %eax,0x12d724 return _Thread_Dispatch_disable_level; 10633c: a1 24 d7 12 00 mov 0x12d724,%eax */ _Thread_Disable_dispatch(); sc = rtems_task_variable_get( task_id, (void *) &rtems_current_user_env, (void *) &env 106341: 8d 44 24 1c lea 0x1c(%esp),%eax 106345: 89 44 24 08 mov %eax,0x8(%esp) /* * We have to disable the thread dispatching to prevent deletion of the * environment in the meantime. */ _Thread_Disable_dispatch(); sc = rtems_task_variable_get( 106349: c7 44 24 04 a0 9d 12 movl $0x129da0,0x4(%esp) 106350: 00 106351: 89 1c 24 mov %ebx,(%esp) 106354: e8 9f 19 00 00 call 107cf8 task_id, (void *) &rtems_current_user_env, (void *) &env ); if (sc == RTEMS_SUCCESSFUL) { 106359: 85 c0 test %eax,%eax 10635b: 75 4f jne 1063ac ++env->reference_count; 10635d: 8b 44 24 1c mov 0x1c(%esp),%eax 106361: ff 40 28 incl 0x28(%eax) } else { sc = RTEMS_UNSATISFIED; } _Thread_Enable_dispatch(); 106364: e8 47 35 00 00 call 1098b0 <_Thread_Enable_dispatch> if (sc == RTEMS_SUCCESSFUL) { sc = rtems_task_variable_add( 106369: c7 44 24 08 b4 61 10 movl $0x1061b4,0x8(%esp) 106370: 00 106371: c7 44 24 04 a0 9d 12 movl $0x129da0,0x4(%esp) 106378: 00 106379: c7 04 24 00 00 00 00 movl $0x0,(%esp) 106380: e8 2b 18 00 00 call 107bb0 106385: 89 c3 mov %eax,%ebx RTEMS_SELF, (void **) &rtems_current_user_env, free_user_env ); if (sc == RTEMS_SUCCESSFUL) { 106387: 85 c0 test %eax,%eax 106389: 75 35 jne 1063c0 <== NEVER TAKEN free_user_env_protected(rtems_current_user_env); 10638b: a1 a0 9d 12 00 mov 0x129da0,%eax 106390: e8 67 fe ff ff call 1061fc rtems_current_user_env = env; 106395: 8b 44 24 1c mov 0x1c(%esp),%eax 106399: a3 a0 9d 12 00 mov %eax,0x129da0 10639e: eb 02 jmp 1063a2 return sc; } rtems_status_code rtems_libio_share_private_env(rtems_id task_id) { rtems_status_code sc = RTEMS_SUCCESSFUL; 1063a0: 31 db xor %ebx,%ebx } } } return sc; } 1063a2: 89 d8 mov %ebx,%eax 1063a4: 83 c4 28 add $0x28,%esp 1063a7: 5b pop %ebx 1063a8: c3 ret 1063a9: 8d 76 00 lea 0x0(%esi),%esi if (sc == RTEMS_SUCCESSFUL) { ++env->reference_count; } else { sc = RTEMS_UNSATISFIED; } _Thread_Enable_dispatch(); 1063ac: e8 ff 34 00 00 call 1098b0 <_Thread_Enable_dispatch> (void *) &env ); if (sc == RTEMS_SUCCESSFUL) { ++env->reference_count; } else { sc = RTEMS_UNSATISFIED; 1063b1: bb 0d 00 00 00 mov $0xd,%ebx } } } return sc; } 1063b6: 89 d8 mov %ebx,%eax 1063b8: 83 c4 28 add $0x28,%esp 1063bb: 5b pop %ebx 1063bc: c3 ret 1063bd: 8d 76 00 lea 0x0(%esi),%esi ); if (sc == RTEMS_SUCCESSFUL) { free_user_env_protected(rtems_current_user_env); rtems_current_user_env = env; } else { free_user_env_protected(env); 1063c0: 8b 44 24 1c mov 0x1c(%esp),%eax <== NOT EXECUTED 1063c4: e8 33 fe ff ff call 1061fc <== NOT EXECUTED sc = RTEMS_TOO_MANY; 1063c9: bb 05 00 00 00 mov $0x5,%ebx <== NOT EXECUTED 1063ce: eb d2 jmp 1063a2 <== NOT EXECUTED =============================================================================== 0010fd1c : * * Convert RTEMS internal flags to UNIX fnctl(2) flags */ int rtems_libio_to_fcntl_flags( uint32_t flags ) { 10fd1c: 8b 54 24 04 mov 0x4(%esp),%edx int fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10fd20: 89 d0 mov %edx,%eax 10fd22: 83 e0 06 and $0x6,%eax 10fd25: 83 f8 06 cmp $0x6,%eax 10fd28: 74 2a je 10fd54 <== NEVER TAKEN fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10fd2a: f6 c2 02 test $0x2,%dl 10fd2d: 75 21 jne 10fd50 <== ALWAYS TAKEN fcntl_flags |= O_RDONLY; } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) { 10fd2f: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fd31: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED int rtems_libio_to_fcntl_flags( uint32_t flags ) { int fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10fd34: 83 e0 01 and $0x1,%eax <== NOT EXECUTED fcntl_flags |= O_RDONLY; } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) { fcntl_flags |= O_WRONLY; } if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) { 10fd37: f6 c2 01 test $0x1,%dl 10fd3a: 74 03 je 10fd3f fcntl_flags |= O_NONBLOCK; 10fd3c: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10fd3f: f6 c6 02 test $0x2,%dh 10fd42: 74 03 je 10fd47 fcntl_flags |= O_APPEND; 10fd44: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10fd47: 80 e6 04 and $0x4,%dh 10fd4a: 74 03 je 10fd4f fcntl_flags |= O_CREAT; 10fd4c: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10fd4f: c3 ret int fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { fcntl_flags |= O_RDONLY; 10fd50: 31 c0 xor %eax,%eax 10fd52: eb e3 jmp 10fd37 int rtems_libio_to_fcntl_flags( uint32_t flags ) { int fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10fd54: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10fd59: eb dc jmp 10fd37 <== NOT EXECUTED =============================================================================== 001063d0 : { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_user_env_t *env = rtems_current_user_env; bool uses_private_env = env != &rtems_global_user_env; if (uses_private_env) { 1063d0: 81 3d a0 9d 12 00 c0 cmpl $0x129dc0,0x129da0 1063d7: 9d 12 00 1063da: 74 28 je 106404 return sc; } void rtems_libio_use_global_env(void) { 1063dc: 83 ec 1c sub $0x1c,%esp rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_user_env_t *env = rtems_current_user_env; bool uses_private_env = env != &rtems_global_user_env; if (uses_private_env) { sc = rtems_task_variable_delete( 1063df: c7 44 24 04 a0 9d 12 movl $0x129da0,0x4(%esp) 1063e6: 00 1063e7: c7 04 24 00 00 00 00 movl $0x0,(%esp) 1063ee: e8 6d 18 00 00 call 107c60 RTEMS_SELF, (void **) &rtems_current_user_env ); if (sc != RTEMS_SUCCESSFUL) { 1063f3: 85 c0 test %eax,%eax 1063f5: 75 0e jne 106405 <== NEVER TAKEN rtems_fatal_error_occurred(0xdeadbeef); } rtems_current_user_env = &rtems_global_user_env; 1063f7: c7 05 a0 9d 12 00 c0 movl $0x129dc0,0x129da0 1063fe: 9d 12 00 } } 106401: 83 c4 1c add $0x1c,%esp 106404: c3 ret sc = rtems_task_variable_delete( RTEMS_SELF, (void **) &rtems_current_user_env ); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred(0xdeadbeef); 106405: c7 04 24 ef be ad de movl $0xdeadbeef,(%esp) <== NOT EXECUTED 10640c: e8 53 1b 00 00 call 107f64 <== NOT EXECUTED =============================================================================== 0010ab88 : * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) { 10ab88: 83 ec 2c sub $0x2c,%esp uintptr_t size; if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) { 10ab8b: 8d 44 24 1c lea 0x1c(%esp),%eax 10ab8f: 89 44 24 08 mov %eax,0x8(%esp) 10ab93: 8b 44 24 30 mov 0x30(%esp),%eax 10ab97: 89 44 24 04 mov %eax,0x4(%esp) 10ab9b: a1 50 27 13 00 mov 0x132750,%eax 10aba0: 89 04 24 mov %eax,(%esp) 10aba3: e8 a8 67 00 00 call 111350 <_Protected_heap_Get_block_size> 10aba8: 84 c0 test %al,%al 10abaa: 74 12 je 10abbe <== NEVER TAKEN MSBUMP(lifetime_freed, size); 10abac: 8b 44 24 1c mov 0x1c(%esp),%eax 10abb0: 31 d2 xor %edx,%edx 10abb2: 01 05 e4 72 13 00 add %eax,0x1372e4 10abb8: 11 15 e8 72 13 00 adc %edx,0x1372e8 } } 10abbe: 83 c4 2c add $0x2c,%esp 10abc1: c3 ret =============================================================================== 0010abc4 : } static void rtems_malloc_statistics_at_malloc( void *pointer ) { 10abc4: 83 ec 2c sub $0x2c,%esp 10abc7: 8b 44 24 30 mov 0x30(%esp),%eax uintptr_t actual_size = 0; 10abcb: c7 44 24 1c 00 00 00 movl $0x0,0x1c(%esp) 10abd2: 00 uint32_t current_depth; rtems_malloc_statistics_t *s = &rtems_malloc_statistics; if ( !pointer ) 10abd3: 85 c0 test %eax,%eax 10abd5: 74 49 je 10ac20 <== NEVER TAKEN return; _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size); 10abd7: 8d 54 24 1c lea 0x1c(%esp),%edx 10abdb: 89 54 24 08 mov %edx,0x8(%esp) 10abdf: 89 44 24 04 mov %eax,0x4(%esp) 10abe3: a1 50 27 13 00 mov 0x132750,%eax 10abe8: 89 04 24 mov %eax,(%esp) 10abeb: e8 60 67 00 00 call 111350 <_Protected_heap_Get_block_size> MSBUMP(lifetime_allocated, actual_size); 10abf0: 8b 44 24 1c mov 0x1c(%esp),%eax 10abf4: 31 d2 xor %edx,%edx 10abf6: 03 05 dc 72 13 00 add 0x1372dc,%eax 10abfc: 13 15 e0 72 13 00 adc 0x1372e0,%edx 10ac02: a3 dc 72 13 00 mov %eax,0x1372dc 10ac07: 89 15 e0 72 13 00 mov %edx,0x1372e0 current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 10ac0d: 2b 05 e4 72 13 00 sub 0x1372e4,%eax if (current_depth > s->max_depth) 10ac13: 3b 05 d8 72 13 00 cmp 0x1372d8,%eax 10ac19: 76 05 jbe 10ac20 s->max_depth = current_depth; 10ac1b: a3 d8 72 13 00 mov %eax,0x1372d8 } 10ac20: 83 c4 2c add $0x2c,%esp 10ac23: c3 ret =============================================================================== 00113e08 : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 113e08: 53 push %ebx 113e09: 83 ec 28 sub $0x28,%esp 113e0c: 8b 5c 24 30 mov 0x30(%esp),%ebx void *return_this; /* * Parameter error checks */ if ( !pointer ) 113e10: 85 db test %ebx,%ebx 113e12: 74 69 je 113e7d return EINVAL; *pointer = NULL; 113e14: c7 03 00 00 00 00 movl $0x0,(%ebx) /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 113e1a: 83 3d e0 47 13 00 03 cmpl $0x3,0x1347e0 113e21: 74 51 je 113e74 return EINVAL; /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 113e23: e8 fc 50 ff ff call 108f24 Heap_Control *heap, uintptr_t size, uintptr_t alignment ) { return 113e28: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 113e2f: 00 113e30: 8b 44 24 34 mov 0x34(%esp),%eax 113e34: 89 44 24 08 mov %eax,0x8(%esp) 113e38: 8b 44 24 38 mov 0x38(%esp),%eax 113e3c: 89 44 24 04 mov %eax,0x4(%esp) 113e40: a1 54 02 13 00 mov 0x130254,%eax 113e45: 89 04 24 mov %eax,(%esp) 113e48: e8 33 aa ff ff call 10e880 <_Protected_heap_Allocate_aligned_with_boundary> return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 113e4d: 85 c0 test %eax,%eax 113e4f: 74 37 je 113e88 return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 113e51: 8b 15 28 29 13 00 mov 0x132928,%edx 113e57: 85 d2 test %edx,%edx 113e59: 74 0e je 113e69 (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 113e5b: 89 1c 24 mov %ebx,(%esp) 113e5e: 89 44 24 1c mov %eax,0x1c(%esp) 113e62: ff 52 04 call *0x4(%edx) 113e65: 8b 44 24 1c mov 0x1c(%esp),%eax *pointer = return_this; 113e69: 89 03 mov %eax,(%ebx) return 0; 113e6b: 31 c0 xor %eax,%eax } 113e6d: 83 c4 28 add $0x28,%esp 113e70: 5b pop %ebx 113e71: c3 ret 113e72: 66 90 xchg %ax,%ax /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && !malloc_is_system_state_OK() ) 113e74: e8 73 50 ff ff call 108eec *pointer = NULL; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 113e79: 84 c0 test %al,%al 113e7b: 75 a6 jne 113e23 <== ALWAYS TAKEN /* * Parameter error checks */ if ( !pointer ) return EINVAL; 113e7d: b8 16 00 00 00 mov $0x16,%eax if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_malloc)(pointer); *pointer = return_this; return 0; } 113e82: 83 c4 28 add $0x28,%esp 113e85: 5b pop %ebx 113e86: c3 ret 113e87: 90 nop RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) return ENOMEM; 113e88: b8 0c 00 00 00 mov $0xc,%eax if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_malloc)(pointer); *pointer = return_this; return 0; } 113e8d: 83 c4 28 add $0x28,%esp 113e90: 5b pop %ebx 113e91: c3 ret =============================================================================== 0010d5dc : return (retval); } int rtems_mkdir(const char *path, mode_t mode) { 10d5dc: 55 push %ebp 10d5dd: 57 push %edi 10d5de: 56 push %esi 10d5df: 53 push %ebx 10d5e0: 83 ec 6c sub $0x6c,%esp int success = 0; char *dup_path = strdup(path); 10d5e3: 8b 84 24 80 00 00 00 mov 0x80(%esp),%eax 10d5ea: 89 04 24 mov %eax,(%esp) 10d5ed: e8 42 95 01 00 call 126b34 10d5f2: 89 c6 mov %eax,%esi if (dup_path != NULL) { 10d5f4: 85 c0 test %eax,%eax 10d5f6: 0f 84 1b 01 00 00 je 10d717 char *p; p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ 10d5fc: 8a 00 mov (%eax),%al 10d5fe: 3c 2f cmp $0x2f,%al 10d600: 0f 84 fa 00 00 00 je 10d700 10d606: 89 f3 mov %esi,%ebx 10d608: 31 ff xor %edi,%edi 10d60a: b9 01 00 00 00 mov $0x1,%ecx ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') 10d60f: 84 c0 test %al,%al 10d611: 74 10 je 10d623 <== NEVER TAKEN 10d613: 90 nop last = 1; else if (p[0] != '/') 10d614: 3c 2f cmp $0x2f,%al 10d616: 0f 84 84 00 00 00 je 10d6a0 p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { 10d61c: 43 inc %ebx 10d61d: 8a 03 mov (%ebx),%al if (p[0] == '\0') 10d61f: 84 c0 test %al,%al 10d621: 75 f1 jne 10d614 last = 1; else if (p[0] != '/') continue; *p = '\0'; 10d623: c6 03 00 movb $0x0,(%ebx) 10d626: bd 01 00 00 00 mov $0x1,%ebp if (!last && p[1] == '\0') last = 1; if (first) { 10d62b: 85 c9 test %ecx,%ecx 10d62d: 75 55 jne 10d684 oumask = umask(0); numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) 10d62f: 85 ed test %ebp,%ebp 10d631: 75 1d jne 10d650 (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 10d633: c7 44 24 04 ff 01 00 movl $0x1ff,0x4(%esp) 10d63a: 00 10d63b: 89 34 24 mov %esi,(%esp) 10d63e: e8 59 f1 ff ff call 10c79c 10d643: 85 c0 test %eax,%eax 10d645: 78 6d js 10d6b4 retval = 0; break; } } if (!last) *p = '/'; 10d647: c6 03 2f movb $0x2f,(%ebx) 10d64a: 31 c9 xor %ecx,%ecx 10d64c: eb ce jmp 10d61c 10d64e: 66 90 xchg %ax,%ax numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) (void)umask(oumask); 10d650: 89 3c 24 mov %edi,(%esp) 10d653: e8 a4 26 00 00 call 10fcfc if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 10d658: 8b 84 24 84 00 00 00 mov 0x84(%esp),%eax 10d65f: 89 44 24 04 mov %eax,0x4(%esp) 10d663: 89 34 24 mov %esi,(%esp) 10d666: e8 31 f1 ff ff call 10c79c 10d66b: 85 c0 test %eax,%eax 10d66d: 78 45 js 10d6b4 int success = 0; char *dup_path = strdup(path); if (dup_path != NULL) { success = build(dup_path, mode); free(dup_path); 10d66f: 89 34 24 mov %esi,(%esp) 10d672: e8 c9 ea ff ff call 10c140 } return success != 0 ? 0 : -1; 10d677: 31 c0 xor %eax,%eax } 10d679: 83 c4 6c add $0x6c,%esp 10d67c: 5b pop %ebx 10d67d: 5e pop %esi 10d67e: 5f pop %edi 10d67f: 5d pop %ebp 10d680: c3 ret 10d681: 8d 76 00 lea 0x0(%esi),%esi * mkdir [-m mode] dir * * We change the user's umask and then restore it, * instead of doing chmod's. */ oumask = umask(0); 10d684: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10d68b: e8 6c 26 00 00 call 10fcfc 10d690: 89 c7 mov %eax,%edi numask = oumask & ~(S_IWUSR | S_IXUSR); 10d692: 24 3f and $0x3f,%al (void)umask(numask); 10d694: 89 04 24 mov %eax,(%esp) 10d697: e8 60 26 00 00 call 10fcfc 10d69c: eb 91 jmp 10d62f 10d69e: 66 90 xchg %ax,%ax for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') last = 1; else if (p[0] != '/') continue; *p = '\0'; 10d6a0: c6 03 00 movb $0x0,(%ebx) 10d6a3: 31 c0 xor %eax,%eax 10d6a5: 80 7b 01 00 cmpb $0x0,0x1(%ebx) 10d6a9: 0f 94 c0 sete %al 10d6ac: 89 c5 mov %eax,%ebp 10d6ae: e9 78 ff ff ff jmp 10d62b 10d6b3: 90 nop first = 0; } if (last) (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { if (errno == EEXIST || errno == EISDIR) { 10d6b4: e8 93 78 01 00 call 124f4c <__errno> 10d6b9: 83 38 11 cmpl $0x11,(%eax) 10d6bc: 74 0a je 10d6c8 10d6be: e8 89 78 01 00 call 124f4c <__errno> 10d6c3: 83 38 15 cmpl $0x15,(%eax) 10d6c6: 75 43 jne 10d70b <== ALWAYS TAKEN if (stat(path, &sb) < 0) { 10d6c8: 8d 44 24 18 lea 0x18(%esp),%eax 10d6cc: 89 44 24 04 mov %eax,0x4(%esp) 10d6d0: 89 34 24 mov %esi,(%esp) 10d6d3: e8 70 00 00 00 call 10d748 10d6d8: 85 c0 test %eax,%eax 10d6da: 78 2f js 10d70b <== NEVER TAKEN retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { 10d6dc: 8b 44 24 24 mov 0x24(%esp),%eax 10d6e0: 25 00 f0 00 00 and $0xf000,%eax 10d6e5: 3d 00 40 00 00 cmp $0x4000,%eax 10d6ea: 75 4a jne 10d736 else errno = ENOTDIR; retval = 0; break; } if (last) 10d6ec: 85 ed test %ebp,%ebp 10d6ee: 0f 85 7b ff ff ff jne 10d66f retval = 0; break; } } if (!last) *p = '/'; 10d6f4: c6 03 2f movb $0x2f,(%ebx) 10d6f7: 31 c9 xor %ecx,%ecx 10d6f9: e9 1e ff ff ff jmp 10d61c 10d6fe: 66 90 xchg %ax,%ax p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; 10d700: 8d 5e 01 lea 0x1(%esi),%ebx 10d703: 8a 46 01 mov 0x1(%esi),%al 10d706: e9 fd fe ff ff jmp 10d608 } } if (!last) *p = '/'; } if (!first && !last) 10d70b: 85 ed test %ebp,%ebp 10d70d: 74 1d je 10d72c <== NEVER TAKEN int success = 0; char *dup_path = strdup(path); if (dup_path != NULL) { success = build(dup_path, mode); free(dup_path); 10d70f: 89 34 24 mov %esi,(%esp) 10d712: e8 29 ea ff ff call 10c140 } return success != 0 ? 0 : -1; 10d717: b8 ff ff ff ff mov $0xffffffff,%eax 10d71c: e9 58 ff ff ff jmp 10d679 break; } else if (!S_ISDIR(sb.st_mode)) { if (last) errno = EEXIST; else errno = ENOTDIR; 10d721: e8 26 78 01 00 call 124f4c <__errno> 10d726: c7 00 14 00 00 00 movl $0x14,(%eax) } if (!last) *p = '/'; } if (!first && !last) (void)umask(oumask); 10d72c: 89 3c 24 mov %edi,(%esp) 10d72f: e8 c8 25 00 00 call 10fcfc 10d734: eb d9 jmp 10d70f if (errno == EEXIST || errno == EISDIR) { if (stat(path, &sb) < 0) { retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { if (last) 10d736: 85 ed test %ebp,%ebp 10d738: 74 e7 je 10d721 errno = EEXIST; 10d73a: e8 0d 78 01 00 call 124f4c <__errno> 10d73f: c7 00 11 00 00 00 movl $0x11,(%eax) 10d745: eb c8 jmp 10d70f =============================================================================== 0010d3f0 : rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) { 10d3f0: 57 push %edi 10d3f1: 56 push %esi 10d3f2: 53 push %ebx 10d3f3: 83 ec 10 sub $0x10,%esp 10d3f6: 8b 7c 24 28 mov 0x28(%esp),%edi int i; /* * Validate parameters and look up information structure. */ if ( !info ) 10d3fa: 85 ff test %edi,%edi 10d3fc: 74 62 je 10d460 return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10d3fe: 0f b7 44 24 24 movzwl 0x24(%esp),%eax 10d403: 89 44 24 04 mov %eax,0x4(%esp) 10d407: 8b 44 24 20 mov 0x20(%esp),%eax 10d40b: 89 04 24 mov %eax,(%esp) 10d40e: e8 41 1b 00 00 call 10ef54 <_Objects_Get_information> if ( !obj_info ) 10d413: 85 c0 test %eax,%eax 10d415: 74 55 je 10d46c return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10d417: 8b 50 08 mov 0x8(%eax),%edx 10d41a: 89 17 mov %edx,(%edi) info->maximum_id = obj_info->maximum_id; 10d41c: 8b 50 0c mov 0xc(%eax),%edx 10d41f: 89 57 04 mov %edx,0x4(%edi) info->auto_extend = obj_info->auto_extend; 10d422: 8a 50 12 mov 0x12(%eax),%dl 10d425: 88 57 0c mov %dl,0xc(%edi) info->maximum = obj_info->maximum; 10d428: 0f b7 58 10 movzwl 0x10(%eax),%ebx 10d42c: 89 5f 08 mov %ebx,0x8(%edi) for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10d42f: 85 db test %ebx,%ebx 10d431: 74 45 je 10d478 <== NEVER TAKEN 10d433: 8b 70 1c mov 0x1c(%eax),%esi 10d436: b9 01 00 00 00 mov $0x1,%ecx 10d43b: b8 01 00 00 00 mov $0x1,%eax 10d440: 31 d2 xor %edx,%edx 10d442: 66 90 xchg %ax,%ax if ( !obj_info->local_table[i] ) unallocated++; 10d444: 83 3c 8e 01 cmpl $0x1,(%esi,%ecx,4) 10d448: 83 d2 00 adc $0x0,%edx info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10d44b: 40 inc %eax 10d44c: 89 c1 mov %eax,%ecx 10d44e: 39 c3 cmp %eax,%ebx 10d450: 73 f2 jae 10d444 if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10d452: 89 57 10 mov %edx,0x10(%edi) return RTEMS_SUCCESSFUL; 10d455: 31 c0 xor %eax,%eax } 10d457: 83 c4 10 add $0x10,%esp 10d45a: 5b pop %ebx 10d45b: 5e pop %esi 10d45c: 5f pop %edi 10d45d: c3 ret 10d45e: 66 90 xchg %ax,%ax /* * Validate parameters and look up information structure. */ if ( !info ) return RTEMS_INVALID_ADDRESS; 10d460: b8 09 00 00 00 mov $0x9,%eax unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10d465: 83 c4 10 add $0x10,%esp 10d468: 5b pop %ebx 10d469: 5e pop %esi 10d46a: 5f pop %edi 10d46b: c3 ret if ( !info ) return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); if ( !obj_info ) return RTEMS_INVALID_NUMBER; 10d46c: b8 0a 00 00 00 mov $0xa,%eax unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10d471: 83 c4 10 add $0x10,%esp 10d474: 5b pop %ebx 10d475: 5e pop %esi 10d476: 5f pop %edi 10d477: c3 ret info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10d478: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d47a: eb d6 jmp 10d452 <== NOT EXECUTED =============================================================================== 001193f4 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 1193f4: 56 push %esi 1193f5: 53 push %ebx 1193f6: 83 ec 14 sub $0x14,%esp 1193f9: 8b 74 24 20 mov 0x20(%esp),%esi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1193fd: 85 f6 test %esi,%esi 1193ff: 75 0b jne 11940c return RTEMS_INVALID_NAME; 119401: b8 03 00 00 00 mov $0x3,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 119406: 83 c4 14 add $0x14,%esp 119409: 5b pop %ebx 11940a: 5e pop %esi 11940b: c3 ret register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) 11940c: 8b 5c 24 24 mov 0x24(%esp),%ebx 119410: 85 db test %ebx,%ebx 119412: 74 1c je 119430 return RTEMS_INVALID_ADDRESS; if ( !id ) 119414: 8b 4c 24 34 mov 0x34(%esp),%ecx 119418: 85 c9 test %ecx,%ecx 11941a: 74 14 je 119430 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 11941c: 8b 54 24 28 mov 0x28(%esp),%edx 119420: 85 d2 test %edx,%edx 119422: 75 18 jne 11943c !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 119424: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 119429: 83 c4 14 add $0x14,%esp 11942c: 5b pop %ebx 11942d: 5e pop %esi 11942e: c3 ret 11942f: 90 nop if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 119430: b8 09 00 00 00 mov $0x9,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 119435: 83 c4 14 add $0x14,%esp 119438: 5b pop %ebx 119439: 5e pop %esi 11943a: c3 ret 11943b: 90 nop return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 11943c: 8b 44 24 2c mov 0x2c(%esp),%eax 119440: 85 c0 test %eax,%eax 119442: 74 e0 je 119424 119444: 8b 44 24 2c mov 0x2c(%esp),%eax 119448: 39 44 24 28 cmp %eax,0x28(%esp) 11944c: 72 d6 jb 119424 11944e: a8 03 test $0x3,%al 119450: 75 d2 jne 119424 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 119452: f6 44 24 24 03 testb $0x3,0x24(%esp) 119457: 75 d7 jne 119430 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 119459: a1 04 da 14 00 mov 0x14da04,%eax 11945e: 40 inc %eax 11945f: a3 04 da 14 00 mov %eax,0x14da04 return _Thread_Dispatch_disable_level; 119464: a1 04 da 14 00 mov 0x14da04,%eax * This function allocates a partition control block from * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 119469: c7 04 24 80 d8 14 00 movl $0x14d880,(%esp) 119470: e8 63 4a 00 00 call 11ded8 <_Objects_Allocate> 119475: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 119477: 85 c0 test %eax,%eax 119479: 74 6c je 1194e7 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 11947b: 8b 54 24 24 mov 0x24(%esp),%edx 11947f: 89 50 10 mov %edx,0x10(%eax) the_partition->length = length; 119482: 8b 44 24 28 mov 0x28(%esp),%eax 119486: 89 43 14 mov %eax,0x14(%ebx) the_partition->buffer_size = buffer_size; 119489: 8b 54 24 2c mov 0x2c(%esp),%edx 11948d: 89 53 18 mov %edx,0x18(%ebx) the_partition->attribute_set = attribute_set; 119490: 8b 44 24 30 mov 0x30(%esp),%eax 119494: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 119497: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 11949e: 89 54 24 0c mov %edx,0xc(%esp) 1194a2: 8b 44 24 28 mov 0x28(%esp),%eax 1194a6: 31 d2 xor %edx,%edx 1194a8: f7 74 24 2c divl 0x2c(%esp) 1194ac: 89 44 24 08 mov %eax,0x8(%esp) 1194b0: 8b 44 24 24 mov 0x24(%esp),%eax 1194b4: 89 44 24 04 mov %eax,0x4(%esp) 1194b8: 8d 43 24 lea 0x24(%ebx),%eax 1194bb: 89 04 24 mov %eax,(%esp) 1194be: e8 39 34 00 00 call 11c8fc <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1194c3: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1194c6: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1194c9: 8b 15 9c d8 14 00 mov 0x14d89c,%edx 1194cf: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1194d2: 89 73 0c mov %esi,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1194d5: 8b 54 24 34 mov 0x34(%esp),%edx 1194d9: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1194db: e8 84 5b 00 00 call 11f064 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1194e0: 31 c0 xor %eax,%eax 1194e2: e9 1f ff ff ff jmp 119406 _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { _Thread_Enable_dispatch(); 1194e7: e8 78 5b 00 00 call 11f064 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 1194ec: b8 05 00 00 00 mov $0x5,%eax 1194f1: e9 10 ff ff ff jmp 119406 =============================================================================== 00119624 : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 119624: 53 push %ebx 119625: 83 ec 28 sub $0x28,%esp register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); 119628: 8d 44 24 1c lea 0x1c(%esp),%eax 11962c: 89 44 24 08 mov %eax,0x8(%esp) RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 119630: 8b 44 24 30 mov 0x30(%esp),%eax 119634: 89 44 24 04 mov %eax,0x4(%esp) 119638: c7 04 24 80 d8 14 00 movl $0x14d880,(%esp) 11963f: e8 8c 4d 00 00 call 11e3d0 <_Objects_Get> switch ( location ) { 119644: 8b 54 24 1c mov 0x1c(%esp),%edx 119648: 85 d2 test %edx,%edx 11964a: 75 48 jne 119694 11964c: 89 c3 mov %eax,%ebx ) { void *starting; void *ending; starting = the_partition->starting_address; 11964e: 8b 40 10 mov 0x10(%eax),%eax ending = _Addresses_Add_offset( starting, the_partition->length ); 119651: 8b 53 14 mov 0x14(%ebx),%edx const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 119654: 39 44 24 34 cmp %eax,0x34(%esp) 119658: 72 46 jb 1196a0 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 11965a: 01 c2 add %eax,%edx const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 11965c: 39 54 24 34 cmp %edx,0x34(%esp) 119660: 77 3e ja 1196a0 <== NEVER TAKEN RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 119662: 8b 54 24 34 mov 0x34(%esp),%edx 119666: 29 c2 sub %eax,%edx 119668: 89 d0 mov %edx,%eax offset = (uint32_t) _Addresses_Subtract( the_buffer, the_partition->starting_address ); return ((offset % the_partition->buffer_size) == 0); 11966a: 31 d2 xor %edx,%edx 11966c: f7 73 18 divl 0x18(%ebx) starting = the_partition->starting_address; ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 11966f: 85 d2 test %edx,%edx 119671: 75 2d jne 1196a0 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 119673: 8b 44 24 34 mov 0x34(%esp),%eax 119677: 89 44 24 04 mov %eax,0x4(%esp) 11967b: 8d 43 24 lea 0x24(%ebx),%eax 11967e: 89 04 24 mov %eax,(%esp) 119681: e8 32 32 00 00 call 11c8b8 <_Chain_Append> case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 119686: ff 4b 20 decl 0x20(%ebx) _Thread_Enable_dispatch(); 119689: e8 d6 59 00 00 call 11f064 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11968e: 31 c0 xor %eax,%eax 119690: eb 07 jmp 119699 119692: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 119694: b8 04 00 00 00 mov $0x4,%eax } 119699: 83 c4 28 add $0x28,%esp 11969c: 5b pop %ebx 11969d: c3 ret 11969e: 66 90 xchg %ax,%ax _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1196a0: e8 bf 59 00 00 call 11f064 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 1196a5: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1196aa: 83 c4 28 add $0x28,%esp 1196ad: 5b pop %ebx 1196ae: c3 ret =============================================================================== 001375cc : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 1375cc: 57 push %edi 1375cd: 56 push %esi 1375ce: 53 push %ebx 1375cf: 83 ec 30 sub $0x30,%esp 1375d2: 8b 5c 24 40 mov 0x40(%esp),%ebx Objects_Locations location; rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); 1375d6: 8d 44 24 2c lea 0x2c(%esp),%eax 1375da: 89 44 24 08 mov %eax,0x8(%esp) 1375de: 89 5c 24 04 mov %ebx,0x4(%esp) 1375e2: c7 04 24 20 b6 17 00 movl $0x17b620,(%esp) 1375e9: e8 6e 58 fd ff call 10ce5c <_Objects_Get> switch ( location ) { 1375ee: 8b 54 24 2c mov 0x2c(%esp),%edx 1375f2: 85 d2 test %edx,%edx 1375f4: 75 1e jne 137614 1375f6: 89 c6 mov %eax,%esi case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 1375f8: a1 cc b3 17 00 mov 0x17b3cc,%eax 1375fd: 39 46 40 cmp %eax,0x40(%esi) 137600: 74 1e je 137620 _Thread_Enable_dispatch(); 137602: e8 69 64 fd ff call 10da70 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 137607: b8 17 00 00 00 mov $0x17,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 13760c: 83 c4 30 add $0x30,%esp 13760f: 5b pop %ebx 137610: 5e pop %esi 137611: 5f pop %edi 137612: c3 ret 137613: 90 nop #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 137614: b8 04 00 00 00 mov $0x4,%eax } 137619: 83 c4 30 add $0x30,%esp 13761c: 5b pop %ebx 13761d: 5e pop %esi 13761e: 5f pop %edi 13761f: c3 ret if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 137620: 8b 44 24 44 mov 0x44(%esp),%eax 137624: 85 c0 test %eax,%eax 137626: 74 68 je 137690 } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 137628: 9c pushf 137629: fa cli 13762a: 5f pop %edi if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 13762b: 8b 46 38 mov 0x38(%esi),%eax 13762e: 85 c0 test %eax,%eax 137630: 0f 84 82 00 00 00 je 1376b8 _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 137636: 83 f8 02 cmp $0x2,%eax 137639: 0f 84 cf 00 00 00 je 13770e _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 13763f: 83 f8 04 cmp $0x4,%eax 137642: 75 d0 jne 137614 <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 137644: 89 f0 mov %esi,%eax 137646: e8 2d fe ff ff call 137478 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 13764b: 57 push %edi 13764c: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 13764d: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) the_period->next_length = length; 137654: 8b 44 24 44 mov 0x44(%esp),%eax 137658: 89 46 3c mov %eax,0x3c(%esi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 13765b: 89 46 1c mov %eax,0x1c(%esi) _Watchdog_Insert_ticks( &the_period->Timer, length ); 13765e: 8d 46 10 lea 0x10(%esi),%eax 137661: 89 44 24 04 mov %eax,0x4(%esp) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 137665: c7 04 24 08 b2 17 00 movl $0x17b208,(%esp) 13766c: e8 e3 6f fd ff call 10e654 <_Watchdog_Insert> 137671: 8b 46 3c mov 0x3c(%esi),%eax 137674: 89 44 24 04 mov %eax,0x4(%esp) 137678: 8b 46 40 mov 0x40(%esi),%eax 13767b: 89 04 24 mov %eax,(%esp) 13767e: ff 15 14 36 17 00 call *0x173614 _Scheduler_Release_job(the_period->owner, the_period->next_length); _Thread_Enable_dispatch(); 137684: e8 e7 63 fd ff call 10da70 <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 137689: b8 06 00 00 00 mov $0x6,%eax 13768e: eb 89 jmp 137619 _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 137690: 8b 46 38 mov 0x38(%esi),%eax 137693: 83 f8 04 cmp $0x4,%eax 137696: 77 1c ja 1376b4 <== NEVER TAKEN 137698: 8b 04 85 f4 e2 15 00 mov 0x15e2f4(,%eax,4),%eax case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 13769f: 89 44 24 1c mov %eax,0x1c(%esp) 1376a3: e8 c8 63 fd ff call 10da70 <_Thread_Enable_dispatch> 1376a8: 8b 44 24 1c mov 0x1c(%esp),%eax 1376ac: e9 68 ff ff ff jmp 137619 1376b1: 8d 76 00 lea 0x0(%esi),%esi _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 1376b4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1376b6: eb e7 jmp 13769f <== NOT EXECUTED return( return_value ); } _ISR_Disable( level ); if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { _ISR_Enable( level ); 1376b8: 57 push %edi 1376b9: 9d popf the_period->next_length = length; 1376ba: 8b 44 24 44 mov 0x44(%esp),%eax 1376be: 89 46 3c mov %eax,0x3c(%esi) /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 1376c1: 89 34 24 mov %esi,(%esp) 1376c4: e8 8f fe ff ff call 137558 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 1376c9: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1376d0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) the_watchdog->routine = routine; 1376d7: c7 46 2c 78 77 13 00 movl $0x137778,0x2c(%esi) the_watchdog->id = id; 1376de: 89 5e 30 mov %ebx,0x30(%esi) the_watchdog->user_data = user_data; 1376e1: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 1376e8: 8b 44 24 44 mov 0x44(%esp),%eax 1376ec: 89 46 1c mov %eax,0x1c(%esi) _Rate_monotonic_Timeout, id, NULL ); _Watchdog_Insert_ticks( &the_period->Timer, length ); 1376ef: 83 c6 10 add $0x10,%esi 1376f2: 89 74 24 04 mov %esi,0x4(%esp) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 1376f6: c7 04 24 08 b2 17 00 movl $0x17b208,(%esp) 1376fd: e8 52 6f fd ff call 10e654 <_Watchdog_Insert> _Thread_Enable_dispatch(); 137702: e8 69 63 fd ff call 10da70 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 137707: 31 c0 xor %eax,%eax 137709: e9 0b ff ff ff jmp 137619 if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 13770e: 89 f0 mov %esi,%eax 137710: e8 63 fd ff ff call 137478 <_Rate_monotonic_Update_statistics> /* * This tells the _Rate_monotonic_Timeout that this task is * in the process of blocking on the period and that we * may be changing the length of the next period. */ the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; 137715: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi) the_period->next_length = length; 13771c: 8b 44 24 44 mov 0x44(%esp),%eax 137720: 89 46 3c mov %eax,0x3c(%esi) _ISR_Enable( level ); 137723: 57 push %edi 137724: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 137725: a1 cc b3 17 00 mov 0x17b3cc,%eax 13772a: 8b 56 08 mov 0x8(%esi),%edx 13772d: 89 50 20 mov %edx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 137730: c7 44 24 04 00 40 00 movl $0x4000,0x4(%esp) 137737: 00 137738: 89 04 24 mov %eax,(%esp) 13773b: e8 48 6b fd ff call 10e288 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 137740: 9c pushf 137741: fa cli 137742: 5a pop %edx local_state = the_period->state; 137743: 8b 46 38 mov 0x38(%esi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 137746: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) _ISR_Enable( level ); 13774d: 52 push %edx 13774e: 9d popf /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) 13774f: 83 f8 03 cmp $0x3,%eax 137752: 74 0c je 137760 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); _Thread_Enable_dispatch(); 137754: e8 17 63 fd ff call 10da70 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 137759: 31 c0 xor %eax,%eax 13775b: e9 b9 fe ff ff jmp 137619 /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 137760: c7 44 24 04 00 40 00 movl $0x4000,0x4(%esp) 137767: 00 137768: a1 cc b3 17 00 mov 0x17b3cc,%eax 13776d: 89 04 24 mov %eax,(%esp) 137770: e8 57 5f fd ff call 10d6cc <_Thread_Clear_state> 137775: eb dd jmp 137754 =============================================================================== 0012a98c : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 12a98c: 55 push %ebp 12a98d: 57 push %edi 12a98e: 56 push %esi 12a98f: 53 push %ebx 12a990: 81 ec 9c 00 00 00 sub $0x9c,%esp 12a996: 8b b4 24 b0 00 00 00 mov 0xb0(%esp),%esi 12a99d: 8b 9c 24 b4 00 00 00 mov 0xb4(%esp),%ebx rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 12a9a4: 85 db test %ebx,%ebx 12a9a6: 0f 84 ec 00 00 00 je 12aa98 <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 12a9ac: c7 44 24 04 a8 b3 15 movl $0x15b3a8,0x4(%esp) 12a9b3: 00 12a9b4: 89 34 24 mov %esi,(%esp) 12a9b7: ff d3 call *%ebx #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 12a9b9: c7 44 24 04 e0 b3 15 movl $0x15b3e0,0x4(%esp) 12a9c0: 00 12a9c1: 89 34 24 mov %esi,(%esp) 12a9c4: ff d3 call *%ebx (*print)( context, "--- Wall times are in seconds ---\n" ); 12a9c6: c7 44 24 04 04 b4 15 movl $0x15b404,0x4(%esp) 12a9cd: 00 12a9ce: 89 34 24 mov %esi,(%esp) 12a9d1: ff d3 call *%ebx Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 12a9d3: c7 44 24 04 28 b4 15 movl $0x15b428,0x4(%esp) 12a9da: 00 12a9db: 89 34 24 mov %esi,(%esp) 12a9de: ff d3 call *%ebx #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 12a9e0: c7 44 24 04 74 b4 15 movl $0x15b474,0x4(%esp) 12a9e7: 00 12a9e8: 89 34 24 mov %esi,(%esp) 12a9eb: ff d3 call *%ebx /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 12a9ed: 8b 2d 28 b6 17 00 mov 0x17b628,%ebp 12a9f3: 8d 7c 24 58 lea 0x58(%esp),%edi 12a9f7: 3b 2d 2c b6 17 00 cmp 0x17b62c,%ebp 12a9fd: 76 12 jbe 12aa11 <== ALWAYS TAKEN 12a9ff: e9 94 00 00 00 jmp 12aa98 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 12aa04: 45 inc %ebp /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 12aa05: 39 2d 2c b6 17 00 cmp %ebp,0x17b62c 12aa0b: 0f 82 87 00 00 00 jb 12aa98 id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 12aa11: 89 7c 24 04 mov %edi,0x4(%esp) 12aa15: 89 2c 24 mov %ebp,(%esp) 12aa18: e8 73 c6 00 00 call 137090 if ( status != RTEMS_SUCCESSFUL ) 12aa1d: 85 c0 test %eax,%eax 12aa1f: 75 e3 jne 12aa04 #if defined(RTEMS_DEBUG) status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; #else (void) rtems_rate_monotonic_get_status( id, &the_status ); 12aa21: 8d 44 24 40 lea 0x40(%esp),%eax 12aa25: 89 44 24 04 mov %eax,0x4(%esp) 12aa29: 89 2c 24 mov %ebp,(%esp) 12aa2c: e8 6b c8 00 00 call 13729c #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 12aa31: 8d 54 24 33 lea 0x33(%esp),%edx 12aa35: 89 54 24 08 mov %edx,0x8(%esp) 12aa39: c7 44 24 04 05 00 00 movl $0x5,0x4(%esp) 12aa40: 00 12aa41: 8b 44 24 40 mov 0x40(%esp),%eax 12aa45: 89 04 24 mov %eax,(%esp) 12aa48: e8 1f 80 fe ff call 112a6c /* * Print part of report line that is not dependent on granularity */ (*print)( context, 12aa4d: 8b 44 24 5c mov 0x5c(%esp),%eax 12aa51: 89 44 24 14 mov %eax,0x14(%esp) 12aa55: 8b 44 24 58 mov 0x58(%esp),%eax 12aa59: 89 44 24 10 mov %eax,0x10(%esp) "0x%08" PRIx32 " %4s %5" PRId32 " %6" PRId32 " ", id, name, 12aa5d: 8d 44 24 33 lea 0x33(%esp),%eax 12aa61: 89 44 24 0c mov %eax,0xc(%esp) rtems_object_get_name( the_status.owner, sizeof(name), name ); /* * Print part of report line that is not dependent on granularity */ (*print)( context, 12aa65: 89 6c 24 08 mov %ebp,0x8(%esp) 12aa69: c7 44 24 04 c6 b3 15 movl $0x15b3c6,0x4(%esp) 12aa70: 00 12aa71: 89 34 24 mov %esi,(%esp) 12aa74: ff d3 call *%ebx ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 12aa76: 8b 44 24 58 mov 0x58(%esp),%eax 12aa7a: 85 c0 test %eax,%eax 12aa7c: 75 26 jne 12aaa4 (*print)( context, "\n" ); 12aa7e: c7 44 24 04 35 54 15 movl $0x155435,0x4(%esp) 12aa85: 00 12aa86: 89 34 24 mov %esi,(%esp) 12aa89: ff d3 call *%ebx * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 12aa8b: 45 inc %ebp /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 12aa8c: 39 2d 2c b6 17 00 cmp %ebp,0x17b62c 12aa92: 0f 83 79 ff ff ff jae 12aa11 <== ALWAYS TAKEN the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 12aa98: 81 c4 9c 00 00 00 add $0x9c,%esp 12aa9e: 5b pop %ebx 12aa9f: 5e pop %esi 12aaa0: 5f pop %edi 12aaa1: 5d pop %ebp 12aaa2: c3 ret 12aaa3: 90 nop struct timespec cpu_average; struct timespec *min_cpu = &the_stats.min_cpu_time; struct timespec *max_cpu = &the_stats.max_cpu_time; struct timespec *total_cpu = &the_stats.total_cpu_time; _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 12aaa4: 8d 4c 24 38 lea 0x38(%esp),%ecx 12aaa8: 89 4c 24 08 mov %ecx,0x8(%esp) 12aaac: 89 44 24 04 mov %eax,0x4(%esp) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ struct timespec cpu_average; struct timespec *min_cpu = &the_stats.min_cpu_time; struct timespec *max_cpu = &the_stats.max_cpu_time; struct timespec *total_cpu = &the_stats.total_cpu_time; 12aab0: 8d 44 24 70 lea 0x70(%esp),%eax 12aab4: 89 04 24 mov %eax,(%esp) _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 12aab7: 89 4c 24 2c mov %ecx,0x2c(%esp) 12aabb: e8 d8 0a 00 00 call 12b598 <_Timespec_Divide_by_integer> (*print)( context, 12aac0: b8 d3 4d 62 10 mov $0x10624dd3,%eax 12aac5: f7 6c 24 3c imull 0x3c(%esp) 12aac9: c1 fa 06 sar $0x6,%edx 12aacc: 89 54 24 28 mov %edx,0x28(%esp) 12aad0: 8b 44 24 3c mov 0x3c(%esp),%eax 12aad4: 99 cltd 12aad5: 29 54 24 28 sub %edx,0x28(%esp) 12aad9: 8b 54 24 28 mov 0x28(%esp),%edx 12aadd: 89 54 24 1c mov %edx,0x1c(%esp) 12aae1: 8b 44 24 38 mov 0x38(%esp),%eax 12aae5: 89 44 24 18 mov %eax,0x18(%esp) 12aae9: b8 d3 4d 62 10 mov $0x10624dd3,%eax 12aaee: f7 6c 24 6c imull 0x6c(%esp) 12aaf2: c1 fa 06 sar $0x6,%edx 12aaf5: 89 54 24 28 mov %edx,0x28(%esp) 12aaf9: 8b 44 24 6c mov 0x6c(%esp),%eax 12aafd: 99 cltd 12aafe: 29 54 24 28 sub %edx,0x28(%esp) 12ab02: 8b 54 24 28 mov 0x28(%esp),%edx 12ab06: 89 54 24 14 mov %edx,0x14(%esp) 12ab0a: 8b 44 24 68 mov 0x68(%esp),%eax 12ab0e: 89 44 24 10 mov %eax,0x10(%esp) 12ab12: b8 d3 4d 62 10 mov $0x10624dd3,%eax 12ab17: f7 6c 24 64 imull 0x64(%esp) 12ab1b: 89 44 24 20 mov %eax,0x20(%esp) 12ab1f: 89 54 24 24 mov %edx,0x24(%esp) 12ab23: c1 fa 06 sar $0x6,%edx 12ab26: 89 54 24 28 mov %edx,0x28(%esp) 12ab2a: 8b 44 24 64 mov 0x64(%esp),%eax 12ab2e: 99 cltd 12ab2f: 29 54 24 28 sub %edx,0x28(%esp) 12ab33: 8b 54 24 28 mov 0x28(%esp),%edx 12ab37: 89 54 24 0c mov %edx,0xc(%esp) 12ab3b: 8b 44 24 60 mov 0x60(%esp),%eax 12ab3f: 89 44 24 08 mov %eax,0x8(%esp) 12ab43: c7 44 24 04 c0 b4 15 movl $0x15b4c0,0x4(%esp) 12ab4a: 00 12ab4b: 89 34 24 mov %esi,(%esp) 12ab4e: ff d3 call *%ebx struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 12ab50: 8b 4c 24 2c mov 0x2c(%esp),%ecx 12ab54: 89 4c 24 08 mov %ecx,0x8(%esp) 12ab58: 8b 44 24 58 mov 0x58(%esp),%eax 12ab5c: 89 44 24 04 mov %eax,0x4(%esp) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; 12ab60: 8d 84 24 88 00 00 00 lea 0x88(%esp),%eax 12ab67: 89 04 24 mov %eax,(%esp) _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 12ab6a: e8 29 0a 00 00 call 12b598 <_Timespec_Divide_by_integer> (*print)( context, 12ab6f: 8b 4c 24 3c mov 0x3c(%esp),%ecx 12ab73: b8 d3 4d 62 10 mov $0x10624dd3,%eax 12ab78: f7 e9 imul %ecx 12ab7a: 89 54 24 24 mov %edx,0x24(%esp) 12ab7e: 8b 44 24 24 mov 0x24(%esp),%eax 12ab82: c1 f8 06 sar $0x6,%eax 12ab85: c1 f9 1f sar $0x1f,%ecx 12ab88: 29 c8 sub %ecx,%eax 12ab8a: 89 44 24 1c mov %eax,0x1c(%esp) 12ab8e: 8b 44 24 38 mov 0x38(%esp),%eax 12ab92: 89 44 24 18 mov %eax,0x18(%esp) 12ab96: 8b 8c 24 84 00 00 00 mov 0x84(%esp),%ecx 12ab9d: b8 d3 4d 62 10 mov $0x10624dd3,%eax 12aba2: f7 e9 imul %ecx 12aba4: 89 54 24 24 mov %edx,0x24(%esp) 12aba8: 8b 44 24 24 mov 0x24(%esp),%eax 12abac: c1 f8 06 sar $0x6,%eax 12abaf: c1 f9 1f sar $0x1f,%ecx 12abb2: 29 c8 sub %ecx,%eax 12abb4: 89 44 24 14 mov %eax,0x14(%esp) 12abb8: 8b 84 24 80 00 00 00 mov 0x80(%esp),%eax 12abbf: 89 44 24 10 mov %eax,0x10(%esp) 12abc3: 8b 4c 24 7c mov 0x7c(%esp),%ecx 12abc7: b8 d3 4d 62 10 mov $0x10624dd3,%eax 12abcc: f7 e9 imul %ecx 12abce: 89 44 24 20 mov %eax,0x20(%esp) 12abd2: 89 54 24 24 mov %edx,0x24(%esp) 12abd6: 8b 44 24 24 mov 0x24(%esp),%eax 12abda: c1 f8 06 sar $0x6,%eax 12abdd: c1 f9 1f sar $0x1f,%ecx 12abe0: 29 c8 sub %ecx,%eax 12abe2: 89 44 24 0c mov %eax,0xc(%esp) 12abe6: 8b 44 24 78 mov 0x78(%esp),%eax 12abea: 89 44 24 08 mov %eax,0x8(%esp) 12abee: c7 44 24 04 e0 b4 15 movl $0x15b4e0,0x4(%esp) 12abf5: 00 12abf6: 89 34 24 mov %esi,(%esp) 12abf9: ff d3 call *%ebx 12abfb: e9 04 fe ff ff jmp 12aa04 =============================================================================== 0012ac1c : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 12ac1c: 53 push %ebx 12ac1d: 83 ec 18 sub $0x18,%esp * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 12ac20: a1 64 b1 17 00 mov 0x17b164,%eax 12ac25: 40 inc %eax 12ac26: a3 64 b1 17 00 mov %eax,0x17b164 return _Thread_Dispatch_disable_level; 12ac2b: a1 64 b1 17 00 mov 0x17b164,%eax /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 12ac30: 8b 1d 28 b6 17 00 mov 0x17b628,%ebx 12ac36: 3b 1d 2c b6 17 00 cmp 0x17b62c,%ebx 12ac3c: 77 13 ja 12ac51 <== NEVER TAKEN 12ac3e: 66 90 xchg %ax,%ax id <= _Rate_monotonic_Information.maximum_id ; id++ ) { (void) rtems_rate_monotonic_reset_statistics( id ); 12ac40: 89 1c 24 mov %ebx,(%esp) 12ac43: e8 14 00 00 00 call 12ac5c * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 12ac48: 43 inc %ebx /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 12ac49: 39 1d 2c b6 17 00 cmp %ebx,0x17b62c 12ac4f: 73 ef jae 12ac40 /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 12ac51: 83 c4 18 add $0x18,%esp 12ac54: 5b pop %ebx } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 12ac55: e9 16 2e fe ff jmp 10da70 <_Thread_Enable_dispatch> =============================================================================== 0010c9e0 : return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { 10c9e0: 55 push %ebp 10c9e1: 57 push %edi 10c9e2: 56 push %esi 10c9e3: 53 push %ebx 10c9e4: 83 ec 2c sub $0x2c,%esp 10c9e7: 8b 6c 24 40 mov 0x40(%esp),%ebp 10c9eb: 8b 4c 24 44 mov 0x44(%esp),%ecx void *ptr = NULL; rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; 10c9ef: 8b 75 30 mov 0x30(%ebp),%esi #include static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 10c9f2: 89 c8 mov %ecx,%eax 10c9f4: 31 d2 xor %edx,%edx 10c9f6: f7 f6 div %esi if (excess > 0) { 10c9f8: 85 d2 test %edx,%edx 10c9fa: 75 54 jne 10ca50 <== NEVER TAKEN rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { 10c9fc: 89 ce mov %ecx,%esi 10c9fe: 85 c9 test %ecx,%ecx 10ca00: 74 1a je 10ca1c 10ca02: 66 90 xchg %ax,%ax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 10ca04: 8b 7d 00 mov 0x0(%ebp),%edi rtems_chain_control *free_chain, size_t size ) { rtems_chain_node *current = rtems_chain_first(free_chain); const rtems_chain_node *tail = rtems_chain_tail(free_chain); 10ca07: 8d 45 04 lea 0x4(%ebp),%eax rtems_rbheap_chunk *big_enough = NULL; while (current != tail && big_enough == NULL) { 10ca0a: 39 c7 cmp %eax,%edi 10ca0c: 74 0e je 10ca1c rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current; if (free_chunk->size >= size) { 10ca0e: 8b 5f 1c mov 0x1c(%edi),%ebx 10ca11: 39 f3 cmp %esi,%ebx 10ca13: 73 13 jae 10ca28 rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk)); if (chunk != NULL) { rtems_rbheap_add_to_spare_descriptor_chain(control, chunk); } } 10ca15: 8b 3f mov (%edi),%edi { rtems_chain_node *current = rtems_chain_first(free_chain); const rtems_chain_node *tail = rtems_chain_tail(free_chain); rtems_rbheap_chunk *big_enough = NULL; while (current != tail && big_enough == NULL) { 10ca17: 39 f8 cmp %edi,%eax 10ca19: 75 f3 jne 10ca0e <== NEVER TAKEN 10ca1b: 90 nop return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; 10ca1c: 31 c0 xor %eax,%eax } } } return ptr; } 10ca1e: 83 c4 2c add $0x2c,%esp 10ca21: 5b pop %ebx 10ca22: 5e pop %esi 10ca23: 5f pop %edi 10ca24: 5d pop %ebp 10ca25: c3 ret 10ca26: 66 90 xchg %ax,%ax rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size); if (free_chunk != NULL) { uintptr_t free_size = free_chunk->size; if (free_size > aligned_size) { 10ca28: 39 de cmp %ebx,%esi 10ca2a: 72 34 jb 10ca60 ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10ca2c: 8b 17 mov (%edi),%edx previous = the_node->previous; 10ca2e: 8b 47 04 mov 0x4(%edi),%eax next->previous = previous; 10ca31: 89 42 04 mov %eax,0x4(%edx) previous->next = next; 10ca34: 89 10 mov %edx,(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 10ca36: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) 10ca3d: c7 07 00 00 00 00 movl $0x0,(%edi) ptr = (void *) new_chunk->begin; } } else { rtems_chain_extract_unprotected(&free_chunk->chain_node); rtems_chain_set_off_chain(&free_chunk->chain_node); ptr = (void *) free_chunk->begin; 10ca43: 8b 47 18 mov 0x18(%edi),%eax } } } return ptr; } 10ca46: 83 c4 2c add $0x2c,%esp 10ca49: 5b pop %ebx 10ca4a: 5e pop %esi 10ca4b: 5f pop %edi 10ca4c: 5d pop %ebp 10ca4d: c3 ret 10ca4e: 66 90 xchg %ax,%ax static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; if (excess > 0) { value += alignment - excess; 10ca50: 01 ce add %ecx,%esi <== NOT EXECUTED 10ca52: 29 d6 sub %edx,%esi <== NOT EXECUTED rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { 10ca54: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ca56: 74 c4 je 10ca1c <== NOT EXECUTED 10ca58: 39 f1 cmp %esi,%ecx <== NOT EXECUTED 10ca5a: 76 a8 jbe 10ca04 <== NOT EXECUTED return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; 10ca5c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ca5e: eb be jmp 10ca1e <== NOT EXECUTED if (free_chunk != NULL) { uintptr_t free_size = free_chunk->size; if (free_size > aligned_size) { rtems_rbheap_chunk *new_chunk = get_chunk(control); 10ca60: 89 e8 mov %ebp,%eax 10ca62: e8 91 fd ff ff call 10c7f8 10ca67: 89 c2 mov %eax,%edx if (new_chunk != NULL) { 10ca69: 85 c0 test %eax,%eax 10ca6b: 74 af je 10ca1c <== NEVER TAKEN uintptr_t new_free_size = free_size - aligned_size; 10ca6d: 29 f3 sub %esi,%ebx free_chunk->size = new_free_size; 10ca6f: 89 5f 1c mov %ebx,0x1c(%edi) new_chunk->begin = free_chunk->begin + new_free_size; 10ca72: 03 5f 18 add 0x18(%edi),%ebx 10ca75: 89 58 18 mov %ebx,0x18(%eax) new_chunk->size = aligned_size; 10ca78: 89 70 1c mov %esi,0x1c(%eax) 10ca7b: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 10ca82: c7 00 00 00 00 00 movl $0x0,(%eax) static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 10ca88: 8d 40 08 lea 0x8(%eax),%eax 10ca8b: 89 44 24 04 mov %eax,0x4(%esp) void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; 10ca8f: 83 c5 18 add $0x18,%ebp 10ca92: 89 2c 24 mov %ebp,(%esp) static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 10ca95: 89 54 24 1c mov %edx,0x1c(%esp) 10ca99: e8 c6 17 00 00 call 10e264 <_RBTree_Insert_unprotected> free_chunk->size = new_free_size; new_chunk->begin = free_chunk->begin + new_free_size; new_chunk->size = aligned_size; rtems_chain_set_off_chain(&new_chunk->chain_node); insert_into_tree(chunk_tree, new_chunk); ptr = (void *) new_chunk->begin; 10ca9e: 8b 54 24 1c mov 0x1c(%esp),%edx 10caa2: 8b 42 18 mov 0x18(%edx),%eax } } } return ptr; } 10caa5: 83 c4 2c add $0x2c,%esp 10caa8: 5b pop %ebx 10caa9: 5e pop %esi 10caaa: 5f pop %edi 10caab: 5d pop %ebp 10caac: c3 ret =============================================================================== 0010cbc0 : /* Do nothing */ } void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control) { 10cbc0: 53 push %ebx <== NOT EXECUTED 10cbc1: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10cbc4: 8b 5c 24 20 mov 0x20(%esp),%ebx <== NOT EXECUTED rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk)); 10cbc8: c7 04 24 20 00 00 00 movl $0x20,(%esp) <== NOT EXECUTED 10cbcf: e8 2c b7 ff ff call 108300 <== NOT EXECUTED if (chunk != NULL) { 10cbd4: 85 c0 test %eax,%eax <== NOT EXECUTED 10cbd6: 74 11 je 10cbe9 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node); 10cbd8: 8d 53 0c lea 0xc(%ebx),%edx <== NOT EXECUTED 10cbdb: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 10cbde: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED after_node->next = the_node; 10cbe1: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED the_node->next = before_node; 10cbe4: 89 10 mov %edx,(%eax) <== NOT EXECUTED before_node->previous = the_node; 10cbe6: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED rtems_rbheap_add_to_spare_descriptor_chain(control, chunk); } } 10cbe9: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10cbec: 5b pop %ebx <== NOT EXECUTED 10cbed: c3 ret <== NOT EXECUTED =============================================================================== 0010cab0 : _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { 10cab0: 55 push %ebp 10cab1: 57 push %edi 10cab2: 56 push %esi 10cab3: 53 push %ebx 10cab4: 83 ec 4c sub $0x4c,%esp 10cab7: 8b 54 24 64 mov 0x64(%esp),%edx rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { 10cabb: 85 d2 test %edx,%edx 10cabd: 0f 84 dd 00 00 00 je 10cba0 rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; 10cac3: 8b 5c 24 60 mov 0x60(%esp),%ebx 10cac7: 83 c3 18 add $0x18,%ebx #define NULL_PAGE rtems_rbheap_chunk_of_node(NULL) static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key) { rtems_rbheap_chunk chunk = { .begin = key }; 10caca: 8d 7c 24 20 lea 0x20(%esp),%edi 10cace: b9 20 00 00 00 mov $0x20,%ecx 10cad3: 31 c0 xor %eax,%eax 10cad5: f3 aa rep stos %al,%es:(%edi) 10cad7: 89 54 24 38 mov %edx,0x38(%esp) RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; 10cadb: 8b 44 24 60 mov 0x60(%esp),%eax 10cadf: 8b 68 1c mov 0x1c(%eax),%ebp RBTree_Node* found = NULL; int compare_result; while (iter_node) { 10cae2: 85 ed test %ebp,%ebp 10cae4: 0f 84 c2 00 00 00 je 10cbac <== NEVER TAKEN 10caea: 31 f6 xor %esi,%esi 10caec: 8d 7c 24 28 lea 0x28(%esp),%edi compare_result = the_rbtree->compare_function(the_node, iter_node); 10caf0: 89 6c 24 04 mov %ebp,0x4(%esp) return rtems_rbheap_chunk_of_node( 10caf4: 89 3c 24 mov %edi,(%esp) 10caf7: ff 53 10 call *0x10(%ebx) if ( _RBTree_Is_equal( compare_result ) ) { 10cafa: 85 c0 test %eax,%eax 10cafc: 75 08 jne 10cb06 found = iter_node; if ( the_rbtree->is_unique ) 10cafe: 89 ee mov %ebp,%esi 10cb00: 80 7b 14 00 cmpb $0x0,0x14(%ebx) 10cb04: 75 10 jne 10cb16 <== ALWAYS TAKEN RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater( int compare_result ) { return compare_result > 0; 10cb06: 85 c0 test %eax,%eax 10cb08: 0f 9f c0 setg %al 10cb0b: 0f b6 c0 movzbl %al,%eax break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 10cb0e: 8b 6c 85 04 mov 0x4(%ebp,%eax,4),%ebp ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { 10cb12: 85 ed test %ebp,%ebp 10cb14: 75 da jne 10caf0 10cb16: 8d 7e f8 lea -0x8(%esi),%edi if (ptr != NULL) { rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { 10cb19: 83 ff f8 cmp $0xfffffff8,%edi 10cb1c: 0f 84 8a 00 00 00 je 10cbac */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 10cb22: 8b 46 f8 mov -0x8(%esi),%eax 10cb25: 85 c0 test %eax,%eax 10cb27: 74 0d je 10cb36 check_and_merge(free_chain, chunk_tree, chunk, succ); add_to_chain(free_chain, chunk); check_and_merge(free_chain, chunk_tree, chunk, pred); } else { sc = RTEMS_INCORRECT_STATE; 10cb29: b8 0e 00 00 00 mov $0xe,%eax sc = RTEMS_INVALID_ID; } } return sc; } 10cb2e: 83 c4 4c add $0x4c,%esp 10cb31: 5b pop %ebx 10cb32: 5e pop %esi 10cb33: 5f pop %edi 10cb34: 5d pop %ebp 10cb35: c3 ret 10cb36: 8b 6f 04 mov 0x4(%edi),%ebp 10cb39: 85 ed test %ebp,%ebp 10cb3b: 75 ec jne 10cb29 <== NEVER TAKEN static rtems_rbheap_chunk *get_next( const rtems_rbheap_chunk *chunk, RBTree_Direction dir ) { return rtems_rbheap_chunk_of_node( 10cb3d: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10cb44: 00 10cb45: 89 34 24 mov %esi,(%esp) 10cb48: e8 b7 19 00 00 call 10e504 <_RBTree_Next_unprotected> 10cb4d: 89 44 24 1c mov %eax,0x1c(%esp) 10cb51: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 10cb58: 00 10cb59: 89 34 24 mov %esi,(%esp) 10cb5c: e8 a3 19 00 00 call 10e504 <_RBTree_Next_unprotected> 10cb61: 83 e8 08 sub $0x8,%eax if (chunk != NULL_PAGE) { if (!rtems_rbheap_is_chunk_free(chunk)) { rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT); rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT); check_and_merge(free_chain, chunk_tree, chunk, succ); 10cb64: 89 04 24 mov %eax,(%esp) 10cb67: 89 f9 mov %edi,%ecx 10cb69: 89 da mov %ebx,%edx 10cb6b: 8b 44 24 60 mov 0x60(%esp),%eax 10cb6f: e8 d0 fc ff ff call 10c844 Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10cb74: 8b 44 24 60 mov 0x60(%esp),%eax 10cb78: 89 47 04 mov %eax,0x4(%edi) before_node = after_node->next; 10cb7b: 89 c2 mov %eax,%edx 10cb7d: 8b 00 mov (%eax),%eax after_node->next = the_node; 10cb7f: 89 3a mov %edi,(%edx) the_node->next = before_node; 10cb81: 89 07 mov %eax,(%edi) before_node->previous = the_node; 10cb83: 89 78 04 mov %edi,0x4(%eax) static rtems_rbheap_chunk *get_next( const rtems_rbheap_chunk *chunk, RBTree_Direction dir ) { return rtems_rbheap_chunk_of_node( 10cb86: 8b 44 24 1c mov 0x1c(%esp),%eax 10cb8a: 83 e8 08 sub $0x8,%eax rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT); rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT); check_and_merge(free_chain, chunk_tree, chunk, succ); add_to_chain(free_chain, chunk); check_and_merge(free_chain, chunk_tree, chunk, pred); 10cb8d: 89 04 24 mov %eax,(%esp) 10cb90: 89 f9 mov %edi,%ecx 10cb92: 89 da mov %ebx,%edx 10cb94: 8b 44 24 60 mov 0x60(%esp),%eax 10cb98: e8 a7 fc ff ff call 10c844 10cb9d: 8d 76 00 lea 0x0(%esi),%esi } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { rtems_status_code sc = RTEMS_SUCCESSFUL; 10cba0: 31 c0 xor %eax,%eax sc = RTEMS_INVALID_ID; } } return sc; } 10cba2: 83 c4 4c add $0x4c,%esp 10cba5: 5b pop %ebx 10cba6: 5e pop %esi 10cba7: 5f pop %edi 10cba8: 5d pop %ebp 10cba9: c3 ret 10cbaa: 66 90 xchg %ax,%ax check_and_merge(free_chain, chunk_tree, chunk, pred); } else { sc = RTEMS_INCORRECT_STATE; } } else { sc = RTEMS_INVALID_ID; 10cbac: b8 04 00 00 00 mov $0x4,%eax } } return sc; } 10cbb1: 83 c4 4c add $0x4c,%esp 10cbb4: 5b pop %ebx 10cbb5: 5e pop %esi 10cbb6: 5f pop %edi 10cbb7: 5d pop %ebp 10cbb8: c3 ret =============================================================================== 0010c8ac : uintptr_t area_size, uintptr_t alignment, rtems_rbheap_extend_descriptors extend_descriptors, void *handler_arg ) { 10c8ac: 57 push %edi 10c8ad: 56 push %esi 10c8ae: 53 push %ebx 10c8af: 83 ec 10 sub $0x10,%esp 10c8b2: 8b 4c 24 2c mov 0x2c(%esp),%ecx rtems_status_code sc = RTEMS_SUCCESSFUL; if (alignment > 0) { 10c8b6: 85 c9 test %ecx,%ecx 10c8b8: 75 0e jne 10c8c8 } } else { sc = RTEMS_INVALID_ADDRESS; } } else { sc = RTEMS_INVALID_NUMBER; 10c8ba: b8 0a 00 00 00 mov $0xa,%eax } return sc; } 10c8bf: 83 c4 10 add $0x10,%esp 10c8c2: 5b pop %ebx 10c8c3: 5e pop %esi 10c8c4: 5f pop %edi 10c8c5: c3 ret 10c8c6: 66 90 xchg %ax,%ax { rtems_status_code sc = RTEMS_SUCCESSFUL; if (alignment > 0) { uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; 10c8c8: 8b 5c 24 24 mov 0x24(%esp),%ebx 10c8cc: 03 5c 24 28 add 0x28(%esp),%ebx #include static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 10c8d0: 8b 44 24 24 mov 0x24(%esp),%eax 10c8d4: 31 d2 xor %edx,%edx 10c8d6: f7 f1 div %ecx if (excess > 0) { 10c8d8: 85 d2 test %edx,%edx 10c8da: 0f 85 c4 00 00 00 jne 10c9a4 return value; } static uintptr_t align_down(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 10c8e0: 89 d8 mov %ebx,%eax 10c8e2: 31 d2 xor %edx,%edx 10c8e4: f7 f1 div %ecx return value - excess; 10c8e6: 89 df mov %ebx,%edi 10c8e8: 29 d7 sub %edx,%edi uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; uintptr_t aligned_begin = align_up(alignment, begin); uintptr_t aligned_end = align_down(alignment, end); if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) { 10c8ea: 39 5c 24 24 cmp %ebx,0x24(%esp) 10c8ee: 0f 83 b6 00 00 00 jae 10c9aa 10c8f4: 8b 74 24 24 mov 0x24(%esp),%esi 10c8f8: 39 f7 cmp %esi,%edi 10c8fa: 0f 86 aa 00 00 00 jbe 10c9aa RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10c900: 8b 44 24 20 mov 0x20(%esp),%eax 10c904: 83 c0 04 add $0x4,%eax 10c907: 8b 54 24 20 mov 0x20(%esp),%edx 10c90b: 89 02 mov %eax,(%edx) head->next = tail; head->previous = NULL; 10c90d: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) tail->previous = head; 10c914: 89 52 08 mov %edx,0x8(%edx) RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10c917: 89 d0 mov %edx,%eax 10c919: 83 c0 0c add $0xc,%eax 10c91c: 83 c2 10 add $0x10,%edx 10c91f: 8b 5c 24 20 mov 0x20(%esp),%ebx 10c923: 89 53 0c mov %edx,0xc(%ebx) head->next = tail; head->previous = NULL; 10c926: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 10c92d: 89 43 14 mov %eax,0x14(%ebx) RBTree_Control *the_rbtree, RBTree_Compare_function compare_function, bool is_unique ) { the_rbtree->permanent_null = NULL; 10c930: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_rbtree->root = NULL; 10c937: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_rbtree->first[0] = NULL; 10c93e: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) the_rbtree->first[1] = NULL; 10c945: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) the_rbtree->compare_function = compare_function; 10c94c: c7 43 28 e8 c7 10 00 movl $0x10c7e8,0x28(%ebx) the_rbtree->is_unique = is_unique; 10c953: c6 43 2c 01 movb $0x1,0x2c(%ebx) rtems_rbheap_chunk *first = NULL; rtems_chain_initialize_empty(free_chain); rtems_chain_initialize_empty(&control->spare_descriptor_chain); rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true); control->alignment = alignment; 10c957: 89 4b 30 mov %ecx,0x30(%ebx) control->handler_arg = handler_arg; 10c95a: 8b 44 24 34 mov 0x34(%esp),%eax 10c95e: 89 43 38 mov %eax,0x38(%ebx) control->extend_descriptors = extend_descriptors; 10c961: 8b 44 24 30 mov 0x30(%esp),%eax 10c965: 89 43 34 mov %eax,0x34(%ebx) first = get_chunk(control); 10c968: 89 d8 mov %ebx,%eax 10c96a: e8 89 fe ff ff call 10c7f8 if (first != NULL) { 10c96f: 85 c0 test %eax,%eax 10c971: 74 62 je 10c9d5 first->begin = aligned_begin; 10c973: 89 70 18 mov %esi,0x18(%eax) first->size = aligned_end - aligned_begin; 10c976: 29 f7 sub %esi,%edi 10c978: 89 78 1c mov %edi,0x1c(%eax) Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10c97b: 89 58 04 mov %ebx,0x4(%eax) before_node = after_node->next; 10c97e: 8b 13 mov (%ebx),%edx after_node->next = the_node; 10c980: 89 03 mov %eax,(%ebx) the_node->next = before_node; 10c982: 89 10 mov %edx,(%eax) before_node->previous = the_node; 10c984: 89 42 04 mov %eax,0x4(%edx) static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 10c987: 83 c0 08 add $0x8,%eax 10c98a: 89 44 24 04 mov %eax,0x4(%esp) uintptr_t aligned_begin = align_up(alignment, begin); uintptr_t aligned_end = align_down(alignment, end); if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) { rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; 10c98e: 89 d8 mov %ebx,%eax 10c990: 83 c0 18 add $0x18,%eax 10c993: 89 04 24 mov %eax,(%esp) static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 10c996: e8 c9 18 00 00 call 10e264 <_RBTree_Insert_unprotected> uintptr_t alignment, rtems_rbheap_extend_descriptors extend_descriptors, void *handler_arg ) { rtems_status_code sc = RTEMS_SUCCESSFUL; 10c99b: 31 c0 xor %eax,%eax 10c99d: e9 1d ff ff ff jmp 10c8bf 10c9a2: 66 90 xchg %ax,%ax uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; uintptr_t aligned_begin = align_up(alignment, begin); uintptr_t aligned_end = align_down(alignment, end); if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) { 10c9a4: 39 5c 24 24 cmp %ebx,0x24(%esp) 10c9a8: 72 0e jb 10c9b8 insert_into_tree(chunk_tree, first); } else { sc = RTEMS_NO_MEMORY; } } else { sc = RTEMS_INVALID_ADDRESS; 10c9aa: b8 09 00 00 00 mov $0x9,%eax } else { sc = RTEMS_INVALID_NUMBER; } return sc; } 10c9af: 83 c4 10 add $0x10,%esp 10c9b2: 5b pop %ebx 10c9b3: 5e pop %esi 10c9b4: 5f pop %edi 10c9b5: c3 ret 10c9b6: 66 90 xchg %ax,%ax static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; if (excess > 0) { value += alignment - excess; 10c9b8: 8b 74 24 24 mov 0x24(%esp),%esi 10c9bc: 01 ce add %ecx,%esi 10c9be: 29 d6 sub %edx,%esi uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; uintptr_t aligned_begin = align_up(alignment, begin); uintptr_t aligned_end = align_down(alignment, end); if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) { 10c9c0: 39 74 24 24 cmp %esi,0x24(%esp) 10c9c4: 77 e4 ja 10c9aa <== NEVER TAKEN return value; } static uintptr_t align_down(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 10c9c6: 89 d8 mov %ebx,%eax 10c9c8: 31 d2 xor %edx,%edx 10c9ca: f7 f1 div %ecx return value - excess; 10c9cc: 89 df mov %ebx,%edi 10c9ce: 29 d7 sub %edx,%edi 10c9d0: e9 23 ff ff ff jmp 10c8f8 first->begin = aligned_begin; first->size = aligned_end - aligned_begin; add_to_chain(free_chain, first); insert_into_tree(chunk_tree, first); } else { sc = RTEMS_NO_MEMORY; 10c9d5: b8 1a 00 00 00 mov $0x1a,%eax 10c9da: e9 e0 fe ff ff jmp 10c8bf =============================================================================== 0011ac6c : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 11ac6c: 53 push %ebx 11ac6d: 83 ec 28 sub $0x28,%esp 11ac70: 8b 5c 24 34 mov 0x34(%esp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 11ac74: 85 db test %ebx,%ebx 11ac76: 75 0c jne 11ac84 return RTEMS_INVALID_NUMBER; 11ac78: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11ac7d: 83 c4 28 add $0x28,%esp 11ac80: 5b pop %ebx 11ac81: c3 ret 11ac82: 66 90 xchg %ax,%ax ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 11ac84: 8d 44 24 1c lea 0x1c(%esp),%eax 11ac88: 89 44 24 04 mov %eax,0x4(%esp) 11ac8c: 8b 44 24 30 mov 0x30(%esp),%eax 11ac90: 89 04 24 mov %eax,(%esp) 11ac93: e8 ec 43 00 00 call 11f084 <_Thread_Get> switch ( location ) { 11ac98: 8b 54 24 1c mov 0x1c(%esp),%edx 11ac9c: 85 d2 test %edx,%edx 11ac9e: 75 38 jne 11acd8 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 11aca0: 8b 90 e0 00 00 00 mov 0xe0(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 11aca6: 8b 4a 0c mov 0xc(%edx),%ecx 11aca9: 85 c9 test %ecx,%ecx 11acab: 74 35 je 11ace2 if ( asr->is_enabled ) { 11acad: 80 7a 08 00 cmpb $0x0,0x8(%edx) 11acb1: 74 3d je 11acf0 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 11acb3: 9c pushf 11acb4: fa cli 11acb5: 59 pop %ecx *signal_set |= signals; 11acb6: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 11acb9: 51 push %ecx 11acba: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 11acbb: 8b 15 68 dc 14 00 mov 0x14dc68,%edx 11acc1: 85 d2 test %edx,%edx 11acc3: 74 08 je 11accd 11acc5: 3b 05 6c dc 14 00 cmp 0x14dc6c,%eax 11accb: 74 2d je 11acfa <== ALWAYS TAKEN _Thread_Dispatch_necessary = true; } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 11accd: e8 92 43 00 00 call 11f064 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11acd2: 31 c0 xor %eax,%eax 11acd4: eb a7 jmp 11ac7d 11acd6: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11acd8: b8 04 00 00 00 mov $0x4,%eax } 11acdd: 83 c4 28 add $0x28,%esp 11ace0: 5b pop %ebx 11ace1: c3 ret _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 11ace2: e8 7d 43 00 00 call 11f064 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 11ace7: b8 0b 00 00 00 mov $0xb,%eax 11acec: eb 8f jmp 11ac7d 11acee: 66 90 xchg %ax,%ax rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 11acf0: 9c pushf 11acf1: fa cli 11acf2: 58 pop %eax *signal_set |= signals; 11acf3: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 11acf6: 50 push %eax 11acf7: 9d popf 11acf8: eb d3 jmp 11accd if ( ! _ASR_Is_null_handler( asr->handler ) ) { if ( asr->is_enabled ) { _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 11acfa: c6 05 78 dc 14 00 01 movb $0x1,0x14dc78 11ad01: eb ca jmp 11accd =============================================================================== 001274e8 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 1274e8: 57 push %edi 1274e9: 56 push %esi 1274ea: 8b 44 24 0c mov 0xc(%esp),%eax Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 1274ee: 8b 70 08 mov 0x8(%eax),%esi 1274f1: 85 f6 test %esi,%esi 1274f3: 74 15 je 12750a <== NEVER TAKEN return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 1274f5: 8b b8 b4 00 00 00 mov 0xb4(%eax),%edi 1274fb: 83 c7 08 add $0x8,%edi 1274fe: be 6c b5 17 00 mov $0x17b56c,%esi 127503: b9 04 00 00 00 mov $0x4,%ecx 127508: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } 12750a: 5e pop %esi 12750b: 5f pop %edi 12750c: c3 ret =============================================================================== 00127460 : */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) { 127460: 57 push %edi 127461: 53 push %ebx 127462: 8b 54 24 10 mov 0x10(%esp),%edx static uint32_t pattern[ 4 ] = { 0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */ 0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */ }; if ( Stack_check_Initialized ) 127466: 8b 0d 28 a9 17 00 mov 0x17a928,%ecx 12746c: 85 c9 test %ecx,%ecx 12746e: 75 5a jne 1274ca /* * Dope the pattern and fill areas */ p = Stack_check_Pattern.pattern; for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) { p[i] = pattern[ i%4 ]; 127470: c7 05 6c b5 17 00 0d movl $0xfeedf00d,0x17b56c 127477: f0 ed fe 12747a: c7 05 70 b5 17 00 06 movl $0xbad0d06,0x17b570 127481: 0d ad 0b 127484: c7 05 74 b5 17 00 0d movl $0xdeadf00d,0x17b574 12748b: f0 ad de 12748e: c7 05 78 b5 17 00 06 movl $0x600d0d06,0x17b578 127495: 0d 0d 60 /* * If appropriate, setup the interrupt stack for high water testing * also. */ #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) { 127498: 8b 1d c0 b3 17 00 mov 0x17b3c0,%ebx 12749e: 85 db test %ebx,%ebx 1274a0: 74 1e je 1274c0 <== NEVER TAKEN 1274a2: 8b 0d c4 b3 17 00 mov 0x17b3c4,%ecx 1274a8: 85 c9 test %ecx,%ecx 1274aa: 74 14 je 1274c0 <== NEVER TAKEN Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 1274ac: 89 1d 80 b5 17 00 mov %ebx,0x17b580 Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 1274b2: 29 d9 sub %ebx,%ecx 1274b4: 89 0d 7c b5 17 00 mov %ecx,0x17b57c (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 1274ba: b0 a5 mov $0xa5,%al 1274bc: 89 df mov %ebx,%edi 1274be: f3 aa rep stos %al,%es:(%edi) } #endif Stack_check_Initialized = 1; 1274c0: c7 05 28 a9 17 00 01 movl $0x1,0x17a928 1274c7: 00 00 00 Thread_Control *the_thread ) { Stack_check_Initialize(); if (the_thread) 1274ca: 85 d2 test %edx,%edx 1274cc: 74 12 je 1274e0 <== NEVER TAKEN Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 1274ce: 8b 9a b4 00 00 00 mov 0xb4(%edx),%ebx 1274d4: 8b 8a b0 00 00 00 mov 0xb0(%edx),%ecx 1274da: b0 a5 mov $0xa5,%al 1274dc: 89 df mov %ebx,%edi 1274de: f3 aa rep stos %al,%es:(%edi) return true; } 1274e0: b0 01 mov $0x1,%al 1274e2: 5b pop %ebx 1274e3: 5f pop %edi 1274e4: c3 ret =============================================================================== 0012766c : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 12766c: 55 push %ebp 12766d: 89 e5 mov %esp,%ebp 12766f: 56 push %esi 127670: 53 push %ebx 127671: 83 ec 10 sub $0x10,%esp Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 127674: 8b 35 cc b3 17 00 mov 0x17b3cc,%esi ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 12767a: 8b 86 b4 00 00 00 mov 0xb4(%esi),%eax 127680: 39 c5 cmp %eax,%ebp 127682: 73 30 jae 1276b4 <== ALWAYS TAKEN */ bool rtems_stack_checker_is_blown( void ) { Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; bool sp_ok; bool pattern_ok = true; 127684: b2 01 mov $0x1,%dl <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 127686: 83 3d 28 a9 17 00 00 cmpl $0x0,0x17a928 <== NOT EXECUTED 12768d: 74 42 je 1276d1 <== NOT EXECUTED pattern_ok = (!memcmp( 12768f: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp) <== NOT EXECUTED 127696: 00 127697: c7 44 24 04 6c b5 17 movl $0x17b56c,0x4(%esp) <== NOT EXECUTED 12769e: 00 12769f: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 1276a2: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1276a5: e8 0e 6e 01 00 call 13e4b8 <== NOT EXECUTED 1276aa: 85 c0 test %eax,%eax <== NOT EXECUTED 1276ac: 0f 94 c2 sete %dl <== NOT EXECUTED 1276af: eb 20 jmp 1276d1 <== NOT EXECUTED 1276b1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { return false; } if ( sp > (the_stack->area + the_stack->size) ) { 1276b4: 8b 96 b0 00 00 00 mov 0xb0(%esi),%edx 1276ba: 01 c2 add %eax,%edx 1276bc: 39 d5 cmp %edx,%ebp 1276be: 0f 96 c3 setbe %bl /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 1276c1: 8b 15 28 a9 17 00 mov 0x17a928,%edx 1276c7: 85 d2 test %edx,%edx 1276c9: 75 15 jne 1276e0 <== ALWAYS TAKEN */ bool rtems_stack_checker_is_blown( void ) { Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; bool sp_ok; bool pattern_ok = true; 1276cb: b2 01 mov $0x1,%dl <== NOT EXECUTED /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { 1276cd: 84 db test %bl,%bl <== NOT EXECUTED 1276cf: 75 37 jne 127708 <== NOT EXECUTED Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 1276d1: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED 1276d4: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 1276d8: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 1276db: e8 30 fe ff ff call 127510 <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { pattern_ok = (!memcmp( 1276e0: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp) 1276e7: 00 1276e8: c7 44 24 04 6c b5 17 movl $0x17b56c,0x4(%esp) 1276ef: 00 1276f0: 83 c0 08 add $0x8,%eax 1276f3: 89 04 24 mov %eax,(%esp) 1276f6: e8 bd 6d 01 00 call 13e4b8 1276fb: 85 c0 test %eax,%eax 1276fd: 0f 94 c2 sete %dl /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { 127700: 84 db test %bl,%bl 127702: 74 cd je 1276d1 <== NEVER TAKEN 127704: 84 d2 test %dl,%dl 127706: 74 c9 je 1276d1 <== NEVER TAKEN /* * The Stack Pointer and the Pattern Area are OK so return false. */ return false; } 127708: 31 c0 xor %eax,%eax 12770a: 83 c4 10 add $0x10,%esp 12770d: 5b pop %ebx 12770e: 5e pop %esi 12770f: 5d pop %ebp 127710: c3 ret =============================================================================== 00127780 : void rtems_stack_checker_report_usage( void ) { 127780: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 127783: c7 44 24 04 90 98 12 movl $0x129890,0x4(%esp) <== NOT EXECUTED 12778a: 00 12778b: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 127792: e8 7d ff ff ff call 127714 <== NOT EXECUTED } 127797: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED 12779a: c3 ret <== NOT EXECUTED =============================================================================== 00127714 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 127714: 56 push %esi <== NOT EXECUTED 127715: 53 push %ebx <== NOT EXECUTED 127716: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 127719: 8b 74 24 20 mov 0x20(%esp),%esi <== NOT EXECUTED 12771d: 8b 5c 24 24 mov 0x24(%esp),%ebx <== NOT EXECUTED if ( !print ) 127721: 85 db test %ebx,%ebx <== NOT EXECUTED 127723: 74 52 je 127777 <== NOT EXECUTED return; print_context = context; 127725: 89 35 2c a9 17 00 mov %esi,0x17a92c <== NOT EXECUTED print_handler = print; 12772b: 89 1d 30 a9 17 00 mov %ebx,0x17a930 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 127731: c7 44 24 04 13 ae 15 movl $0x15ae13,0x4(%esp) <== NOT EXECUTED 127738: 00 127739: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 12773c: ff d3 call *%ebx <== NOT EXECUTED (*print)( context, 12773e: c7 44 24 04 98 ae 15 movl $0x15ae98,0x4(%esp) <== NOT EXECUTED 127745: 00 127746: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 127749: ff d3 call *%ebx <== NOT EXECUTED " ID NAME LOW HIGH CURRENT AVAILABLE USED\n" ); /* iterate over all threads and dump the usage */ rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage ); 12774b: c7 04 24 dc 72 12 00 movl $0x1272dc,(%esp) <== NOT EXECUTED 127752: e8 8d 3b 00 00 call 12b2e4 <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 127757: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 12775e: e8 79 fb ff ff call 1272dc <== NOT EXECUTED #endif print_context = NULL; 127763: c7 05 2c a9 17 00 00 movl $0x0,0x17a92c <== NOT EXECUTED 12776a: 00 00 00 print_handler = NULL; 12776d: c7 05 30 a9 17 00 00 movl $0x0,0x17a930 <== NOT EXECUTED 127774: 00 00 00 } 127777: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 12777a: 5b pop %ebx <== NOT EXECUTED 12777b: 5e pop %esi <== NOT EXECUTED 12777c: c3 ret <== NOT EXECUTED =============================================================================== 001275f4 : */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) { 1275f4: 55 push %ebp 1275f5: 89 e5 mov %esp,%ebp 1275f7: 53 push %ebx 1275f8: 83 ec 14 sub $0x14,%esp 1275fb: 8b 5d 08 mov 0x8(%ebp),%ebx Stack_Control *the_stack = &running->Start.Initial_stack; void *pattern; bool sp_ok; bool pattern_ok = true; pattern = Stack_check_Get_pattern_area(the_stack); 1275fe: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax 127604: 8d 50 08 lea 0x8(%eax),%edx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 127607: 39 c5 cmp %eax,%ebp 127609: 72 0a jb 127615 <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 12760b: 03 83 b0 00 00 00 add 0xb0(%ebx),%eax 127611: 39 c5 cmp %eax,%ebp 127613: 76 2f jbe 127644 <== ALWAYS TAKEN /* * Check for an out of bounds stack pointer or an overwrite */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); pattern_ok = (!memcmp( pattern, 127615: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp) <== NOT EXECUTED 12761c: 00 12761d: c7 44 24 04 6c b5 17 movl $0x17b56c,0x4(%esp) <== NOT EXECUTED 127624: 00 127625: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 127628: e8 8b 6e 01 00 call 13e4b8 <== NOT EXECUTED 12762d: 85 c0 test %eax,%eax <== NOT EXECUTED 12762f: 0f 94 c0 sete %al <== NOT EXECUTED (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { Stack_check_report_blown_task( running, pattern_ok ); 127632: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 127635: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 127639: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 12763c: e8 cf fe ff ff call 127510 <== NOT EXECUTED 127641: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Check for an out of bounds stack pointer or an overwrite */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); pattern_ok = (!memcmp( pattern, 127644: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp) 12764b: 00 12764c: c7 44 24 04 6c b5 17 movl $0x17b56c,0x4(%esp) 127653: 00 127654: 89 14 24 mov %edx,(%esp) 127657: e8 5c 6e 01 00 call 13e4b8 (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 12765c: 85 c0 test %eax,%eax 12765e: 75 06 jne 127666 <== NEVER TAKEN Stack_check_report_blown_task( running, pattern_ok ); } } 127660: 83 c4 14 add $0x14,%esp 127663: 5b pop %ebx 127664: 5d pop %ebp 127665: c3 ret sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); pattern_ok = (!memcmp( pattern, (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 127666: 31 c0 xor %eax,%eax 127668: eb c8 jmp 127632 <== NOT EXECUTED =============================================================================== 00111454 : rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) { 111454: 53 push %ebx 111455: 83 ec 38 sub $0x38,%esp 111458: 8b 5c 24 44 mov 0x44(%esp),%ebx double result; char *end; if ( !n ) 11145c: 85 db test %ebx,%ebx 11145e: 74 6c je 1114cc return RTEMS_INVALID_ADDRESS; errno = 0; 111460: e8 fb 2a 00 00 call 113f60 <__errno> 111465: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 11146b: c7 03 00 00 00 00 movl $0x0,(%ebx) 111471: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtod( s, &end ); 111478: 8d 44 24 2c lea 0x2c(%esp),%eax 11147c: 89 44 24 04 mov %eax,0x4(%esp) 111480: 8b 44 24 40 mov 0x40(%esp),%eax 111484: 89 04 24 mov %eax,(%esp) 111487: e8 58 57 00 00 call 116be4 if ( endptr ) *endptr = end; 11148c: 8b 44 24 2c mov 0x2c(%esp),%eax errno = 0; *n = 0; result = strtod( s, &end ); if ( endptr ) 111490: 8b 54 24 48 mov 0x48(%esp),%edx 111494: 85 d2 test %edx,%edx 111496: 74 06 je 11149e *endptr = end; 111498: 8b 54 24 48 mov 0x48(%esp),%edx 11149c: 89 02 mov %eax,(%edx) if ( end == s ) 11149e: 39 44 24 40 cmp %eax,0x40(%esp) 1114a2: 74 1c je 1114c0 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1114a4: dd 5c 24 10 fstpl 0x10(%esp) 1114a8: e8 b3 2a 00 00 call 113f60 <__errno> 1114ad: 83 38 22 cmpl $0x22,(%eax) 1114b0: dd 44 24 10 fldl 0x10(%esp) 1114b4: 74 22 je 1114d8 (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) return RTEMS_INVALID_NUMBER; *n = result; 1114b6: dd 1b fstpl (%ebx) return RTEMS_SUCCESSFUL; 1114b8: 31 c0 xor %eax,%eax } 1114ba: 83 c4 38 add $0x38,%esp 1114bd: 5b pop %ebx 1114be: c3 ret 1114bf: 90 nop 1114c0: dd d8 fstp %st(0) if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 1114c2: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1114c7: 83 c4 38 add $0x38,%esp 1114ca: 5b pop %ebx 1114cb: c3 ret { double result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 1114cc: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1114d1: 83 c4 38 add $0x38,%esp 1114d4: 5b pop %ebx 1114d5: c3 ret 1114d6: 66 90 xchg %ax,%ax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1114d8: d9 ee fldz 1114da: d9 c9 fxch %st(1) 1114dc: dd e1 fucom %st(1) 1114de: df e0 fnstsw %ax 1114e0: dd d9 fstp %st(1) 1114e2: 80 e4 45 and $0x45,%ah 1114e5: 80 fc 40 cmp $0x40,%ah 1114e8: 75 16 jne 111500 <== ALWAYS TAKEN 1114ea: dd d8 fstp %st(0) <== NOT EXECUTED 1114ec: eb 0a jmp 1114f8 <== NOT EXECUTED 1114ee: 66 90 xchg %ax,%ax <== NOT EXECUTED 1114f0: dd d8 fstp %st(0) 1114f2: eb 04 jmp 1114f8 1114f4: dd d8 fstp %st(0) 1114f6: 66 90 xchg %ax,%ax (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) return RTEMS_INVALID_NUMBER; 1114f8: b8 0a 00 00 00 mov $0xa,%eax 1114fd: eb bb jmp 1114ba 1114ff: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) 111500: dd 05 30 6a 12 00 fldl 0x126a30 111506: d9 c9 fxch %st(1) 111508: dd e1 fucom %st(1) 11150a: df e0 fnstsw %ax 11150c: dd d9 fstp %st(1) 11150e: f6 c4 45 test $0x45,%ah 111511: 74 dd je 1114f0 111513: dd 05 38 6a 12 00 fldl 0x126a38 111519: dd e9 fucomp %st(1) 11151b: df e0 fnstsw %ax 11151d: f6 c4 45 test $0x45,%ah 111520: 74 d2 je 1114f4 <== ALWAYS TAKEN 111522: eb 92 jmp 1114b6 <== NOT EXECUTED =============================================================================== 00111524 : rtems_status_code rtems_string_to_float ( const char *s, float *n, char **endptr ) { 111524: 53 push %ebx 111525: 83 ec 38 sub $0x38,%esp 111528: 8b 5c 24 44 mov 0x44(%esp),%ebx float result; char *end; if ( !n ) 11152c: 85 db test %ebx,%ebx 11152e: 74 64 je 111594 return RTEMS_INVALID_ADDRESS; errno = 0; 111530: e8 2b 2a 00 00 call 113f60 <__errno> 111535: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 11153b: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtof( s, &end ); 111541: 8d 44 24 2c lea 0x2c(%esp),%eax 111545: 89 44 24 04 mov %eax,0x4(%esp) 111549: 8b 44 24 40 mov 0x40(%esp),%eax 11154d: 89 04 24 mov %eax,(%esp) 111550: e8 b3 56 00 00 call 116c08 if ( endptr ) *endptr = end; 111555: 8b 44 24 2c mov 0x2c(%esp),%eax errno = 0; *n = 0; result = strtof( s, &end ); if ( endptr ) 111559: 8b 54 24 48 mov 0x48(%esp),%edx 11155d: 85 d2 test %edx,%edx 11155f: 74 06 je 111567 *endptr = end; 111561: 8b 54 24 48 mov 0x48(%esp),%edx 111565: 89 02 mov %eax,(%edx) if ( end == s ) 111567: 39 44 24 40 cmp %eax,0x40(%esp) 11156b: 74 1b je 111588 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11156d: d9 5c 24 10 fstps 0x10(%esp) 111571: e8 ea 29 00 00 call 113f60 <__errno> 111576: 83 38 22 cmpl $0x22,(%eax) 111579: d9 44 24 10 flds 0x10(%esp) 11157d: 74 21 je 1115a0 (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) return RTEMS_INVALID_NUMBER; *n = result; 11157f: d9 1b fstps (%ebx) return RTEMS_SUCCESSFUL; 111581: 31 c0 xor %eax,%eax } 111583: 83 c4 38 add $0x38,%esp 111586: 5b pop %ebx 111587: c3 ret 111588: dd d8 fstp %st(0) if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 11158a: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 11158f: 83 c4 38 add $0x38,%esp 111592: 5b pop %ebx 111593: c3 ret { float result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 111594: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 111599: 83 c4 38 add $0x38,%esp 11159c: 5b pop %ebx 11159d: c3 ret 11159e: 66 90 xchg %ax,%ax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1115a0: d9 ee fldz 1115a2: d9 c9 fxch %st(1) 1115a4: dd e1 fucom %st(1) 1115a6: df e0 fnstsw %ax 1115a8: dd d9 fstp %st(1) 1115aa: 80 e4 45 and $0x45,%ah 1115ad: 80 fc 40 cmp $0x40,%ah 1115b0: 75 16 jne 1115c8 <== ALWAYS TAKEN 1115b2: dd d8 fstp %st(0) <== NOT EXECUTED 1115b4: eb 0a jmp 1115c0 <== NOT EXECUTED 1115b6: 66 90 xchg %ax,%ax <== NOT EXECUTED 1115b8: dd d8 fstp %st(0) 1115ba: eb 04 jmp 1115c0 1115bc: dd d8 fstp %st(0) 1115be: 66 90 xchg %ax,%ax (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) return RTEMS_INVALID_NUMBER; 1115c0: b8 0a 00 00 00 mov $0xa,%eax 1115c5: eb bc jmp 111583 1115c7: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) 1115c8: d9 05 40 6a 12 00 flds 0x126a40 1115ce: d9 c9 fxch %st(1) 1115d0: dd e1 fucom %st(1) 1115d2: df e0 fnstsw %ax 1115d4: dd d9 fstp %st(1) 1115d6: f6 c4 45 test $0x45,%ah 1115d9: 74 dd je 1115b8 1115db: d9 05 44 6a 12 00 flds 0x126a44 1115e1: dd e9 fucomp %st(1) 1115e3: df e0 fnstsw %ax 1115e5: f6 c4 45 test $0x45,%ah 1115e8: 74 d2 je 1115bc <== ALWAYS TAKEN 1115ea: eb 93 jmp 11157f <== NOT EXECUTED =============================================================================== 00121700 : const char *s, int *n, char **endptr, int base ) { 121700: 56 push %esi 121701: 53 push %ebx 121702: 83 ec 24 sub $0x24,%esp 121705: 8b 5c 24 34 mov 0x34(%esp),%ebx long result; char *end; if ( !n ) 121709: 85 db test %ebx,%ebx 12170b: 74 67 je 121774 return RTEMS_INVALID_ADDRESS; errno = 0; 12170d: e8 c6 9b 01 00 call 13b2d8 <__errno> 121712: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 121718: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtol( s, &end, base ); 12171e: 8b 44 24 3c mov 0x3c(%esp),%eax 121722: 89 44 24 08 mov %eax,0x8(%esp) 121726: 8d 44 24 1c lea 0x1c(%esp),%eax 12172a: 89 44 24 04 mov %eax,0x4(%esp) 12172e: 8b 44 24 30 mov 0x30(%esp),%eax 121732: 89 04 24 mov %eax,(%esp) 121735: e8 e2 12 02 00 call 142a1c 12173a: 89 c6 mov %eax,%esi if ( endptr ) *endptr = end; 12173c: 8b 54 24 1c mov 0x1c(%esp),%edx errno = 0; *n = 0; result = strtol( s, &end, base ); if ( endptr ) 121740: 8b 44 24 38 mov 0x38(%esp),%eax 121744: 85 c0 test %eax,%eax 121746: 74 06 je 12174e *endptr = end; 121748: 8b 44 24 38 mov 0x38(%esp),%eax 12174c: 89 10 mov %edx,(%eax) if ( end == s ) 12174e: 39 54 24 30 cmp %edx,0x30(%esp) 121752: 74 14 je 121768 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 121754: e8 7f 9b 01 00 call 13b2d8 <__errno> 121759: 83 38 22 cmpl $0x22,(%eax) 12175c: 74 22 je 121780 errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 12175e: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 121760: 31 c0 xor %eax,%eax } 121762: 83 c4 24 add $0x24,%esp 121765: 5b pop %ebx 121766: 5e pop %esi 121767: c3 ret if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 121768: b8 0b 00 00 00 mov $0xb,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 12176d: 83 c4 24 add $0x24,%esp 121770: 5b pop %ebx 121771: 5e pop %esi 121772: c3 ret 121773: 90 nop { long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 121774: b8 09 00 00 00 mov $0x9,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 121779: 83 c4 24 add $0x24,%esp 12177c: 5b pop %ebx 12177d: 5e pop %esi 12177e: c3 ret 12177f: 90 nop *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 121780: 85 f6 test %esi,%esi 121782: 75 08 jne 12178c <== ALWAYS TAKEN (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; 121784: b8 0a 00 00 00 mov $0xa,%eax 121789: eb d7 jmp 121762 12178b: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 12178c: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi 121792: 74 f0 je 121784 121794: 81 fe 00 00 00 80 cmp $0x80000000,%esi 12179a: 75 c2 jne 12175e <== NEVER TAKEN 12179c: eb e6 jmp 121784 =============================================================================== 0011174c : const char *s, long *n, char **endptr, int base ) { 11174c: 56 push %esi 11174d: 53 push %ebx 11174e: 83 ec 24 sub $0x24,%esp 111751: 8b 5c 24 34 mov 0x34(%esp),%ebx long result; char *end; if ( !n ) 111755: 85 db test %ebx,%ebx 111757: 74 67 je 1117c0 return RTEMS_INVALID_ADDRESS; errno = 0; 111759: e8 02 28 00 00 call 113f60 <__errno> 11175e: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 111764: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtol( s, &end, base ); 11176a: 8b 44 24 3c mov 0x3c(%esp),%eax 11176e: 89 44 24 08 mov %eax,0x8(%esp) 111772: 8d 44 24 1c lea 0x1c(%esp),%eax 111776: 89 44 24 04 mov %eax,0x4(%esp) 11177a: 8b 44 24 30 mov 0x30(%esp),%eax 11177e: 89 04 24 mov %eax,(%esp) 111781: e8 96 56 00 00 call 116e1c 111786: 89 c6 mov %eax,%esi if ( endptr ) *endptr = end; 111788: 8b 54 24 1c mov 0x1c(%esp),%edx errno = 0; *n = 0; result = strtol( s, &end, base ); if ( endptr ) 11178c: 8b 44 24 38 mov 0x38(%esp),%eax 111790: 85 c0 test %eax,%eax 111792: 74 06 je 11179a *endptr = end; 111794: 8b 44 24 38 mov 0x38(%esp),%eax 111798: 89 10 mov %edx,(%eax) if ( end == s ) 11179a: 39 54 24 30 cmp %edx,0x30(%esp) 11179e: 74 14 je 1117b4 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1117a0: e8 bb 27 00 00 call 113f60 <__errno> 1117a5: 83 38 22 cmpl $0x22,(%eax) 1117a8: 74 22 je 1117cc (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; *n = result; 1117aa: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 1117ac: 31 c0 xor %eax,%eax } 1117ae: 83 c4 24 add $0x24,%esp 1117b1: 5b pop %ebx 1117b2: 5e pop %esi 1117b3: c3 ret if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 1117b4: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1117b9: 83 c4 24 add $0x24,%esp 1117bc: 5b pop %ebx 1117bd: 5e pop %esi 1117be: c3 ret 1117bf: 90 nop { long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 1117c0: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1117c5: 83 c4 24 add $0x24,%esp 1117c8: 5b pop %ebx 1117c9: 5e pop %esi 1117ca: c3 ret 1117cb: 90 nop *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1117cc: 85 f6 test %esi,%esi 1117ce: 75 08 jne 1117d8 <== ALWAYS TAKEN (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; 1117d0: b8 0a 00 00 00 mov $0xa,%eax 1117d5: eb d7 jmp 1117ae 1117d7: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 1117d8: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi 1117de: 74 f0 je 1117d0 1117e0: 81 fe 00 00 00 80 cmp $0x80000000,%esi 1117e6: 75 c2 jne 1117aa <== NEVER TAKEN 1117e8: eb e6 jmp 1117d0 =============================================================================== 0011168c : const char *s, long long *n, char **endptr, int base ) { 11168c: 56 push %esi 11168d: 53 push %ebx 11168e: 83 ec 34 sub $0x34,%esp 111691: 8b 5c 24 44 mov 0x44(%esp),%ebx long long result; char *end; if ( !n ) 111695: 85 db test %ebx,%ebx 111697: 74 7b je 111714 return RTEMS_INVALID_ADDRESS; errno = 0; 111699: e8 c2 28 00 00 call 113f60 <__errno> 11169e: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 1116a4: c7 03 00 00 00 00 movl $0x0,(%ebx) 1116aa: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtoll( s, &end, base ); 1116b1: 8b 44 24 4c mov 0x4c(%esp),%eax 1116b5: 89 44 24 08 mov %eax,0x8(%esp) 1116b9: 8d 44 24 2c lea 0x2c(%esp),%eax 1116bd: 89 44 24 04 mov %eax,0x4(%esp) 1116c1: 8b 44 24 40 mov 0x40(%esp),%eax 1116c5: 89 04 24 mov %eax,(%esp) 1116c8: e8 7b 57 00 00 call 116e48 1116cd: 89 c6 mov %eax,%esi if ( endptr ) *endptr = end; 1116cf: 8b 4c 24 2c mov 0x2c(%esp),%ecx errno = 0; *n = 0; result = strtoll( s, &end, base ); if ( endptr ) 1116d3: 8b 44 24 48 mov 0x48(%esp),%eax 1116d7: 85 c0 test %eax,%eax 1116d9: 74 06 je 1116e1 *endptr = end; 1116db: 8b 44 24 48 mov 0x48(%esp),%eax 1116df: 89 08 mov %ecx,(%eax) if ( end == s ) 1116e1: 39 4c 24 40 cmp %ecx,0x40(%esp) 1116e5: 74 21 je 111708 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1116e7: 89 54 24 1c mov %edx,0x1c(%esp) 1116eb: e8 70 28 00 00 call 113f60 <__errno> 1116f0: 83 38 22 cmpl $0x22,(%eax) 1116f3: 8b 54 24 1c mov 0x1c(%esp),%edx 1116f7: 74 27 je 111720 (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) return RTEMS_INVALID_NUMBER; *n = result; 1116f9: 89 33 mov %esi,(%ebx) 1116fb: 89 53 04 mov %edx,0x4(%ebx) return RTEMS_SUCCESSFUL; 1116fe: 31 c0 xor %eax,%eax } 111700: 83 c4 34 add $0x34,%esp 111703: 5b pop %ebx 111704: 5e pop %esi 111705: c3 ret 111706: 66 90 xchg %ax,%ax if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 111708: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 11170d: 83 c4 34 add $0x34,%esp 111710: 5b pop %ebx 111711: 5e pop %esi 111712: c3 ret 111713: 90 nop { long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 111714: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 111719: 83 c4 34 add $0x34,%esp 11171c: 5b pop %ebx 11171d: 5e pop %esi 11171e: c3 ret 11171f: 90 nop *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 111720: 89 d0 mov %edx,%eax 111722: 09 f0 or %esi,%eax 111724: 75 0a jne 111730 <== ALWAYS TAKEN (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) return RTEMS_INVALID_NUMBER; 111726: b8 0a 00 00 00 mov $0xa,%eax 11172b: eb d3 jmp 111700 11172d: 8d 76 00 lea 0x0(%esi),%esi if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) 111730: 89 d1 mov %edx,%ecx 111732: 81 f1 ff ff ff 7f xor $0x7fffffff,%ecx 111738: 89 f0 mov %esi,%eax 11173a: f7 d0 not %eax 11173c: 09 c1 or %eax,%ecx 11173e: 74 e6 je 111726 111740: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax 111746: 09 f0 or %esi,%eax 111748: 75 af jne 1116f9 <== NEVER TAKEN 11174a: eb da jmp 111726 =============================================================================== 001217cc : const char *s, unsigned char *n, char **endptr, int base ) { 1217cc: 56 push %esi 1217cd: 53 push %ebx 1217ce: 83 ec 24 sub $0x24,%esp 1217d1: 8b 5c 24 34 mov 0x34(%esp),%ebx unsigned long result; char *end; if ( !n ) 1217d5: 85 db test %ebx,%ebx 1217d7: 74 6f je 121848 return RTEMS_INVALID_ADDRESS; errno = 0; 1217d9: e8 fa 9a 01 00 call 13b2d8 <__errno> 1217de: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 1217e4: c6 03 00 movb $0x0,(%ebx) result = strtoul( s, &end, base ); 1217e7: 8b 44 24 3c mov 0x3c(%esp),%eax 1217eb: 89 44 24 08 mov %eax,0x8(%esp) 1217ef: 8d 44 24 1c lea 0x1c(%esp),%eax 1217f3: 89 44 24 04 mov %eax,0x4(%esp) 1217f7: 8b 44 24 30 mov 0x30(%esp),%eax 1217fb: 89 04 24 mov %eax,(%esp) 1217fe: e8 95 17 02 00 call 142f98 121803: 89 c6 mov %eax,%esi if ( endptr ) *endptr = end; 121805: 8b 54 24 1c mov 0x1c(%esp),%edx errno = 0; *n = 0; result = strtoul( s, &end, base ); if ( endptr ) 121809: 8b 44 24 38 mov 0x38(%esp),%eax 12180d: 85 c0 test %eax,%eax 12180f: 74 06 je 121817 *endptr = end; 121811: 8b 44 24 38 mov 0x38(%esp),%eax 121815: 89 10 mov %edx,(%eax) if ( end == s ) 121817: 39 54 24 30 cmp %edx,0x30(%esp) 12181b: 74 1f je 12183c return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 12181d: e8 b6 9a 01 00 call 13b2d8 <__errno> 121822: 83 38 22 cmpl $0x22,(%eax) 121825: 74 45 je 12186c (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; #if (UCHAR_MAX < ULONG_MAX) if ( result > UCHAR_MAX ) { 121827: 81 fe ff 00 00 00 cmp $0xff,%esi 12182d: 77 25 ja 121854 errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 12182f: 89 f0 mov %esi,%eax 121831: 88 03 mov %al,(%ebx) return RTEMS_SUCCESSFUL; 121833: 31 c0 xor %eax,%eax } 121835: 83 c4 24 add $0x24,%esp 121838: 5b pop %ebx 121839: 5e pop %esi 12183a: c3 ret 12183b: 90 nop if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 12183c: b8 0b 00 00 00 mov $0xb,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 121841: 83 c4 24 add $0x24,%esp 121844: 5b pop %ebx 121845: 5e pop %esi 121846: c3 ret 121847: 90 nop { unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 121848: b8 09 00 00 00 mov $0x9,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 12184d: 83 c4 24 add $0x24,%esp 121850: 5b pop %ebx 121851: 5e pop %esi 121852: c3 ret 121853: 90 nop (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; #if (UCHAR_MAX < ULONG_MAX) if ( result > UCHAR_MAX ) { errno = ERANGE; 121854: e8 7f 9a 01 00 call 13b2d8 <__errno> 121859: c7 00 22 00 00 00 movl $0x22,(%eax) return RTEMS_INVALID_NUMBER; 12185f: b8 0a 00 00 00 mov $0xa,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 121864: 83 c4 24 add $0x24,%esp 121867: 5b pop %ebx 121868: 5e pop %esi 121869: c3 ret 12186a: 66 90 xchg %ax,%ax if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_MAX ))) 12186c: 8d 46 ff lea -0x1(%esi),%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 12186f: 83 f8 fd cmp $0xfffffffd,%eax 121872: 76 b3 jbe 121827 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; 121874: b8 0a 00 00 00 mov $0xa,%eax 121879: eb c6 jmp 121841 =============================================================================== 001118c8 : const char *s, unsigned int *n, char **endptr, int base ) { 1118c8: 56 push %esi 1118c9: 53 push %ebx 1118ca: 83 ec 24 sub $0x24,%esp 1118cd: 8b 5c 24 34 mov 0x34(%esp),%ebx unsigned long result; char *end; if ( !n ) 1118d1: 85 db test %ebx,%ebx 1118d3: 74 67 je 11193c return RTEMS_INVALID_ADDRESS; errno = 0; 1118d5: e8 86 26 00 00 call 113f60 <__errno> 1118da: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 1118e0: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 1118e6: 8b 44 24 3c mov 0x3c(%esp),%eax 1118ea: 89 44 24 08 mov %eax,0x8(%esp) 1118ee: 8d 44 24 1c lea 0x1c(%esp),%eax 1118f2: 89 44 24 04 mov %eax,0x4(%esp) 1118f6: 8b 44 24 30 mov 0x30(%esp),%eax 1118fa: 89 04 24 mov %eax,(%esp) 1118fd: e8 96 5a 00 00 call 117398 111902: 89 c6 mov %eax,%esi if ( endptr ) *endptr = end; 111904: 8b 54 24 1c mov 0x1c(%esp),%edx errno = 0; *n = 0; result = strtoul( s, &end, base ); if ( endptr ) 111908: 8b 44 24 38 mov 0x38(%esp),%eax 11190c: 85 c0 test %eax,%eax 11190e: 74 06 je 111916 *endptr = end; 111910: 8b 44 24 38 mov 0x38(%esp),%eax 111914: 89 10 mov %edx,(%eax) if ( end == s ) 111916: 39 54 24 30 cmp %edx,0x30(%esp) 11191a: 74 14 je 111930 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11191c: e8 3f 26 00 00 call 113f60 <__errno> 111921: 83 38 22 cmpl $0x22,(%eax) 111924: 74 22 je 111948 errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 111926: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 111928: 31 c0 xor %eax,%eax } 11192a: 83 c4 24 add $0x24,%esp 11192d: 5b pop %ebx 11192e: 5e pop %esi 11192f: c3 ret if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 111930: b8 0b 00 00 00 mov $0xb,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 111935: 83 c4 24 add $0x24,%esp 111938: 5b pop %ebx 111939: 5e pop %esi 11193a: c3 ret 11193b: 90 nop { unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 11193c: b8 09 00 00 00 mov $0x9,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 111941: 83 c4 24 add $0x24,%esp 111944: 5b pop %ebx 111945: 5e pop %esi 111946: c3 ret 111947: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_MAX ))) 111948: 8d 46 ff lea -0x1(%esi),%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11194b: 83 f8 fd cmp $0xfffffffd,%eax 11194e: 76 d6 jbe 111926 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; 111950: b8 0a 00 00 00 mov $0xa,%eax 111955: eb d3 jmp 11192a =============================================================================== 0010f6f4 : const char *s, unsigned long *n, char **endptr, int base ) { 10f6f4: 56 push %esi 10f6f5: 53 push %ebx 10f6f6: 83 ec 24 sub $0x24,%esp 10f6f9: 8b 5c 24 34 mov 0x34(%esp),%ebx unsigned long result; char *end; if ( !n ) 10f6fd: 85 db test %ebx,%ebx 10f6ff: 74 67 je 10f768 return RTEMS_INVALID_ADDRESS; errno = 0; 10f701: e8 d2 bb 02 00 call 13b2d8 <__errno> 10f706: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f70c: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 10f712: 8b 44 24 3c mov 0x3c(%esp),%eax 10f716: 89 44 24 08 mov %eax,0x8(%esp) 10f71a: 8d 44 24 1c lea 0x1c(%esp),%eax 10f71e: 89 44 24 04 mov %eax,0x4(%esp) 10f722: 8b 44 24 30 mov 0x30(%esp),%eax 10f726: 89 04 24 mov %eax,(%esp) 10f729: e8 6a 38 03 00 call 142f98 10f72e: 89 c6 mov %eax,%esi if ( endptr ) *endptr = end; 10f730: 8b 54 24 1c mov 0x1c(%esp),%edx errno = 0; *n = 0; result = strtoul( s, &end, base ); if ( endptr ) 10f734: 8b 44 24 38 mov 0x38(%esp),%eax 10f738: 85 c0 test %eax,%eax 10f73a: 74 06 je 10f742 *endptr = end; 10f73c: 8b 44 24 38 mov 0x38(%esp),%eax 10f740: 89 10 mov %edx,(%eax) if ( end == s ) 10f742: 39 54 24 30 cmp %edx,0x30(%esp) 10f746: 74 14 je 10f75c return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f748: e8 8b bb 02 00 call 13b2d8 <__errno> 10f74d: 83 38 22 cmpl $0x22,(%eax) 10f750: 74 22 je 10f774 (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 10f752: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 10f754: 31 c0 xor %eax,%eax } 10f756: 83 c4 24 add $0x24,%esp 10f759: 5b pop %ebx 10f75a: 5e pop %esi 10f75b: c3 ret if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 10f75c: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 10f761: 83 c4 24 add $0x24,%esp 10f764: 5b pop %ebx 10f765: 5e pop %esi 10f766: c3 ret 10f767: 90 nop { unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f768: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 10f76d: 83 c4 24 add $0x24,%esp 10f770: 5b pop %ebx 10f771: 5e pop %esi 10f772: c3 ret 10f773: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_MAX ))) 10f774: 8d 46 ff lea -0x1(%esi),%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f777: 83 f8 fd cmp $0xfffffffd,%eax 10f77a: 76 d6 jbe 10f752 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; 10f77c: b8 0a 00 00 00 mov $0xa,%eax 10f781: eb d3 jmp 10f756 =============================================================================== 00111958 : const char *s, unsigned long long *n, char **endptr, int base ) { 111958: 57 push %edi 111959: 56 push %esi 11195a: 53 push %ebx 11195b: 83 ec 20 sub $0x20,%esp 11195e: 8b 5c 24 34 mov 0x34(%esp),%ebx unsigned long long result; char *end; if ( !n ) 111962: 85 db test %ebx,%ebx 111964: 74 76 je 1119dc return RTEMS_INVALID_ADDRESS; errno = 0; 111966: e8 f5 25 00 00 call 113f60 <__errno> 11196b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 111971: c7 03 00 00 00 00 movl $0x0,(%ebx) 111977: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtoull( s, &end, base ); 11197e: 8b 44 24 3c mov 0x3c(%esp),%eax 111982: 89 44 24 08 mov %eax,0x8(%esp) 111986: 8d 44 24 1c lea 0x1c(%esp),%eax 11198a: 89 44 24 04 mov %eax,0x4(%esp) 11198e: 8b 44 24 30 mov 0x30(%esp),%eax 111992: 89 04 24 mov %eax,(%esp) 111995: e8 2a 5a 00 00 call 1173c4 11199a: 89 c6 mov %eax,%esi 11199c: 89 d7 mov %edx,%edi if ( endptr ) *endptr = end; 11199e: 8b 44 24 1c mov 0x1c(%esp),%eax errno = 0; *n = 0; result = strtoull( s, &end, base ); if ( endptr ) 1119a2: 8b 54 24 38 mov 0x38(%esp),%edx 1119a6: 85 d2 test %edx,%edx 1119a8: 74 06 je 1119b0 *endptr = end; 1119aa: 8b 54 24 38 mov 0x38(%esp),%edx 1119ae: 89 02 mov %eax,(%edx) if ( end == s ) 1119b0: 39 44 24 30 cmp %eax,0x30(%esp) 1119b4: 74 1a je 1119d0 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1119b6: e8 a5 25 00 00 call 113f60 <__errno> 1119bb: 83 38 22 cmpl $0x22,(%eax) 1119be: 74 28 je 1119e8 (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 1119c0: 89 33 mov %esi,(%ebx) 1119c2: 89 7b 04 mov %edi,0x4(%ebx) return RTEMS_SUCCESSFUL; 1119c5: 31 c0 xor %eax,%eax } 1119c7: 83 c4 20 add $0x20,%esp 1119ca: 5b pop %ebx 1119cb: 5e pop %esi 1119cc: 5f pop %edi 1119cd: c3 ret 1119ce: 66 90 xchg %ax,%ax if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 1119d0: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1119d5: 83 c4 20 add $0x20,%esp 1119d8: 5b pop %ebx 1119d9: 5e pop %esi 1119da: 5f pop %edi 1119db: c3 ret { unsigned long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 1119dc: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1119e1: 83 c4 20 add $0x20,%esp 1119e4: 5b pop %ebx 1119e5: 5e pop %esi 1119e6: 5f pop %edi 1119e7: c3 ret if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_LONG_MAX ))) 1119e8: 89 f0 mov %esi,%eax 1119ea: 89 fa mov %edi,%edx 1119ec: 83 c0 ff add $0xffffffff,%eax 1119ef: 83 d2 ff adc $0xffffffff,%edx *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1119f2: 83 fa ff cmp $0xffffffff,%edx 1119f5: 72 c9 jb 1119c0 <== NEVER TAKEN 1119f7: 83 f8 fd cmp $0xfffffffd,%eax 1119fa: 76 c4 jbe 1119c0 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; 1119fc: b8 0a 00 00 00 mov $0xa,%eax 111a01: eb c4 jmp 1119c7 =============================================================================== 001128c8 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 1128c8: 55 push %ebp 1128c9: 57 push %edi 1128ca: 56 push %esi 1128cb: 53 push %ebx 1128cc: 83 ec 0c sub $0xc,%esp ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 1128cf: 8b 4c 24 28 mov 0x28(%esp),%ecx 1128d3: 85 c9 test %ecx,%ecx 1128d5: 0f 84 25 01 00 00 je 112a00 return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 1128db: 8b 35 6c f8 12 00 mov 0x12f86c,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 1128e1: 8b 9e e0 00 00 00 mov 0xe0(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 1128e7: 80 7e 70 01 cmpb $0x1,0x70(%esi) 1128eb: 19 ff sbb %edi,%edi 1128ed: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 1128f3: 8b 56 78 mov 0x78(%esi),%edx 1128f6: 85 d2 test %edx,%edx 1128f8: 0f 85 f6 00 00 00 jne 1129f4 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 1128fe: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 112902: 19 ed sbb %ebp,%ebp 112904: 81 e5 00 04 00 00 and $0x400,%ebp old_mode |= _ISR_Get_level(); 11290a: e8 1d c7 ff ff call 10f02c <_CPU_ISR_Get_level> if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 11290f: 09 e8 or %ebp,%eax old_mode |= _ISR_Get_level(); 112911: 09 f8 or %edi,%eax 112913: 8b 54 24 28 mov 0x28(%esp),%edx 112917: 89 02 mov %eax,(%edx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 112919: f7 44 24 24 00 01 00 testl $0x100,0x24(%esp) 112920: 00 112921: 74 10 je 112933 112923: 8b 44 24 20 mov 0x20(%esp),%eax 112927: c1 e8 08 shr $0x8,%eax 11292a: 83 f0 01 xor $0x1,%eax 11292d: 83 e0 01 and $0x1,%eax 112930: 88 46 70 mov %al,0x70(%esi) executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; if ( mask & RTEMS_TIMESLICE_MASK ) { 112933: f7 44 24 24 00 02 00 testl $0x200,0x24(%esp) 11293a: 00 11293b: 74 1d je 11295a if ( _Modes_Is_timeslice(mode_set) ) { 11293d: f7 44 24 20 00 02 00 testl $0x200,0x20(%esp) 112944: 00 112945: 0f 84 c5 00 00 00 je 112a10 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 11294b: c7 46 78 01 00 00 00 movl $0x1,0x78(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 112952: a1 d8 f5 12 00 mov 0x12f5d8,%eax 112957: 89 46 74 mov %eax,0x74(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 11295a: f6 44 24 24 01 testb $0x1,0x24(%esp) 11295f: 74 0c je 11296d */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 112961: f6 44 24 20 01 testb $0x1,0x20(%esp) 112966: 0f 84 bc 00 00 00 je 112a28 11296c: fa cli * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { 11296d: f7 44 24 24 00 04 00 testl $0x400,0x24(%esp) 112974: 00 112975: 74 41 je 1129b8 is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; 112977: 8b 44 24 20 mov 0x20(%esp),%eax 11297b: c1 e8 0a shr $0xa,%eax 11297e: 83 f0 01 xor $0x1,%eax 112981: 83 e0 01 and $0x1,%eax if ( is_asr_enabled != asr->is_enabled ) { 112984: 38 43 08 cmp %al,0x8(%ebx) 112987: 74 2f je 1129b8 asr->is_enabled = is_asr_enabled; 112989: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 11298c: 9c pushf 11298d: fa cli 11298e: 58 pop %eax _signals = information->signals_pending; 11298f: 8b 4b 18 mov 0x18(%ebx),%ecx information->signals_pending = information->signals_posted; 112992: 8b 53 14 mov 0x14(%ebx),%edx 112995: 89 53 18 mov %edx,0x18(%ebx) information->signals_posted = _signals; 112998: 89 4b 14 mov %ecx,0x14(%ebx) _ISR_Enable( _level ); 11299b: 50 push %eax 11299c: 9d popf _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 11299d: 8b 43 14 mov 0x14(%ebx),%eax 1129a0: 85 c0 test %eax,%eax 1129a2: 0f 95 c0 setne %al needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 1129a5: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760 1129ac: 74 15 je 1129c3 <== ALWAYS TAKEN if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; 1129ae: 31 c0 xor %eax,%eax } 1129b0: 83 c4 0c add $0xc,%esp 1129b3: 5b pop %ebx 1129b4: 5e pop %esi 1129b5: 5f pop %edi 1129b6: 5d pop %ebp 1129b7: c3 ret /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 1129b8: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 1129ba: 83 3d 60 f7 12 00 03 cmpl $0x3,0x12f760 1129c1: 75 eb jne 1129ae bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 1129c3: 8b 15 6c f8 12 00 mov 0x12f86c,%edx if ( are_signals_pending || 1129c9: 84 c0 test %al,%al 1129cb: 75 0e jne 1129db 1129cd: 3b 15 70 f8 12 00 cmp 0x12f870,%edx 1129d3: 74 d9 je 1129ae (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 1129d5: 80 7a 70 00 cmpb $0x0,0x70(%edx) 1129d9: 74 d3 je 1129ae <== NEVER TAKEN _Thread_Dispatch_necessary = true; 1129db: c6 05 78 f8 12 00 01 movb $0x1,0x12f878 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 1129e2: e8 5d b2 ff ff call 10dc44 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 1129e7: 31 c0 xor %eax,%eax } 1129e9: 83 c4 0c add $0xc,%esp 1129ec: 5b pop %ebx 1129ed: 5e pop %esi 1129ee: 5f pop %edi 1129ef: 5d pop %ebp 1129f0: c3 ret 1129f1: 8d 76 00 lea 0x0(%esi),%esi old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 1129f4: 81 cf 00 02 00 00 or $0x200,%edi 1129fa: e9 ff fe ff ff jmp 1128fe 1129ff: 90 nop bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) return RTEMS_INVALID_ADDRESS; 112a00: b8 09 00 00 00 mov $0x9,%eax if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; } 112a05: 83 c4 0c add $0xc,%esp 112a08: 5b pop %ebx 112a09: 5e pop %esi 112a0a: 5f pop %edi 112a0b: 5d pop %ebp 112a0c: c3 ret 112a0d: 8d 76 00 lea 0x0(%esi),%esi if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 112a10: c7 46 78 00 00 00 00 movl $0x0,0x78(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 112a17: f6 44 24 24 01 testb $0x1,0x24(%esp) 112a1c: 0f 84 4b ff ff ff je 11296d 112a22: e9 3a ff ff ff jmp 112961 112a27: 90 nop 112a28: fb sti 112a29: e9 3f ff ff ff jmp 11296d =============================================================================== 0010f99c : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10f99c: 53 push %ebx 10f99d: 83 ec 28 sub $0x28,%esp 10f9a0: 8b 5c 24 34 mov 0x34(%esp),%ebx register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10f9a4: 85 db test %ebx,%ebx 10f9a6: 74 0b je 10f9b3 RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 10f9a8: 0f b6 05 ac 01 13 00 movzbl 0x1301ac,%eax */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10f9af: 39 c3 cmp %eax,%ebx 10f9b1: 77 79 ja 10fa2c !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10f9b3: 8b 44 24 38 mov 0x38(%esp),%eax 10f9b7: 85 c0 test %eax,%eax 10f9b9: 74 59 je 10fa14 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10f9bb: 8d 44 24 1c lea 0x1c(%esp),%eax 10f9bf: 89 44 24 04 mov %eax,0x4(%esp) 10f9c3: 8b 44 24 30 mov 0x30(%esp),%eax 10f9c7: 89 04 24 mov %eax,(%esp) 10f9ca: e8 f1 20 00 00 call 111ac0 <_Thread_Get> switch ( location ) { 10f9cf: 8b 4c 24 1c mov 0x1c(%esp),%ecx 10f9d3: 85 c9 test %ecx,%ecx 10f9d5: 75 49 jne 10fa20 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10f9d7: 8b 50 14 mov 0x14(%eax),%edx 10f9da: 8b 4c 24 38 mov 0x38(%esp),%ecx 10f9de: 89 11 mov %edx,(%ecx) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10f9e0: 85 db test %ebx,%ebx 10f9e2: 74 23 je 10fa07 the_thread->real_priority = new_priority; 10f9e4: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10f9e7: 8b 50 1c mov 0x1c(%eax),%edx 10f9ea: 85 d2 test %edx,%edx 10f9ec: 74 05 je 10f9f3 10f9ee: 3b 58 14 cmp 0x14(%eax),%ebx 10f9f1: 73 14 jae 10fa07 <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10f9f3: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10f9fa: 00 10f9fb: 89 5c 24 04 mov %ebx,0x4(%esp) 10f9ff: 89 04 24 mov %eax,(%esp) 10fa02: e8 2d 1c 00 00 call 111634 <_Thread_Change_priority> } _Thread_Enable_dispatch(); 10fa07: e8 94 20 00 00 call 111aa0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10fa0c: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa0e: 83 c4 28 add $0x28,%esp 10fa11: 5b pop %ebx 10fa12: c3 ret 10fa13: 90 nop if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10fa14: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa19: 83 c4 28 add $0x28,%esp 10fa1c: 5b pop %ebx 10fa1d: c3 ret 10fa1e: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10fa20: b8 04 00 00 00 mov $0x4,%eax } 10fa25: 83 c4 28 add $0x28,%esp 10fa28: 5b pop %ebx 10fa29: c3 ret 10fa2a: 66 90 xchg %ax,%ax register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10fa2c: b8 13 00 00 00 mov $0x13,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa31: 83 c4 28 add $0x28,%esp 10fa34: 5b pop %ebx 10fa35: c3 ret =============================================================================== 00107c60 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 107c60: 53 push %ebx 107c61: 83 ec 28 sub $0x28,%esp 107c64: 8b 5c 24 34 mov 0x34(%esp),%ebx Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 107c68: 85 db test %ebx,%ebx 107c6a: 74 58 je 107cc4 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 107c6c: 8d 44 24 1c lea 0x1c(%esp),%eax 107c70: 89 44 24 04 mov %eax,0x4(%esp) 107c74: 8b 44 24 30 mov 0x30(%esp),%eax 107c78: 89 04 24 mov %eax,(%esp) 107c7b: e8 50 1c 00 00 call 1098d0 <_Thread_Get> switch (location) { 107c80: 8b 54 24 1c mov 0x1c(%esp),%edx 107c84: 85 d2 test %edx,%edx 107c86: 75 30 jne 107cb8 case OBJECTS_LOCAL: tvp = the_thread->task_variables; 107c88: 8b 88 ec 00 00 00 mov 0xec(%eax),%ecx while (tvp) { 107c8e: 85 c9 test %ecx,%ecx 107c90: 74 17 je 107ca9 if (tvp->ptr == ptr) { 107c92: 39 59 04 cmp %ebx,0x4(%ecx) 107c95: 75 0c jne 107ca3 107c97: eb 50 jmp 107ce9 107c99: 8d 76 00 lea 0x0(%esi),%esi 107c9c: 39 5a 04 cmp %ebx,0x4(%edx) 107c9f: 74 2f je 107cd0 107ca1: 89 d1 mov %edx,%ecx _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 107ca3: 8b 11 mov (%ecx),%edx the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 107ca5: 85 d2 test %edx,%edx 107ca7: 75 f3 jne 107c9c <== ALWAYS TAKEN return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 107ca9: e8 02 1c 00 00 call 1098b0 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 107cae: b8 09 00 00 00 mov $0x9,%eax 107cb3: eb 08 jmp 107cbd 107cb5: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 107cb8: b8 04 00 00 00 mov $0x4,%eax } 107cbd: 83 c4 28 add $0x28,%esp 107cc0: 5b pop %ebx 107cc1: c3 ret 107cc2: 66 90 xchg %ax,%ax Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 107cc4: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 107cc9: 83 c4 28 add $0x28,%esp 107ccc: 5b pop %ebx 107ccd: c3 ret 107cce: 66 90 xchg %ax,%ax case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 107cd0: 8b 1a mov (%edx),%ebx 107cd2: 89 19 mov %ebx,(%ecx) else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 107cd4: 89 54 24 04 mov %edx,0x4(%esp) 107cd8: 89 04 24 mov %eax,(%esp) 107cdb: e8 98 00 00 00 call 107d78 <_RTEMS_Tasks_Invoke_task_variable_dtor> _Thread_Enable_dispatch(); 107ce0: e8 cb 1b 00 00 call 1098b0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 107ce5: 31 c0 xor %eax,%eax 107ce7: eb d4 jmp 107cbd while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 107ce9: 8b 11 mov (%ecx),%edx 107ceb: 89 90 ec 00 00 00 mov %edx,0xec(%eax) 107cf1: 89 ca mov %ecx,%edx 107cf3: eb df jmp 107cd4 =============================================================================== 00107cf8 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 107cf8: 53 push %ebx 107cf9: 83 ec 28 sub $0x28,%esp 107cfc: 8b 5c 24 34 mov 0x34(%esp),%ebx Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 107d00: 85 db test %ebx,%ebx 107d02: 74 50 je 107d54 return RTEMS_INVALID_ADDRESS; if ( !result ) 107d04: 8b 4c 24 38 mov 0x38(%esp),%ecx 107d08: 85 c9 test %ecx,%ecx 107d0a: 74 48 je 107d54 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 107d0c: 8d 44 24 1c lea 0x1c(%esp),%eax 107d10: 89 44 24 04 mov %eax,0x4(%esp) 107d14: 8b 44 24 30 mov 0x30(%esp),%eax 107d18: 89 04 24 mov %eax,(%esp) 107d1b: e8 b0 1b 00 00 call 1098d0 <_Thread_Get> switch (location) { 107d20: 8b 54 24 1c mov 0x1c(%esp),%edx 107d24: 85 d2 test %edx,%edx 107d26: 75 38 jne 107d60 case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 107d28: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax while (tvp) { 107d2e: 85 c0 test %eax,%eax 107d30: 75 08 jne 107d3a 107d32: eb 38 jmp 107d6c */ *result = tvp->tval; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 107d34: 8b 00 mov (%eax),%eax case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 107d36: 85 c0 test %eax,%eax 107d38: 74 32 je 107d6c <== NEVER TAKEN if (tvp->ptr == ptr) { 107d3a: 39 58 04 cmp %ebx,0x4(%eax) 107d3d: 75 f5 jne 107d34 /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 107d3f: 8b 40 0c mov 0xc(%eax),%eax 107d42: 8b 54 24 38 mov 0x38(%esp),%edx 107d46: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 107d48: e8 63 1b 00 00 call 1098b0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 107d4d: 31 c0 xor %eax,%eax 107d4f: eb 08 jmp 107d59 107d51: 8d 76 00 lea 0x0(%esi),%esi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 107d54: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 107d59: 83 c4 28 add $0x28,%esp 107d5c: 5b pop %ebx 107d5d: c3 ret 107d5e: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 107d60: b8 04 00 00 00 mov $0x4,%eax } 107d65: 83 c4 28 add $0x28,%esp 107d68: 5b pop %ebx 107d69: c3 ret 107d6a: 66 90 xchg %ax,%ax _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 107d6c: e8 3f 1b 00 00 call 1098b0 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 107d71: b8 09 00 00 00 mov $0x9,%eax 107d76: eb e1 jmp 107d59 =============================================================================== 0010a530 : #include int rtems_termios_baud_to_index( rtems_termios_baud_t termios_baud ) { 10a530: 8b 44 24 04 mov 0x4(%esp),%eax int baud_index; switch (termios_baud) { 10a534: 83 f8 09 cmp $0x9,%eax 10a537: 0f 84 03 01 00 00 je 10a640 10a53d: 76 35 jbe 10a574 10a53f: 83 f8 0e cmp $0xe,%eax 10a542: 0f 84 08 01 00 00 je 10a650 10a548: 76 52 jbe 10a59c 10a54a: 3d 02 10 00 00 cmp $0x1002,%eax 10a54f: 0f 84 db 00 00 00 je 10a630 10a555: 0f 86 8d 00 00 00 jbe 10a5e8 10a55b: 3d 03 10 00 00 cmp $0x1003,%eax 10a560: 0f 84 d2 00 00 00 je 10a638 10a566: 3d 04 10 00 00 cmp $0x1004,%eax 10a56b: 75 60 jne 10a5cd case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; case B230400: baud_index = 18; break; case B460800: baud_index = 19; break; 10a56d: b8 13 00 00 00 mov $0x13,%eax 10a572: c3 ret 10a573: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10a574: 83 f8 04 cmp $0x4,%eax 10a577: 0f 84 cb 00 00 00 je 10a648 10a57d: 76 3d jbe 10a5bc 10a57f: 83 f8 06 cmp $0x6,%eax 10a582: 74 7c je 10a600 10a584: 72 4e jb 10a5d4 10a586: 83 f8 07 cmp $0x7,%eax 10a589: 0f 84 89 00 00 00 je 10a618 10a58f: 83 f8 08 cmp $0x8,%eax 10a592: 75 39 jne 10a5cd <== NEVER TAKEN case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; 10a594: b8 08 00 00 00 mov $0x8,%eax 10a599: c3 ret 10a59a: 66 90 xchg %ax,%ax rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10a59c: 83 f8 0b cmp $0xb,%eax 10a59f: 0f 84 83 00 00 00 je 10a628 10a5a5: 72 39 jb 10a5e0 10a5a7: 83 f8 0c cmp $0xc,%eax 10a5aa: 0f 84 a8 00 00 00 je 10a658 10a5b0: 83 f8 0d cmp $0xd,%eax 10a5b3: 75 18 jne 10a5cd <== NEVER TAKEN case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; 10a5b5: b8 0d 00 00 00 mov $0xd,%eax 10a5ba: c3 ret 10a5bb: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10a5bc: 83 f8 01 cmp $0x1,%eax 10a5bf: 74 5f je 10a620 10a5c1: 72 19 jb 10a5dc 10a5c3: 83 f8 02 cmp $0x2,%eax 10a5c6: 74 48 je 10a610 10a5c8: 83 f8 03 cmp $0x3,%eax 10a5cb: 74 2d je 10a5fa <== ALWAYS TAKEN case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; case B230400: baud_index = 18; break; case B460800: baud_index = 19; break; default: baud_index = -1; break; 10a5cd: b8 ff ff ff ff mov $0xffffffff,%eax 10a5d2: c3 ret 10a5d3: 90 nop case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; 10a5d4: b8 05 00 00 00 mov $0x5,%eax 10a5d9: c3 ret 10a5da: 66 90 xchg %ax,%ax ) { int baud_index; switch (termios_baud) { case B0: baud_index = 0; break; 10a5dc: 31 c0 xor %eax,%eax 10a5de: c3 ret 10a5df: 90 nop case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; 10a5e0: b8 0a 00 00 00 mov $0xa,%eax 10a5e5: c3 ret 10a5e6: 66 90 xchg %ax,%ax rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10a5e8: 83 f8 0f cmp $0xf,%eax 10a5eb: 74 1b je 10a608 10a5ed: 3d 01 10 00 00 cmp $0x1001,%eax 10a5f2: 75 d9 jne 10a5cd <== NEVER TAKEN case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; 10a5f4: b8 10 00 00 00 mov $0x10,%eax 10a5f9: c3 ret switch (termios_baud) { case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; 10a5fa: b8 03 00 00 00 mov $0x3,%eax 10a5ff: c3 ret case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; 10a600: b8 06 00 00 00 mov $0x6,%eax 10a605: c3 ret 10a606: 66 90 xchg %ax,%ax case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; 10a608: b8 0f 00 00 00 mov $0xf,%eax 10a60d: c3 ret 10a60e: 66 90 xchg %ax,%ax int baud_index; switch (termios_baud) { case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; 10a610: b8 02 00 00 00 mov $0x2,%eax 10a615: c3 ret 10a616: 66 90 xchg %ax,%ax case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; 10a618: b8 07 00 00 00 mov $0x7,%eax 10a61d: c3 ret 10a61e: 66 90 xchg %ax,%ax { int baud_index; switch (termios_baud) { case B0: baud_index = 0; break; case B50: baud_index = 1; break; 10a620: b8 01 00 00 00 mov $0x1,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 10a625: c3 ret 10a626: 66 90 xchg %ax,%ax case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; 10a628: b8 0b 00 00 00 mov $0xb,%eax 10a62d: c3 ret 10a62e: 66 90 xchg %ax,%ax case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; 10a630: b8 11 00 00 00 mov $0x11,%eax 10a635: c3 ret 10a636: 66 90 xchg %ax,%ax case B230400: baud_index = 18; break; 10a638: b8 12 00 00 00 mov $0x12,%eax 10a63d: c3 ret 10a63e: 66 90 xchg %ax,%ax case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; 10a640: b8 09 00 00 00 mov $0x9,%eax 10a645: c3 ret 10a646: 66 90 xchg %ax,%ax switch (termios_baud) { case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; 10a648: b8 04 00 00 00 mov $0x4,%eax 10a64d: c3 ret 10a64e: 66 90 xchg %ax,%ax case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; 10a650: b8 0e 00 00 00 mov $0xe,%eax 10a655: c3 ret 10a656: 66 90 xchg %ax,%ax case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; 10a658: b8 0c 00 00 00 mov $0xc,%eax 10a65d: c3 ret =============================================================================== 00109aa8 : } } rtems_status_code rtems_termios_close (void *arg) { 109aa8: 56 push %esi 109aa9: 53 push %ebx 109aaa: 83 ec 14 sub $0x14,%esp 109aad: 8b 74 24 20 mov 0x20(%esp),%esi rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 109ab1: 8b 06 mov (%esi),%eax 109ab3: 8b 58 2c mov 0x2c(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain( 109ab6: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 109abd: 00 109abe: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 109ac5: 00 109ac6: a1 2c f5 12 00 mov 0x12f52c,%eax 109acb: 89 04 24 mov %eax,(%esp) 109ace: e8 a9 1e 00 00 call 10b97c rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 109ad3: 85 c0 test %eax,%eax 109ad5: 0f 85 a1 01 00 00 jne 109c7c <== NEVER TAKEN rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 109adb: ff 4b 08 decl 0x8(%ebx) 109ade: 0f 85 c3 00 00 00 jne 109ba7 if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 109ae4: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109aea: c1 e0 05 shl $0x5,%eax 109aed: 8b 80 a4 f1 12 00 mov 0x12f1a4(%eax),%eax 109af3: 85 c0 test %eax,%eax 109af5: 0f 84 01 01 00 00 je 109bfc /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 109afb: 89 1c 24 mov %ebx,(%esp) 109afe: ff d0 call *%eax } drainOutput (tty); rtems_semaphore_release (tty->osem); } if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 109b00: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 109b07: 0f 84 37 01 00 00 je 109c44 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT ); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if (tty->device.lastClose) 109b0d: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 109b13: 85 c0 test %eax,%eax 109b15: 74 13 je 109b2a (*tty->device.lastClose)(tty->major, tty->minor, arg); 109b17: 89 74 24 08 mov %esi,0x8(%esp) 109b1b: 8b 53 10 mov 0x10(%ebx),%edx 109b1e: 89 54 24 04 mov %edx,0x4(%esp) 109b22: 8b 53 0c mov 0xc(%ebx),%edx 109b25: 89 14 24 mov %edx,(%esp) 109b28: ff d0 call *%eax if (tty->forw == NULL) { 109b2a: 8b 03 mov (%ebx),%eax rtems_termios_ttyTail = tty->back; 109b2c: 8b 53 04 mov 0x4(%ebx),%edx if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if (tty->device.lastClose) (*tty->device.lastClose)(tty->major, tty->minor, arg); if (tty->forw == NULL) { 109b2f: 85 c0 test %eax,%eax 109b31: 0f 84 a9 00 00 00 je 109be0 rtems_termios_ttyTail = tty->back; if ( rtems_termios_ttyTail != NULL ) { rtems_termios_ttyTail->forw = NULL; } } else { tty->forw->back = tty->back; 109b37: 89 50 04 mov %edx,0x4(%eax) 109b3a: 8b 53 04 mov 0x4(%ebx),%edx } if (tty->back == NULL) { 109b3d: 85 d2 test %edx,%edx 109b3f: 0f 84 87 00 00 00 je 109bcc <== ALWAYS TAKEN rtems_termios_ttyHead = tty->forw; if ( rtems_termios_ttyHead != NULL ) { rtems_termios_ttyHead->back = NULL; } } else { tty->back->forw = tty->forw; 109b45: 89 02 mov %eax,(%edx) <== NOT EXECUTED } rtems_semaphore_delete (tty->isem); 109b47: 8b 43 14 mov 0x14(%ebx),%eax 109b4a: 89 04 24 mov %eax,(%esp) 109b4d: e8 52 1d 00 00 call 10b8a4 rtems_semaphore_delete (tty->osem); 109b52: 8b 43 18 mov 0x18(%ebx),%eax 109b55: 89 04 24 mov %eax,(%esp) 109b58: e8 47 1d 00 00 call 10b8a4 rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 109b5d: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 109b63: 89 04 24 mov %eax,(%esp) 109b66: e8 39 1d 00 00 call 10b8a4 if ((tty->device.pollRead == NULL) || 109b6b: 8b 8b a0 00 00 00 mov 0xa0(%ebx),%ecx 109b71: 85 c9 test %ecx,%ecx 109b73: 74 47 je 109bbc 109b75: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 109b7c: 74 3e je 109bbc (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); free (tty->rawInBuf.theBuf); 109b7e: 8b 43 58 mov 0x58(%ebx),%eax 109b81: 89 04 24 mov %eax,(%esp) 109b84: e8 b3 dd ff ff call 10793c free (tty->rawOutBuf.theBuf); 109b89: 8b 43 7c mov 0x7c(%ebx),%eax 109b8c: 89 04 24 mov %eax,(%esp) 109b8f: e8 a8 dd ff ff call 10793c free (tty->cbuf); 109b94: 8b 43 1c mov 0x1c(%ebx),%eax 109b97: 89 04 24 mov %eax,(%esp) 109b9a: e8 9d dd ff ff call 10793c free (tty); 109b9f: 89 1c 24 mov %ebx,(%esp) 109ba2: e8 95 dd ff ff call 10793c } rtems_semaphore_release (rtems_termios_ttyMutex); 109ba7: a1 2c f5 12 00 mov 0x12f52c,%eax 109bac: 89 04 24 mov %eax,(%esp) 109baf: e8 f4 1e 00 00 call 10baa8 return RTEMS_SUCCESSFUL; } 109bb4: 31 c0 xor %eax,%eax 109bb6: 83 c4 14 add $0x14,%esp 109bb9: 5b pop %ebx 109bba: 5e pop %esi 109bbb: c3 ret rtems_semaphore_delete (tty->isem); rtems_semaphore_delete (tty->osem); rtems_semaphore_delete (tty->rawOutBuf.Semaphore); if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); 109bbc: 8b 43 68 mov 0x68(%ebx),%eax 109bbf: 89 04 24 mov %eax,(%esp) 109bc2: e8 dd 1c 00 00 call 10b8a4 109bc7: eb b5 jmp 109b7e 109bc9: 8d 76 00 lea 0x0(%esi),%esi } else { tty->forw->back = tty->back; } if (tty->back == NULL) { rtems_termios_ttyHead = tty->forw; 109bcc: a3 34 f5 12 00 mov %eax,0x12f534 if ( rtems_termios_ttyHead != NULL ) { rtems_termios_ttyHead->back = NULL; 109bd1: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 109bd8: e9 6a ff ff ff jmp 109b47 109bdd: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred (sc); } if (tty->device.lastClose) (*tty->device.lastClose)(tty->major, tty->minor, arg); if (tty->forw == NULL) { rtems_termios_ttyTail = tty->back; 109be0: 89 15 30 f5 12 00 mov %edx,0x12f530 if ( rtems_termios_ttyTail != NULL ) { 109be6: 85 d2 test %edx,%edx 109be8: 0f 84 96 00 00 00 je 109c84 <== ALWAYS TAKEN rtems_termios_ttyTail->forw = NULL; 109bee: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED 109bf4: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 109bf6: e9 4a ff ff ff jmp 109b45 <== NOT EXECUTED 109bfb: 90 nop <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_close(tty); } else { /* * default: just flush output buffer */ sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 109bfc: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 109c03: 00 109c04: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 109c0b: 00 109c0c: 8b 43 18 mov 0x18(%ebx),%eax 109c0f: 89 04 24 mov %eax,(%esp) 109c12: e8 65 1d 00 00 call 10b97c if (sc != RTEMS_SUCCESSFUL) { 109c17: 85 c0 test %eax,%eax 109c19: 75 61 jne 109c7c <== NEVER TAKEN drainOutput (struct rtems_termios_tty *tty) { rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 109c1b: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax 109c21: 85 c0 test %eax,%eax 109c23: 74 07 je 109c2c 109c25: 89 d8 mov %ebx,%eax 109c27: e8 a0 f9 ff ff call 1095cc sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { rtems_fatal_error_occurred (sc); } drainOutput (tty); rtems_semaphore_release (tty->osem); 109c2c: 8b 43 18 mov 0x18(%ebx),%eax 109c2f: 89 04 24 mov %eax,(%esp) 109c32: e8 71 1e 00 00 call 10baa8 } if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 109c37: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 109c3e: 0f 85 c9 fe ff ff jne 109b0d /* * send "terminate" to I/O tasks */ sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT ); 109c44: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 109c4b: 00 109c4c: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax 109c52: 89 04 24 mov %eax,(%esp) 109c55: e8 96 18 00 00 call 10b4f0 if (sc != RTEMS_SUCCESSFUL) 109c5a: 85 c0 test %eax,%eax 109c5c: 75 1e jne 109c7c <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT ); 109c5e: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 109c65: 00 109c66: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax 109c6c: 89 04 24 mov %eax,(%esp) 109c6f: e8 7c 18 00 00 call 10b4f0 if (sc != RTEMS_SUCCESSFUL) 109c74: 85 c0 test %eax,%eax 109c76: 0f 84 91 fe ff ff je 109b0d <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 109c7c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 109c7f: e8 2c 24 00 00 call 10c0b0 <== NOT EXECUTED } else { tty->forw->back = tty->back; } if (tty->back == NULL) { rtems_termios_ttyHead = tty->forw; 109c84: c7 05 34 f5 12 00 00 movl $0x0,0x12f534 109c8b: 00 00 00 109c8e: e9 b4 fe ff ff jmp 109b47 =============================================================================== 0010ae78 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 10ae78: 83 ec 1c sub $0x1c,%esp 10ae7b: 8b 44 24 20 mov 0x20(%esp),%eax rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 10ae7f: 8b 54 24 24 mov 0x24(%esp),%edx 10ae83: 01 90 90 00 00 00 add %edx,0x90(%eax) if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10ae89: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 10ae90: 74 2a je 10aebc if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); return 0; /* nothing to output in IRQ... */ } if (tty->t_line == PPPDISC ) { 10ae92: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax) 10ae99: 74 09 je 10aea4 } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); } 10ae9b: 83 c4 1c add $0x1c,%esp rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 10ae9e: e9 6d e4 ff ff jmp 109310 10aea3: 90 nop if (tty->t_line == PPPDISC ) { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 10aea4: 8b 15 54 f2 12 00 mov 0x12f254,%edx 10aeaa: 85 d2 test %edx,%edx 10aeac: 74 05 je 10aeb3 <== NEVER TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 10aeae: 89 04 24 mov %eax,(%esp) 10aeb1: ff d2 call *%edx } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); } 10aeb3: 31 c0 xor %eax,%eax 10aeb5: 83 c4 1c add $0x1c,%esp 10aeb8: c3 ret 10aeb9: 8d 76 00 lea 0x0(%esi),%esi if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT); 10aebc: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp) 10aec3: 00 10aec4: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax 10aeca: 89 04 24 mov %eax,(%esp) 10aecd: e8 1e 06 00 00 call 10b4f0 if (sc != RTEMS_SUCCESSFUL) 10aed2: 85 c0 test %eax,%eax 10aed4: 74 dd je 10aeb3 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 10aed6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10aed9: e8 d2 11 00 00 call 10c0b0 <== NOT EXECUTED =============================================================================== 0010aafc : * device receive interrupt handler. * Returns the number of characters dropped because of overflow. */ int rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len) { 10aafc: 55 push %ebp 10aafd: 57 push %edi 10aafe: 56 push %esi 10aaff: 53 push %ebx 10ab00: 83 ec 3c sub $0x3c,%esp 10ab03: 8b 5c 24 50 mov 0x50(%esp),%ebx 10ab07: 8b 6c 24 54 mov 0x54(%esp),%ebp 10ab0b: 8b 7c 24 58 mov 0x58(%esp),%edi char c; int dropped = 0; bool flow_rcv = false; /* true, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { 10ab0f: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10ab15: c1 e0 05 shl $0x5,%eax 10ab18: 8b 80 b0 f1 12 00 mov 0x12f1b0(%eax),%eax 10ab1e: 85 c0 test %eax,%eax 10ab20: 74 6a je 10ab8c while (len--) { 10ab22: 85 ff test %edi,%edi 10ab24: 74 28 je 10ab4e <== NEVER TAKEN * NOTE: This routine runs in the context of the * device receive interrupt handler. * Returns the number of characters dropped because of overflow. */ int rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len) 10ab26: 4f dec %edi 10ab27: 31 f6 xor %esi,%esi 10ab29: eb 11 jmp 10ab3c 10ab2b: 90 nop 10ab2c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10ab32: c1 e0 05 shl $0x5,%eax 10ab35: 8b 80 b0 f1 12 00 mov 0x12f1b0(%eax),%eax 10ab3b: 46 inc %esi rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { while (len--) { c = *buf++; rtems_termios_linesw[tty->t_line].l_rint(c,tty); 10ab3c: 89 5c 24 04 mov %ebx,0x4(%esp) 10ab40: 0f be 54 35 00 movsbl 0x0(%ebp,%esi,1),%edx 10ab45: 89 14 24 mov %edx,(%esp) 10ab48: ff d0 call *%eax int dropped = 0; bool flow_rcv = false; /* true, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { while (len--) { 10ab4a: 39 fe cmp %edi,%esi 10ab4c: 75 de jne 10ab2c } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 10ab4e: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 10ab54: 85 c0 test %eax,%eax 10ab56: 75 26 jne 10ab7e <== NEVER TAKEN 10ab58: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 10ab5e: 85 c0 test %eax,%eax 10ab60: 74 1c je 10ab7e (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10ab62: 8b 93 e0 00 00 00 mov 0xe0(%ebx),%edx 10ab68: 89 54 24 04 mov %edx,0x4(%esp) 10ab6c: 8d 53 30 lea 0x30(%ebx),%edx 10ab6f: 89 14 24 mov %edx,(%esp) 10ab72: ff d0 call *%eax tty->tty_rcvwakeup = 1; 10ab74: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) 10ab7b: 00 00 00 } return 0; 10ab7e: 31 ff xor %edi,%edi } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; } 10ab80: 89 f8 mov %edi,%eax 10ab82: 83 c4 3c add $0x3c,%esp 10ab85: 5b pop %ebx 10ab86: 5e pop %esi 10ab87: 5f pop %edi 10ab88: 5d pop %ebp 10ab89: c3 ret 10ab8a: 66 90 xchg %ax,%ax * NOTE: This routine runs in the context of the * device receive interrupt handler. * Returns the number of characters dropped because of overflow. */ int rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len) 10ab8c: 01 ef add %ebp,%edi 10ab8e: 89 7c 24 1c mov %edi,0x1c(%esp) 10ab92: c6 44 24 23 00 movb $0x0,0x23(%esp) 10ab97: 31 ff xor %edi,%edi /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10ab99: 8d 43 30 lea 0x30(%ebx),%eax 10ab9c: 89 44 24 28 mov %eax,0x28(%esp) (tty->rawOutBufState == rob_idle)) { /* if tx is stopped due to XOFF or out of data */ /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); 10aba0: 8d 53 4a lea 0x4a(%ebx),%edx 10aba3: 89 54 24 2c mov %edx,0x2c(%esp) 10aba7: 89 7c 24 10 mov %edi,0x10(%esp) 10abab: 90 nop tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 10abac: 3b 6c 24 1c cmp 0x1c(%esp),%ebp 10abb0: 0f 84 06 01 00 00 je 10acbc c = *buf++; 10abb6: 8a 4d 00 mov 0x0(%ebp),%cl 10abb9: 45 inc %ebp /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 10abba: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10abc0: f6 c4 02 test $0x2,%ah 10abc3: 74 1b je 10abe0 /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 10abc5: 0f be c1 movsbl %cl,%eax 10abc8: 0f b6 53 4a movzbl 0x4a(%ebx),%edx 10abcc: 39 d0 cmp %edx,%eax if (c == tty->termios.c_cc[VSTART]) { 10abce: 0f b6 53 49 movzbl 0x49(%ebx),%edx c = *buf++; /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 10abd2: 0f 84 00 01 00 00 je 10acd8 /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 10abd8: 39 d0 cmp %edx,%eax 10abda: 0f 84 58 01 00 00 je 10ad38 <== NEVER TAKEN /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; flow_rcv = true; } } if (flow_rcv) { 10abe0: 80 7c 24 23 00 cmpb $0x0,0x23(%esp) 10abe5: 0f 85 09 01 00 00 jne 10acf4 <== NEVER TAKEN } /* reenable interrupts */ rtems_interrupt_enable(level); } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 10abeb: 8b 43 60 mov 0x60(%ebx),%eax 10abee: 8b 7b 64 mov 0x64(%ebx),%edi 10abf1: 40 inc %eax 10abf2: 31 d2 xor %edx,%edx 10abf4: f7 f7 div %edi 10abf6: 89 d6 mov %edx,%esi /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 10abf8: 9c pushf 10abf9: fa cli 10abfa: 8f 44 24 24 popl 0x24(%esp) if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 10abfe: 8b 53 5c mov 0x5c(%ebx),%edx 10ac01: 8b 43 64 mov 0x64(%ebx),%eax % tty->rawInBuf.Size) > tty->highwater) && 10ac04: 8b 7b 64 mov 0x64(%ebx),%edi 10ac07: 89 7c 24 18 mov %edi,0x18(%esp) } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 10ac0b: 29 d0 sub %edx,%eax 10ac0d: 01 f0 add %esi,%eax % tty->rawInBuf.Size) > tty->highwater) && 10ac0f: 31 d2 xor %edx,%edx 10ac11: f7 f7 div %edi } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 10ac13: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx 10ac19: 76 45 jbe 10ac60 <== ALWAYS TAKEN % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { 10ac1b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) % tty->rawInBuf.Size) > tty->highwater) && 10ac21: a8 01 test $0x1,%al <== NOT EXECUTED 10ac23: 75 3b jne 10ac60 <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 10ac25: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10ac2b: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10ac2e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 10ac34: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10ac3a: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 10ac3f: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED == (FL_MDXOF ) ) { if ((tty->flow_ctrl & FL_OSTOP) || 10ac44: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 10ac4a: 0f 84 2a 01 00 00 je 10ad7a <== NOT EXECUTED /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) { 10ac50: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 10ac55: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 10ac5a: 0f 84 64 01 00 00 je 10adc4 <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 10ac60: ff 74 24 24 pushl 0x24(%esp) 10ac64: 9d popf if (newTail == tty->rawInBuf.Head) { 10ac65: 8b 43 5c mov 0x5c(%ebx),%eax 10ac68: 39 f0 cmp %esi,%eax 10ac6a: 0f 84 bc 00 00 00 je 10ad2c <== NEVER TAKEN dropped++; } else { tty->rawInBuf.theBuf[newTail] = c; 10ac70: 8b 43 58 mov 0x58(%ebx),%eax 10ac73: 88 0c 30 mov %cl,(%eax,%esi,1) tty->rawInBuf.Tail = newTail; 10ac76: 89 73 60 mov %esi,0x60(%ebx) /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 10ac79: 8b 8b e4 00 00 00 mov 0xe4(%ebx),%ecx 10ac7f: 85 c9 test %ecx,%ecx 10ac81: 0f 85 25 ff ff ff jne 10abac <== NEVER TAKEN 10ac87: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 10ac8d: 85 c0 test %eax,%eax 10ac8f: 0f 84 17 ff ff ff je 10abac <== ALWAYS TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10ac95: 8b 93 e0 00 00 00 mov 0xe0(%ebx),%edx <== NOT EXECUTED 10ac9b: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 10ac9f: 8b 7c 24 28 mov 0x28(%esp),%edi <== NOT EXECUTED 10aca3: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10aca6: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 10aca8: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 10acaf: 00 00 00 tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 10acb2: 3b 6c 24 1c cmp 0x1c(%esp),%ebp <== NOT EXECUTED 10acb6: 0f 85 fa fe ff ff jne 10abb6 <== NOT EXECUTED 10acbc: 8b 7c 24 10 mov 0x10(%esp),%edi } } } } tty->rawInBufDropped += dropped; 10acc0: 01 7b 78 add %edi,0x78(%ebx) rtems_semaphore_release (tty->rawInBuf.Semaphore); 10acc3: 8b 43 68 mov 0x68(%ebx),%eax 10acc6: 89 04 24 mov %eax,(%esp) 10acc9: e8 da 0d 00 00 call 10baa8 return dropped; } 10acce: 89 f8 mov %edi,%eax 10acd0: 83 c4 3c add $0x3c,%esp 10acd3: 5b pop %ebx 10acd4: 5e pop %esi 10acd5: 5f pop %edi 10acd6: 5d pop %ebp 10acd7: c3 ret /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { if (c == tty->termios.c_cc[VSTART]) { 10acd8: 39 d0 cmp %edx,%eax /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 10acda: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { if (c == tty->termios.c_cc[VSTART]) { 10ace0: 0f 84 86 00 00 00 je 10ad6c <== NEVER TAKEN tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 10ace6: 83 c8 10 or $0x10,%eax 10ace9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) * NOTE: This routine runs in the context of the * device receive interrupt handler. * Returns the number of characters dropped because of overflow. */ int rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len) 10acef: c6 44 24 23 01 movb $0x1,0x23(%esp) flow_rcv = true; } } if (flow_rcv) { /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 10acf4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10acfa: 83 e0 30 and $0x30,%eax 10acfd: 83 f8 20 cmp $0x20,%eax 10ad00: 0f 85 a6 fe ff ff jne 10abac <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 10ad06: 9c pushf <== NOT EXECUTED 10ad07: fa cli <== NOT EXECUTED 10ad08: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 10ad09: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10ad0f: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 10ad12: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 10ad18: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED 10ad1e: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad20: 75 27 jne 10ad49 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 10ad22: 56 push %esi <== NOT EXECUTED 10ad23: 9d popf <== NOT EXECUTED 10ad24: e9 83 fe ff ff jmp 10abac <== NOT EXECUTED 10ad29: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* reenable interrupts */ rtems_interrupt_enable(level); if (newTail == tty->rawInBuf.Head) { dropped++; 10ad2c: ff 44 24 10 incl 0x10(%esp) <== NOT EXECUTED 10ad30: e9 77 fe ff ff jmp 10abac <== NOT EXECUTED 10ad35: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 10ad38: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10ad3e: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 10ad41: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 10ad47: eb a6 jmp 10acef <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); 10ad49: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED rtems_interrupt_disable(level); tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)( 10ad4f: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED 10ad56: 00 10ad57: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 10ad5a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10ad5e: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10ad61: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10ad64: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10ad6a: eb b6 jmp 10ad22 <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { if (c == tty->termios.c_cc[VSTART]) { /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 10ad6c: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 10ad6f: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 10ad75: e9 75 ff ff ff jmp 10acef <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) == (FL_MDXOF ) ) { if ((tty->flow_ctrl & FL_OSTOP) || 10ad7a: a8 20 test $0x20,%al <== NOT EXECUTED 10ad7c: 75 0e jne 10ad8c <== NOT EXECUTED 10ad7e: 8b bb 94 00 00 00 mov 0x94(%ebx),%edi <== NOT EXECUTED 10ad84: 85 ff test %edi,%edi <== NOT EXECUTED 10ad86: 0f 85 d4 fe ff ff jne 10ac60 <== NOT EXECUTED (tty->rawOutBufState == rob_idle)) { /* if tx is stopped due to XOFF or out of data */ /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; 10ad8c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10ad92: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10ad95: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED (*tty->device.write)(tty->minor, 10ad9b: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED 10ada2: 00 (void *)&(tty->termios.c_cc[VSTOP]), 1); 10ada3: 8b 7c 24 2c mov 0x2c(%esp),%edi <== NOT EXECUTED 10ada7: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED if ((tty->flow_ctrl & FL_OSTOP) || (tty->rawOutBufState == rob_idle)) { /* if tx is stopped due to XOFF or out of data */ /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; (*tty->device.write)(tty->minor, 10adab: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10adae: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10adb1: 88 4c 24 14 mov %cl,0x14(%esp) <== NOT EXECUTED 10adb5: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10adbb: 8a 4c 24 14 mov 0x14(%esp),%cl <== NOT EXECUTED 10adbf: e9 9c fe ff ff jmp 10ac60 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) { tty->flow_ctrl |= FL_IRTSOFF; 10adc4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10adca: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10adcd: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 10add3: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED 10add9: 85 c0 test %eax,%eax <== NOT EXECUTED 10addb: 0f 84 7f fe ff ff je 10ac60 <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 10ade1: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED 10ade4: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10ade7: 88 4c 24 14 mov %cl,0x14(%esp) <== NOT EXECUTED 10adeb: ff d0 call *%eax <== NOT EXECUTED 10aded: 8a 4c 24 14 mov 0x14(%esp),%cl <== NOT EXECUTED 10adf1: e9 6a fe ff ff jmp 10ac60 <== NOT EXECUTED =============================================================================== 00109cb4 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 109cb4: 55 push %ebp 109cb5: 57 push %edi 109cb6: 56 push %esi 109cb7: 53 push %ebx 109cb8: 83 ec 2c sub $0x2c,%esp 109cbb: 8b 74 24 40 mov 0x40(%esp),%esi rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 109cbf: 8b 06 mov (%esi),%eax 109cc1: 8b 58 2c mov 0x2c(%eax),%ebx struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 109cc4: 8b 7e 08 mov 0x8(%esi),%edi rtems_status_code sc; args->ioctl_return = 0; 109cc7: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 109cce: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 109cd5: 00 109cd6: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 109cdd: 00 109cde: 8b 43 18 mov 0x18(%ebx),%eax 109ce1: 89 04 24 mov %eax,(%esp) 109ce4: e8 93 1c 00 00 call 10b97c 109ce9: 89 c5 mov %eax,%ebp if (sc != RTEMS_SUCCESSFUL) { 109ceb: 85 c0 test %eax,%eax 109ced: 75 4c jne 109d3b <== NEVER TAKEN return sc; } switch (args->command) { 109cef: 8b 46 04 mov 0x4(%esi),%eax 109cf2: 83 f8 04 cmp $0x4,%eax 109cf5: 74 25 je 109d1c 109cf7: 77 4f ja 109d48 109cf9: 83 f8 02 cmp $0x2,%eax 109cfc: 0f 84 86 00 00 00 je 109d88 109d02: 0f 86 fc 01 00 00 jbe 109f04 drainOutput (struct rtems_termios_tty *tty) { rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 109d08: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax 109d0e: 85 c0 test %eax,%eax 109d10: 74 1e je 109d30 109d12: 89 d8 mov %ebx,%eax 109d14: e8 b3 f8 ff ff call 1095cc 109d19: eb 15 jmp 109d30 109d1b: 90 nop case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; break; case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 109d1c: 8b 07 mov (%edi),%eax 109d1e: 8b 57 04 mov 0x4(%edi),%edx 109d21: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx) 109d27: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx) 109d2d: 8d 76 00 lea 0x0(%esi),%esi *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; } break; } rtems_semaphore_release (tty->osem); 109d30: 8b 43 18 mov 0x18(%ebx),%eax 109d33: 89 04 24 mov %eax,(%esp) 109d36: e8 6d 1d 00 00 call 10baa8 return sc; } 109d3b: 89 e8 mov %ebp,%eax 109d3d: 83 c4 2c add $0x2c,%esp 109d40: 5b pop %ebx 109d41: 5e pop %esi 109d42: 5f pop %edi 109d43: 5d pop %ebp 109d44: c3 ret 109d45: 8d 76 00 lea 0x0(%esi),%esi args->ioctl_return = 0; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { return sc; } switch (args->command) { 109d48: 3d 7f 66 04 40 cmp $0x4004667f,%eax 109d4d: 0f 84 91 01 00 00 je 109ee4 <== NEVER TAKEN 109d53: 0f 87 c7 01 00 00 ja 109f20 109d59: 83 f8 05 cmp $0x5,%eax 109d5c: 0f 84 2e 02 00 00 je 109f90 default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 109d62: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109d68: c1 e0 05 shl $0x5,%eax 109d6b: 8b 80 b8 f1 12 00 mov 0x12f1b8(%eax),%eax 109d71: 85 c0 test %eax,%eax 109d73: 0f 84 2f 02 00 00 je 109fa8 <== NEVER TAKEN sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 109d79: 89 74 24 04 mov %esi,0x4(%esp) 109d7d: 89 1c 24 mov %ebx,(%esp) 109d80: ff d0 call *%eax 109d82: 89 c5 mov %eax,%ebp 109d84: eb aa jmp 109d30 109d86: 66 90 xchg %ax,%ax case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; break; case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 109d88: 8b 76 08 mov 0x8(%esi),%esi 109d8b: 8d 43 30 lea 0x30(%ebx),%eax 109d8e: 89 44 24 1c mov %eax,0x1c(%esp) 109d92: b9 09 00 00 00 mov $0x9,%ecx 109d97: 89 c7 mov %eax,%edi 109d99: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * check for flow control options to be switched off */ /* check for outgoing XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXON) && 109d9b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109da1: f6 c4 02 test $0x2,%ah 109da4: 74 46 je 109dec 109da6: f6 43 31 04 testb $0x4,0x31(%ebx) 109daa: 75 40 jne 109dec !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 109dac: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109db2: 25 ef fd ff ff and $0xfffffdef,%eax 109db7: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) /* has output been stopped due to received XOFF? */ if (tty->flow_ctrl & FL_OSTOP) { 109dbd: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109dc3: a8 20 test $0x20,%al 109dc5: 74 25 je 109dec <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 109dc7: 9c pushf <== NOT EXECUTED 109dc8: fa cli <== NOT EXECUTED 109dc9: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 109dca: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109dd0: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 109dd3: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 109dd9: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED 109ddf: 85 c0 test %eax,%eax <== NOT EXECUTED 109de1: 0f 85 3f 02 00 00 jne 10a026 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 109de7: 56 push %esi <== NOT EXECUTED 109de8: 9d popf <== NOT EXECUTED 109de9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) { 109dec: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109df2: f6 c4 04 test $0x4,%ah 109df5: 74 24 je 109e1b 109df7: f6 43 31 10 testb $0x10,0x31(%ebx) 109dfb: 75 1e jne 109e1b <== NEVER TAKEN /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 109dfd: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109e03: 80 e4 fb and $0xfb,%ah 109e06: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) /* FIXME: what happens, if we had sent XOFF but not yet XON? */ tty->flow_ctrl &= ~(FL_ISNTXOF); 109e0c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109e12: 83 e0 fd and $0xfffffffd,%eax 109e15: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) { 109e1b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109e21: f6 c4 01 test $0x1,%ah 109e24: 8b 43 38 mov 0x38(%ebx),%eax 109e27: 74 46 je 109e6f <== ALWAYS TAKEN 109e29: 85 c0 test %eax,%eax <== NOT EXECUTED 109e2b: 0f 88 cb 01 00 00 js 109ffc <== NOT EXECUTED /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 109e31: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx <== NOT EXECUTED 109e37: 80 e6 fe and $0xfe,%dh <== NOT EXECUTED 109e3a: 89 93 b8 00 00 00 mov %edx,0xb8(%ebx) <== NOT EXECUTED /* restart remote Tx, if it was stopped */ if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) { 109e40: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx <== NOT EXECUTED 109e46: 83 e2 04 and $0x4,%edx <== NOT EXECUTED 109e49: 74 15 je 109e60 <== NOT EXECUTED 109e4b: 8b 93 b0 00 00 00 mov 0xb0(%ebx),%edx <== NOT EXECUTED 109e51: 85 d2 test %edx,%edx <== NOT EXECUTED 109e53: 74 0b je 109e60 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 109e55: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 109e58: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 109e5b: ff d2 call *%edx <== NOT EXECUTED 109e5d: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 109e60: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx <== NOT EXECUTED 109e66: 83 e2 fb and $0xfffffffb,%edx <== NOT EXECUTED 109e69: 89 93 b8 00 00 00 mov %edx,0xb8(%ebx) <== NOT EXECUTED /* * check for flow control options to be switched on */ /* check for incoming RTS/CTS flow control switched on */ if (tty->termios.c_cflag & CRTSCTS) { 109e6f: 85 c0 test %eax,%eax 109e71: 0f 88 85 01 00 00 js 109ffc <== NEVER TAKEN tty->flow_ctrl |= FL_MDRTS; } /* check for incoming XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXOFF) { 109e77: 8b 43 30 mov 0x30(%ebx),%eax 109e7a: f6 c4 10 test $0x10,%ah 109e7d: 74 0f je 109e8e tty->flow_ctrl |= FL_MDXOF; 109e7f: 8b 93 b8 00 00 00 mov 0xb8(%ebx),%edx 109e85: 80 ce 04 or $0x4,%dh 109e88: 89 93 b8 00 00 00 mov %edx,0xb8(%ebx) } /* check for outgoing XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXON) { 109e8e: f6 c4 04 test $0x4,%ah 109e91: 74 0f je 109ea2 tty->flow_ctrl |= FL_MDXON; 109e93: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109e99: 80 cc 02 or $0x2,%ah 109e9c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) tty->termios = *(struct termios *)args->buffer; /* check for and process change in flow control options */ termios_set_flowctrl(tty); if (tty->termios.c_lflag & ICANON) { 109ea2: f6 43 3c 02 testb $0x2,0x3c(%ebx) 109ea6: 0f 84 08 01 00 00 je 109fb4 tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; } else { if (tty->termios.c_cc[VMIN]) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 109eac: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 109eb3: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 109eba: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; } } } if (tty->device.setAttributes) 109ec1: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 109ec7: 85 c0 test %eax,%eax 109ec9: 0f 84 61 fe ff ff je 109d30 <== NEVER TAKEN (*tty->device.setAttributes)(tty->minor, &tty->termios); 109ecf: 8b 54 24 1c mov 0x1c(%esp),%edx 109ed3: 89 54 24 04 mov %edx,0x4(%esp) 109ed7: 8b 53 10 mov 0x10(%ebx),%edx 109eda: 89 14 24 mov %edx,(%esp) 109edd: ff d0 call *%eax 109edf: e9 4c fe ff ff jmp 109d30 case TIOCGETD: *(int*)(args->buffer)=tty->t_line; break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 109ee4: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 109ee7: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED if ( rawnc < 0 ) 109eea: 29 d0 sub %edx,%eax <== NOT EXECUTED 109eec: 0f 88 fe 00 00 00 js 109ff0 <== NOT EXECUTED rawnc += tty->rawInBuf.Size; /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 109ef2: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED 109ef5: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED 109ef8: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED 109efb: 89 02 mov %eax,(%edx) <== NOT EXECUTED } break; 109efd: e9 2e fe ff ff jmp 109d30 <== NOT EXECUTED 109f02: 66 90 xchg %ax,%ax <== NOT EXECUTED args->ioctl_return = 0; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { return sc; } switch (args->command) { 109f04: 48 dec %eax 109f05: 0f 85 57 fe ff ff jne 109d62 <== NEVER TAKEN sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 109f0b: 8b 46 08 mov 0x8(%esi),%eax 109f0e: 8d 73 30 lea 0x30(%ebx),%esi 109f11: b9 09 00 00 00 mov $0x9,%ecx 109f16: 89 c7 mov %eax,%edi 109f18: f3 a5 rep movsl %ds:(%esi),%es:(%edi) break; 109f1a: e9 11 fe ff ff jmp 109d30 109f1f: 90 nop args->ioctl_return = 0; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { return sc; } switch (args->command) { 109f20: 3d 1a 74 04 40 cmp $0x4004741a,%eax 109f25: 74 59 je 109f80 109f27: 3d 1b 74 04 80 cmp $0x8004741b,%eax 109f2c: 0f 85 30 fe ff ff jne 109d62 <== NEVER TAKEN #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 109f32: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109f38: c1 e0 05 shl $0x5,%eax 109f3b: 8b 80 a4 f1 12 00 mov 0x12f1a4(%eax),%eax 109f41: 85 c0 test %eax,%eax 109f43: 74 07 je 109f4c sc = rtems_termios_linesw[tty->t_line].l_close(tty); 109f45: 89 1c 24 mov %ebx,(%esp) 109f48: ff d0 call *%eax 109f4a: 89 c5 mov %eax,%ebp } tty->t_line=*(int*)(args->buffer); 109f4c: 8b 46 08 mov 0x8(%esi),%eax 109f4f: 8b 00 mov (%eax),%eax 109f51: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) tty->t_sc = NULL; /* ensure that no more valid data */ 109f57: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) 109f5e: 00 00 00 /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 109f61: c1 e0 05 shl $0x5,%eax 109f64: 8b 80 a0 f1 12 00 mov 0x12f1a0(%eax),%eax 109f6a: 85 c0 test %eax,%eax 109f6c: 0f 84 be fd ff ff je 109d30 sc = rtems_termios_linesw[tty->t_line].l_open(tty); 109f72: 89 1c 24 mov %ebx,(%esp) 109f75: ff d0 call *%eax 109f77: 89 c5 mov %eax,%ebp 109f79: e9 b2 fd ff ff jmp 109d30 109f7e: 66 90 xchg %ax,%ax } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 109f80: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx 109f86: 8b 46 08 mov 0x8(%esi),%eax 109f89: 89 10 mov %edx,(%eax) break; 109f8b: e9 a0 fd ff ff jmp 109d30 case RTEMS_IO_TCDRAIN: drainOutput (tty); break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 109f90: 8b 07 mov (%edi),%eax 109f92: 8b 57 04 mov 0x4(%edi),%edx 109f95: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx) 109f9b: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx) break; 109fa1: e9 8a fd ff ff jmp 109d30 109fa6: 66 90 xchg %ax,%ax default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); } else { sc = RTEMS_INVALID_NUMBER; 109fa8: bd 0a 00 00 00 mov $0xa,%ebp <== NOT EXECUTED 109fad: e9 7e fd ff ff jmp 109d30 <== NOT EXECUTED 109fb2: 66 90 xchg %ax,%ax <== NOT EXECUTED if (tty->termios.c_lflag & ICANON) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 109fb4: 0f b6 73 46 movzbl 0x46(%ebx),%esi rtems_clock_get_ticks_per_second() / 10; 109fb8: e8 13 13 00 00 call 10b2d0 if (tty->termios.c_lflag & ICANON) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 109fbd: 0f af c6 imul %esi,%eax rtems_clock_get_ticks_per_second() / 10; 109fc0: ba cd cc cc cc mov $0xcccccccd,%edx 109fc5: f7 e2 mul %edx 109fc7: c1 ea 03 shr $0x3,%edx if (tty->termios.c_lflag & ICANON) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 109fca: 89 53 54 mov %edx,0x54(%ebx) rtems_clock_get_ticks_per_second() / 10; if (tty->termios.c_cc[VTIME]) { 109fcd: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 109fd1: 74 3d je 10a010 tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 109fd3: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 109fda: 89 53 70 mov %edx,0x70(%ebx) if (tty->termios.c_cc[VMIN]) 109fdd: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 109fe1: 0f 85 d3 fe ff ff jne 109eba tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 109fe7: 89 53 74 mov %edx,0x74(%ebx) 109fea: e9 d2 fe ff ff jmp 109ec1 109fef: 90 nop break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; if ( rawnc < 0 ) rawnc += tty->rawInBuf.Size; 109ff0: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED 109ff3: 01 d0 add %edx,%eax <== NOT EXECUTED 109ff5: e9 f8 fe ff ff jmp 109ef2 <== NOT EXECUTED 109ffa: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * check for flow control options to be switched on */ /* check for incoming RTS/CTS flow control switched on */ if (tty->termios.c_cflag & CRTSCTS) { tty->flow_ctrl |= FL_MDRTS; 109ffc: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a002: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 10a005: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 10a00b: e9 67 fe ff ff jmp 109e77 <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; } else { if (tty->termios.c_cc[VMIN]) { 10a010: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 10a014: 0f 85 92 fe ff ff jne 109eac <== NEVER TAKEN tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 10a01a: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) 10a021: e9 9b fe ff ff jmp 109ec1 tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 10a026: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED rtems_interrupt_disable(level); tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)( 10a02c: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED 10a033: 00 10a034: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 10a037: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10a03b: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10a03e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a041: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10a047: e9 9b fd ff ff jmp 109de7 <== NOT EXECUTED =============================================================================== 00109624 : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 109624: 55 push %ebp 109625: 57 push %edi 109626: 56 push %esi 109627: 53 push %ebx 109628: 83 ec 3c sub $0x3c,%esp 10962b: 8b 6c 24 50 mov 0x50(%esp),%ebp struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain( 10962f: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 109636: 00 109637: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10963e: 00 10963f: a1 2c f5 12 00 mov 0x12f52c,%eax 109644: 89 04 24 mov %eax,(%esp) 109647: e8 30 23 00 00 call 10b97c 10964c: 89 44 24 2c mov %eax,0x2c(%esp) rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 109650: 85 c0 test %eax,%eax 109652: 75 73 jne 1096c7 <== NEVER TAKEN return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 109654: 8b 3d 34 f5 12 00 mov 0x12f534,%edi 10965a: 85 ff test %edi,%edi 10965c: 74 76 je 1096d4 10965e: 89 fb mov %edi,%ebx 109660: 8b 44 24 54 mov 0x54(%esp),%eax 109664: eb 08 jmp 10966e 109666: 66 90 xchg %ax,%ax 109668: 8b 1b mov (%ebx),%ebx 10966a: 85 db test %ebx,%ebx 10966c: 74 66 je 1096d4 <== ALWAYS TAKEN if ((tty->major == major) && (tty->minor == minor)) 10966e: 39 6b 0c cmp %ebp,0xc(%ebx) 109671: 75 f5 jne 109668 109673: 39 43 10 cmp %eax,0x10(%ebx) 109676: 75 f0 jne 109668 */ if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; 109678: 8b 54 24 58 mov 0x58(%esp),%edx 10967c: 8b 02 mov (%edx),%eax 10967e: 89 58 2c mov %ebx,0x2c(%eax) if (!tty->refcount++) { 109681: 8b 43 08 mov 0x8(%ebx),%eax 109684: 8d 50 01 lea 0x1(%eax),%edx 109687: 89 53 08 mov %edx,0x8(%ebx) 10968a: 85 c0 test %eax,%eax 10968c: 75 2c jne 1096ba if (tty->device.firstOpen) 10968e: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax 109694: 85 c0 test %eax,%eax 109696: 74 15 je 1096ad (*tty->device.firstOpen)(major, minor, arg); 109698: 8b 54 24 58 mov 0x58(%esp),%edx 10969c: 89 54 24 08 mov %edx,0x8(%esp) 1096a0: 8b 54 24 54 mov 0x54(%esp),%edx 1096a4: 89 54 24 04 mov %edx,0x4(%esp) 1096a8: 89 2c 24 mov %ebp,(%esp) 1096ab: ff d0 call *%eax /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1096ad: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 1096b4: 0f 84 85 02 00 00 je 10993f tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } rtems_semaphore_release (rtems_termios_ttyMutex); 1096ba: a1 2c f5 12 00 mov 0x12f52c,%eax 1096bf: 89 04 24 mov %eax,(%esp) 1096c2: e8 e1 23 00 00 call 10baa8 return RTEMS_SUCCESSFUL; } 1096c7: 8b 44 24 2c mov 0x2c(%esp),%eax 1096cb: 83 c4 3c add $0x3c,%esp 1096ce: 5b pop %ebx 1096cf: 5e pop %esi 1096d0: 5f pop %edi 1096d1: 5d pop %ebp 1096d2: c3 ret 1096d3: 90 nop static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 1096d4: c7 44 24 04 e8 00 00 movl $0xe8,0x4(%esp) 1096db: 00 1096dc: c7 04 24 01 00 00 00 movl $0x1,(%esp) 1096e3: e8 00 e0 ff ff call 1076e8 1096e8: 89 c3 mov %eax,%ebx if (tty == NULL) { 1096ea: 85 c0 test %eax,%eax 1096ec: 0f 84 ae 02 00 00 je 1099a0 return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 1096f2: a1 34 d2 12 00 mov 0x12d234,%eax 1096f7: 89 43 64 mov %eax,0x64(%ebx) tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 1096fa: 8b 43 64 mov 0x64(%ebx),%eax 1096fd: 89 04 24 mov %eax,(%esp) 109700: e8 4b e5 ff ff call 107c50 109705: 89 c6 mov %eax,%esi 109707: 89 43 58 mov %eax,0x58(%ebx) if (tty->rawInBuf.theBuf == NULL) { 10970a: 85 c0 test %eax,%eax 10970c: 0f 84 86 02 00 00 je 109998 return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 109712: a1 38 d2 12 00 mov 0x12d238,%eax 109717: 89 83 88 00 00 00 mov %eax,0x88(%ebx) tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 10971d: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 109723: 89 04 24 mov %eax,(%esp) 109726: e8 25 e5 ff ff call 107c50 10972b: 89 c2 mov %eax,%edx 10972d: 89 43 7c mov %eax,0x7c(%ebx) if (tty->rawOutBuf.theBuf == NULL) { 109730: 85 c0 test %eax,%eax 109732: 0f 84 58 02 00 00 je 109990 return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 109738: a1 3c d2 12 00 mov 0x12d23c,%eax 10973d: 89 04 24 mov %eax,(%esp) 109740: 89 54 24 28 mov %edx,0x28(%esp) 109744: e8 07 e5 ff ff call 107c50 109749: 89 43 1c mov %eax,0x1c(%ebx) if (tty->cbuf == NULL) { 10974c: 85 c0 test %eax,%eax 10974e: 8b 54 24 28 mov 0x28(%esp),%edx 109752: 0f 84 30 02 00 00 je 109988 return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 109758: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx) 10975f: 00 00 00 tty->tty_snd.sw_arg = NULL; 109762: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx) 109769: 00 00 00 tty->tty_rcv.sw_pfn = NULL; 10976c: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) 109773: 00 00 00 tty->tty_rcv.sw_arg = NULL; 109776: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 10977d: 00 00 00 tty->tty_rcvwakeup = 0; 109780: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 109787: 00 00 00 /* * link tty */ tty->forw = rtems_termios_ttyHead; 10978a: 89 3b mov %edi,(%ebx) tty->back = NULL; 10978c: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) if (rtems_termios_ttyHead != NULL) 109793: 85 ff test %edi,%edi 109795: 74 03 je 10979a rtems_termios_ttyHead->back = tty; 109797: 89 5f 04 mov %ebx,0x4(%edi) rtems_termios_ttyHead = tty; 10979a: 89 1d 34 f5 12 00 mov %ebx,0x12f534 if (rtems_termios_ttyTail == NULL) 1097a0: 8b 15 30 f5 12 00 mov 0x12f530,%edx 1097a6: 85 d2 test %edx,%edx 1097a8: 0f 84 ee 02 00 00 je 109a9c rtems_termios_ttyTail = tty; tty->minor = minor; 1097ae: 8b 54 24 54 mov 0x54(%esp),%edx 1097b2: 89 53 10 mov %edx,0x10(%ebx) tty->major = major; 1097b5: 89 6b 0c mov %ebp,0xc(%ebx) /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 1097b8: 8d 43 14 lea 0x14(%ebx),%eax 1097bb: 89 44 24 10 mov %eax,0x10(%esp) 1097bf: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 1097c6: 00 1097c7: c7 44 24 08 54 00 00 movl $0x54,0x8(%esp) 1097ce: 00 1097cf: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 1097d6: 00 rtems_build_name ('T', 'R', 'i', c), 1097d7: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax tty->major = major; /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 1097de: 0d 00 69 52 54 or $0x54526900,%eax 1097e3: 89 04 24 mov %eax,(%esp) 1097e6: e8 dd 1e 00 00 call 10b6c8 rtems_build_name ('T', 'R', 'i', c), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->isem); if (sc != RTEMS_SUCCESSFUL) 1097eb: 85 c0 test %eax,%eax 1097ed: 0f 85 0e 02 00 00 jne 109a01 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 1097f3: 8d 43 18 lea 0x18(%ebx),%eax 1097f6: 89 44 24 10 mov %eax,0x10(%esp) 1097fa: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 109801: 00 109802: c7 44 24 08 54 00 00 movl $0x54,0x8(%esp) 109809: 00 10980a: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 109811: 00 rtems_build_name ('T', 'R', 'o', c), 109812: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->isem); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 109819: 0d 00 6f 52 54 or $0x54526f00,%eax 10981e: 89 04 24 mov %eax,(%esp) 109821: e8 a2 1e 00 00 call 10b6c8 rtems_build_name ('T', 'R', 'o', c), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->osem); if (sc != RTEMS_SUCCESSFUL) 109826: 85 c0 test %eax,%eax 109828: 0f 85 d3 01 00 00 jne 109a01 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10982e: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax 109834: 89 44 24 10 mov %eax,0x10(%esp) 109838: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 10983f: 00 109840: c7 44 24 08 20 00 00 movl $0x20,0x8(%esp) 109847: 00 109848: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10984f: 00 rtems_build_name ('T', 'R', 'x', c), 109850: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->osem); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 109857: 0d 00 78 52 54 or $0x54527800,%eax 10985c: 89 04 24 mov %eax,(%esp) 10985f: e8 64 1e 00 00 call 10b6c8 rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 109864: 85 c0 test %eax,%eax 109866: 0f 85 95 01 00 00 jne 109a01 rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 10986c: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 109873: 00 00 00 /* * Set callbacks */ tty->device = *callbacks; 109876: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi 10987c: b9 08 00 00 00 mov $0x8,%ecx 109881: 8b 74 24 5c mov 0x5c(%esp),%esi 109885: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 109887: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 10988e: 0f 84 78 01 00 00 je 109a0c &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 109894: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 10989a: 85 c0 test %eax,%eax 10989c: 0f 84 24 01 00 00 je 1099c6 1098a2: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 1098a9: 0f 84 17 01 00 00 je 1099c6 } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 1098af: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx) tty->termios.c_oflag = OPOST | ONLCR | XTABS; 1098b6: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx) tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 1098bd: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx) tty->termios.c_lflag = 1098c4: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx) ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; tty->termios.c_cc[VINTR] = '\003'; 1098cb: c6 43 41 03 movb $0x3,0x41(%ebx) tty->termios.c_cc[VQUIT] = '\034'; 1098cf: c6 43 42 1c movb $0x1c,0x42(%ebx) tty->termios.c_cc[VERASE] = '\177'; 1098d3: c6 43 43 7f movb $0x7f,0x43(%ebx) tty->termios.c_cc[VKILL] = '\025'; 1098d7: c6 43 44 15 movb $0x15,0x44(%ebx) tty->termios.c_cc[VEOF] = '\004'; 1098db: c6 43 45 04 movb $0x4,0x45(%ebx) tty->termios.c_cc[VEOL] = '\000'; 1098df: c6 43 4c 00 movb $0x0,0x4c(%ebx) tty->termios.c_cc[VEOL2] = '\000'; 1098e3: c6 43 51 00 movb $0x0,0x51(%ebx) tty->termios.c_cc[VSTART] = '\021'; 1098e7: c6 43 49 11 movb $0x11,0x49(%ebx) tty->termios.c_cc[VSTOP] = '\023'; 1098eb: c6 43 4a 13 movb $0x13,0x4a(%ebx) tty->termios.c_cc[VSUSP] = '\032'; 1098ef: c6 43 4b 1a movb $0x1a,0x4b(%ebx) tty->termios.c_cc[VREPRINT] = '\022'; 1098f3: c6 43 4d 12 movb $0x12,0x4d(%ebx) tty->termios.c_cc[VDISCARD] = '\017'; 1098f7: c6 43 4e 0f movb $0xf,0x4e(%ebx) tty->termios.c_cc[VWERASE] = '\027'; 1098fb: c6 43 4f 17 movb $0x17,0x4f(%ebx) tty->termios.c_cc[VLNEXT] = '\026'; 1098ff: c6 43 50 16 movb $0x16,0x50(%ebx) /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 109903: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx) 10990a: 00 00 00 /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 10990d: 8b 43 64 mov 0x64(%ebx),%eax 109910: d1 e8 shr %eax 109912: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) tty->highwater = tty->rawInBuf.Size * 3/4; 109918: 8b 43 64 mov 0x64(%ebx),%eax 10991b: 8d 04 40 lea (%eax,%eax,2),%eax 10991e: c1 e8 02 shr $0x2,%eax 109921: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx) /* * Bump name characer */ if (c++ == 'z') 109927: a0 40 d2 12 00 mov 0x12d240,%al 10992c: 3c 7a cmp $0x7a,%al 10992e: 0f 84 86 00 00 00 je 1099ba 109934: 40 inc %eax 109935: a2 40 d2 12 00 mov %al,0x12d240 10993a: e9 39 fd ff ff jmp 109678 /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_start( 10993f: 89 5c 24 08 mov %ebx,0x8(%esp) 109943: c7 44 24 04 f8 ad 10 movl $0x10adf8,0x4(%esp) 10994a: 00 10994b: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax 109951: 89 04 24 mov %eax,(%esp) 109954: e8 df 24 00 00 call 10be38 tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 109959: 85 c0 test %eax,%eax 10995b: 0f 85 a0 00 00 00 jne 109a01 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_start( 109961: 89 5c 24 08 mov %ebx,0x8(%esp) 109965: c7 44 24 04 5c 95 10 movl $0x10955c,0x4(%esp) 10996c: 00 10996d: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax 109973: 89 04 24 mov %eax,(%esp) 109976: e8 bd 24 00 00 call 10be38 tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 10997b: 85 c0 test %eax,%eax 10997d: 0f 84 37 fd ff ff je 1096ba <== ALWAYS TAKEN 109983: eb 7c jmp 109a01 <== NOT EXECUTED 109985: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); if (tty->cbuf == NULL) { free((void *)(tty->rawOutBuf.theBuf)); 109988: 89 14 24 mov %edx,(%esp) 10998b: e8 ac df ff ff call 10793c free((void *)(tty->rawInBuf.theBuf)); 109990: 89 34 24 mov %esi,(%esp) 109993: e8 a4 df ff ff call 10793c free(tty); 109998: 89 1c 24 mov %ebx,(%esp) 10999b: e8 9c df ff ff call 10793c rtems_semaphore_release (rtems_termios_ttyMutex); 1099a0: a1 2c f5 12 00 mov 0x12f52c,%eax 1099a5: 89 04 24 mov %eax,(%esp) 1099a8: e8 fb 20 00 00 call 10baa8 return RTEMS_NO_MEMORY; 1099ad: c7 44 24 2c 1a 00 00 movl $0x1a,0x2c(%esp) 1099b4: 00 1099b5: e9 0d fd ff ff jmp 1096c7 tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') c = 'a'; 1099ba: c6 05 40 d2 12 00 61 movb $0x61,0x12d240 1099c1: e9 b2 fc ff ff jmp 109678 rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 1099c6: 8d 43 68 lea 0x68(%ebx),%eax 1099c9: 89 44 24 10 mov %eax,0x10(%esp) 1099cd: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 1099d4: 00 1099d5: c7 44 24 08 24 00 00 movl $0x24,0x8(%esp) 1099dc: 00 1099dd: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 1099e4: 00 rtems_build_name ('T', 'R', 'r', c), 1099e5: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 1099ec: 0d 00 72 52 54 or $0x54527200,%eax 1099f1: 89 04 24 mov %eax,(%esp) 1099f4: e8 cf 1c 00 00 call 10b6c8 rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 1099f9: 85 c0 test %eax,%eax 1099fb: 0f 84 ae fe ff ff je 1098af rtems_fatal_error_occurred (sc); sc = rtems_task_start( tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 109a01: 89 04 24 mov %eax,(%esp) 109a04: e8 a7 26 00 00 call 10c0b0 109a09: 8d 76 00 lea 0x0(%esi),%esi /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 109a0c: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 109a12: 89 44 24 14 mov %eax,0x14(%esp) 109a16: c7 44 24 10 00 00 00 movl $0x0,0x10(%esp) 109a1d: 00 109a1e: c7 44 24 0c 00 05 00 movl $0x500,0xc(%esp) 109a25: 00 109a26: c7 44 24 08 00 04 00 movl $0x400,0x8(%esp) 109a2d: 00 109a2e: c7 44 24 04 0a 00 00 movl $0xa,0x4(%esp) 109a35: 00 rtems_build_name ('T', 'x', 'T', c), 109a36: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 109a3d: 0d 00 54 78 54 or $0x54785400,%eax 109a42: 89 04 24 mov %eax,(%esp) 109a45: e8 fe 20 00 00 call 10bb48 TERMIOS_TXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) 109a4a: 85 c0 test %eax,%eax 109a4c: 75 b3 jne 109a01 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 109a4e: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax 109a54: 89 44 24 14 mov %eax,0x14(%esp) 109a58: c7 44 24 10 00 00 00 movl $0x0,0x10(%esp) 109a5f: 00 109a60: c7 44 24 0c 00 05 00 movl $0x500,0xc(%esp) 109a67: 00 109a68: c7 44 24 08 00 04 00 movl $0x400,0x8(%esp) 109a6f: 00 109a70: c7 44 24 04 09 00 00 movl $0x9,0x4(%esp) 109a77: 00 rtems_build_name ('R', 'x', 'T', c), 109a78: 0f be 05 40 d2 12 00 movsbl 0x12d240,%eax RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 109a7f: 0d 00 54 78 52 or $0x52785400,%eax 109a84: 89 04 24 mov %eax,(%esp) 109a87: e8 bc 20 00 00 call 10bb48 TERMIOS_RXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) 109a8c: 85 c0 test %eax,%eax 109a8e: 0f 84 00 fe ff ff je 109894 <== ALWAYS TAKEN 109a94: e9 68 ff ff ff jmp 109a01 <== NOT EXECUTED 109a99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty; if (rtems_termios_ttyTail == NULL) rtems_termios_ttyTail = tty; 109a9c: 89 1d 30 f5 12 00 mov %ebx,0x12f530 109aa2: e9 07 fd ff ff jmp 1097ae =============================================================================== 0010a04c : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, size_t len, struct rtems_termios_tty *tty) { 10a04c: 55 push %ebp 10a04d: 57 push %edi 10a04e: 56 push %esi 10a04f: 53 push %ebx 10a050: 83 ec 2c sub $0x2c,%esp 10a053: 8b 74 24 40 mov 0x40(%esp),%esi 10a057: 8b 4c 24 44 mov 0x44(%esp),%ecx 10a05b: 89 4c 24 18 mov %ecx,0x18(%esp) 10a05f: 8b 6c 24 48 mov 0x48(%esp),%ebp const unsigned char *buf = _buf; unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 10a063: 8b 85 b4 00 00 00 mov 0xb4(%ebp),%eax 10a069: 85 c0 test %eax,%eax 10a06b: 0f 84 f7 00 00 00 je 10a168 (*tty->device.write)(tty->minor, buf, len); return; } newHead = tty->rawOutBuf.Head; 10a071: 8b bd 80 00 00 00 mov 0x80(%ebp),%edi while (len) { 10a077: 8b 44 24 18 mov 0x18(%esp),%eax 10a07b: 85 c0 test %eax,%eax 10a07d: 0f 84 b2 00 00 00 je 10a135 <== NEVER TAKEN 10a083: 90 nop * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 10a084: 8d 47 01 lea 0x1(%edi),%eax 10a087: 8b 8d 88 00 00 00 mov 0x88(%ebp),%ecx 10a08d: 31 d2 xor %edx,%edx 10a08f: f7 f1 div %ecx 10a091: 89 54 24 1c mov %edx,0x1c(%esp) 10a095: 89 d7 mov %edx,%edi rtems_interrupt_disable (level); 10a097: 9c pushf 10a098: fa cli 10a099: 5a pop %edx while (newHead == tty->rawOutBuf.Tail) { 10a09a: 8b 9d 84 00 00 00 mov 0x84(%ebp),%ebx 10a0a0: 39 fb cmp %edi,%ebx 10a0a2: 75 3f jne 10a0e3 tty->rawOutBufState = rob_wait; 10a0a4: c7 85 94 00 00 00 02 movl $0x2,0x94(%ebp) 10a0ab: 00 00 00 rtems_interrupt_enable (level); 10a0ae: 52 push %edx 10a0af: 9d popf sc = rtems_semaphore_obtain( 10a0b0: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10a0b7: 00 10a0b8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10a0bf: 00 10a0c0: 8b 85 8c 00 00 00 mov 0x8c(%ebp),%eax 10a0c6: 89 04 24 mov %eax,(%esp) 10a0c9: e8 ae 18 00 00 call 10b97c tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 10a0ce: 85 c0 test %eax,%eax 10a0d0: 0f 85 b0 00 00 00 jne 10a186 <== NEVER TAKEN rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 10a0d6: 9c pushf 10a0d7: fa cli 10a0d8: 5a pop %edx * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; rtems_interrupt_disable (level); while (newHead == tty->rawOutBuf.Tail) { 10a0d9: 8b 85 84 00 00 00 mov 0x84(%ebp),%eax 10a0df: 39 d8 cmp %ebx,%eax 10a0e1: 74 c1 je 10a0a4 <== NEVER TAKEN tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 10a0e3: 8b 85 80 00 00 00 mov 0x80(%ebp),%eax 10a0e9: 8b 5d 7c mov 0x7c(%ebp),%ebx 10a0ec: 8a 0e mov (%esi),%cl 10a0ee: 88 0c 03 mov %cl,(%ebx,%eax,1) 10a0f1: 46 inc %esi tty->rawOutBuf.Head = newHead; 10a0f2: 8b 44 24 1c mov 0x1c(%esp),%eax 10a0f6: 89 85 80 00 00 00 mov %eax,0x80(%ebp) if (tty->rawOutBufState == rob_idle) { 10a0fc: 8b 85 94 00 00 00 mov 0x94(%ebp),%eax 10a102: 85 c0 test %eax,%eax 10a104: 75 23 jne 10a129 /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 10a106: 8b 85 b8 00 00 00 mov 0xb8(%ebp),%eax 10a10c: a8 10 test $0x10,%al 10a10e: 74 2d je 10a13d <== ALWAYS TAKEN (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } else { /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; 10a110: 8b 85 b8 00 00 00 mov 0xb8(%ebp),%eax <== NOT EXECUTED 10a116: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10a119: 89 85 b8 00 00 00 mov %eax,0xb8(%ebp) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 10a11f: c7 85 94 00 00 00 01 movl $0x1,0x94(%ebp) 10a126: 00 00 00 } rtems_interrupt_enable (level); 10a129: 52 push %edx 10a12a: 9d popf if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 10a12b: ff 4c 24 18 decl 0x18(%esp) 10a12f: 0f 85 4f ff ff ff jne 10a084 tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 10a135: 83 c4 2c add $0x2c,%esp 10a138: 5b pop %ebx 10a139: 5e pop %esi 10a13a: 5f pop %edi 10a13b: 5d pop %ebp 10a13c: c3 ret tty->rawOutBuf.Head = newHead; if (tty->rawOutBufState == rob_idle) { /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 10a13d: 8b 85 84 00 00 00 mov 0x84(%ebp),%eax tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; tty->rawOutBuf.Head = newHead; if (tty->rawOutBufState == rob_idle) { /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { (*tty->device.write)( 10a143: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) 10a14a: 00 10a14b: 03 45 7c add 0x7c(%ebp),%eax 10a14e: 89 44 24 04 mov %eax,0x4(%esp) 10a152: 8b 45 10 mov 0x10(%ebp),%eax 10a155: 89 04 24 mov %eax,(%esp) 10a158: 89 54 24 14 mov %edx,0x14(%esp) 10a15c: ff 95 a4 00 00 00 call *0xa4(%ebp) 10a162: 8b 54 24 14 mov 0x14(%esp),%edx 10a166: eb b7 jmp 10a11f unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, buf, len); 10a168: 89 4c 24 48 mov %ecx,0x48(%esp) 10a16c: 89 74 24 44 mov %esi,0x44(%esp) 10a170: 8b 45 10 mov 0x10(%ebp),%eax 10a173: 89 44 24 40 mov %eax,0x40(%esp) 10a177: 8b 85 a4 00 00 00 mov 0xa4(%ebp),%eax tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 10a17d: 83 c4 2c add $0x2c,%esp 10a180: 5b pop %ebx 10a181: 5e pop %esi 10a182: 5f pop %edi 10a183: 5d pop %ebp unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, buf, len); 10a184: ff e0 jmp *%eax tty->rawOutBufState = rob_wait; rtems_interrupt_enable (level); sc = rtems_semaphore_obtain( tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 10a186: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a189: e8 22 1f 00 00 call 10c0b0 <== NOT EXECUTED =============================================================================== 0010a774 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 10a774: 55 push %ebp 10a775: 57 push %edi 10a776: 56 push %esi 10a777: 53 push %ebx 10a778: 83 ec 3c sub $0x3c,%esp rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 10a77b: 8b 4c 24 50 mov 0x50(%esp),%ecx 10a77f: 8b 01 mov (%ecx),%eax 10a781: 8b 58 2c mov 0x2c(%eax),%ebx uint32_t count = args->count; 10a784: 8b 49 10 mov 0x10(%ecx),%ecx 10a787: 89 4c 24 24 mov %ecx,0x24(%esp) char *buffer = args->buffer; 10a78b: 8b 4c 24 50 mov 0x50(%esp),%ecx 10a78f: 8b 49 0c mov 0xc(%ecx),%ecx 10a792: 89 4c 24 28 mov %ecx,0x28(%esp) rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10a796: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10a79d: 00 10a79e: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10a7a5: 00 10a7a6: 8b 43 14 mov 0x14(%ebx),%eax 10a7a9: 89 04 24 mov %eax,(%esp) 10a7ac: e8 cb 11 00 00 call 10b97c 10a7b1: 89 44 24 20 mov %eax,0x20(%esp) if (sc != RTEMS_SUCCESSFUL) 10a7b5: 85 c0 test %eax,%eax 10a7b7: 75 39 jne 10a7f2 <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 10a7b9: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10a7bf: c1 e0 05 shl $0x5,%eax 10a7c2: 8b 80 a8 f1 12 00 mov 0x12f1a8(%eax),%eax 10a7c8: 85 c0 test %eax,%eax 10a7ca: 74 34 je 10a800 sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 10a7cc: 8b 4c 24 50 mov 0x50(%esp),%ecx 10a7d0: 89 4c 24 04 mov %ecx,0x4(%esp) 10a7d4: 89 1c 24 mov %ebx,(%esp) 10a7d7: ff d0 call *%eax 10a7d9: 89 44 24 20 mov %eax,0x20(%esp) tty->tty_rcvwakeup = 0; 10a7dd: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10a7e4: 00 00 00 rtems_semaphore_release (tty->isem); 10a7e7: 8b 43 14 mov 0x14(%ebx),%eax 10a7ea: 89 04 24 mov %eax,(%esp) 10a7ed: e8 b6 12 00 00 call 10baa8 } args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; } 10a7f2: 8b 44 24 20 mov 0x20(%esp),%eax 10a7f6: 83 c4 3c add $0x3c,%esp 10a7f9: 5b pop %ebx 10a7fa: 5e pop %esi 10a7fb: 5f pop %edi 10a7fc: 5d pop %ebp 10a7fd: c3 ret 10a7fe: 66 90 xchg %ax,%ax tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; } if (tty->cindex == tty->ccount) { 10a800: 8b 43 20 mov 0x20(%ebx),%eax 10a803: 39 43 24 cmp %eax,0x24(%ebx) 10a806: 74 70 je 10a878 <== ALWAYS TAKEN sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 10a808: 8b 74 24 24 mov 0x24(%esp),%esi 10a80c: 85 f6 test %esi,%esi 10a80e: 74 31 je 10a841 <== NEVER TAKEN 10a810: 8b 43 24 mov 0x24(%ebx),%eax 10a813: 3b 43 20 cmp 0x20(%ebx),%eax 10a816: 7d 31 jge 10a849 } return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) 10a818: 8b 4c 24 28 mov 0x28(%esp),%ecx 10a81c: 29 c1 sub %eax,%ecx 10a81e: 8b 54 24 24 mov 0x24(%esp),%edx 10a822: 89 cf mov %ecx,%edi 10a824: eb 0b jmp 10a831 10a826: 66 90 xchg %ax,%ax sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 10a828: 39 43 20 cmp %eax,0x20(%ebx) 10a82b: 0f 8e df 01 00 00 jle 10aa10 *buffer++ = tty->cbuf[tty->cindex++]; 10a831: 8b 73 1c mov 0x1c(%ebx),%esi 10a834: 8a 0c 06 mov (%esi,%eax,1),%cl 10a837: 88 0c 07 mov %cl,(%edi,%eax,1) 10a83a: 40 inc %eax 10a83b: 89 43 24 mov %eax,0x24(%ebx) sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 10a83e: 4a dec %edx 10a83f: 75 e7 jne 10a828 10a841: c7 44 24 24 00 00 00 movl $0x0,0x24(%esp) 10a848: 00 *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 10a849: 8b 4c 24 50 mov 0x50(%esp),%ecx 10a84d: 8b 41 10 mov 0x10(%ecx),%eax 10a850: 2b 44 24 24 sub 0x24(%esp),%eax 10a854: 89 41 18 mov %eax,0x18(%ecx) tty->tty_rcvwakeup = 0; 10a857: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10a85e: 00 00 00 rtems_semaphore_release (tty->isem); 10a861: 8b 43 14 mov 0x14(%ebx),%eax 10a864: 89 04 24 mov %eax,(%esp) 10a867: e8 3c 12 00 00 call 10baa8 return sc; } 10a86c: 8b 44 24 20 mov 0x20(%esp),%eax 10a870: 83 c4 3c add $0x3c,%esp 10a873: 5b pop %ebx 10a874: 5e pop %esi 10a875: 5f pop %edi 10a876: 5d pop %ebp 10a877: c3 ret rtems_semaphore_release (tty->isem); return sc; } if (tty->cindex == tty->ccount) { tty->cindex = tty->ccount = 0; 10a878: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) 10a87f: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) tty->read_start_column = tty->column; 10a886: 8b 43 28 mov 0x28(%ebx),%eax 10a889: 89 43 2c mov %eax,0x2c(%ebx) if (tty->device.pollRead != NULL && 10a88c: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 10a892: 85 c0 test %eax,%eax 10a894: 74 0e je 10a8a4 10a896: 8b 93 b4 00 00 00 mov 0xb4(%ebx),%edx 10a89c: 85 d2 test %edx,%edx 10a89e: 0f 84 75 01 00 00 je 10aa19 * Fill the input buffer from the raw input queue */ static rtems_status_code fillBufferQueue (struct rtems_termios_tty *tty) { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; 10a8a4: 8b 7b 74 mov 0x74(%ebx),%edi rtems_status_code sc; int wait = 1; 10a8a7: be 01 00 00 00 mov $0x1,%esi == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) || (tty->flow_ctrl & FL_OSTOP))) { /* XON should be sent now... */ (*tty->device.write)( tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); 10a8ac: 8d 4b 49 lea 0x49(%ebx),%ecx 10a8af: 89 4c 24 2c mov %ecx,0x2c(%esp) 10a8b3: 90 nop while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10a8b4: 8b 53 5c mov 0x5c(%ebx),%edx 10a8b7: 8b 43 60 mov 0x60(%ebx),%eax 10a8ba: 39 c2 cmp %eax,%edx 10a8bc: 0f 84 ca 00 00 00 je 10a98c (tty->ccount < (CBUFSIZE-1))) { 10a8c2: a1 3c d2 12 00 mov 0x12d23c,%eax 10a8c7: 48 dec %eax while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10a8c8: 3b 43 20 cmp 0x20(%ebx),%eax 10a8cb: 0f 86 bb 00 00 00 jbe 10a98c <== NEVER TAKEN 10a8d1: 8d 76 00 lea 0x0(%esi),%esi (tty->ccount < (CBUFSIZE-1))) { unsigned char c; unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; 10a8d4: 8b 43 5c mov 0x5c(%ebx),%eax 10a8d7: 8b 4b 64 mov 0x64(%ebx),%ecx 10a8da: 40 inc %eax 10a8db: 31 d2 xor %edx,%edx 10a8dd: f7 f1 div %ecx c = tty->rawInBuf.theBuf[newHead]; 10a8df: 8b 43 58 mov 0x58(%ebx),%eax 10a8e2: 8a 0c 10 mov (%eax,%edx,1),%cl tty->rawInBuf.Head = newHead; 10a8e5: 89 53 5c mov %edx,0x5c(%ebx) if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 10a8e8: 8b 43 60 mov 0x60(%ebx),%eax 10a8eb: 8b 6b 64 mov 0x64(%ebx),%ebp % tty->rawInBuf.Size) 10a8ee: 8b 7b 64 mov 0x64(%ebx),%edi unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; c = tty->rawInBuf.theBuf[newHead]; tty->rawInBuf.Head = newHead; if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 10a8f1: 01 e8 add %ebp,%eax 10a8f3: 29 d0 sub %edx,%eax % tty->rawInBuf.Size) 10a8f5: 31 d2 xor %edx,%edx 10a8f7: f7 f7 div %edi unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; c = tty->rawInBuf.theBuf[newHead]; tty->rawInBuf.Head = newHead; if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 10a8f9: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx 10a8ff: 73 5b jae 10a95c <== NEVER TAKEN % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 10a901: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a907: 83 e0 fe and $0xfffffffe,%eax 10a90a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) /* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) 10a910: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a916: 25 02 02 00 00 and $0x202,%eax 10a91b: 3d 02 02 00 00 cmp $0x202,%eax 10a920: 0f 84 a6 00 00 00 je 10a9cc <== NEVER TAKEN && ((tty->rawOutBufState == rob_idle) || (tty->flow_ctrl & FL_OSTOP))) { /* XON should be sent now... */ (*tty->device.write)( tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 10a926: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10a92c: f6 c4 01 test $0x1,%ah 10a92f: 74 2b je 10a95c <== ALWAYS TAKEN tty->flow_ctrl &= ~FL_IRTSOFF; 10a931: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a937: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10a93a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 10a940: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 10a946: 85 c0 test %eax,%eax <== NOT EXECUTED 10a948: 74 12 je 10a95c <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 10a94a: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED 10a94d: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10a950: 88 4c 24 1c mov %cl,0x1c(%esp) <== NOT EXECUTED 10a954: ff d0 call *%eax <== NOT EXECUTED 10a956: 8a 4c 24 1c mov 0x1c(%esp),%cl <== NOT EXECUTED 10a95a: 66 90 xchg %ax,%ax <== NOT EXECUTED } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) 10a95c: 0f b6 c1 movzbl %cl,%eax 10a95f: 89 da mov %ebx,%edx } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 10a961: f6 43 3c 02 testb $0x2,0x3c(%ebx) 10a965: 74 51 je 10a9b8 <== NEVER TAKEN if (siproc (c, tty)) 10a967: e8 e4 fc ff ff call 10a650 10a96c: 85 c0 test %eax,%eax 10a96e: 75 56 jne 10a9c6 } else { siproc (c, tty); if (tty->ccount >= tty->termios.c_cc[VMIN]) wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 10a970: 8b 7b 70 mov 0x70(%ebx),%edi while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10a973: 8b 53 5c mov 0x5c(%ebx),%edx 10a976: 8b 43 60 mov 0x60(%ebx),%eax 10a979: 39 c2 cmp %eax,%edx 10a97b: 74 0f je 10a98c (tty->ccount < (CBUFSIZE-1))) { 10a97d: a1 3c d2 12 00 mov 0x12d23c,%eax 10a982: 48 dec %eax while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10a983: 39 43 20 cmp %eax,0x20(%ebx) 10a986: 0f 82 48 ff ff ff jb 10a8d4 <== ALWAYS TAKEN } /* * Wait for characters */ if ( wait ) { 10a98c: 85 f6 test %esi,%esi 10a98e: 0f 84 74 fe ff ff je 10a808 sc = rtems_semaphore_obtain( 10a994: 89 7c 24 08 mov %edi,0x8(%esp) 10a998: 8b 43 6c mov 0x6c(%ebx),%eax 10a99b: 89 44 24 04 mov %eax,0x4(%esp) 10a99f: 8b 43 68 mov 0x68(%ebx),%eax 10a9a2: 89 04 24 mov %eax,(%esp) 10a9a5: e8 d2 0f 00 00 call 10b97c tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 10a9aa: 85 c0 test %eax,%eax 10a9ac: 0f 84 02 ff ff ff je 10a8b4 10a9b2: e9 51 fe ff ff jmp 10a808 10a9b7: 90 nop /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) wait = 0; } else { siproc (c, tty); 10a9b8: e8 93 fc ff ff call 10a650 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 10a9bd: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED 10a9c1: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED 10a9c4: 7c aa jl 10a970 <== NOT EXECUTED } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) wait = 0; 10a9c6: 31 f6 xor %esi,%esi 10a9c8: eb a6 jmp 10a970 10a9ca: 66 90 xchg %ax,%ax < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; /* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) 10a9cc: 8b bb 94 00 00 00 mov 0x94(%ebx),%edi <== NOT EXECUTED 10a9d2: 85 ff test %edi,%edi <== NOT EXECUTED 10a9d4: 74 0e je 10a9e4 <== NOT EXECUTED || (tty->flow_ctrl & FL_OSTOP))) { 10a9d6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a9dc: a8 20 test $0x20,%al <== NOT EXECUTED 10a9de: 0f 84 42 ff ff ff je 10a926 <== NOT EXECUTED /* XON should be sent now... */ (*tty->device.write)( 10a9e4: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED 10a9eb: 00 tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); 10a9ec: 8b 44 24 2c mov 0x2c(%esp),%eax <== NOT EXECUTED 10a9f0: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) || (tty->flow_ctrl & FL_OSTOP))) { /* XON should be sent now... */ (*tty->device.write)( 10a9f4: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10a9f7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a9fa: 88 4c 24 1c mov %cl,0x1c(%esp) <== NOT EXECUTED 10a9fe: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10aa04: 8a 4c 24 1c mov 0x1c(%esp),%cl <== NOT EXECUTED 10aa08: e9 4f ff ff ff jmp 10a95c <== NOT EXECUTED 10aa0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10aa10: 89 54 24 24 mov %edx,0x24(%esp) 10aa14: e9 30 fe ff ff jmp 10a849 static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 10aa19: f6 43 3c 02 testb $0x2,0x3c(%ebx) 10aa1d: 75 1f jne 10aa3e 10aa1f: eb 37 jmp 10aa58 10aa21: 8d 76 00 lea 0x0(%esi),%esi for (;;) { n = (*tty->device.pollRead)(tty->minor); if (n < 0) { rtems_task_wake_after (1); } else { if (siproc (n, tty)) 10aa24: 25 ff 00 00 00 and $0xff,%eax 10aa29: 89 da mov %ebx,%edx 10aa2b: e8 20 fc ff ff call 10a650 10aa30: 85 c0 test %eax,%eax 10aa32: 0f 85 d0 fd ff ff jne 10a808 10aa38: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax { int n; if (tty->termios.c_lflag & ICANON) { for (;;) { n = (*tty->device.pollRead)(tty->minor); 10aa3e: 8b 53 10 mov 0x10(%ebx),%edx 10aa41: 89 14 24 mov %edx,(%esp) 10aa44: ff d0 call *%eax if (n < 0) { 10aa46: 85 c0 test %eax,%eax 10aa48: 79 da jns 10aa24 rtems_task_wake_after (1); 10aa4a: c7 04 24 01 00 00 00 movl $0x1,(%esp) 10aa51: e8 62 14 00 00 call 10beb8 10aa56: eb e0 jmp 10aa38 } } } else { rtems_interval then, now; then = rtems_clock_get_ticks_since_boot(); 10aa58: e8 83 08 00 00 call 10b2e0 10aa5d: 89 c6 mov %eax,%esi 10aa5f: 90 nop for (;;) { n = (*tty->device.pollRead)(tty->minor); 10aa60: 8b 53 10 mov 0x10(%ebx),%edx 10aa63: 89 14 24 mov %edx,(%esp) 10aa66: ff 93 a0 00 00 00 call *0xa0(%ebx) if (n < 0) { 10aa6c: 85 c0 test %eax,%eax 10aa6e: 78 28 js 10aa98 break; } } rtems_task_wake_after (1); } else { siproc (n, tty); 10aa70: 25 ff 00 00 00 and $0xff,%eax 10aa75: 89 da mov %ebx,%edx 10aa77: e8 d4 fb ff ff call 10a650 if (tty->ccount >= tty->termios.c_cc[VMIN]) 10aa7c: 8a 43 47 mov 0x47(%ebx),%al 10aa7f: 0f b6 d0 movzbl %al,%edx 10aa82: 39 53 20 cmp %edx,0x20(%ebx) 10aa85: 0f 8d 7d fd ff ff jge 10a808 break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 10aa8b: 84 c0 test %al,%al 10aa8d: 74 d1 je 10aa60 <== NEVER TAKEN 10aa8f: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 10aa93: 74 cb je 10aa60 <== NEVER TAKEN 10aa95: eb c1 jmp 10aa58 10aa97: 90 nop then = rtems_clock_get_ticks_since_boot(); for (;;) { n = (*tty->device.pollRead)(tty->minor); if (n < 0) { if (tty->termios.c_cc[VMIN]) { 10aa98: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 10aa9c: 74 1c je 10aaba <== NEVER TAKEN if (tty->termios.c_cc[VTIME] && tty->ccount) { 10aa9e: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 10aaa2: 74 08 je 10aaac <== NEVER TAKEN 10aaa4: 8b 6b 20 mov 0x20(%ebx),%ebp 10aaa7: 85 ed test %ebp,%ebp 10aaa9: 75 19 jne 10aac4 10aaab: 90 nop now = rtems_clock_get_ticks_since_boot(); if ((now - then) > tty->vtimeTicks) { break; } } rtems_task_wake_after (1); 10aaac: c7 04 24 01 00 00 00 movl $0x1,(%esp) 10aab3: e8 00 14 00 00 call 10beb8 10aab8: eb a6 jmp 10aa60 if ((now - then) > tty->vtimeTicks) { break; } } } else { if (!tty->termios.c_cc[VTIME]) 10aaba: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 10aabe: 0f 84 44 fd ff ff je 10a808 <== NOT EXECUTED break; now = rtems_clock_get_ticks_since_boot(); 10aac4: e8 17 08 00 00 call 10b2e0 if ((now - then) > tty->vtimeTicks) { 10aac9: 29 f0 sub %esi,%eax 10aacb: 3b 43 54 cmp 0x54(%ebx),%eax 10aace: 76 dc jbe 10aaac 10aad0: e9 33 fd ff ff jmp 10a808 =============================================================================== 00109310 : * in task-driven mode, this function is called in Tx task context * in interrupt-driven mode, this function is called in TxIRQ context */ static int rtems_termios_refill_transmitter (struct rtems_termios_tty *tty) { 109310: 57 push %edi 109311: 56 push %esi 109312: 53 push %ebx 109313: 83 ec 10 sub $0x10,%esp 109316: 89 c3 mov %eax,%ebx int nToSend; rtems_interrupt_level level; int len; /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF)) 109318: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax 10931e: 25 03 04 00 00 and $0x403,%eax 109323: 3d 01 04 00 00 cmp $0x401,%eax 109328: 0f 84 5e 01 00 00 je 10948c <== NEVER TAKEN tty->flow_ctrl |= FL_ISNTXOF; rtems_interrupt_enable(level); nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) { 10932e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109334: 83 e0 03 and $0x3,%eax 109337: 83 f8 02 cmp $0x2,%eax 10933a: 0f 84 90 01 00 00 je 1094d0 <== NEVER TAKEN tty->flow_ctrl &= ~FL_ISNTXOF; rtems_interrupt_enable(level); nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 109340: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 109346: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 10934c: 39 c2 cmp %eax,%edx 10934e: 0f 84 a8 00 00 00 je 1093fc rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; } rtems_interrupt_disable(level); 109354: 9c pushf 109355: fa cli 109356: 58 pop %eax len = tty->t_dqlen; 109357: 8b b3 90 00 00 00 mov 0x90(%ebx),%esi tty->t_dqlen = 0; 10935d: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx) 109364: 00 00 00 rtems_interrupt_enable(level); 109367: 50 push %eax 109368: 9d popf newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 109369: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 10936f: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 109375: 01 f0 add %esi,%eax 109377: 31 d2 xor %edx,%edx 109379: f7 f1 div %ecx 10937b: 89 d6 mov %edx,%esi tty->rawOutBuf.Tail = newTail; 10937d: 89 93 84 00 00 00 mov %edx,0x84(%ebx) if (tty->rawOutBufState == rob_wait) { 109383: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 10938a: 0f 84 e8 00 00 00 je 109478 * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } if (newTail == tty->rawOutBuf.Head) { 109390: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 109396: 39 f0 cmp %esi,%eax 109398: 74 7a je 109414 if ( tty->tty_snd.sw_pfn != NULL) { (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 10939a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1093a0: 25 10 02 00 00 and $0x210,%eax 1093a5: 3d 10 02 00 00 cmp $0x210,%eax 1093aa: 0f 84 64 01 00 00 je 109514 <== NEVER TAKEN nToSend = 0; } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 1093b0: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 1093b6: 39 c6 cmp %eax,%esi 1093b8: 0f 87 92 00 00 00 ja 109450 nToSend = tty->rawOutBuf.Size - newTail; else nToSend = tty->rawOutBuf.Head - newTail; 1093be: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi 1093c4: 29 f7 sub %esi,%edi /* when flow control XON or XOF, don't send blocks of data */ /* to allow fast reaction on incoming flow ctrl and low latency*/ /* for outgoing flow control */ if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) { 1093c6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1093cc: f6 c4 06 test $0x6,%ah 1093cf: 0f 85 92 00 00 00 jne 109467 1093d5: 89 f8 mov %edi,%eax nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ 1093d7: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 1093de: 00 00 00 (*tty->device.write)( 1093e1: 89 44 24 08 mov %eax,0x8(%esp) 1093e5: 8b 43 7c mov 0x7c(%ebx),%eax 1093e8: 01 f0 add %esi,%eax 1093ea: 89 44 24 04 mov %eax,0x4(%esp) 1093ee: 8b 43 10 mov 0x10(%ebx),%eax 1093f1: 89 04 24 mov %eax,(%esp) 1093f4: ff 93 a4 00 00 00 call *0xa4(%ebx) 1093fa: eb 44 jmp 109440 } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 1093fc: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 109403: 0f 84 33 01 00 00 je 10953c <== NEVER TAKEN /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; 109409: 31 ff xor %edi,%edi tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 10940b: 89 f8 mov %edi,%eax 10940d: 83 c4 10 add $0x10,%esp 109410: 5b pop %ebx 109411: 5e pop %esi 109412: 5f pop %edi 109413: c3 ret if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 109414: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 10941b: 00 00 00 nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 10941e: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax 109424: 85 c0 test %eax,%eax 109426: 0f 84 28 01 00 00 je 109554 <== ALWAYS TAKEN (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 10942c: 8b 93 d8 00 00 00 mov 0xd8(%ebx),%edx <== NOT EXECUTED 109432: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 109436: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 109439: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10943c: ff d0 call *%eax <== NOT EXECUTED if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; nToSend = 0; 10943e: 31 ff xor %edi,%edi <== NOT EXECUTED } tty->rawOutBufState = rob_busy; /*apm*/ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 109440: 89 b3 84 00 00 00 mov %esi,0x84(%ebx) } return nToSend; } 109446: 89 f8 mov %edi,%eax 109448: 83 c4 10 add $0x10,%esp 10944b: 5b pop %ebx 10944c: 5e pop %esi 10944d: 5f pop %edi 10944e: c3 ret 10944f: 90 nop } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) nToSend = tty->rawOutBuf.Size - newTail; 109450: 8b bb 88 00 00 00 mov 0x88(%ebx),%edi 109456: 29 f7 sub %esi,%edi else nToSend = tty->rawOutBuf.Head - newTail; /* when flow control XON or XOF, don't send blocks of data */ /* to allow fast reaction on incoming flow ctrl and low latency*/ /* for outgoing flow control */ if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) { 109458: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10945e: f6 c4 06 test $0x6,%ah 109461: 0f 84 6e ff ff ff je 1093d5 <== ALWAYS TAKEN 109467: b8 01 00 00 00 mov $0x1,%eax nToSend = 1; 10946c: bf 01 00 00 00 mov $0x1,%edi 109471: e9 61 ff ff ff jmp 1093d7 109476: 66 90 xchg %ax,%ax tty->rawOutBuf.Tail = newTail; if (tty->rawOutBufState == rob_wait) { /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 109478: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 10947e: 89 04 24 mov %eax,(%esp) 109481: e8 22 26 00 00 call 10baa8 109486: e9 05 ff ff ff jmp 109390 10948b: 90 nop /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF)) == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); 10948c: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED 109493: 00 109494: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 109497: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10949b: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10949e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1094a1: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 1094a7: 9c pushf <== NOT EXECUTED 1094a8: fa cli <== NOT EXECUTED 1094a9: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 1094aa: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 1094b0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1094b6: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 1094b9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 1094bf: 52 push %edx <== NOT EXECUTED 1094c0: 9d popf <== NOT EXECUTED nToSend = 1; 1094c1: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 1094c6: 89 f8 mov %edi,%eax <== NOT EXECUTED 1094c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1094cb: 5b pop %ebx <== NOT EXECUTED 1094cc: 5e pop %esi <== NOT EXECUTED 1094cd: 5f pop %edi <== NOT EXECUTED 1094ce: c3 ret <== NOT EXECUTED 1094cf: 90 nop <== NOT EXECUTED * FIXME: this .write call will generate another * dequeue callback. This will advance the "Tail" in the data * buffer, although the corresponding data is not yet out! * Therefore the dequeue "length" should be reduced by 1 */ (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); 1094d0: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) <== NOT EXECUTED 1094d7: 00 1094d8: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 1094db: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1094df: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1094e2: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1094e5: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 1094eb: 9c pushf <== NOT EXECUTED 1094ec: fa cli <== NOT EXECUTED 1094ed: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 1094ee: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 1094f4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1094fa: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 1094fd: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 109503: 52 push %edx <== NOT EXECUTED 109504: 9d popf <== NOT EXECUTED nToSend = 1; 109505: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 10950a: 89 f8 mov %edi,%eax <== NOT EXECUTED 10950c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10950f: 5b pop %ebx <== NOT EXECUTED 109510: 5e pop %esi <== NOT EXECUTED 109511: 5f pop %edi <== NOT EXECUTED 109512: c3 ret <== NOT EXECUTED 109513: 90 nop <== NOT EXECUTED /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) == (FL_MDXON | FL_ORCVXOF)) { /* Buffer not empty, but output stops due to XOFF */ /* set flag, that output has been stopped */ rtems_interrupt_disable(level); 109514: 9c pushf <== NOT EXECUTED 109515: fa cli <== NOT EXECUTED 109516: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 109517: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10951d: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 109520: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 109526: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 10952d: 00 00 00 rtems_interrupt_enable(level); 109530: 52 push %edx <== NOT EXECUTED 109531: 9d popf <== NOT EXECUTED nToSend = 0; 109532: 31 ff xor %edi,%edi <== NOT EXECUTED 109534: e9 07 ff ff ff jmp 109440 <== NOT EXECUTED 109539: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ if (tty->rawOutBufState == rob_wait) { /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 10953c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED 109542: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 109545: e8 5e 25 00 00 call 10baa8 <== NOT EXECUTED } return 0; 10954a: 31 ff xor %edi,%edi <== NOT EXECUTED 10954c: e9 ba fe ff ff jmp 10940b <== NOT EXECUTED 109551: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; nToSend = 0; 109554: 31 ff xor %edi,%edi 109556: e9 e5 fe ff ff jmp 109440 =============================================================================== 0010adf8 : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 10adf8: 57 push %edi 10adf9: 56 push %esi 10adfa: 53 push %ebx 10adfb: 83 ec 20 sub $0x20,%esp 10adfe: 8b 5c 24 30 mov 0x30(%esp),%ebx 10ae02: 8d 74 24 1c lea 0x1c(%esp),%esi 10ae06: 8d 7c 24 1b lea 0x1b(%esp),%edi 10ae0a: eb 11 jmp 10ae1d } /* * do something */ c = tty->device.pollRead(tty->minor); 10ae0c: 8b 43 10 mov 0x10(%ebx),%eax 10ae0f: 89 04 24 mov %eax,(%esp) 10ae12: ff 93 a0 00 00 00 call *0xa0(%ebx) if (c != EOF) { 10ae18: 83 f8 ff cmp $0xffffffff,%eax 10ae1b: 75 3f jne 10ae5c while (1) { /* * wait for rtems event */ rtems_event_receive( 10ae1d: 89 74 24 0c mov %esi,0xc(%esp) 10ae21: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10ae28: 00 10ae29: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp) 10ae30: 00 10ae31: c7 04 24 03 00 00 00 movl $0x3,(%esp) 10ae38: e8 fb 04 00 00 call 10b338 (TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event ); if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) { 10ae3d: f6 44 24 1c 01 testb $0x1,0x1c(%esp) 10ae42: 74 c8 je 10ae0c <== ALWAYS TAKEN tty->rxTaskId = 0; 10ae44: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 10ae4b: 00 00 00 rtems_task_delete(RTEMS_SELF); 10ae4e: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 10ae55: e8 5e 0e 00 00 call 10bcb8 <== NOT EXECUTED 10ae5a: eb b0 jmp 10ae0c <== NOT EXECUTED c = tty->device.pollRead(tty->minor); if (c != EOF) { /* * pollRead did call enqueue on its own */ c_buf = c; 10ae5c: 88 44 24 1b mov %al,0x1b(%esp) rtems_termios_enqueue_raw_characters ( tty,&c_buf,1); 10ae60: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp) 10ae67: 00 10ae68: 89 7c 24 04 mov %edi,0x4(%esp) 10ae6c: 89 1c 24 mov %ebx,(%esp) 10ae6f: e8 88 fc ff ff call 10aafc 10ae74: eb a7 jmp 10ae1d =============================================================================== 0010955c : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 10955c: 56 push %esi 10955d: 53 push %ebx 10955e: 83 ec 24 sub $0x24,%esp 109561: 8b 5c 24 30 mov 0x30(%esp),%ebx 109565: 8d 74 24 1c lea 0x1c(%esp),%esi 109569: eb 20 jmp 10958b 10956b: 90 nop } /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 10956c: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx 109572: c1 e2 05 shl $0x5,%edx 109575: 8b 82 b4 f1 12 00 mov 0x12f1b4(%edx),%eax 10957b: 85 c0 test %eax,%eax 10957d: 74 05 je 109584 rtems_termios_linesw[tty->t_line].l_start(tty); 10957f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109582: ff d0 call *%eax <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 109584: 89 d8 mov %ebx,%eax 109586: e8 85 fd ff ff call 109310 while (1) { /* * wait for rtems event */ rtems_event_receive( 10958b: 89 74 24 0c mov %esi,0xc(%esp) 10958f: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 109596: 00 109597: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp) 10959e: 00 10959f: c7 04 24 03 00 00 00 movl $0x3,(%esp) 1095a6: e8 8d 1d 00 00 call 10b338 (TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event ); if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) { 1095ab: f6 44 24 1c 01 testb $0x1,0x1c(%esp) 1095b0: 74 ba je 10956c tty->txTaskId = 0; 1095b2: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 1095b9: 00 00 00 rtems_task_delete(RTEMS_SELF); 1095bc: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 1095c3: e8 f0 26 00 00 call 10bcb8 <== NOT EXECUTED 1095c8: eb a2 jmp 10956c <== NOT EXECUTED =============================================================================== 0010a6b0 : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 10a6b0: 55 push %ebp 10a6b1: 57 push %edi 10a6b2: 56 push %esi 10a6b3: 53 push %ebx 10a6b4: 83 ec 2c sub $0x2c,%esp 10a6b7: 8b 6c 24 40 mov 0x40(%esp),%ebp rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 10a6bb: 8b 45 00 mov 0x0(%ebp),%eax 10a6be: 8b 58 2c mov 0x2c(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10a6c1: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10a6c8: 00 10a6c9: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10a6d0: 00 10a6d1: 8b 43 18 mov 0x18(%ebx),%eax 10a6d4: 89 04 24 mov %eax,(%esp) 10a6d7: e8 a0 12 00 00 call 10b97c 10a6dc: 89 c7 mov %eax,%edi if (sc != RTEMS_SUCCESSFUL) 10a6de: 85 c0 test %eax,%eax 10a6e0: 75 29 jne 10a70b <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 10a6e2: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10a6e8: c1 e0 05 shl $0x5,%eax 10a6eb: 8b 80 ac f1 12 00 mov 0x12f1ac(%eax),%eax 10a6f1: 85 c0 test %eax,%eax 10a6f3: 74 23 je 10a718 sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 10a6f5: 89 6c 24 04 mov %ebp,0x4(%esp) 10a6f9: 89 1c 24 mov %ebx,(%esp) 10a6fc: ff d0 call *%eax 10a6fe: 89 c7 mov %eax,%edi rtems_semaphore_release (tty->osem); 10a700: 8b 43 18 mov 0x18(%ebx),%eax 10a703: 89 04 24 mov %eax,(%esp) 10a706: e8 9d 13 00 00 call 10baa8 rtems_termios_puts (args->buffer, args->count, tty); args->bytes_moved = args->count; } rtems_semaphore_release (tty->osem); return sc; } 10a70b: 89 f8 mov %edi,%eax 10a70d: 83 c4 2c add $0x2c,%esp 10a710: 5b pop %ebx 10a711: 5e pop %esi 10a712: 5f pop %edi 10a713: 5d pop %ebp 10a714: c3 ret 10a715: 8d 76 00 lea 0x0(%esi),%esi if (rtems_termios_linesw[tty->t_line].l_write != NULL) { sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); rtems_semaphore_release (tty->osem); return sc; } if (tty->termios.c_oflag & OPOST) { 10a718: f6 43 34 01 testb $0x1,0x34(%ebx) 10a71c: 74 3a je 10a758 <== NEVER TAKEN uint32_t count = args->count; 10a71e: 8b 45 10 mov 0x10(%ebp),%eax 10a721: 89 44 24 1c mov %eax,0x1c(%esp) char *buffer = args->buffer; 10a725: 8b 75 0c mov 0xc(%ebp),%esi while (count--) 10a728: 85 c0 test %eax,%eax 10a72a: 74 44 je 10a770 <== NEVER TAKEN oproc (*buffer++, tty); 10a72c: 0f b6 06 movzbl (%esi),%eax 10a72f: 46 inc %esi 10a730: 89 da mov %ebx,%edx 10a732: e8 59 fa ff ff call 10a190 return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 10a737: ff 4c 24 1c decl 0x1c(%esp) 10a73b: 75 ef jne 10a72c oproc (*buffer++, tty); args->bytes_moved = args->count; } else { rtems_termios_puts (args->buffer, args->count, tty); args->bytes_moved = args->count; 10a73d: 8b 45 10 mov 0x10(%ebp),%eax 10a740: 89 45 18 mov %eax,0x18(%ebp) } rtems_semaphore_release (tty->osem); 10a743: 8b 43 18 mov 0x18(%ebx),%eax 10a746: 89 04 24 mov %eax,(%esp) 10a749: e8 5a 13 00 00 call 10baa8 return sc; } 10a74e: 89 f8 mov %edi,%eax 10a750: 83 c4 2c add $0x2c,%esp 10a753: 5b pop %ebx 10a754: 5e pop %esi 10a755: 5f pop %edi 10a756: 5d pop %ebp 10a757: c3 ret char *buffer = args->buffer; while (count--) oproc (*buffer++, tty); args->bytes_moved = args->count; } else { rtems_termios_puts (args->buffer, args->count, tty); 10a758: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED 10a75c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a75f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10a763: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a766: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a769: e8 de f8 ff ff call 10a04c <== NOT EXECUTED 10a76e: eb cd jmp 10a73d <== NOT EXECUTED return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 10a770: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a772: eb cc jmp 10a740 <== NOT EXECUTED =============================================================================== 0011b6b8 : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 11b6b8: 83 ec 2c sub $0x2c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 11b6bb: 8d 44 24 1c lea 0x1c(%esp),%eax 11b6bf: 89 44 24 08 mov %eax,0x8(%esp) RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 11b6c3: 8b 44 24 30 mov 0x30(%esp),%eax 11b6c7: 89 44 24 04 mov %eax,0x4(%esp) 11b6cb: c7 04 24 40 dd 14 00 movl $0x14dd40,(%esp) 11b6d2: e8 f9 2c 00 00 call 11e3d0 <_Objects_Get> switch ( location ) { 11b6d7: 8b 54 24 1c mov 0x1c(%esp),%edx 11b6db: 85 d2 test %edx,%edx 11b6dd: 75 1d jne 11b6fc case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 11b6df: 83 78 38 04 cmpl $0x4,0x38(%eax) 11b6e3: 74 0b je 11b6f0 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 11b6e5: 83 c0 10 add $0x10,%eax 11b6e8: 89 04 24 mov %eax,(%esp) 11b6eb: e8 34 48 00 00 call 11ff24 <_Watchdog_Remove> _Thread_Enable_dispatch(); 11b6f0: e8 6f 39 00 00 call 11f064 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11b6f5: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11b6f7: 83 c4 2c add $0x2c,%esp 11b6fa: c3 ret 11b6fb: 90 nop #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11b6fc: b8 04 00 00 00 mov $0x4,%eax } 11b701: 83 c4 2c add $0x2c,%esp 11b704: c3 ret =============================================================================== 0011bc38 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 11bc38: 57 push %edi 11bc39: 56 push %esi 11bc3a: 53 push %ebx 11bc3b: 83 ec 20 sub $0x20,%esp Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 11bc3e: 8b 1d 80 dd 14 00 mov 0x14dd80,%ebx if ( !timer_server ) 11bc44: 85 db test %ebx,%ebx 11bc46: 74 3c je 11bc84 return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) 11bc48: 80 3d d4 d9 14 00 00 cmpb $0x0,0x14d9d4 11bc4f: 75 0f jne 11bc60 <== ALWAYS TAKEN return RTEMS_NOT_DEFINED; 11bc51: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11bc56: 83 c4 20 add $0x20,%esp 11bc59: 5b pop %ebx 11bc5a: 5e pop %esi 11bc5b: 5f pop %edi 11bc5c: c3 ret 11bc5d: 8d 76 00 lea 0x0(%esi),%esi return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 11bc60: 8b 54 24 38 mov 0x38(%esp),%edx 11bc64: 85 d2 test %edx,%edx 11bc66: 74 28 je 11bc90 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 11bc68: 8b 44 24 34 mov 0x34(%esp),%eax 11bc6c: 89 04 24 mov %eax,(%esp) 11bc6f: e8 98 cc ff ff call 11890c <_TOD_Validate> 11bc74: 84 c0 test %al,%al 11bc76: 75 24 jne 11bc9c return RTEMS_INVALID_CLOCK; 11bc78: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11bc7d: 83 c4 20 add $0x20,%esp 11bc80: 5b pop %ebx 11bc81: 5e pop %esi 11bc82: 5f pop %edi 11bc83: c3 ret Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 11bc84: b8 0e 00 00 00 mov $0xe,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11bc89: 83 c4 20 add $0x20,%esp 11bc8c: 5b pop %ebx 11bc8d: 5e pop %esi 11bc8e: 5f pop %edi 11bc8f: c3 ret if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 11bc90: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11bc95: 83 c4 20 add $0x20,%esp 11bc98: 5b pop %ebx 11bc99: 5e pop %esi 11bc9a: 5f pop %edi 11bc9b: c3 ret return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 11bc9c: 8b 54 24 34 mov 0x34(%esp),%edx 11bca0: 89 14 24 mov %edx,(%esp) 11bca3: e8 d4 cb ff ff call 11887c <_TOD_To_seconds> 11bca8: 89 c6 mov %eax,%esi 11bcaa: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 11bcb1: 3b 11bcb2: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 11bcb9: 00 11bcba: a1 c0 d9 14 00 mov 0x14d9c0,%eax 11bcbf: 8b 15 c4 d9 14 00 mov 0x14d9c4,%edx 11bcc5: 89 04 24 mov %eax,(%esp) 11bcc8: 89 54 24 04 mov %edx,0x4(%esp) 11bccc: e8 73 43 01 00 call 130044 <__divdi3> if ( seconds <= _TOD_Seconds_since_epoch() ) 11bcd1: 39 c6 cmp %eax,%esi 11bcd3: 76 a3 jbe 11bc78 return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 11bcd5: 8d 44 24 1c lea 0x1c(%esp),%eax 11bcd9: 89 44 24 08 mov %eax,0x8(%esp) 11bcdd: 8b 54 24 30 mov 0x30(%esp),%edx 11bce1: 89 54 24 04 mov %edx,0x4(%esp) 11bce5: c7 04 24 40 dd 14 00 movl $0x14dd40,(%esp) 11bcec: e8 df 26 00 00 call 11e3d0 <_Objects_Get> 11bcf1: 89 c7 mov %eax,%edi switch ( location ) { 11bcf3: 8b 44 24 1c mov 0x1c(%esp),%eax 11bcf7: 85 c0 test %eax,%eax 11bcf9: 75 70 jne 11bd6b case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 11bcfb: 8d 47 10 lea 0x10(%edi),%eax 11bcfe: 89 04 24 mov %eax,(%esp) 11bd01: e8 1e 42 00 00 call 11ff24 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 11bd06: c7 47 38 03 00 00 00 movl $0x3,0x38(%edi) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 11bd0d: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 11bd14: 8b 44 24 38 mov 0x38(%esp),%eax 11bd18: 89 47 2c mov %eax,0x2c(%edi) the_watchdog->id = id; 11bd1b: 8b 54 24 30 mov 0x30(%esp),%edx 11bd1f: 89 57 30 mov %edx,0x30(%edi) the_watchdog->user_data = user_data; 11bd22: 8b 44 24 3c mov 0x3c(%esp),%eax 11bd26: 89 47 34 mov %eax,0x34(%edi) 11bd29: c7 44 24 08 00 ca 9a movl $0x3b9aca00,0x8(%esp) 11bd30: 3b 11bd31: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) 11bd38: 00 11bd39: a1 c0 d9 14 00 mov 0x14d9c0,%eax 11bd3e: 8b 15 c4 d9 14 00 mov 0x14d9c4,%edx 11bd44: 89 04 24 mov %eax,(%esp) 11bd47: 89 54 24 04 mov %edx,0x4(%esp) 11bd4b: e8 f4 42 01 00 call 130044 <__divdi3> _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 11bd50: 29 c6 sub %eax,%esi 11bd52: 89 77 1c mov %esi,0x1c(%edi) (*timer_server->schedule_operation)( timer_server, the_timer ); 11bd55: 89 7c 24 04 mov %edi,0x4(%esp) 11bd59: 89 1c 24 mov %ebx,(%esp) 11bd5c: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 11bd5f: e8 00 33 00 00 call 11f064 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11bd64: 31 c0 xor %eax,%eax 11bd66: e9 eb fe ff ff jmp 11bc56 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11bd6b: b8 04 00 00 00 mov $0x4,%eax 11bd70: e9 e1 fe ff ff jmp 11bc56 =============================================================================== 0010773c : static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { 10773c: 55 push %ebp 10773d: 57 push %edi 10773e: 56 push %esi 10773f: 53 push %ebx 107740: 83 ec 2c sub $0x2c,%esp 107743: 89 c3 mov %eax,%ebx 107745: 89 d5 mov %edx,%ebp int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) { 107747: a9 00 00 00 20 test $0x20000000,%eax 10774c: 74 30 je 10777e if (rtems_panic_in_progress++) 10774e: 8b 15 d0 f4 12 00 mov 0x12f4d0,%edx 107754: 8d 42 01 lea 0x1(%edx),%eax 107757: a3 d0 f4 12 00 mov %eax,0x12f4d0 10775c: 85 d2 test %edx,%edx 10775e: 74 15 je 107775 <== ALWAYS TAKEN * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { _Thread_Dispatch_disable_level++; 107760: a1 04 f6 12 00 mov 0x12f604,%eax <== NOT EXECUTED 107765: 40 inc %eax <== NOT EXECUTED 107766: a3 04 f6 12 00 mov %eax,0x12f604 <== NOT EXECUTED return _Thread_Dispatch_disable_level; 10776b: a1 04 f6 12 00 mov 0x12f604,%eax <== NOT EXECUTED void _Thread_Disable_dispatch( void ); #else RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void ) { _Thread_Dispatch_increment_disable_level(); RTEMS_COMPILER_MEMORY_BARRIER(); 107770: a1 d0 f4 12 00 mov 0x12f4d0,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 107775: 83 f8 02 cmp $0x2,%eax 107778: 0f 8f b6 00 00 00 jg 107834 <== NEVER TAKEN return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10777e: a1 20 d4 12 00 mov 0x12d420,%eax 107783: 8b 40 08 mov 0x8(%eax),%eax 107786: 89 04 24 mov %eax,(%esp) 107789: 89 4c 24 1c mov %ecx,0x1c(%esp) 10778d: e8 ce b8 00 00 call 113060 status = error_flag & ~RTEMS_ERROR_MASK; 107792: 89 df mov %ebx,%edi 107794: 81 e7 ff ff ff 8f and $0x8fffffff,%edi if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 10779a: 81 e3 00 00 00 40 and $0x40000000,%ebx 1077a0: 8b 4c 24 1c mov 0x1c(%esp),%ecx 1077a4: 0f 85 c2 00 00 00 jne 10786c rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { int local_errno = 0; 1077aa: 31 f6 xor %esi,%esi #if defined(RTEMS_MULTIPROCESSING) if (_System_state_Is_multiprocessing) fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node); #endif chars_written += vfprintf(stderr, printf_format, arglist); 1077ac: 89 4c 24 08 mov %ecx,0x8(%esp) 1077b0: 89 6c 24 04 mov %ebp,0x4(%esp) 1077b4: a1 20 d4 12 00 mov 0x12d420,%eax 1077b9: 8b 40 0c mov 0xc(%eax),%eax 1077bc: 89 04 24 mov %eax,(%esp) 1077bf: e8 ec 32 01 00 call 11aab0 1077c4: 89 c3 mov %eax,%ebx if (status) 1077c6: 85 ff test %edi,%edi 1077c8: 75 76 jne 107840 chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { 1077ca: 83 fe 00 cmp $0x0,%esi 1077cd: 74 31 je 107800 if ((local_errno > 0) && *strerror(local_errno)) 1077cf: 7e 11 jle 1077e2 1077d1: 89 34 24 mov %esi,(%esp) 1077d4: e8 8f c6 00 00 call 113e68 1077d9: 80 38 00 cmpb $0x0,(%eax) 1077dc: 0f 85 9e 00 00 00 jne 107880 <== ALWAYS TAKEN chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 1077e2: 89 74 24 08 mov %esi,0x8(%esp) 1077e6: c7 44 24 04 e4 0f 12 movl $0x120fe4,0x4(%esp) 1077ed: 00 1077ee: a1 20 d4 12 00 mov 0x12d420,%eax 1077f3: 8b 40 0c mov 0xc(%eax),%eax 1077f6: 89 04 24 mov %eax,(%esp) 1077f9: e8 22 bc 00 00 call 113420 1077fe: 01 c3 add %eax,%ebx } chars_written += fprintf(stderr, "\n"); 107800: c7 44 24 04 c1 09 12 movl $0x1209c1,0x4(%esp) 107807: 00 107808: a1 20 d4 12 00 mov 0x12d420,%eax 10780d: 8b 40 0c mov 0xc(%eax),%eax 107810: 89 04 24 mov %eax,(%esp) 107813: e8 08 bc 00 00 call 113420 107818: 01 c3 add %eax,%ebx (void) fflush(stderr); 10781a: a1 20 d4 12 00 mov 0x12d420,%eax 10781f: 8b 40 0c mov 0xc(%eax),%eax 107822: 89 04 24 mov %eax,(%esp) 107825: e8 36 b8 00 00 call 113060 return chars_written; } 10782a: 89 d8 mov %ebx,%eax 10782c: 83 c4 2c add $0x2c,%esp 10782f: 5b pop %ebx 107830: 5e pop %esi 107831: 5f pop %edi 107832: 5d pop %ebp 107833: c3 ret if (rtems_panic_in_progress++) _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) return 0; 107834: 31 db xor %ebx,%ebx chars_written += fprintf(stderr, "\n"); (void) fflush(stderr); return chars_written; } 107836: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107838: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 10783b: 5b pop %ebx <== NOT EXECUTED 10783c: 5e pop %esi <== NOT EXECUTED 10783d: 5f pop %edi <== NOT EXECUTED 10783e: 5d pop %ebp <== NOT EXECUTED 10783f: c3 ret <== NOT EXECUTED chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 107840: 89 3c 24 mov %edi,(%esp) 107843: e8 d8 fe ff ff call 107720 107848: 89 44 24 08 mov %eax,0x8(%esp) 10784c: c7 44 24 04 c9 0f 12 movl $0x120fc9,0x4(%esp) 107853: 00 107854: a1 20 d4 12 00 mov 0x12d420,%eax 107859: 8b 40 0c mov 0xc(%eax),%eax 10785c: 89 04 24 mov %eax,(%esp) 10785f: e8 bc bb 00 00 call 113420 #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += 107864: 01 c3 add %eax,%ebx 107866: e9 5f ff ff ff jmp 1077ca 10786b: 90 nop (void) fflush(stdout); /* in case stdout/stderr same */ status = error_flag & ~RTEMS_ERROR_MASK; if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ local_errno = errno; 10786c: 89 4c 24 1c mov %ecx,0x1c(%esp) 107870: e8 83 b4 00 00 call 112cf8 <__errno> 107875: 8b 30 mov (%eax),%esi 107877: 8b 4c 24 1c mov 0x1c(%esp),%ecx 10787b: e9 2c ff ff ff jmp 1077ac chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { if ((local_errno > 0) && *strerror(local_errno)) chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 107880: 89 34 24 mov %esi,(%esp) 107883: e8 e0 c5 00 00 call 113e68 107888: 89 44 24 08 mov %eax,0x8(%esp) 10788c: c7 44 24 04 d7 0f 12 movl $0x120fd7,0x4(%esp) 107893: 00 107894: e9 55 ff ff ff jmp 1077ee =============================================================================== 00128cc8 : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 128cc8: 55 push %ebp 128cc9: 57 push %edi 128cca: 56 push %esi 128ccb: 53 push %ebx 128ccc: 83 ec 2c sub $0x2c,%esp 128ccf: 89 c3 mov %eax,%ebx 128cd1: 89 54 24 1c mov %edx,0x1c(%esp) int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0; 128cd5: 31 ff xor %edi,%edi static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; unsigned int limit = INT_MAX; 128cd7: bd ff ff ff 7f mov $0x7fffffff,%ebp */ static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; 128cdc: 31 f6 xor %esi,%esi unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 128cde: ff 4b 04 decl 0x4(%ebx) 128ce1: 78 45 js 128d28 <== NEVER TAKEN 128ce3: 8b 03 mov (%ebx),%eax 128ce5: 0f b6 10 movzbl (%eax),%edx 128ce8: 40 inc %eax 128ce9: 89 03 mov %eax,(%ebx) if (c == ':') 128ceb: 83 fa 3a cmp $0x3a,%edx 128cee: 74 50 je 128d40 break; if (sign == 0) { 128cf0: 85 ff test %edi,%edi 128cf2: 75 0a jne 128cfe if (c == '-') { 128cf4: 83 fa 2d cmp $0x2d,%edx 128cf7: 74 7f je 128d78 sign = -1; limit++; continue; } sign = 1; 128cf9: bf 01 00 00 00 mov $0x1,%edi } if (!isdigit(c)) 128cfe: a1 74 5f 17 00 mov 0x175f74,%eax 128d03: f6 44 10 01 04 testb $0x4,0x1(%eax,%edx,1) 128d08: 74 62 je 128d6c return 0; d = c - '0'; 128d0a: 8d 4a d0 lea -0x30(%edx),%ecx if ((i > (limit / 10)) 128d0d: b8 cd cc cc cc mov $0xcccccccd,%eax 128d12: f7 e5 mul %ebp 128d14: c1 ea 03 shr $0x3,%edx 128d17: 39 d6 cmp %edx,%esi 128d19: 77 51 ja 128d6c || ((i == (limit / 10)) && (d > (limit % 10)))) 128d1b: 74 3f je 128d5c return 0; i = i * 10 + d; 128d1d: 8d 04 b6 lea (%esi,%esi,4),%eax 128d20: 8d 34 41 lea (%ecx,%eax,2),%esi unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 128d23: ff 4b 04 decl 0x4(%ebx) 128d26: 79 bb jns 128ce3 <== ALWAYS TAKEN 128d28: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 128d2c: a1 80 5f 17 00 mov 0x175f80,%eax <== NOT EXECUTED 128d31: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 128d34: e8 57 76 01 00 call 140390 <__srget_r> <== NOT EXECUTED 128d39: 89 c2 mov %eax,%edx <== NOT EXECUTED if (c == ':') 128d3b: 83 fa 3a cmp $0x3a,%edx <== NOT EXECUTED 128d3e: 75 b0 jne 128cf0 <== NOT EXECUTED if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; } if (sign == 0) 128d40: 85 ff test %edi,%edi 128d42: 74 28 je 128d6c <== NEVER TAKEN return 0; *val = i * sign; 128d44: 0f af f7 imul %edi,%esi 128d47: 8b 54 24 1c mov 0x1c(%esp),%edx 128d4b: 89 32 mov %esi,(%edx) return 1; 128d4d: b8 01 00 00 00 mov $0x1,%eax } 128d52: 83 c4 2c add $0x2c,%esp 128d55: 5b pop %ebx 128d56: 5e pop %esi 128d57: 5f pop %edi 128d58: 5d pop %ebp 128d59: c3 ret 128d5a: 66 90 xchg %ax,%ax } if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) 128d5c: 8d 04 b6 lea (%esi,%esi,4),%eax 128d5f: d1 e0 shl %eax 128d61: 89 ea mov %ebp,%edx 128d63: 29 c2 sub %eax,%edx 128d65: 39 d1 cmp %edx,%ecx 128d67: 76 b4 jbe 128d1d <== NEVER TAKEN 128d69: 8d 76 00 lea 0x0(%esi),%esi continue; } sign = 1; } if (!isdigit(c)) return 0; 128d6c: 31 c0 xor %eax,%eax } if (sign == 0) return 0; *val = i * sign; return 1; } 128d6e: 83 c4 2c add $0x2c,%esp 128d71: 5b pop %ebx 128d72: 5e pop %esi 128d73: 5f pop %edi 128d74: 5d pop %ebp 128d75: c3 ret 128d76: 66 90 xchg %ax,%ax if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; limit++; 128d78: 45 inc %ebp c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; 128d79: bf ff ff ff ff mov $0xffffffff,%edi limit++; continue; 128d7e: e9 5b ff ff ff jmp 128cde =============================================================================== 00128d84 : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 128d84: 57 push %edi 128d85: 56 push %esi 128d86: 53 push %ebx 128d87: 83 ec 10 sub $0x10,%esp 128d8a: 89 c3 mov %eax,%ebx 128d8c: 89 ce mov %ecx,%esi 128d8e: 8b 7c 24 20 mov 0x20(%esp),%edi int c; *name = *bufp; 128d92: 8b 01 mov (%ecx),%eax 128d94: 89 02 mov %eax,(%edx) 128d96: eb 24 jmp 128dbc for (;;) { c = getc(fp); 128d98: 8b 13 mov (%ebx),%edx 128d9a: 0f b6 02 movzbl (%edx),%eax 128d9d: 42 inc %edx 128d9e: 89 13 mov %edx,(%ebx) if (c == ':') { 128da0: 83 f8 3a cmp $0x3a,%eax 128da3: 74 33 je 128dd8 if (nlFlag) return 0; break; } if (c == '\n') { 128da5: 83 f8 0a cmp $0xa,%eax 128da8: 74 4e je 128df8 if (!nlFlag) return 0; break; } if (c == EOF) 128daa: 83 f8 ff cmp $0xffffffff,%eax 128dad: 74 51 je 128e00 return 0; if (*nleft < 2) 128daf: 83 3f 01 cmpl $0x1,(%edi) 128db2: 76 4c jbe 128e00 return 0; **bufp = c; 128db4: 8b 16 mov (%esi),%edx 128db6: 88 02 mov %al,(%edx) ++(*bufp); 128db8: ff 06 incl (%esi) --(*nleft); 128dba: ff 0f decl (%edi) { int c; *name = *bufp; for (;;) { c = getc(fp); 128dbc: ff 4b 04 decl 0x4(%ebx) 128dbf: 79 d7 jns 128d98 128dc1: 89 5c 24 04 mov %ebx,0x4(%esp) 128dc5: a1 80 5f 17 00 mov 0x175f80,%eax 128dca: 89 04 24 mov %eax,(%esp) 128dcd: e8 be 75 01 00 call 140390 <__srget_r> if (c == ':') { 128dd2: 83 f8 3a cmp $0x3a,%eax 128dd5: 75 ce jne 128da5 <== ALWAYS TAKEN 128dd7: 90 nop if (nlFlag) 128dd8: 8b 54 24 24 mov 0x24(%esp),%edx 128ddc: 85 d2 test %edx,%edx 128dde: 75 20 jne 128e00 return 0; **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; 128de0: 8b 06 mov (%esi),%eax 128de2: c6 00 00 movb $0x0,(%eax) ++(*bufp); 128de5: ff 06 incl (%esi) --(*nleft); 128de7: ff 0f decl (%edi) return 1; 128de9: b8 01 00 00 00 mov $0x1,%eax } 128dee: 83 c4 10 add $0x10,%esp 128df1: 5b pop %ebx 128df2: 5e pop %esi 128df3: 5f pop %edi 128df4: c3 ret 128df5: 8d 76 00 lea 0x0(%esi),%esi if (nlFlag) return 0; break; } if (c == '\n') { if (!nlFlag) 128df8: 8b 44 24 24 mov 0x24(%esp),%eax 128dfc: 85 c0 test %eax,%eax 128dfe: 75 e0 jne 128de0 *name = *bufp; for (;;) { c = getc(fp); if (c == ':') { if (nlFlag) return 0; 128e00: 31 c0 xor %eax,%eax } **bufp = '\0'; ++(*bufp); --(*nleft); return 1; } 128e02: 83 c4 10 add $0x10,%esp 128e05: 5b pop %ebx 128e06: 5e pop %esi 128e07: 5f pop %edi 128e08: c3 ret =============================================================================== 00128e0c : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 128e0c: 56 push %esi 128e0d: 53 push %ebx 128e0e: 83 ec 34 sub $0x34,%esp 128e11: 89 c3 mov %eax,%ebx 128e13: 89 d6 mov %edx,%esi 128e15: 89 4c 24 1c mov %ecx,0x1c(%esp) int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 128e19: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 128e20: 00 128e21: 8d 44 24 40 lea 0x40(%esp),%eax 128e25: 89 04 24 mov %eax,(%esp) 128e28: 8d 4c 24 1c lea 0x1c(%esp),%ecx 128e2c: 89 d8 mov %ebx,%eax 128e2e: e8 51 ff ff ff call 128d84 128e33: 85 c0 test %eax,%eax 128e35: 75 09 jne 128e40 || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) return 0; 128e37: 31 c0 xor %eax,%eax grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; return 1; } 128e39: 83 c4 34 add $0x34,%esp 128e3c: 5b pop %ebx 128e3d: 5e pop %esi 128e3e: c3 ret 128e3f: 90 nop int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) 128e40: 8d 56 04 lea 0x4(%esi),%edx 128e43: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 128e4a: 00 128e4b: 8d 44 24 40 lea 0x40(%esp),%eax 128e4f: 89 04 24 mov %eax,(%esp) 128e52: 8d 4c 24 1c lea 0x1c(%esp),%ecx 128e56: 89 d8 mov %ebx,%eax 128e58: e8 27 ff ff ff call 128d84 128e5d: 85 c0 test %eax,%eax 128e5f: 74 d6 je 128e37 <== NEVER TAKEN || !scanInt(fp, &grgid) 128e61: 8d 54 24 28 lea 0x28(%esp),%edx 128e65: 89 d8 mov %ebx,%eax 128e67: e8 5c fe ff ff call 128cc8 128e6c: 85 c0 test %eax,%eax 128e6e: 74 c7 je 128e37 <== NEVER TAKEN || !scanString(fp, &grmem, &buffer, &bufsize, 1)) 128e70: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 128e77: 00 128e78: 8d 44 24 40 lea 0x40(%esp),%eax 128e7c: 89 04 24 mov %eax,(%esp) 128e7f: 8d 4c 24 1c lea 0x1c(%esp),%ecx 128e83: 8d 54 24 2c lea 0x2c(%esp),%edx 128e87: 89 d8 mov %ebx,%eax 128e89: e8 f6 fe ff ff call 128d84 128e8e: 85 c0 test %eax,%eax 128e90: 74 a5 je 128e37 <== NEVER TAKEN return 0; grp->gr_gid = grgid; 128e92: 8b 44 24 28 mov 0x28(%esp),%eax 128e96: 66 89 46 08 mov %ax,0x8(%esi) /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 128e9a: 8b 5c 24 2c mov 0x2c(%esp),%ebx 128e9e: 8a 03 mov (%ebx),%al 128ea0: 84 c0 test %al,%al 128ea2: 0f 84 83 00 00 00 je 128f2b <== NEVER TAKEN 128ea8: 89 da mov %ebx,%edx 128eaa: b9 01 00 00 00 mov $0x1,%ecx 128eaf: eb 0a jmp 128ebb 128eb1: 8d 76 00 lea 0x0(%esi),%esi 128eb4: 42 inc %edx 128eb5: 8a 02 mov (%edx),%al 128eb7: 84 c0 test %al,%al 128eb9: 74 09 je 128ec4 if(*cp == ',') 128ebb: 3c 2c cmp $0x2c,%al 128ebd: 75 f5 jne 128eb4 memcount++; 128ebf: 41 inc %ecx 128ec0: eb f2 jmp 128eb4 128ec2: 66 90 xchg %ax,%ax 128ec4: 8d 04 8d 13 00 00 00 lea 0x13(,%ecx,4),%eax } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 128ecb: 39 44 24 40 cmp %eax,0x40(%esp) 128ecf: 0f 82 62 ff ff ff jb 128e37 <== NEVER TAKEN return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 128ed5: 8b 44 24 1c mov 0x1c(%esp),%eax 128ed9: 83 c0 0f add $0xf,%eax 128edc: 83 e0 f0 and $0xfffffff0,%eax 128edf: 89 46 0c mov %eax,0xc(%esi) /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 128ee2: 89 18 mov %ebx,(%eax) for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 128ee4: 8b 44 24 2c mov 0x2c(%esp),%eax 128ee8: 8a 10 mov (%eax),%dl 128eea: 84 d2 test %dl,%dl 128eec: 74 44 je 128f32 <== NEVER TAKEN } /* * Extract a single group record from the database */ static int scangr( 128eee: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 128eef: b9 01 00 00 00 mov $0x1,%ecx 128ef4: eb 09 jmp 128eff 128ef6: 66 90 xchg %ax,%ax 128ef8: 8a 10 mov (%eax),%dl 128efa: 40 inc %eax 128efb: 84 d2 test %dl,%dl 128efd: 74 15 je 128f14 if(*cp == ',') { 128eff: 80 fa 2c cmp $0x2c,%dl 128f02: 75 f4 jne 128ef8 *cp = '\0'; 128f04: c6 40 ff 00 movb $0x0,-0x1(%eax) grp->gr_mem[memcount++] = cp + 1; 128f08: 8b 56 0c mov 0xc(%esi),%edx 128f0b: 89 04 8a mov %eax,(%edx,%ecx,4) 128f0e: 41 inc %ecx 128f0f: eb e7 jmp 128ef8 128f11: 8d 76 00 lea 0x0(%esi),%esi 128f14: c1 e1 02 shl $0x2,%ecx } } grp->gr_mem[memcount] = NULL; 128f17: 8b 46 0c mov 0xc(%esi),%eax 128f1a: c7 04 08 00 00 00 00 movl $0x0,(%eax,%ecx,1) return 1; 128f21: b8 01 00 00 00 mov $0x1,%eax 128f26: e9 0e ff ff ff jmp 128e39 grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 128f2b: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED 128f30: eb 99 jmp 128ecb <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 128f32: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 128f37: eb de jmp 128f17 <== NOT EXECUTED =============================================================================== 00128f3c : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 128f3c: 56 push %esi 128f3d: 53 push %ebx 128f3e: 83 ec 34 sub $0x34,%esp 128f41: 89 c3 mov %eax,%ebx 128f43: 89 d6 mov %edx,%esi 128f45: 89 4c 24 1c mov %ecx,0x1c(%esp) int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 128f49: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 128f50: 00 128f51: 8d 44 24 40 lea 0x40(%esp),%eax 128f55: 89 04 24 mov %eax,(%esp) 128f58: 8d 4c 24 1c lea 0x1c(%esp),%ecx 128f5c: 89 d8 mov %ebx,%eax 128f5e: e8 21 fe ff ff call 128d84 128f63: 85 c0 test %eax,%eax 128f65: 75 09 jne 128f70 || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) return 0; 128f67: 31 c0 xor %eax,%eax pwd->pw_uid = pwuid; pwd->pw_gid = pwgid; return 1; } 128f69: 83 c4 34 add $0x34,%esp 128f6c: 5b pop %ebx 128f6d: 5e pop %esi 128f6e: c3 ret 128f6f: 90 nop ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) 128f70: 8d 56 04 lea 0x4(%esi),%edx 128f73: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 128f7a: 00 128f7b: 8d 44 24 40 lea 0x40(%esp),%eax 128f7f: 89 04 24 mov %eax,(%esp) 128f82: 8d 4c 24 1c lea 0x1c(%esp),%ecx 128f86: 89 d8 mov %ebx,%eax 128f88: e8 f7 fd ff ff call 128d84 128f8d: 85 c0 test %eax,%eax 128f8f: 74 d6 je 128f67 <== NEVER TAKEN || !scanInt(fp, &pwuid) 128f91: 8d 54 24 28 lea 0x28(%esp),%edx 128f95: 89 d8 mov %ebx,%eax 128f97: e8 2c fd ff ff call 128cc8 128f9c: 85 c0 test %eax,%eax 128f9e: 74 c7 je 128f67 || !scanInt(fp, &pwgid) 128fa0: 8d 54 24 2c lea 0x2c(%esp),%edx 128fa4: 89 d8 mov %ebx,%eax 128fa6: e8 1d fd ff ff call 128cc8 128fab: 85 c0 test %eax,%eax 128fad: 74 b8 je 128f67 || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) 128faf: 8d 56 0c lea 0xc(%esi),%edx 128fb2: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 128fb9: 00 128fba: 8d 44 24 40 lea 0x40(%esp),%eax 128fbe: 89 04 24 mov %eax,(%esp) 128fc1: 8d 4c 24 1c lea 0x1c(%esp),%ecx 128fc5: 89 d8 mov %ebx,%eax 128fc7: e8 b8 fd ff ff call 128d84 128fcc: 85 c0 test %eax,%eax 128fce: 74 97 je 128f67 <== NEVER TAKEN || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) 128fd0: 8d 56 10 lea 0x10(%esi),%edx 128fd3: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 128fda: 00 128fdb: 8d 44 24 40 lea 0x40(%esp),%eax 128fdf: 89 04 24 mov %eax,(%esp) 128fe2: 8d 4c 24 1c lea 0x1c(%esp),%ecx 128fe6: 89 d8 mov %ebx,%eax 128fe8: e8 97 fd ff ff call 128d84 128fed: 85 c0 test %eax,%eax 128fef: 0f 84 72 ff ff ff je 128f67 <== NEVER TAKEN || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) 128ff5: 8d 56 14 lea 0x14(%esi),%edx 128ff8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 128fff: 00 129000: 8d 44 24 40 lea 0x40(%esp),%eax 129004: 89 04 24 mov %eax,(%esp) 129007: 8d 4c 24 1c lea 0x1c(%esp),%ecx 12900b: 89 d8 mov %ebx,%eax 12900d: e8 72 fd ff ff call 128d84 129012: 85 c0 test %eax,%eax 129014: 0f 84 4d ff ff ff je 128f67 <== NEVER TAKEN || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) 12901a: 8d 56 18 lea 0x18(%esi),%edx 12901d: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp) 129024: 00 129025: 8d 44 24 40 lea 0x40(%esp),%eax 129029: 89 04 24 mov %eax,(%esp) 12902c: 8d 4c 24 1c lea 0x1c(%esp),%ecx 129030: 89 d8 mov %ebx,%eax 129032: e8 4d fd ff ff call 128d84 129037: 85 c0 test %eax,%eax 129039: 0f 84 28 ff ff ff je 128f67 return 0; pwd->pw_uid = pwuid; 12903f: 8b 44 24 28 mov 0x28(%esp),%eax 129043: 66 89 46 08 mov %ax,0x8(%esi) pwd->pw_gid = pwgid; 129047: 8b 44 24 2c mov 0x2c(%esp),%eax 12904b: 66 89 46 0a mov %ax,0xa(%esi) return 1; 12904f: b8 01 00 00 00 mov $0x1,%eax 129054: e9 10 ff ff ff jmp 128f69 =============================================================================== 0010a650 : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 10a650: 56 push %esi 10a651: 53 push %ebx 10a652: 83 ec 14 sub $0x14,%esp 10a655: 89 d3 mov %edx,%ebx 10a657: 89 c6 mov %eax,%esi int i; /* * Obtain output semaphore if character will be echoed */ if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) { 10a659: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) 10a660: 75 12 jne 10a674 <== ALWAYS TAKEN rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); i = iproc (c, tty); rtems_semaphore_release (tty->osem); } else { i = iproc (c, tty); 10a662: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10a665: 89 da mov %ebx,%edx <== NOT EXECUTED } return i; } 10a667: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10a66a: 5b pop %ebx <== NOT EXECUTED 10a66b: 5e pop %esi <== NOT EXECUTED rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); i = iproc (c, tty); rtems_semaphore_release (tty->osem); } else { i = iproc (c, tty); 10a66c: e9 47 fe ff ff jmp 10a4b8 <== NOT EXECUTED 10a671: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Obtain output semaphore if character will be echoed */ if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) { rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10a674: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10a67b: 00 10a67c: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10a683: 00 10a684: 8b 42 18 mov 0x18(%edx),%eax 10a687: 89 04 24 mov %eax,(%esp) 10a68a: e8 ed 12 00 00 call 10b97c i = iproc (c, tty); 10a68f: 89 f2 mov %esi,%edx 10a691: 0f b6 c2 movzbl %dl,%eax 10a694: 89 da mov %ebx,%edx 10a696: e8 1d fe ff ff call 10a4b8 10a69b: 89 c6 mov %eax,%esi rtems_semaphore_release (tty->osem); 10a69d: 8b 43 18 mov 0x18(%ebx),%eax 10a6a0: 89 04 24 mov %eax,(%esp) 10a6a3: e8 00 14 00 00 call 10baa8 } else { i = iproc (c, tty); } return i; } 10a6a8: 89 f0 mov %esi,%eax 10a6aa: 83 c4 14 add $0x14,%esp 10a6ad: 5b pop %ebx 10a6ae: 5e pop %esi 10a6af: c3 ret =============================================================================== 0010a0cc : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 10a0cc: 53 push %ebx 10a0cd: 83 ec 18 sub $0x18,%esp 10a0d0: 8b 44 24 20 mov 0x20(%esp),%eax /* * The sync_wrapper() function will operate on the current thread's * reent structure so we will temporarily use that. */ this_reent = t->libc_reent; 10a0d4: 8b 90 dc 00 00 00 mov 0xdc(%eax),%edx if ( this_reent ) { 10a0da: 85 d2 test %edx,%edx 10a0dc: 74 33 je 10a111 <== NEVER TAKEN current_reent = _Thread_Executing->libc_reent; 10a0de: 8b 0d 6c 18 13 00 mov 0x13186c,%ecx 10a0e4: 8b 99 dc 00 00 00 mov 0xdc(%ecx),%ebx _Thread_Executing->libc_reent = this_reent; 10a0ea: 89 91 dc 00 00 00 mov %edx,0xdc(%ecx) _fwalk (t->libc_reent, sync_wrapper); 10a0f0: c7 44 24 04 18 a1 10 movl $0x10a118,0x4(%esp) 10a0f7: 00 10a0f8: 8b 80 dc 00 00 00 mov 0xdc(%eax),%eax 10a0fe: 89 04 24 mov %eax,(%esp) 10a101: e8 fe a8 00 00 call 114a04 <_fwalk> _Thread_Executing->libc_reent = current_reent; 10a106: a1 6c 18 13 00 mov 0x13186c,%eax 10a10b: 89 98 dc 00 00 00 mov %ebx,0xdc(%eax) } } 10a111: 83 c4 18 add $0x18,%esp 10a114: 5b pop %ebx 10a115: c3 ret =============================================================================== 0011876c : int tcsetattr( int fd, int opt, struct termios *tp ) { 11876c: 56 push %esi 11876d: 53 push %ebx 11876e: 83 ec 14 sub $0x14,%esp 118771: 8b 5c 24 20 mov 0x20(%esp),%ebx 118775: 8b 44 24 24 mov 0x24(%esp),%eax 118779: 8b 74 24 28 mov 0x28(%esp),%esi switch (opt) { 11877d: 85 c0 test %eax,%eax 11877f: 74 37 je 1187b8 118781: 48 dec %eax 118782: 74 18 je 11879c default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 118784: e8 af 38 00 00 call 11c038 <__errno> 118789: c7 00 86 00 00 00 movl $0x86,(%eax) * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); } } 11878f: b8 ff ff ff ff mov $0xffffffff,%eax 118794: 83 c4 14 add $0x14,%esp 118797: 5b pop %ebx 118798: 5e pop %esi 118799: c3 ret 11879a: 66 90 xchg %ax,%ax switch (opt) { default: rtems_set_errno_and_return_minus_one( ENOTSUP ); case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 11879c: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 1187a3: 00 1187a4: c7 44 24 04 03 00 00 movl $0x3,0x4(%esp) 1187ab: 00 1187ac: 89 1c 24 mov %ebx,(%esp) 1187af: e8 8c f7 ff ff call 117f40 1187b4: 85 c0 test %eax,%eax 1187b6: 78 d7 js 11878f <== NEVER TAKEN return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1187b8: 89 74 24 28 mov %esi,0x28(%esp) 1187bc: c7 44 24 24 02 00 00 movl $0x2,0x24(%esp) 1187c3: 00 1187c4: 89 5c 24 20 mov %ebx,0x20(%esp) } } 1187c8: 83 c4 14 add $0x14,%esp 1187cb: 5b pop %ebx 1187cc: 5e pop %esi return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1187cd: e9 6e f7 ff ff jmp 117f40 =============================================================================== 0010b2c4 : return mt_entry == root->mt_entry || mt_entry == current->mt_entry; } int unmount( const char *path ) { 10b2c4: 57 push %edi 10b2c5: 56 push %esi 10b2c6: 53 push %ebx 10b2c7: 83 ec 50 sub $0x50,%esp int rv = 0; rtems_filesystem_eval_path_context_t ctx; int eval_flags = RTEMS_FS_FOLLOW_LINK; const rtems_filesystem_location_info_t *currentloc = 10b2ca: c7 44 24 08 18 00 00 movl $0x18,0x8(%esp) 10b2d1: 00 10b2d2: 8b 44 24 60 mov 0x60(%esp),%eax 10b2d6: 89 44 24 04 mov %eax,0x4(%esp) rtems_filesystem_eval_path_start( &ctx, path, eval_flags ); 10b2da: 8d 7c 24 18 lea 0x18(%esp),%edi 10b2de: 89 3c 24 mov %edi,(%esp) int unmount( const char *path ) { int rv = 0; rtems_filesystem_eval_path_context_t ctx; int eval_flags = RTEMS_FS_FOLLOW_LINK; const rtems_filesystem_location_info_t *currentloc = 10b2e1: e8 b2 dd ff ff call 109098 rtems_filesystem_eval_path_start( &ctx, path, eval_flags ); rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry; 10b2e6: 8b 58 14 mov 0x14(%eax),%ebx const rtems_filesystem_location_info_t *loc ) { const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry; return (*mt_entry->ops->are_nodes_equal_h)( 10b2e9: 8b 53 0c mov 0xc(%ebx),%edx 10b2ec: 8b 4b 24 mov 0x24(%ebx),%ecx 10b2ef: 89 4c 24 04 mov %ecx,0x4(%esp) 10b2f3: 89 04 24 mov %eax,(%esp) 10b2f6: ff 52 10 call *0x10(%edx) if ( rtems_filesystem_location_is_root( currentloc ) ) { 10b2f9: 84 c0 test %al,%al 10b2fb: 0f 84 9d 00 00 00 je 10b39e static bool contains_root_or_current_directory( const rtems_filesystem_mount_table_entry_t *mt_entry ) { const rtems_filesystem_location_info_t *root = &rtems_filesystem_root->location; 10b301: a1 00 e7 12 00 mov 0x12e700,%eax const rtems_filesystem_location_info_t *current = &rtems_filesystem_current->location; 10b306: 8b 10 mov (%eax),%edx return mt_entry == root->mt_entry || mt_entry == current->mt_entry; 10b308: 8b 40 04 mov 0x4(%eax),%eax 10b30b: 3b 58 14 cmp 0x14(%eax),%ebx 10b30e: 74 7c je 10b38c 10b310: 3b 5a 14 cmp 0x14(%edx),%ebx 10b313: 74 77 je 10b38c rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry; if ( rtems_filesystem_location_is_root( currentloc ) ) { if ( !contains_root_or_current_directory( mt_entry ) ) { const rtems_filesystem_operations_table *mt_point_ops = mt_entry->mt_point_node->location.mt_entry->ops; 10b315: 8b 43 20 mov 0x20(%ebx),%eax 10b318: 8b 40 14 mov 0x14(%eax),%eax rv = (*mt_point_ops->unmount_h)( mt_entry ); 10b31b: 8b 40 0c mov 0xc(%eax),%eax 10b31e: 89 1c 24 mov %ebx,(%esp) 10b321: ff 50 38 call *0x38(%eax) 10b324: 89 c6 mov %eax,%esi if ( rv == 0 ) { 10b326: 85 c0 test %eax,%eax 10b328: 74 12 je 10b33c } else { errno = EACCES; rv = -1; } rtems_filesystem_eval_path_cleanup( &ctx ); 10b32a: 89 3c 24 mov %edi,(%esp) 10b32d: e8 52 de ff ff call 109184 rtems_fatal_error_occurred( 0xdeadbeef ); } } return rv; } 10b332: 89 f0 mov %esi,%eax 10b334: 83 c4 50 add $0x50,%esp 10b337: 5b pop %ebx 10b338: 5e pop %esi 10b339: 5f pop %edi 10b33a: c3 ret 10b33b: 90 nop const rtems_filesystem_operations_table *mt_point_ops = mt_entry->mt_point_node->location.mt_entry->ops; rv = (*mt_point_ops->unmount_h)( mt_entry ); if ( rv == 0 ) { rtems_id self_task_id = rtems_task_self(); 10b33c: e8 3b 0f 00 00 call 10c27c rtems_filesystem_mt_entry_declare_lock_context( lock_context ); rtems_filesystem_mt_entry_lock( lock_context ); 10b341: 9c pushf 10b342: fa cli 10b343: 5a pop %edx mt_entry->unmount_task = self_task_id; 10b344: 89 43 3c mov %eax,0x3c(%ebx) mt_entry->mounted = false; 10b347: c6 43 28 00 movb $0x0,0x28(%ebx) rtems_filesystem_mt_entry_unlock( lock_context ); 10b34b: 52 push %edx 10b34c: 9d popf } else { errno = EACCES; rv = -1; } rtems_filesystem_eval_path_cleanup( &ctx ); 10b34d: 89 3c 24 mov %edi,(%esp) 10b350: e8 2f de ff ff call 109184 if ( rv == 0 ) { rtems_event_set out; rtems_status_code sc = rtems_event_receive( 10b355: 8d 44 24 14 lea 0x14(%esp),%eax 10b359: 89 44 24 0c mov %eax,0xc(%esp) 10b35d: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp) 10b364: 00 10b365: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp) 10b36c: 00 10b36d: c7 04 24 02 00 00 00 movl $0x2,(%esp) 10b374: e8 5b 04 00 00 call 10b7d4 RTEMS_EVENT_ALL | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &out ); if ( sc != RTEMS_SUCCESSFUL ) { 10b379: 85 c0 test %eax,%eax 10b37b: 74 b5 je 10b332 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xdeadbeef ); 10b37d: c7 04 24 ef be ad de movl $0xdeadbeef,(%esp) <== NOT EXECUTED 10b384: e8 77 11 00 00 call 10c500 <== NOT EXECUTED 10b389: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED mt_entry->unmount_task = self_task_id; mt_entry->mounted = false; rtems_filesystem_mt_entry_unlock( lock_context ); } } else { errno = EBUSY; 10b38c: e8 bf 7d 00 00 call 113150 <__errno> 10b391: c7 00 10 00 00 00 movl $0x10,(%eax) rv = -1; 10b397: be ff ff ff ff mov $0xffffffff,%esi 10b39c: eb 8c jmp 10b32a } } else { errno = EACCES; 10b39e: e8 ad 7d 00 00 call 113150 <__errno> 10b3a3: c7 00 0d 00 00 00 movl $0xd,(%eax) rv = -1; 10b3a9: be ff ff ff ff mov $0xffffffff,%esi 10b3ae: e9 77 ff ff ff jmp 10b32a =============================================================================== 0010afa0 : */ void vprintk( const char *fmt, va_list ap ) { 10afa0: 55 push %ebp 10afa1: 57 push %edi 10afa2: 56 push %esi 10afa3: 53 push %ebx 10afa4: 83 ec 5c sub $0x5c,%esp 10afa7: 8b 5c 24 70 mov 0x70(%esp),%ebx for (; *fmt != '\0'; fmt++) { 10afab: 0f be 03 movsbl (%ebx),%eax 10afae: 84 c0 test %al,%al 10afb0: 0f 84 96 01 00 00 je 10b14c <== NEVER TAKEN * console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk( 10afb6: 8d 54 24 3b lea 0x3b(%esp),%edx 10afba: 89 54 24 1c mov %edx,0x1c(%esp) 10afbe: eb 19 jmp 10afd9 bool sign = false; char lead = ' '; char c; if (*fmt != '%') { rtems_putc(*fmt); 10afc0: 89 04 24 mov %eax,(%esp) 10afc3: e8 f8 50 00 00 call 1100c0 continue; 10afc8: 89 dd mov %ebx,%ebp void vprintk( const char *fmt, va_list ap ) { for (; *fmt != '\0'; fmt++) { 10afca: 8d 5d 01 lea 0x1(%ebp),%ebx 10afcd: 0f be 45 01 movsbl 0x1(%ebp),%eax 10afd1: 84 c0 test %al,%al 10afd3: 0f 84 73 01 00 00 je 10b14c bool minus = false; bool sign = false; char lead = ' '; char c; if (*fmt != '%') { 10afd9: 3c 25 cmp $0x25,%al 10afdb: 75 e3 jne 10afc0 rtems_putc(*fmt); continue; } fmt++; if (*fmt == '0' ) { 10afdd: 0f be 43 01 movsbl 0x1(%ebx),%eax 10afe1: 3c 30 cmp $0x30,%al 10afe3: 0f 84 b7 01 00 00 je 10b1a0 if (*fmt != '%') { rtems_putc(*fmt); continue; } fmt++; 10afe9: 8d 6b 01 lea 0x1(%ebx),%ebp unsigned base = 0; unsigned width = 0; bool lflag = false; bool minus = false; bool sign = false; char lead = ' '; 10afec: c6 44 24 28 20 movb $0x20,0x28(%esp) fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; } if (*fmt == '-' ) { 10aff1: 3c 2d cmp $0x2d,%al 10aff3: 0f 84 97 01 00 00 je 10b190 { for (; *fmt != '\0'; fmt++) { unsigned base = 0; unsigned width = 0; bool lflag = false; bool minus = false; 10aff9: c6 44 24 20 00 movb $0x0,0x20(%esp) } if (*fmt == '-' ) { minus = true; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 10affe: 8d 50 d0 lea -0x30(%eax),%edx 10b001: 31 f6 xor %esi,%esi 10b003: 80 fa 09 cmp $0x9,%dl 10b006: 77 14 ja 10b01c width *= 10; 10b008: 8d 14 b6 lea (%esi,%esi,4),%edx width += ((unsigned) *fmt - '0'); 10b00b: 8d 74 50 d0 lea -0x30(%eax,%edx,2),%esi fmt++; 10b00f: 45 inc %ebp } if (*fmt == '-' ) { minus = true; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 10b010: 0f be 45 00 movsbl 0x0(%ebp),%eax 10b014: 8d 50 d0 lea -0x30(%eax),%edx 10b017: 80 fa 09 cmp $0x9,%dl 10b01a: 76 ec jbe 10b008 width *= 10; width += ((unsigned) *fmt - '0'); fmt++; } if ((c = *fmt) == 'l') { 10b01c: 3c 6c cmp $0x6c,%al 10b01e: 0f 84 40 01 00 00 je 10b164 lflag = true; c = *++fmt; } if ( c == 'c' ) { 10b024: 3c 63 cmp $0x63,%al 10b026: 0f 84 45 01 00 00 je 10b171 /* need a cast here since va_arg() only takes fully promoted types */ char chr = (char) va_arg(ap, int); rtems_putc(chr); continue; } if ( c == 's' ) { 10b02c: 3c 73 cmp $0x73,%al 10b02e: 0f 84 80 01 00 00 je 10b1b4 continue; } /* must be a numeric format or something unsupported */ if ( c == 'o' || c == 'O' ) { 10b034: 3c 6f cmp $0x6f,%al 10b036: 0f 84 18 01 00 00 je 10b154 10b03c: 3c 4f cmp $0x4f,%al 10b03e: 0f 84 10 01 00 00 je 10b154 base = 8; sign = false; } else if ( c == 'i' || c == 'I' || 10b044: 3c 69 cmp $0x69,%al 10b046: 74 44 je 10b08c 10b048: 3c 49 cmp $0x49,%al 10b04a: 74 40 je 10b08c 10b04c: 3c 64 cmp $0x64,%al 10b04e: 74 3c je 10b08c c == 'd' || c == 'D' ) { 10b050: 3c 44 cmp $0x44,%al 10b052: 74 38 je 10b08c base = 10; sign = true; } else if ( c == 'u' || c == 'U' ) { 10b054: 3c 75 cmp $0x75,%al 10b056: 0f 84 0a 02 00 00 je 10b266 10b05c: 3c 55 cmp $0x55,%al 10b05e: 0f 84 02 02 00 00 je 10b266 base = 10; sign = false; } else if ( c == 'x' || c == 'X' ) { 10b064: 3c 78 cmp $0x78,%al 10b066: 0f 84 3d 02 00 00 je 10b2a9 10b06c: 3c 58 cmp $0x58,%al 10b06e: 0f 84 35 02 00 00 je 10b2a9 base = 16; sign = false; } else if ( c == 'p' ) { 10b074: 3c 70 cmp $0x70,%al 10b076: 0f 84 2d 02 00 00 je 10b2a9 base = 16; sign = false; lflag = true; } else { rtems_putc(c); 10b07c: 89 04 24 mov %eax,(%esp) 10b07f: e8 3c 50 00 00 call 1100c0 continue; 10b084: e9 41 ff ff ff jmp 10afca 10b089: 8d 76 00 lea 0x0(%esi),%esi /* must be a numeric format or something unsupported */ if ( c == 'o' || c == 'O' ) { base = 8; sign = false; } else if ( c == 'i' || c == 'I' || c == 'd' || c == 'D' ) { base = 10; sign = true; 10b08c: b0 01 mov $0x1,%al 10b08e: c7 44 24 20 0a 00 00 movl $0xa,0x20(%esp) 10b095: 00 } else { rtems_putc(c); continue; } printNum( 10b096: 8b 54 24 74 mov 0x74(%esp),%edx 10b09a: 8b 1a mov (%edx),%ebx lflag ? va_arg(ap, long) : (long) va_arg(ap, int), 10b09c: 83 c2 04 add $0x4,%edx 10b09f: 89 54 24 74 mov %edx,0x74(%esp) unsigned long unsigned_num; unsigned long n; unsigned count; char toPrint[20]; if ( sign && (num < 0) ) { 10b0a3: 84 c0 test %al,%al 10b0a5: 74 08 je 10b0af 10b0a7: 85 db test %ebx,%ebx 10b0a9: 0f 88 c6 01 00 00 js 10b275 } else { unsigned_num = (unsigned long) num; } count = 0; while ((n = unsigned_num / base) > 0) { 10b0af: 89 d8 mov %ebx,%eax 10b0b1: 31 d2 xor %edx,%edx 10b0b3: f7 74 24 20 divl 0x20(%esp) 10b0b7: 89 c1 mov %eax,%ecx 10b0b9: 85 c0 test %eax,%eax 10b0bb: 0f 84 da 01 00 00 je 10b29b 10b0c1: 8a 44 24 20 mov 0x20(%esp),%al if (maxwidth) maxwidth--; } else { unsigned_num = (unsigned long) num; } count = 0; 10b0c5: 31 ff xor %edi,%edi 10b0c7: 89 74 24 2c mov %esi,0x2c(%esp) 10b0cb: 8b 74 24 20 mov 0x20(%esp),%esi 10b0cf: 89 da mov %ebx,%edx 10b0d1: 88 c3 mov %al,%bl 10b0d3: eb 05 jmp 10b0da 10b0d5: 8d 76 00 lea 0x0(%esi),%esi while ((n = unsigned_num / base) > 0) { 10b0d8: 89 c1 mov %eax,%ecx toPrint[count++] = (char) (unsigned_num - (n * base)); 10b0da: 88 d8 mov %bl,%al 10b0dc: f6 e1 mul %cl 10b0de: 29 c2 sub %eax,%edx 10b0e0: 88 54 3c 3c mov %dl,0x3c(%esp,%edi,1) 10b0e4: 47 inc %edi } else { unsigned_num = (unsigned long) num; } count = 0; while ((n = unsigned_num / base) > 0) { 10b0e5: 89 c8 mov %ecx,%eax 10b0e7: 31 d2 xor %edx,%edx 10b0e9: f7 f6 div %esi 10b0eb: 89 ca mov %ecx,%edx 10b0ed: 85 c0 test %eax,%eax 10b0ef: 75 e7 jne 10b0d8 10b0f1: 8b 74 24 2c mov 0x2c(%esp),%esi 10b0f5: 8d 5f 01 lea 0x1(%edi),%ebx toPrint[count++] = (char) (unsigned_num - (n * base)); unsigned_num = n; } toPrint[count++] = (char) unsigned_num; 10b0f8: 88 4c 3c 3c mov %cl,0x3c(%esp,%edi,1) for (n=maxwidth ; n > count; n-- ) 10b0fc: 39 f3 cmp %esi,%ebx 10b0fe: 73 15 jae 10b115 10b100: 0f be 7c 24 28 movsbl 0x28(%esp),%edi 10b105: 8d 76 00 lea 0x0(%esi),%esi rtems_putc(lead); 10b108: 89 3c 24 mov %edi,(%esp) 10b10b: e8 b0 4f 00 00 call 1100c0 toPrint[count++] = (char) (unsigned_num - (n * base)); unsigned_num = n; } toPrint[count++] = (char) unsigned_num; for (n=maxwidth ; n > count; n-- ) 10b110: 4e dec %esi 10b111: 39 f3 cmp %esi,%ebx 10b113: 72 f3 jb 10b108 * console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk( 10b115: 8d 74 1c 3b lea 0x3b(%esp,%ebx,1),%esi toPrint[count++] = (char) unsigned_num; for (n=maxwidth ; n > count; n-- ) rtems_putc(lead); for (n = 0; n < count; n++) { 10b119: 85 db test %ebx,%ebx 10b11b: 0f 84 a9 fe ff ff je 10afca <== NEVER TAKEN 10b121: 8d 76 00 lea 0x0(%esi),%esi rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 10b124: 0f be 06 movsbl (%esi),%eax 10b127: 0f be 80 14 17 12 00 movsbl 0x121714(%eax),%eax 10b12e: 89 04 24 mov %eax,(%esp) 10b131: e8 8a 4f 00 00 call 1100c0 10b136: 4e dec %esi toPrint[count++] = (char) unsigned_num; for (n=maxwidth ; n > count; n-- ) rtems_putc(lead); for (n = 0; n < count; n++) { 10b137: 3b 74 24 1c cmp 0x1c(%esp),%esi 10b13b: 75 e7 jne 10b124 void vprintk( const char *fmt, va_list ap ) { for (; *fmt != '\0'; fmt++) { 10b13d: 8d 5d 01 lea 0x1(%ebp),%ebx 10b140: 0f be 45 01 movsbl 0x1(%ebp),%eax 10b144: 84 c0 test %al,%al 10b146: 0f 85 8d fe ff ff jne 10afd9 <== ALWAYS TAKEN sign, width, lead ); } } 10b14c: 83 c4 5c add $0x5c,%esp 10b14f: 5b pop %ebx 10b150: 5e pop %esi 10b151: 5f pop %edi 10b152: 5d pop %ebp 10b153: c3 ret continue; } /* must be a numeric format or something unsupported */ if ( c == 'o' || c == 'O' ) { base = 8; sign = false; 10b154: 31 c0 xor %eax,%eax 10b156: c7 44 24 20 08 00 00 movl $0x8,0x20(%esp) 10b15d: 00 10b15e: e9 33 ff ff ff jmp 10b096 10b163: 90 nop fmt++; } if ((c = *fmt) == 'l') { lflag = true; c = *++fmt; 10b164: 0f be 45 01 movsbl 0x1(%ebp),%eax 10b168: 45 inc %ebp } if ( c == 'c' ) { 10b169: 3c 63 cmp $0x63,%al 10b16b: 0f 85 bb fe ff ff jne 10b02c <== ALWAYS TAKEN /* need a cast here since va_arg() only takes fully promoted types */ char chr = (char) va_arg(ap, int); 10b171: 8b 5c 24 74 mov 0x74(%esp),%ebx 10b175: 83 c3 04 add $0x4,%ebx rtems_putc(chr); 10b178: 8b 54 24 74 mov 0x74(%esp),%edx 10b17c: 0f be 02 movsbl (%edx),%eax 10b17f: 89 04 24 mov %eax,(%esp) 10b182: e8 39 4f 00 00 call 1100c0 lflag = true; c = *++fmt; } if ( c == 'c' ) { /* need a cast here since va_arg() only takes fully promoted types */ char chr = (char) va_arg(ap, int); 10b187: 89 5c 24 74 mov %ebx,0x74(%esp) rtems_putc(chr); continue; 10b18b: e9 3a fe ff ff jmp 10afca 10b190: 0f be 45 01 movsbl 0x1(%ebp),%eax lead = '0'; fmt++; } if (*fmt == '-' ) { minus = true; fmt++; 10b194: 45 inc %ebp if (*fmt == '0' ) { lead = '0'; fmt++; } if (*fmt == '-' ) { minus = true; 10b195: c6 44 24 20 01 movb $0x1,0x20(%esp) 10b19a: e9 5f fe ff ff jmp 10affe 10b19f: 90 nop continue; } fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; 10b1a0: 8d 6b 02 lea 0x2(%ebx),%ebp 10b1a3: 0f be 43 02 movsbl 0x2(%ebx),%eax rtems_putc(*fmt); continue; } fmt++; if (*fmt == '0' ) { lead = '0'; 10b1a7: c6 44 24 28 30 movb $0x30,0x28(%esp) 10b1ac: e9 40 fe ff ff jmp 10aff1 10b1b1: 8d 76 00 lea 0x0(%esi),%esi } if ( c == 's' ) { unsigned i, len; char *s, *str; str = va_arg(ap, char *); 10b1b4: 8b 44 24 74 mov 0x74(%esp),%eax 10b1b8: 83 c0 04 add $0x4,%eax 10b1bb: 89 44 24 28 mov %eax,0x28(%esp) 10b1bf: 8b 54 24 74 mov 0x74(%esp),%edx 10b1c3: 8b 02 mov (%edx),%eax if ( str == NULL ) { 10b1c5: 85 c0 test %eax,%eax 10b1c7: 0f 84 eb 00 00 00 je 10b2b8 str = ""; } /* calculate length of string */ for ( len=0, s=str ; *s ; len++, s++ ) 10b1cd: 31 db xor %ebx,%ebx 10b1cf: 80 38 00 cmpb $0x0,(%eax) 10b1d2: 74 07 je 10b1db 10b1d4: 43 inc %ebx 10b1d5: 80 3c 18 00 cmpb $0x0,(%eax,%ebx,1) 10b1d9: 75 f9 jne 10b1d4 ; /* leading spaces */ if ( !minus ) 10b1db: 80 7c 24 20 00 cmpb $0x0,0x20(%esp) 10b1e0: 75 1f jne 10b201 for ( i=len ; i 10b1e6: 89 df mov %ebx,%edi 10b1e8: 89 44 24 24 mov %eax,0x24(%esp) rtems_putc(' '); 10b1ec: c7 04 24 20 00 00 00 movl $0x20,(%esp) 10b1f3: e8 c8 4e 00 00 call 1100c0 for ( len=0, s=str ; *s ; len++, s++ ) ; /* leading spaces */ if ( !minus ) for ( i=len ; i 10b1fd: 8b 44 24 24 mov 0x24(%esp),%eax rtems_putc(' '); /* no width option */ if (width == 0) { 10b201: 85 f6 test %esi,%esi 10b203: 75 0a jne 10b20f width = len; } /* output the string */ for ( i=0 ; i 10b20d: 89 de mov %ebx,%esi 10b20f: 0f be 10 movsbl (%eax),%edx 10b212: 84 d2 test %dl,%dl 10b214: 74 26 je 10b23c <== NEVER TAKEN rtems_putc(*str); 10b216: 89 14 24 mov %edx,(%esp) 10b219: 89 44 24 18 mov %eax,0x18(%esp) 10b21d: e8 9e 4e 00 00 call 1100c0 if (width == 0) { width = len; } /* output the string */ for ( i=0 ; i 10b22b: 90 nop rtems_putc(*str); 10b22c: 89 04 24 mov %eax,(%esp) 10b22f: e8 8c 4e 00 00 call 1100c0 if (width == 0) { width = len; } /* output the string */ for ( i=0 ; i rtems_putc(*str); /* trailing spaces */ if ( minus ) 10b23c: 80 7c 24 20 00 cmpb $0x0,0x20(%esp) 10b241: 74 16 je 10b259 for ( i=len ; i 10b247: 90 nop rtems_putc(' '); 10b248: c7 04 24 20 00 00 00 movl $0x20,(%esp) 10b24f: e8 6c 4e 00 00 call 1100c0 for ( i=0 ; i } if ( c == 's' ) { unsigned i, len; char *s, *str; str = va_arg(ap, char *); 10b259: 8b 44 24 28 mov 0x28(%esp),%eax 10b25d: 89 44 24 74 mov %eax,0x74(%esp) 10b261: e9 64 fd ff ff jmp 10afca base = 8; sign = false; } else if ( c == 'i' || c == 'I' || c == 'd' || c == 'D' ) { base = 10; sign = true; } else if ( c == 'u' || c == 'U' ) { base = 10; sign = false; 10b266: 31 c0 xor %eax,%eax 10b268: c7 44 24 20 0a 00 00 movl $0xa,0x20(%esp) 10b26f: 00 10b270: e9 21 fe ff ff jmp 10b096 unsigned long n; unsigned count; char toPrint[20]; if ( sign && (num < 0) ) { rtems_putc('-'); 10b275: c7 04 24 2d 00 00 00 movl $0x2d,(%esp) 10b27c: e8 3f 4e 00 00 call 1100c0 unsigned_num = (unsigned long) -num; 10b281: f7 db neg %ebx if (maxwidth) maxwidth--; 10b283: 83 fe 01 cmp $0x1,%esi 10b286: 83 d6 ff adc $0xffffffff,%esi } else { unsigned_num = (unsigned long) num; } count = 0; while ((n = unsigned_num / base) > 0) { 10b289: 89 d8 mov %ebx,%eax 10b28b: 31 d2 xor %edx,%edx 10b28d: f7 74 24 20 divl 0x20(%esp) 10b291: 89 c1 mov %eax,%ecx 10b293: 85 c0 test %eax,%eax 10b295: 0f 85 26 fe ff ff jne 10b0c1 <== ALWAYS TAKEN 10b29b: 89 d9 mov %ebx,%ecx 10b29d: bb 01 00 00 00 mov $0x1,%ebx if (maxwidth) maxwidth--; } else { unsigned_num = (unsigned long) num; } count = 0; 10b2a2: 31 ff xor %edi,%edi 10b2a4: e9 4f fe ff ff jmp 10b0f8 } else if ( c == 'u' || c == 'U' ) { base = 10; sign = false; } else if ( c == 'x' || c == 'X' ) { base = 16; sign = false; } else if ( c == 'p' ) { base = 16; sign = false; lflag = true; 10b2a9: 31 c0 xor %eax,%eax 10b2ab: c7 44 24 20 10 00 00 movl $0x10,0x20(%esp) 10b2b2: 00 10b2b3: e9 de fd ff ff jmp 10b096 char *s, *str; str = va_arg(ap, char *); if ( str == NULL ) { str = ""; 10b2b8: b8 61 16 12 00 mov $0x121661,%eax 10b2bd: e9 0b ff ff ff jmp 10b1cd } if ( c == 's' ) { unsigned i, len; char *s, *str; str = va_arg(ap, char *); 10b2c2: 8b 54 24 28 mov 0x28(%esp),%edx 10b2c6: 89 54 24 74 mov %edx,0x74(%esp) 10b2ca: e9 fb fc ff ff jmp 10afca =============================================================================== 0011f700 : ssize_t write( int fd, const void *buffer, size_t count ) { 11f700: 53 push %ebx 11f701: 83 ec 08 sub $0x8,%esp 11f704: 8b 44 24 10 mov 0x10(%esp),%eax 11f708: 8b 54 24 14 mov 0x14(%esp),%edx 11f70c: 8b 4c 24 18 mov 0x18(%esp),%ecx rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11f710: 3b 05 c0 b2 12 00 cmp 0x12b2c0,%eax 11f716: 73 44 jae 11f75c iop = rtems_libio_iop( fd ); 11f718: 8d 04 40 lea (%eax,%eax,2),%eax 11f71b: c1 e0 04 shl $0x4,%eax 11f71e: 03 05 d4 f4 12 00 add 0x12f4d4,%eax rtems_libio_check_is_open( iop ); 11f724: 8b 58 0c mov 0xc(%eax),%ebx 11f727: f6 c7 01 test $0x1,%bh 11f72a: 74 30 je 11f75c rtems_libio_check_buffer( buffer ); 11f72c: 85 d2 test %edx,%edx 11f72e: 74 3e je 11f76e <== NEVER TAKEN rtems_libio_check_count( count ); 11f730: 85 c9 test %ecx,%ecx 11f732: 74 20 je 11f754 rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 11f734: 83 e3 04 and $0x4,%ebx 11f737: 74 23 je 11f75c /* * Now process the write() request. */ return (*iop->pathinfo.handlers->write_h)( iop, buffer, count ); 11f739: 8b 58 20 mov 0x20(%eax),%ebx 11f73c: 89 4c 24 18 mov %ecx,0x18(%esp) 11f740: 89 54 24 14 mov %edx,0x14(%esp) 11f744: 89 44 24 10 mov %eax,0x10(%esp) 11f748: 8b 43 0c mov 0xc(%ebx),%eax } 11f74b: 83 c4 08 add $0x8,%esp 11f74e: 5b pop %ebx rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); /* * Now process the write() request. */ return (*iop->pathinfo.handlers->write_h)( iop, buffer, count ); 11f74f: ff e0 jmp *%eax 11f751: 8d 76 00 lea 0x0(%esi),%esi rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); 11f754: 31 c0 xor %eax,%eax /* * Now process the write() request. */ return (*iop->pathinfo.handlers->write_h)( iop, buffer, count ); } 11f756: 83 c4 08 add $0x8,%esp 11f759: 5b pop %ebx 11f75a: c3 ret 11f75b: 90 nop rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 11f75c: e8 97 35 ff ff call 112cf8 <__errno> 11f761: c7 00 09 00 00 00 movl $0x9,(%eax) 11f767: b8 ff ff ff ff mov $0xffffffff,%eax 11f76c: eb e8 jmp 11f756 rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); 11f76e: e8 85 35 ff ff call 112cf8 <__errno> <== NOT EXECUTED 11f773: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11f779: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 11f77e: eb d6 jmp 11f756 <== NOT EXECUTED =============================================================================== 0010bfc8 : ssize_t writev( int fd, const struct iovec *iov, int iovcnt ) { 10bfc8: 55 push %ebp 10bfc9: 57 push %edi 10bfca: 56 push %esi 10bfcb: 53 push %ebx 10bfcc: 83 ec 1c sub $0x1c,%esp 10bfcf: 8b 54 24 30 mov 0x30(%esp),%edx 10bfd3: 8b 5c 24 34 mov 0x34(%esp),%ebx 10bfd7: 8b 44 24 38 mov 0x38(%esp),%eax int bytes; rtems_libio_t *iop; ssize_t old; bool all_zeros; rtems_libio_check_fd( fd ); 10bfdb: 3b 15 c0 c2 12 00 cmp 0x12c2c0,%edx 10bfe1: 0f 83 c3 00 00 00 jae 10c0aa <== NEVER TAKEN iop = rtems_libio_iop( fd ); 10bfe7: 8d 3c 52 lea (%edx,%edx,2),%edi 10bfea: c1 e7 04 shl $0x4,%edi 10bfed: 03 3d d4 04 13 00 add 0x1304d4,%edi rtems_libio_check_is_open( iop ); 10bff3: 8b 57 0c mov 0xc(%edi),%edx 10bff6: f6 c6 01 test $0x1,%dh 10bff9: 0f 84 ab 00 00 00 je 10c0aa rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 10bfff: 83 e2 04 and $0x4,%edx 10c002: 0f 84 a2 00 00 00 je 10c0aa <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 10c008: 85 db test %ebx,%ebx 10c00a: 0f 84 80 00 00 00 je 10c090 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 10c010: 85 c0 test %eax,%eax 10c012: 7e 7c jle 10c090 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 10c014: 3d 00 04 00 00 cmp $0x400,%eax 10c019: 7f 75 jg 10c090 <== NEVER TAKEN #include #include #include ssize_t writev( 10c01b: 8d 34 c3 lea (%ebx,%eax,8),%esi 10c01e: 89 d8 mov %ebx,%eax 10c020: bd 01 00 00 00 mov $0x1,%ebp 10c025: 31 d2 xor %edx,%edx 10c027: eb 05 jmp 10c02e 10c029: 8d 76 00 lea 0x0(%esi),%esi * this loop does that check as well and sets "all-zero" appropriately. * The variable "all_zero" is used as an early exit point before * entering the write loop. */ all_zeros = true; for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) { 10c02c: 89 ca mov %ecx,%edx /* * iov[v].iov_len cannot be less than 0 because size_t is unsigned. * So we only check for zero. */ if ( iov[v].iov_base == 0 ) 10c02e: 8b 08 mov (%eax),%ecx 10c030: 85 c9 test %ecx,%ecx 10c032: 74 5c je 10c090 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len ) 10c034: 8b 48 04 mov 0x4(%eax),%ecx 10c037: 85 c9 test %ecx,%ecx 10c039: 74 02 je 10c03d all_zeros = false; 10c03b: 31 ed xor %ebp,%ebp /* check for wrap */ old = total; total += iov[v].iov_len; 10c03d: 01 d1 add %edx,%ecx if ( total < old || total > SSIZE_MAX ) 10c03f: 39 d1 cmp %edx,%ecx 10c041: 7c 4d jl 10c090 10c043: 83 c0 08 add $0x8,%eax * this loop does that check as well and sets "all-zero" appropriately. * The variable "all_zero" is used as an early exit point before * entering the write loop. */ all_zeros = true; for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) { 10c046: 39 f0 cmp %esi,%eax 10c048: 75 e2 jne 10c02c } /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { 10c04a: 89 e8 mov %ebp,%eax return 0; 10c04c: 31 ed xor %ebp,%ebp } /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { 10c04e: 84 c0 test %al,%al 10c050: 75 4e jne 10c0a0 /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { /* all zero lengths has no effect */ if ( iov[v].iov_len == 0 ) 10c052: 8b 53 04 mov 0x4(%ebx),%edx 10c055: 85 d2 test %edx,%edx 10c057: 75 11 jne 10c06a <== ALWAYS TAKEN 10c059: 8d 76 00 lea 0x0(%esi),%esi 10c05c: 83 c3 08 add $0x8,%ebx } /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 10c05f: 39 f3 cmp %esi,%ebx 10c061: 74 3d je 10c0a0 /* all zero lengths has no effect */ if ( iov[v].iov_len == 0 ) 10c063: 8b 53 04 mov 0x4(%ebx),%edx 10c066: 85 d2 test %edx,%edx 10c068: 74 f2 je 10c05c <== NEVER TAKEN continue; bytes = (*iop->pathinfo.handlers->write_h)( 10c06a: 8b 47 20 mov 0x20(%edi),%eax 10c06d: 89 54 24 08 mov %edx,0x8(%esp) 10c071: 8b 13 mov (%ebx),%edx 10c073: 89 54 24 04 mov %edx,0x4(%esp) 10c077: 89 3c 24 mov %edi,(%esp) 10c07a: ff 50 0c call *0xc(%eax) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 10c07d: 83 f8 00 cmp $0x0,%eax 10c080: 7c 3a jl 10c0bc <== NEVER TAKEN return -1; if ( bytes > 0 ) { 10c082: 74 02 je 10c086 <== NEVER TAKEN total += bytes; 10c084: 01 c5 add %eax,%ebp } if (bytes != iov[ v ].iov_len) 10c086: 3b 43 04 cmp 0x4(%ebx),%eax 10c089: 74 d1 je 10c05c <== ALWAYS TAKEN 10c08b: eb 13 jmp 10c0a0 <== NOT EXECUTED 10c08d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* check for wrap */ old = total; total += iov[v].iov_len; if ( total < old || total > SSIZE_MAX ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c090: e8 87 77 00 00 call 11381c <__errno> 10c095: c7 00 16 00 00 00 movl $0x16,(%eax) 10c09b: bd ff ff ff ff mov $0xffffffff,%ebp if (bytes != iov[ v ].iov_len) break; } return total; } 10c0a0: 89 e8 mov %ebp,%eax 10c0a2: 83 c4 1c add $0x1c,%esp 10c0a5: 5b pop %ebx 10c0a6: 5e pop %esi 10c0a7: 5f pop %edi 10c0a8: 5d pop %ebp 10c0a9: c3 ret bool all_zeros; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 10c0aa: e8 6d 77 00 00 call 11381c <__errno> 10c0af: c7 00 09 00 00 00 movl $0x9,(%eax) 10c0b5: bd ff ff ff ff mov $0xffffffff,%ebp 10c0ba: eb e4 jmp 10c0a0 iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) return -1; 10c0bc: bd ff ff ff ff mov $0xffffffff,%ebp <== NOT EXECUTED 10c0c1: eb dd jmp 10c0a0 <== NOT EXECUTED